elo-ratings 0.0.0

data/ext/bayeselo/CEloRatingCUI.h

@@ -0,0 +1,67 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// CEloRatingCUI.h
+//
+// Remi Coulom
+//
+// December, 2004
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef CEloRatingCUI_Declared
+#define CEloRatingCUI_Declared
+
+#include "consolui.h" // CConsoleUI
+#include "CCondensedResults.h"
+#include "CBradleyTerry.h"
+
+#include <vector>
+#include <string>
+
+class CResultSet;
+class CDistributionCollection;
+class CPredictionCUI;
+
+class CEloRatingCUI : public CConsoleUI // ercui
+{
+ friend class CPredictionCUI;
+
+ private: //////////////////////////////////////////////////////////////////
+  static const char * const tszCommands[];
+  const CResultSet &rs;
+  CCondensedResults crs;
+  std::vector<std::string> vecName;
+  unsigned MaxNameLength;
+  std::vector<int> vPermutation;
+  std::vector<double> veloLower;
+  std::vector<double> veloUpper;
+  CDistributionCollection *pdc;
+
+  double Confidence;
+  double eloMin;
+  double eloMax;
+  int Resolution;
+  double eloOffset;
+  double EloScale;
+  float Prior;
+
+  CBradleyTerry bt;
+  int fLOSComputed;
+
+  void ComputeVariance();
+
+ protected: ////////////////////////////////////////////////////////////////
+  virtual int ProcessCommand(const char *pszCommand,
+                             const char *pszParameters,
+                             std::istream &in,
+                             std::ostream &out);
+
+  virtual void PrintLocalPrompt(std::ostream &out);
+
+ public: ///////////////////////////////////////////////////////////////////
+  CEloRatingCUI(const CResultSet &rsInit,
+                const std::vector<std::string> &vecNameInit,
+                CConsoleUI *pcui = 0,
+                int openmode = OpenModal);
+};
+
+#endif

data/ext/bayeselo/CIndirectCompare.h

@@ -0,0 +1,28 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// CIndirectCompare.h
+//
+// R�mi Coulom
+//
+// December, 2005
+//
+/////////////////////////////////////////////////////////////////////////////
+#ifndef CIndirectCompare_Declared
+#define CIndirectCompare_Declared
+
+template<class T>
+class CIndirectCompare
+{
+ private:
+  const T *pelo;
+
+ public:
+  CIndirectCompare(const T *p) : pelo(p) {}
+
+  bool operator()(int i, int j) const
+  {
+   return pelo[i] > pelo[j];
+  }
+};
+
+#endif

data/ext/bayeselo/CJointBayesian.cpp

