all-up-in-your-elo 0.0.2

data/ext/bayeselo/CCondensedResults.cpp

@@ -0,0 +1,253 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// R�mi Coulom
+//
+// December, 2004
+//
+/////////////////////////////////////////////////////////////////////////////
+#include "CCondensedResults.h"
+#include "CResultSet.h"
+#include "debug.h"
+
+#include <set>
+#include <iostream>
+
+/////////////////////////////////////////////////////////////////////////////
+// Constructor
+/////////////////////////////////////////////////////////////////////////////
+CCondensedResults::CCondensedResults(const CResultSet &rs) :
+ Players(rs.GetPlayers())
+{
+ pOpponents = new int[Players];
+ ppcr = new CCondensedResult*[Players];
+
+ //
+ // Count opponents of each player
+ //
+ {
+  std::set<int> *pset = new std::set<int>[Players];
+
+  for (int i = rs.GetGames(); --i >= 0;)
+  {
+   int White = rs.GetWhite(i);
+   int Black = rs.GetBlack(i);
+   pset[White].insert(Black);
+   pset[Black].insert(White);
+  }
+
+  for (int i = Players; --i >= 0;)
+  {
+   pOpponents[i] = pset[i].size();
+   ppcr[i] = new CCondensedResult[pOpponents[i]];
+   for (int j = pOpponents[i]; --j >= 0;)
+    ppcr[i][j].Reset();
+  }
+
+  delete[] pset;
+ }
+
+ //
+ // Fill-in all CCondensedResult's
+ //
+ for (int i = rs.GetGames(); --i >= 0;)
+ {
+  int White = rs.GetWhite(i);
+  int Black = rs.GetBlack(i);
+
+  CCondensedResult &crWhite = FindOpponent(White, Black);
+  CCondensedResult &crBlack = FindOpponent(Black, White);
+  crWhite.TrueGames++;
+  crBlack.TrueGames++;
+
+  switch(rs.GetResult(i))
+  {
+   case 0: //////////////////////////////////////////////////////////////////
+    crWhite.l_ij++;
+    crBlack.l_ji++;
+   break;
+
+   case 1: //////////////////////////////////////////////////////////////////
+    crWhite.d_ij++;
+    crBlack.d_ji++;
+   break;
+
+   case 2: //////////////////////////////////////////////////////////////////
+    crWhite.w_ij++;
+    crBlack.w_ji++;
+   break;
+  }
+ }
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Add prior
+/////////////////////////////////////////////////////////////////////////////
+void CCondensedResults::AddPrior(float PriorDraw)
+{
+ for (int i = Players; --i >= 0;)
+ {
+  float Prior = PriorDraw * 0.25 / CountTrueGames(i);
+  for (int j = pOpponents[i]; --j >= 0;)
+  {
+   CCondensedResult &crPlayer = ppcr[i][j];
+   CCondensedResult &crOpponent = FindOpponent(crPlayer.Opponent, i);
+   float ThisPrior = Prior * crPlayer.TrueGames;
+   crPlayer.d_ij += ThisPrior;
+   crPlayer.d_ji += ThisPrior;
+   crOpponent.d_ij += ThisPrior;
+   crOpponent.d_ji += ThisPrior;
+  }
+ }
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Reset
+/////////////////////////////////////////////////////////////////////////////
+void CCondensedResult::Reset()
+{
+ Opponent = -1;
+ TrueGames = 0;
+ w_ij = 0;
+ d_ij = 0;
+ l_ij = 0;
+ w_ji = 0;
+ d_ji = 0;
+ l_ji = 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Find Opponent
+/////////////////////////////////////////////////////////////////////////////
+CCondensedResult &CCondensedResults::FindOpponent(int Player, int Opponent)
+{
+ for (int i = pOpponents[Player]; --i >= 0;)
+ {
+  CCondensedResult &cr = ppcr[Player][i];
+  if (cr.Opponent == Opponent)
+   return cr;
+  if (cr.Opponent < 0)
+  {
+   cr.Opponent = Opponent;
+   return cr;
+  }
+ }
+
+ FATAL(1);
+ return ppcr[Player][0];
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Count the number of true games played by one player
+/////////////////////////////////////////////////////////////////////////////
+int CCondensedResults::CountTrueGames(int Player) const
+{
+ int Result = 0;
+ for (int i = pOpponents[Player]; --i >= 0;)
+ {
+  CCondensedResult &cr = ppcr[Player][i];
+  Result += cr.TrueGames;
+ }
+ return Result;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Evaluate the average opponent of one player
+/////////////////////////////////////////////////////////////////////////////
+double CCondensedResults::AverageOpponent(int Player, const double *pelo) const
+{
+ double Total = 0;
+ int GameCount = 0;
+ for (int i = pOpponents[Player]; --i >= 0;)
+ {
+  CCondensedResult &cr = ppcr[Player][i];
+  Total += cr.TrueGames * pelo[cr.Opponent];
+  GameCount += cr.TrueGames;
+ }
+
+ if (GameCount)
+  return Total / GameCount;
+ else
+  return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Count the number of games played by one player
+/////////////////////////////////////////////////////////////////////////////
+float CCondensedResults::CountGames(int Player) const
+{
+ float Result = 0;
+ for (int i = pOpponents[Player]; --i >= 0;)
+ {
+  CCondensedResult &cr = ppcr[Player][i];
+  Result += cr.w_ij + cr.d_ij + cr.l_ij + cr.w_ji + cr.d_ji + cr.l_ji;
+ }
+ return Result;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Count the number of draws played by one player
+/////////////////////////////////////////////////////////////////////////////
+float CCondensedResults::CountDraws(int Player) const
+{
+ float Result = 0;
+ for (int i = pOpponents[Player]; --i >= 0;)
+ {
+  CCondensedResult &cr = ppcr[Player][i];
+  Result += cr.d_ij + cr.d_ji;
+ }
+ return Result;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Get the score of one player
+/////////////////////////////////////////////////////////////////////////////
+float CCondensedResults::Score(int Player) const
+{
+ float Result = 0;
+ for (int i = pOpponents[Player]; --i >= 0;)
+ {
+  CCondensedResult &cr = ppcr[Player][i];
+  Result += 2 * cr.w_ij + cr.d_ij + cr.d_ji + 2 * cr.l_ji;
+ }
+ return Result;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Destructor
+/////////////////////////////////////////////////////////////////////////////
+CCondensedResults::~CCondensedResults()
+{
+ for (int i = Players; --i >= 0;)
+  delete[] ppcr[i];
+ delete[] ppcr;
+ delete[] pOpponents;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Dump
+/////////////////////////////////////////////////////////////////////////////
+void CCondensedResults::Dump(std::ostream &out) const
+{
+ out << "Players = " << Players << '\n';
+ for (int i = 0; i < Players; i++)
+ {
+  out << "Player " << i << '\n';
+  out << "pOpponents[i] = " << pOpponents[i] << '\n';
+  out << "CountTrueGames(i) = " << CountTrueGames(i) << '\n';
+  for (int j = 0; j < pOpponents[i]; j++)
+  {
+   const CCondensedResult &cr = ppcr[i][j];
+   out << "Opponent " << j << " = " << cr.Opponent << '\n';
+   out << "TrueGames = " << cr.TrueGames << '\n';
+   out << "w_ij = " << cr.w_ij << ' ';
+   out << "d_ij = " << cr.d_ij << ' ';
+   out << "l_ij = " << cr.l_ij << ' ';
+   out << "w_ji = " << cr.w_ji << ' ';
+   out << "d_ji = " << cr.d_ji << ' ';
+   out << "l_ji = " << cr.l_ji;
+   out << '\n';
+  }
+  out << '\n';
+ } 
+ out.flush();
+}

data/ext/bayeselo/CCondensedResults.h

@@ -0,0 +1,64 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// R�mi Coulom
+//
+// December, 2004
+//
+/////////////////////////////////////////////////////////////////////////////
+#ifndef CCondensedResults_Declared
+#define CCondensedResults_Declared
+
+#include <iosfwd>
+
+class CResultSet;
+
+class CCondensedResult // cr
+{
+ public:
+  int Opponent;
+  int TrueGames;
+  float w_ij;
+  float d_ij;
+  float l_ij;
+  float w_ji;
+  float d_ji;
+  float l_ji;
+
+  void Reset();
+  float Games() const {return w_ij + d_ij + l_ij + w_ji + d_ji + l_ji;}
+  float Score() const {return w_ij + l_ji + (d_ij + d_ji) * 0.5;}
+};
+
+class CCondensedResults // crs
+{
+ private: ///////////////////////////////////////////////////////////////////
+  int Players;
+  int *pOpponents;
+  CCondensedResult **ppcr;
+
+ public: ////////////////////////////////////////////////////////////////////
+  CCondensedResults(const CResultSet &rs);
+
+  void AddPrior(float PriorDraw);
+
+  int GetPlayers() const {return Players;}
+  int GetOpponents(int Player) const {return pOpponents[Player];}
+
+  const CCondensedResult &GetCondensedResult(int Player, int i) const
+   {return ppcr[Player][i];}
+  CCondensedResult &GetCondensedResult(int Player, int i)
+   {return ppcr[Player][i];}
+  CCondensedResult &FindOpponent(int Player, int Opponent);
+
+  float CountGames(int Player) const;
+  int CountTrueGames(int Player) const;
+  float CountDraws(int Player) const;
+  float Score(int Player) const; // win = 2, draw = 1
+  double AverageOpponent(int Player, const double *pelo) const;
+
+  void Dump(std::ostream &out) const;
+
+  ~CCondensedResults();
+};
+
+#endif

data/ext/bayeselo/CDiscretization.h

@@ -0,0 +1,40 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// R�mi Coulom
+//
+// January, 2005
+//
+/////////////////////////////////////////////////////////////////////////////
+#ifndef CDiscretization_Declared
+#define CDiscretization_Declared
+
+class CDiscretization
+{
+ protected: /////////////////////////////////////////////////////////////////
+  const int Size;
+  const double Min;
+  const double Max;
+
+ public: ////////////////////////////////////////////////////////////////////
+  CDiscretization(int SizeInit, double MinInit, double MaxInit):
+   Size(SizeInit),
+   Min(MinInit),
+   Max(MaxInit)
+  {}
+
+  int GetDiscretizationSize() const {return Size;}
+
+  int IndexFromValue(double x) const
+  {
+   return int(0.5 + (Size - 1) * (x - Min) / (Max - Min));
+  }
+
+  double ValueFromIndex(int i) const
+  {
+   return Min + ((i + 0.5) * (Max - Min)) / Size;
+  }
+
+  virtual ~CDiscretization() {}
+};
+
+#endif

data/ext/bayeselo/CDistribution.cpp

@@ -0,0 +1,123 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// R�mi Coulom
+//
+// December, 2004
+//
+/////////////////////////////////////////////////////////////////////////////
+#include "CDistribution.h"
+
+#include <cmath>
+
+/////////////////////////////////////////////////////////////////////////////
+// reset to zero
+/////////////////////////////////////////////////////////////////////////////
+void CDistribution::Reset()
+{
+ for (int i = vDistribution.size(); --i >= 0;)
+  vDistribution[i] = 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// set to uniform distribution
+/////////////////////////////////////////////////////////////////////////////
+void CDistribution::SetUniform()
+{
+ for (int i = vDistribution.size(); --i >= 0;)
+  vDistribution[i] = 1;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// normalize
+/////////////////////////////////////////////////////////////////////////////
+void CDistribution::Normalize()
+{
+ double Total = 0;
+ for (int i = vDistribution.size(); --i >= 0;)
+  Total += vDistribution[i];
+ if (Total > 0)
+  for (int i = vDistribution.size(); --i >= 0;)
+   vDistribution[i] /= Total;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Normalize, assuming the distribution contains log-likelihoods
+/////////////////////////////////////////////////////////////////////////////
+void CDistribution::LogNormalize()
+{
+ double Max = vDistribution[0];
+ for (int i = vDistribution.size(); --i > 0;)
+  if (vDistribution[i] > Max)
+   Max = vDistribution[i];
+
+ for (int i = vDistribution.size(); --i >= 0;)
+  vDistribution[i] = std::exp(vDistribution[i] - Max);
+
+ Normalize();
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Discrete GetBound
+/////////////////////////////////////////////////////////////////////////////
+int CDistribution::GetBoundIndex(double Confidence,
+                                 int Begin,
+                                 int End,
+                                 int Direction) const
+{
+ const double Threshold = (1 - Confidence) / 2;
+ double P = 0;
+
+ for (int i = Begin; i != End; i += Direction)
+ {
+  P += vDistribution[i];
+  if (P > Threshold)
+   return i;
+ }
+
+ return End;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Discrete lower bound
+/////////////////////////////////////////////////////////////////////////////
+int CDistribution::GetLowerIndex(double Confidence) const
+{
+ return GetBoundIndex(Confidence, 0, vDistribution.size(), +1);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Discrete upper bound
+/////////////////////////////////////////////////////////////////////////////
+int CDistribution::GetUpperIndex(double Confidence) const
+{
+ return GetBoundIndex(Confidence, vDistribution.size() - 1, -1, -1);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Binomial distribution
+/////////////////////////////////////////////////////////////////////////////
+CDistribution BinomialDistribution(double p)
+{
+ CDistribution distResult(2);
+ distResult.vDistribution[0] = 1 - p;
+ distResult.vDistribution[1] = p;
+ return distResult;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Distribution of the sum
+/////////////////////////////////////////////////////////////////////////////
+CDistribution SumDistribution(const CDistribution &dist1,
+                              const CDistribution &dist2)
+{
+ CDistribution distResult(dist1.GetSize() + dist2.GetSize() - 1);
+
+ distResult.Reset();
+
+ for (int i1 = dist1.GetSize(); --i1 >= 0;)
+  for (int i2 = dist2.GetSize(); --i2 >= 0;)
+   distResult.vDistribution[i1 + i2] += dist1.vDistribution[i1] *
+                                        dist2.vDistribution[i2];
+
+ return distResult;
+}