elo-ratings 0.0.0

data/ext/bayeselo/CBradleyTerry.h

@@ -0,0 +1,137 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// R�mi Coulom
+//
+// December, 2004
+//
+/////////////////////////////////////////////////////////////////////////////
+#ifndef CBradleyTerry_Declared
+#define CBradleyTerry_Declared
+
+class CResultSet;
+class CCondensedResults;
+class CCDistribution;
+class CDistributionCollection;
+
+#include "CMatrix.h"
+
+#include <vector>
+#include <cmath>
+
+class CBradleyTerry // bt
+{
+ private: ///////////////////////////////////////////////////////////////////
+  const CCondensedResults &crs;
+  
+  mutable std::vector<double> velo;
+  mutable double eloAdvantage;
+  mutable double eloDraw;
+
+  mutable std::vector<double> v1;
+  mutable std::vector<double> v2;
+  mutable double *pGamma;
+  mutable double *pNextGamma;
+  mutable double ThetaW;
+  mutable double ThetaD;
+
+  CMatrix mCovariance;
+  CMatrix mLOS;
+  CMatrix mWinProbability;
+  CMatrix mLossProbability;
+  CMatrix mDrawProbability;
+
+  void ConvertEloToGamma() const;
+  void UpdateGammas();
+  double UpdateThetaW();
+  double UpdateThetaD();
+  double GetDifference(int n, const double *pd1, const double *pd2);
+
+ public: ////////////////////////////////////////////////////////////////////
+  CBradleyTerry(const CCondensedResults &crsInit);
+
+  //
+  // Gets
+  //
+  const double *GetElo() const {return &velo[0];}
+  double GetElo(int i) const {return velo[i];}
+  double GetAdvantage() const {return eloAdvantage;}
+  double GetDrawElo() const {return eloDraw;}
+
+  //
+  // Sets
+  //
+  double *GetElo() {return &velo[0];}
+  void SetElo(int i, double x) {velo[i] = x;}
+  void SetAdvantage(double x) {eloAdvantage = x;}
+  void SetDrawElo(double x) {eloDraw = x;}
+
+  //
+  // Methods to compute elo ratings
+  //
+  void MinorizationMaximization(int fThetaW,
+                                int fThetaD,
+                                double Epsilon = 1e-5);
+  void ELOstat(double Epsilon = 1e-5);
+  void ELOstatIntervals(double *peloLower, double *peloUpper) const;
+ 
+  //
+  // Basic Probabilities
+  //
+  static double Probability(double eloDelta)
+  {
+   return 1 / (1 + std::pow(10.0, eloDelta / 400.0));
+  }
+
+  double ElostatProbability(double eloDelta) const
+  {
+   return Probability(-eloDelta - eloAdvantage);
+  }
+
+  double WinProbability(double eloDelta) const
+  {
+   return Probability(-eloDelta - eloAdvantage + eloDraw);
+  }
+
+  double LossProbability(double eloDelta) const
+  {
+   return Probability(eloDelta + eloAdvantage + eloDraw);
+  }
+
+  double DrawProbability(double eloDelta) const
+  {
+   return 1 - WinProbability(eloDelta) - LossProbability(eloDelta);
+  }
+
+  double ResultProbability(double eloDelta, int Result) const
+  {
+   if (Result == 0)
+    return LossProbability(eloDelta);
+   else if (Result == 1)
+    return DrawProbability(eloDelta);
+   else
+    return WinProbability(eloDelta);
+  }
+
+  //
+  // Likelihood of results
+  //
+  double LogLikelihood(int Player) const;
+  double LogLikelihood() const;
+  double LogLikelihood(const CResultSet &rs) const;
+
+  //
+  // Likelihood distributions
+  //
+  void GetPlayerDist(int Player, CCDistribution &cdist) const;
+  void GetAdvantageDist(CCDistribution &cdist) const;
+  void GetDrawEloDist(CCDistribution &cdist) const;
+
+  void GetVariance(double *pdVariance) const;
+  void ComputeCovariance();
+  void ComputeLikelihoodOfSuperiority();
+
+  const CMatrix &GetCovariance() const {return mCovariance;}
+  const CMatrix &GetLikelihoodOfSuperiority() const {return mLOS;}
+};
+
+#endif

data/ext/bayeselo/CCDistribution.cpp