@@ -0,0 +1,111 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// R�mi Coulom
+//
+// December, 2004
+//
+/////////////////////////////////////////////////////////////////////////////
+#include "CJointBayesian.h"
+#include "CResultSet.h"
+#include "CCDistribution.h"
+#include "CDistributionCollection.h"
+#include "CBradleyTerry.h"
+
+#include <iostream>
+
+/////////////////////////////////////////////////////////////////////////////
+// Constructor
+/////////////////////////////////////////////////////////////////////////////
+CJointBayesian::CJointBayesian(const CResultSet &rsInit,
+                               CDistributionCollection &dcInit,
+                               const CBradleyTerry &btInit) :
+ rs(rsInit),
+ dc(dcInit),
+ bt(btInit),
+ indexMax(dc.GetDiscretizationSize() - 1)
+{
+ pindex = new int[rs.GetPlayers()];
+
+ //
+ // Pre-compute probability cache
+ //
+ pProbabilityCache = new double[3 * (indexMax * 2 + 1)];
+ for (int Result = 3; --Result >= 0;)
+  for (int i = indexMax * 2 + 1; --i >= 0;)
+   pProbabilityCache[i + Result * (indexMax * 2 + 1)] =
+    bt.ResultProbability(dc.ValueFromIndex(i) - dc.ValueFromIndex(indexMax),
+                         Result);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Destructor
+/////////////////////////////////////////////////////////////////////////////
+CJointBayesian::~CJointBayesian()
+{
+ delete[] pProbabilityCache;
+ delete[] pindex;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Get probability from indices
+/////////////////////////////////////////////////////////////////////////////
+double CJointBayesian::GetProbability() const
+{
+ double P = 1;
+
+ for (int i = rs.GetGames(); --i >= 0;)
+ {
+#if 0
+  P *= bt.ResultProbability(dc.ValueFromIndex(pindex[rs.GetWhite(i)]),
+                            dc.ValueFromIndex(pindex[rs.GetBlack(i)]),
+                            rs.GetResult(i));
+#else
+  P *= pProbabilityCache[indexMax +
+                         pindex[rs.GetWhite(i)] -
+                         pindex[rs.GetBlack(i)] +
+                         rs.GetResult(i) * (indexMax * 2 + 1)];
+#endif
+ }
+
+ return P;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Recursive helper function
+/////////////////////////////////////////////////////////////////////////////
+void CJointBayesian::RecursiveJointBayesian(int player, int indexTotal)
+{
+ if (player < 0)
+ {
+  double p = GetProbability();
+  for (int i = rs.GetPlayers(); --i >= 0;)
+   dc.GetDistribution(i).Add(pindex[i], p);
+  return;
+ }
+
+ int max = indexMax;
+ if (max > indexTotal)
+  max = indexTotal;
+
+ int min = 0;
+ if (min < indexTotal - player * indexMax)
+  min = indexTotal - player * indexMax;
+
+ for (pindex[player] = max + 1; --pindex[player] >= min;)
+  RecursiveJointBayesian(player - 1, indexTotal - pindex[player]);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Estimate rating distributions
+/////////////////////////////////////////////////////////////////////////////
+void CJointBayesian::RunComputation()
+{
+ for (int i = rs.GetPlayers(); --i >= 0;)
+  dc.GetDistribution(i).Reset();
+
+ RecursiveJointBayesian(rs.GetPlayers() - 1,
+                        dc.GetDiscretizationSize() * rs.GetPlayers() / 2);
+
+ for (int i = rs.GetPlayers(); --i >= 0;)
+  dc.GetDistribution(i).Normalize();
+}

data/ext/bayeselo/CJointBayesian.h

@@ -0,0 +1,38 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// R�mi Coulom
+//
+// December, 2004
+//
+/////////////////////////////////////////////////////////////////////////////
+#ifndef CJointBayesian_Declared
+#define CJointBayesian_Declared
+
+class CResultSet;
+class CDistributionCollection;
+class CBradleyTerry;
+
+class CJointBayesian
+{
+ private: //////////////////////////////////////////////////////////////////
+  const CResultSet &rs;
+  CDistributionCollection &dc;
+  const CBradleyTerry &bt;
+  int *pindex;
+  int indexMax;
+  double *pProbabilityCache;
+
+  void RecursiveJointBayesian(int player, int indexTotal);
+  double GetProbability() const;
+
+ public: ///////////////////////////////////////////////////////////////////
+ CJointBayesian(const CResultSet &rsInit,
+                CDistributionCollection &dcInit,
+                const CBradleyTerry &btInit);
+
+ void RunComputation();
+
+ ~CJointBayesian();
+};
+
+#endif

data/ext/bayeselo/CLUDecomposition.cpp

@@ -0,0 +1,154 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// CLUDecomposition.cpp
+//
+// Remi Coulom
+//
+// September, 2000
+//
+////////////////////////////////////////////////////////////////////////////
+#include "CLUDecomposition.h"
+
+#include <math.h>
+
+////////////////////////////////////////////////////////////////////////////
+// Constructor
+////////////////////////////////////////////////////////////////////////////
+CLUDecomposition::CLUDecomposition(int nInit) :
+ n(nInit)
+{
+ pdImplicitScaling = new double[n];
+ pdy = new double[n];
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Decompose
+////////////////////////////////////////////////////////////////////////////
+void CLUDecomposition::Decompose(double *pdMatrix, int *pIndex) const
+{
+ //
+ // Loop over rows to get the implicit scaling information
+ //
+ for (int i = n; --i >= 0;)
+ {
+  pIndex[i] = i;
+  double Max = 0.0;
+  for (int j = n; --j >= 0;)
+  {
+   double a = fabs(pdMatrix[i * n + j]);
+   if (a > Max)
+    Max = a;
+  }
+  pdImplicitScaling[i] = 1.0 / Max;
+ }
+
+ //
+ // Main loop over columns
+ //
+ for (int j = 0; j < n; j++)
+ {
+  for (int i = 0; i < j; i++)
+  {
+   double Sum = pdMatrix[i * n + j];
+   for (int k = 0; k < i; k++)
+    Sum -= pdMatrix[i * n + k] * pdMatrix[k * n + j];
+   pdMatrix[i * n + j] = Sum;
+  }
+
+  int iMax = j;
+  double Max = 0.0;
+  for (int i = j; i < n; i++)
+  {
+   double Sum = pdMatrix[i * n + j];
+   for (int k = 0; k < j; k++)
+    Sum -= pdMatrix[i * n + k] * pdMatrix[k * n + j];
+   pdMatrix[i * n + j] = Sum;
+   double a = pdImplicitScaling[i] * fabs(Sum);
+   if (a > Max)
+   {
+    Max = a;
+    iMax = i;
+   }
+  }
+
+  if (iMax != j)
+  {
+   for (int k = n; --k >= 0;)
+   {
+    double tmp = pdMatrix[iMax * n + k];
+    pdMatrix[iMax * n + k] = pdMatrix[j * n + k];
+    pdMatrix[j * n + k] = tmp;
+   }
+   pdImplicitScaling[iMax] = pdImplicitScaling[j];
+   {
+    int tmp = pIndex[j];
+    pIndex[j] = pIndex[iMax];
+    pIndex[iMax] = tmp;
+   }
+  }
+
+  {
+   double x = 1.0 / pdMatrix[j * n + j];
+   for (int i = j + 1; i < n; i++)
+    pdMatrix[i * n + j] *= x;
+  }
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Backsubstitution
+////////////////////////////////////////////////////////////////////////////
+void CLUDecomposition::Solve(const double *pdMatrix,
+                             const int *pIndex,
+                             const double *pb,
+                             double *px) const
+{
+ for (int i = 0; i < n; i++)
+ {
+  double Sum = pb[pIndex[i]];
+  for (int j = 0; j < i; j++)
+   Sum -= pdMatrix[i * n + j] * px[j];
+  px[i] = Sum;
+ }
+ for (int i = n; --i >= 0;)
+ {
+  double Sum = px[i];
+  for (int j = i + 1; j < n; j++)
+   Sum -= pdMatrix[i * n + j] * px[j];
+  px[i] = Sum / pdMatrix[i * n + i];
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////
+// SolveTranspose
+////////////////////////////////////////////////////////////////////////////
+void CLUDecomposition::SolveTranspose(const double *pdMatrix,
+                                      const int *pIndex,
+                                      const double *pb,
+                                      double *px) const
+{
+ for (int i = 0; i < n; i++)
+ {
+  double Sum = pb[i];
+  for (int j = 0; j < i; j++)
+   Sum -= pdMatrix[j * n + i] * pdy[j];
+  pdy[i] = Sum / pdMatrix[i * n + i];
+ }
+ for (int i = n; --i >= 0;)
+ {
+  double Sum = pdy[i];
+  for (int j = i + 1; j < n; j++)
+   Sum -= pdMatrix[j * n + i] * pdy[j];
+  pdy[i] = Sum;
+  px[pIndex[i]] = pdy[i];
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Destructor
+////////////////////////////////////////////////////////////////////////////
+CLUDecomposition::~CLUDecomposition()
+{
+ delete[] pdImplicitScaling;
+ delete[] pdy;
+}

data/ext/bayeselo/CLUDecomposition.h

@@ -0,0 +1,36 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// CLUDecomposition.h
+//
+// Remi Coulom
+//
+// September, 2000
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef Math_CLUDecomposition_Declared
+#define Math_CLUDecomposition_Declared
+
+class CLUDecomposition // lud
+{
+ private: /////////////////////////////////////////////////////////////////
+  int n;
+  double *pdImplicitScaling;
+  double *pdy;
+
+ public: //////////////////////////////////////////////////////////////////
+  CLUDecomposition(int nInit);
+
+  void Decompose(double *pdMatrix, int *pIndex) const;
+  void Solve(const double *pdMatrix,
+             const int *pIndex,
+             const double *pb,
+             double *px) const;
+  void SolveTranspose(const double *pdMatrix,
+                      const int *pIndex,
+                      const double *pb,
+                      double *px) const;
+
+  ~CLUDecomposition();
+};
+
+#endif

data/ext/bayeselo/CMatrix.cpp

@@ -0,0 +1,48 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// CMatrix.cpp
+//
+// R�mi Coulom
+//
+// February, 2005
+//
+/////////////////////////////////////////////////////////////////////////////
+#include "CMatrix.h"
+#include "debug.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// Constructor
+/////////////////////////////////////////////////////////////////////////////
+CMatrix::CMatrix(int RowsInit, int ColumnsInit):
+ CVector(RowsInit * ColumnsInit),
+ Rows(RowsInit),
+ Columns(ColumnsInit)
+{
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Set size
+/////////////////////////////////////////////////////////////////////////////
+void CMatrix::SetSize(int RowsInit, int ColumnsInit)
+{
+ Rows = RowsInit;
+ Columns = ColumnsInit;
+ CVector::SetSize(Rows * Columns);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Set to mA multiplied by the transpose of mB
+/////////////////////////////////////////////////////////////////////////////
+void CMatrix::SetProductByTranspose(const CMatrix &mA, const CMatrix &mB)
+{
+ FATAL(mA.GetColumns() != mB.GetColumns());
+ SetSize(mA.GetRows(), mB.GetRows());
+ for (int i = mA.GetRows(); --i >= 0;)
+  for (int j = mB.GetRows(); --j >= 0;)
+  {
+   double x = 0.0;
+   for (int k = mA.GetColumns(); --k >= 0;)
+    x += mA.GetElement(i, k) * mB.GetElement(j, k);
+   SetElement(i, j, x);
+  }
+}