void CUnreadWaveCollection::InsertChangesOnly(CWaveCollection * lpLastReported, CWaveCollection * lpCurrent)
{
const TWaveMap & vCurrent = lpCurrent->GetWaves();
const TWaveMap & vLastReported = lpLastReported->GetWaves();
for (TWaveMapConstIter iter = vCurrent.begin(); iter != vCurrent.end(); iter++)
{
TWaveMapConstIter pos = vLastReported.find(iter->first);
CWave * lpReportedWave = pos == vLastReported.end() ? NULL : pos->second;
WAVE_CHANGED_STATUS nStatus = GetChangedStatus(lpReportedWave, iter->second);
if (nStatus == WCS_REFRESH)
{
lpLastReported->AddWave(new CWave(*iter->second));
}
else if (nStatus == WCS_CHANGED)
{
CUnreadWave * lpUnread = GetDifference(lpReportedWave, iter->second);
if (lpUnread != NULL)
{
Insert(lpUnread);
}
}
}
}
// Get the elapsed time, if bReset is true reset the start time
void CProfileTimer::GetElapsedTime(ElapsedTime &cElapsed, bool bReset)
{
::gettimeofday(&sEnd, NULL);
GetDifference(cElapsed, &sStart, &sEnd);
if (bReset)
sStart = sEnd;
}
// used to create a relative time from the systemtime when only systemtime is stored in Sysinternals DbgView files.
// the reverse (creating system-time from relative times) makes no sense.
void DBLogReader::GetRelativeTime(Line& line)
{
if (line.time != 0.0) // if relative time is already filled in do nothing
return;
if (m_linenumber == 1)
{
m_firstFiletime = line.systemTime;
return;
}
line.time = GetDifference(m_firstFiletime, line.systemTime);
}
// Get the elapsed time from start until now
void CProfileTimer::GetElapsedNow(ElapsedTime &cElapsed, const char *pLabel1)
{
// Set as an error flag
cElapsed.lSec = -1;
if (!pLabel1)
return;
struct timeval t1 = GetLabelTimestamp(pLabel1);
if (t1.tv_sec == -1)
return;
struct timeval t2;
::gettimeofday(&t2, NULL);
GetDifference(cElapsed, &t1, &t2);
}
/*! Calculates the angle which is defined as relative position dRel
between start angle dAlpha and end angle dBeta. If dRel=0, the retured
angle is dAlpha and if dRel=1, the returned version is dBeta. The bCCW controls
the arc between start and end.
\retval Relative angle between dAlpha and dBeta taking account the direction.
*/
Angle Angle::GetRelative(
qreal dRel, //!< Relative value from [0,1] interval.
const Angle& dAlpha, //!< First angle
const Angle& dBeta, //!< Second angle
bool bCCW //!< true -> counterclockwise, false -> clockwise.
)
{
ASSERT(dRel >= 0 && dRel <= 1.0);
Angle aDelta = GetDifference(dAlpha,dBeta,bCCW);
if(bCCW)
aDelta = dAlpha + dRel*aDelta;
else
aDelta = dAlpha - dRel*aDelta;
return aDelta;
}
void CUnreadWaveCollection::InsertAllWaves(CWaveCollection * lpCurrent)
{
const TWaveMap & vCurrent = lpCurrent->GetWaves();
for (TWaveMapConstIter iter = vCurrent.begin(); iter != vCurrent.end(); iter++)
{
if (GetChangedStatus(NULL, iter->second) == WCS_CHANGED)
{
CUnreadWave * lpUnread = GetDifference(NULL, iter->second);
if (lpUnread != NULL)
{
Insert(lpUnread);
}
}
}
}
void CProfileTimer::GetElapsed(ElapsedTime &cElapsed, const char *pLabel1, const char *pLabel2, bool bMarkLabel2)
{ // Set as an error flag
cElapsed.lSec = -1;
if (!pLabel1 || !pLabel2)
return;
if (bMarkLabel2)
SetTimestamp(pLabel2);
struct timeval t1 = GetLabelTimestamp(pLabel1);
if (t1.tv_sec == -1)
return;
struct timeval t2 = GetLabelTimestamp(pLabel2);
if (t2.tv_sec == -1)
return;
GetDifference(cElapsed, &t1, &t2);
}
/////////////////////////////////////////////////////////////////////////////
// MM Algorithm
/////////////////////////////////////////////////////////////////////////////
void CBradleyTerry::MinorizationMaximization(int fThetaW,
int fThetaD,
double Epsilon) {
//
// Set initial values
//
ThetaW = fThetaW ? 1.0 : std::pow(10.0, eloAdvantage/400.0);
ThetaD = fThetaD ? 1.0 : std::pow(10.0, eloDraw/400.0);
for (int i = crs.GetPlayers(); --i >= 0;)
pGamma[i] = 1.0;
//
// Main MM loop
//
for (int i = 0; i < 10000; i++) {
UpdateGammas();
double Diff = GetDifference(crs.GetPlayers(), pGamma, pNextGamma);
if (fThetaW) {
double NewThetaW = UpdateThetaW();
double ThetaW_Diff = std::fabs(ThetaW - NewThetaW);
if (ThetaW_Diff > Diff)
Diff = ThetaW_Diff;
ThetaW = NewThetaW;
}
if (fThetaD) {
double NewThetaD = UpdateThetaD();
double ThetaD_Diff = std::fabs(ThetaD - NewThetaD);
if (ThetaD_Diff > Diff)
Diff = ThetaD_Diff;
ThetaD = NewThetaD;
}
if (Diff < Epsilon)
break;
//
// Print iteration information
//
#if 1
if ((i + 1) % 100 == 0) {
std::cout << "Iteration " << i + 1 << ": ";
std::cout << Diff << ' ';
std::cout << '\n';
std::cout.flush();
}
#endif
}
//
// Convert back to Elos
//
{
double Total = 0;
for (int i = crs.GetPlayers(); --i >= 0;)
Total += (velo[i] = std::log10(pGamma[i]) * 400);
double Offset = - Total / crs.GetPlayers();
for (int i = crs.GetPlayers(); --i >= 0;)
velo[i] += Offset;
}
if (fThetaW)
eloAdvantage = std::log10(ThetaW) * 400;
if (fThetaD)
eloDraw = std::log10(ThetaD) * 400;
}
// ////////////////////////////////////////////////////////////////////////////
TimeVal TimeVal::GetDifferenceAbs(const TimeVal &time_1, const TimeVal &time_2)
{
return((time_1 >= time_2) ? GetDifference(time_1, time_2) :
GetDifference(time_2, time_1));
}