@@ -0,0 +1,135 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// R�mi Coulom
+//
+// December, 2004
+//
+/////////////////////////////////////////////////////////////////////////////
+#include "CCDistribution.h"
+
+#include <cmath>
+
+/////////////////////////////////////////////////////////////////////////////
+// Get Bound helper function
+/////////////////////////////////////////////////////////////////////////////
+double CCDistribution::GetBoundValue(double Confidence,
+                                     int Begin,
+                                     int End,
+                                     int Direction) const
+{
+ const double Threshold = (1 - Confidence) / 2;
+ double P = 0;
+ double PreviousDistribution = 0;
+
+ for (int i = Begin; i != End; i += Direction)
+ {
+  double NewDistribution = vDistribution[i];
+  double NewP = P + (PreviousDistribution + NewDistribution) / 2;
+  if (NewP >= Threshold)
+  {
+   double Value = ValueFromIndex(i - Direction);
+   double NewValue = ValueFromIndex(i);
+#if 0
+   double Delta = PreviousDistribution * PreviousDistribution - 
+        4 * (P - Threshold) * (NewDistribution - PreviousDistribution) / 2;
+   double Alpha = (-PreviousDistribution + std::sqrt(Delta)) / 
+                  (NewDistribution - PreviousDistribution);
+   return Value + (NewValue - Value) * Alpha;
+#else
+   // The second-order approximation above causes problems when NewD=PreviousD
+   return Value + (NewValue - Value) * (Threshold - P) / (NewP - P);
+#endif
+  }
+  P = NewP;
+  PreviousDistribution = NewDistribution;
+ }
+ 
+ return ValueFromIndex(End - Direction);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Get Lower Bound
+/////////////////////////////////////////////////////////////////////////////
+double CCDistribution::GetLowerValue(double Confidence) const
+{
+ return GetBoundValue(Confidence, 0, vDistribution.size(), +1);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Get Upper Bound
+/////////////////////////////////////////////////////////////////////////////
+double CCDistribution::GetUpperValue(double Confidence) const
+{
+ return GetBoundValue(Confidence, vDistribution.size() - 1, -1, -1);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Get Most Likely Value
+/////////////////////////////////////////////////////////////////////////////
+double CCDistribution::GetMostLikelyValue() const
+{
+ double MaxP = vDistribution[0];
+ int iMax = 0;
+ for (int i = vDistribution.size(); --i > 0;)
+  if (vDistribution[i] > MaxP)
+  {
+   iMax = i;
+   MaxP = vDistribution[i];
+  }
+ return ValueFromIndex(iMax);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Mean
+/////////////////////////////////////////////////////////////////////////////
+double CCDistribution::GetMean() const
+{
+ double Result = 0;
+ for (int i = vDistribution.size(); --i > 0;)
+  Result += vDistribution[i] * ValueFromIndex(i);
+ return Result;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Variance
+/////////////////////////////////////////////////////////////////////////////
+double CCDistribution::GetVariance(double Mean) const
+{
+ double Result = 0;
+ for (int i = vDistribution.size(); --i > 0;)
+ {
+  double x = ValueFromIndex(i);
+  Result += vDistribution[i] * (x - Mean) * (x - Mean);
+ }
+ return Result;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Gaussian
+/////////////////////////////////////////////////////////////////////////////
+void CCDistribution::SetNormal(double Mu, double Sigma)
+{
+ const double b = 1.0 / (2.0 * Sigma * Sigma);
+
+ for (int i = vDistribution.size(); --i > 0;)
+ {
+  double x = ValueFromIndex(i);
+  double delta = x - Mu;
+  vDistribution[i] = std::exp(-b * delta * delta);
+ }
+ 
+ Normalize();
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Binomial posterior ??? log-likelihood for better stability
+/////////////////////////////////////////////////////////////////////////////
+void CCDistribution::SetBinomialPosterior(int N, int n)
+{
+ for (int i = vDistribution.size(); --i > 0;)
+ {
+  double x = ValueFromIndex(i);
+  vDistribution[i] = std::pow(x, n) * std::pow (1 - x, N - n);
+ }
+ Normalize();
+}

data/ext/bayeselo/CCDistribution.h

@@ -0,0 +1,44 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// R�mi Coulom
+//
+// December, 2004
+//
+/////////////////////////////////////////////////////////////////////////////
+#ifndef CCDistribution_Declared
+#define CCDistribution_Declared
+
+#include "CDistribution.h"
+#include "CDiscretization.h"
+
+class CCDistribution: public CDistribution, public CDiscretization // cdist
+{
+ private: ///////////////////////////////////////////////////////////////////
+  double GetBoundValue(double Confidence,
+                       int Begin,
+                       int End,
+                       int Direction) const;
+
+ public: ////////////////////////////////////////////////////////////////////
+  CCDistribution(int Size, double Min, double Max):
+   CDistribution(Size),
+   CDiscretization(Size, Min, Max)
+  {}
+
+  //
+  // Compute properties of this distribution
+  //
+  double GetLowerValue(double Confidence) const;
+  double GetUpperValue(double Confidence) const;
+  double GetMostLikelyValue() const;
+  double GetMean() const;
+  double GetVariance(double Mean) const;
+
+  //
+  // Standard distributions
+  //
+  void SetNormal(double Mu, double Sigma);
+  void SetBinomialPosterior(int N, int n);
+};
+
+#endif

data/ext/bayeselo/CCDistributionCUI.cpp

@@ -0,0 +1,104 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Remi Coulom
+//
+// January, 2005
+//
+////////////////////////////////////////////////////////////////////////////
+#include "CCDistributionCUI.h"
+#include "CCDistribution.h"
+
+#include <sstream>
+
+////////////////////////////////////////////////////////////////////////////
+// Constructor
+////////////////////////////////////////////////////////////////////////////
+CCDistributionCUI::CCDistributionCUI(const CCDistribution &cdistInit,
+                                     CConsoleUI *pcui,
+                                     int openmode) :
+ CConsoleUI(pcui, openmode),
+ cdist(cdistInit)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Local prompt
+////////////////////////////////////////////////////////////////////////////
+void CCDistributionCUI::PrintLocalPrompt(std::ostream &out)
+{
+ out << "Distribution";
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Command strings
+////////////////////////////////////////////////////////////////////////////
+const char * const CCDistributionCUI::tszCommands[] =
+{
+ "?",
+ "lower",
+ "upper",
+ "mostlikely",
+ "write",
+ 0
+};
+
+////////////////////////////////////////////////////////////////////////////
+// Process commands
+////////////////////////////////////////////////////////////////////////////
+int CCDistributionCUI::ProcessCommand(const char *pszCommand,
+                                      const char *pszParameters,
+                                      std::istream &in,
+                                      std::ostream &out)
+{
+ enum
+ {
+  IDC_Help,
+  IDC_Lower,
+  IDC_Upper,
+  IDC_MostLikely,
+  IDC_Write
+ };
+
+ switch (ArrayLookup(pszCommand, tszCommands))
+ {
+  case IDC_Help: ///////////////////////////////////////////////////////////
+   CConsoleUI::ProcessCommand(pszCommand, pszParameters, in, out);
+   out << "Distribution commands\n";
+   out << "~~~~~~~~~~~~~~~~~~~~~\n";
+   out << "lower [c] ....... lower bound (c=confidence, default=0.95)\n";
+   out << "upper [c] ....... upper bound\n";
+   out << "mostlikely ...... most likely value\n";
+   out << "write ........... write complete distribution\n";
+  break;
+
+  case IDC_Lower: //////////////////////////////////////////////////////////
+  {
+   double Confidence = 0.95;
+   std::istringstream(pszParameters) >> Confidence;
+   out << cdist.GetLowerValue(Confidence) << '\n';
+  }
+  break;
+
+  case IDC_Upper: //////////////////////////////////////////////////////////
+  {
+   double Confidence = 0.95;
+   std::istringstream(pszParameters) >> Confidence;
+   out << cdist.GetUpperValue(Confidence) << '\n';
+  }
+  break;
+
+  case IDC_MostLikely: /////////////////////////////////////////////////////
+   out << cdist.GetMostLikelyValue() << '\n';
+  break;
+
+  case IDC_Write: //////////////////////////////////////////////////////////
+   for (int i = 0; i < cdist.GetSize(); i++)
+    out << cdist.ValueFromIndex(i) << ' ' << cdist.GetProbability(i) << '\n';
+  break;
+
+  default: /////////////////////////////////////////////////////////////////
+   return CConsoleUI::ProcessCommand(pszCommand, pszParameters, in, out);
+ }
+
+ return PC_Continue;
+}

data/ext/bayeselo/CCDistributionCUI.h

@@ -0,0 +1,38 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// CCDistributionCUI.h
+//
+// Remi Coulom
+//
+// January, 2005
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef CCDistributionCUI_Declared
+#define CCDistributionCUI_Declared
+
+#include "consolui.h" // CConsoleUI
+
+class CCDistribution;
+
+class CCDistributionCUI : public CConsoleUI // cdcui
+{
+ private: //////////////////////////////////////////////////////////////////
+  static const char * const tszCommands[];
+
+  const CCDistribution &cdist;
+
+ protected: ////////////////////////////////////////////////////////////////
+  virtual int ProcessCommand(const char *pszCommand,
+                             const char *pszParameters,
+                             std::istream &in,
+                             std::ostream &out);
+
+  virtual void PrintLocalPrompt(std::ostream &out);
+
+ public: ///////////////////////////////////////////////////////////////////
+  CCDistributionCUI(const CCDistribution &cdistInit,
+                    CConsoleUI *pcui = 0,
+                    int openmode = OpenModal);
+};
+
+#endif