all-up-in-your-elo 0.0.2

data/ext/bayeselo/CResultSetCUI.h

@@ -0,0 +1,44 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// CResultSetCUI.h
+//
+// Remi Coulom
+//
+// December, 2004
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef CResultSetCUI_Declared
+#define CResultSetCUI_Declared
+
+#include "consolui.h" // CConsoleUI
+
+#include <vector>
+
+class CResultSet;
+
+class CResultSetCUI : public CConsoleUI // rscui
+{
+ private: //////////////////////////////////////////////////////////////////
+  static const char * const tszCommands[];
+
+  CResultSet &rs;
+  std::vector<std::string> &vecName;
+
+  unsigned ComputePlayerWidth() const;
+
+ protected: ////////////////////////////////////////////////////////////////
+  virtual int ProcessCommand(const char *pszCommand,
+                             const char *pszParameters,
+                             std::istream &in,
+                             std::ostream &out);
+
+  virtual void PrintLocalPrompt(std::ostream &out);
+
+ public: ///////////////////////////////////////////////////////////////////
+  CResultSetCUI(CResultSet &rsInit,
+                std::vector<std::string> &vecNameInit,
+                CConsoleUI *pcui = 0,
+                int openmode = OpenModal);
+};
+
+#endif

data/ext/bayeselo/CTimeIO.cpp

@@ -0,0 +1,58 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// CTimeIO.cpp
+//
+// Remi Coulom
+//
+// August 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#include "CTimeIO.h"
+#include "chtime.h"
+
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+
+////////////////////////////////////////////////////////////////////////////
+// output operator
+////////////////////////////////////////////////////////////////////////////
+std::ostream &operator<<(std::ostream &ostr, const CTime &time)
+{
+ char cOldFill = ostr.fill('0');
+ int OldWidth = ostr.width(2);
+
+ ostr << std::setw(2) << time.GetHours() << ':';
+ ostr << std::setw(2) << time.GetMinutes() << ':';
+ ostr << std::setw(2) << time.GetSeconds() << ',';
+ ostr << std::setw(2) << time.GetHundredths();
+
+ ostr.width(OldWidth);
+ ostr.fill(cOldFill);
+
+ return ostr;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// input operator
+////////////////////////////////////////////////////////////////////////////
+std::istream &operator>>(std::istream &istr, CTime &time)
+{
+ char szBuffer[12];
+
+ {
+  int i = 0;
+  for (; i < (int)sizeof(szBuffer) - 1; i++)
+  {
+   int c = istr.peek();
+   if (c == ' ' || c == '\n' || istr.eof())
+    break;
+   szBuffer[i] = c;
+   istr.ignore();
+  }
+  szBuffer[i] = 0;
+ }
+
+ time.Set(szBuffer);
+ return istr;
+}

data/ext/bayeselo/CTimeIO.h

@@ -0,0 +1,19 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// CTimeIO.h
+//
+// Remi Coulom
+//
+// August, 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef CTimeIO_Declared
+#define CTimeIO_Declared
+
+#include <iosfwd>
+class CTime;
+
+std::ostream &operator<<(std::ostream &ostr, const CTime &time);
+std::istream &operator>>(std::istream &istr, CTime &time);
+
+#endif

data/ext/bayeselo/CVector.cpp

@@ -0,0 +1,110 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// CVector.cpp
+//
+// Remi Coulom
+//
+// September, 2000
+//
+////////////////////////////////////////////////////////////////////////////
+#include "CVector.h"
+
+////////////////////////////////////////////////////////////////////////////
+// Constructor
+////////////////////////////////////////////////////////////////////////////
+CVector::CVector(int SizeInit) :
+ Size(0)
+{
+ SetSize(SizeInit);
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Set Size
+////////////////////////////////////////////////////////////////////////////
+void CVector::SetSize(int NewSize)
+{
+ if (Size)
+ {
+  delete[] pd;
+  Size = 0;
+ }
+ if (NewSize > 0)
+  pd = new double[Size = NewSize];
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Assignment operator
+////////////////////////////////////////////////////////////////////////////
+CVector &CVector::operator=(const CVector &v)
+{
+ if (&v != this)
+ {
+  if (Size != v.GetSize())
+   SetSize(v.GetSize());
+  for (int i = Size; --i >= 0;)
+   pd[i] = v[i];
+ }
+ return *this;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Copy constructor
+////////////////////////////////////////////////////////////////////////////
+CVector::CVector(const CVector &v) :
+ Size(0)
+{
+ *this = v;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Zero
+////////////////////////////////////////////////////////////////////////////
+void CVector::Zero()
+{
+ for (int i = Size; --i >= 0;)
+  pd[i] = 0;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Scale
+////////////////////////////////////////////////////////////////////////////
+void CVector::Scale(double x)
+{
+ for (int i = Size; --i >= 0;)
+  pd[i] *= x;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Add
+////////////////////////////////////////////////////////////////////////////
+void CVector::Add(const double *pdp)
+{
+ for (int i = Size; --i >= 0;)
+  pd[i] += pdp[i];
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Add scaled
+////////////////////////////////////////////////////////////////////////////
+void CVector::AddScaled(const double *pdp, double x)
+{
+ for (int i = Size; --i >= 0;)
+  pd[i] += x * pdp[i];
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Set from a pointer
+////////////////////////////////////////////////////////////////////////////
+void CVector::Set(const double *px)
+{
+ for (int i = Size; --i >= 0;)
+  pd[i] = px[i];
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Destructor
+////////////////////////////////////////////////////////////////////////////
+CVector::~CVector()
+{
+ SetSize(0);
+}

data/ext/bayeselo/CVector.h

@@ -0,0 +1,42 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// CVector.h
+//
+// Remi Coulom
+//
+// September, 2000
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef Math_CVector_Declared
+#define Math_CVector_Declared
+
+class CVector // v
+{
+ private: /////////////////////////////////////////////////////////////////
+  double *pd;
+  int Size;
+
+ public: //////////////////////////////////////////////////////////////////
+  CVector(int SizeInit = 0);
+  CVector(const CVector &v);
+  CVector &operator=(const CVector &v);   
+
+  int GetSize() const {return Size;}
+  void SetSize(int NewSize);
+
+  operator double * () {return pd;}
+  operator const double * () const {return pd;}
+
+  double operator[](int i) const {return pd[i];}
+  double &operator[](int i) {return pd[i];}
+
+  void Zero();
+  void Scale(double x);
+  void Add(const double *pdp);
+  void AddScaled(const double *pdp, double x);
+  void Set(const double *px);
+
+  ~CVector();
+};
+
+#endif

data/ext/bayeselo/EloDataFromFile.cpp

@@ -0,0 +1,120 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// R�mi Coulom
+//
+// December, 2004
+//
+/////////////////////////////////////////////////////////////////////////////
+#include "EloDataFromFile.h"
+#include "pgnlex.h"
+#include "pgn.h"
+#include "str.h"
+#include "CResultSet.h"
+
+#include <map>
+#include <string>
+#include <iostream>
+
+/////////////////////////////////////////////////////////////////////////////
+// Skip a game
+/////////////////////////////////////////////////////////////////////////////
+static void SkipGame(CPGNLex &pgnlex)
+{
+ int Token = pgnlex.GetToken();
+
+ while (Token != CPGNLex::TOK_EOF)
+ {
+  int TokenPrev = Token;
+  Token = pgnlex.ReadNextToken(); 
+
+  if (TokenPrev == CPGNLex::TOK_GameTermination ||
+      Token == CPGNLex::TOK_EOF ||
+      (TokenPrev != CPGNLex::TOK_TagClose &&
+       TokenPrev != CPGNLex::TOK_BOF &&
+       Token == CPGNLex::TOK_TagOpen))
+   return;
+ }
+
+ return;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Read all data for Elo calculation
+/////////////////////////////////////////////////////////////////////////////
+void EloDataFromFile(CPGNLex &pgnlex,
+                     CResultSet &rs,
+                     std::vector<std::string> &vNames)
+{
+ int Players = 0;
+ int Ignored = 0;
+
+ //
+ // Add current players to the name map
+ //
+ std::map<std::string, int> NameMap;
+ for (int i = vNames.size(); --i >= 0;)
+ {
+  std::pair<const std::string, int> Pair(vNames[i], i);
+  NameMap.insert(Pair);
+  Players++;
+ }
+
+ //
+ // Loop over games
+ //
+ while (1)
+ {
+  CSTR str;
+  int fTheEnd = CPGN::ReadSTR(str, pgnlex);
+  SkipGame(pgnlex);
+  
+  if (!fTheEnd)
+  {
+   //
+   // Ignore unknown results
+   //
+   int r = str.GetResult();
+   if (r < 0 || r > 2)
+    Ignored++;
+   else
+   {
+    std::string sWhite(str.GetWhite());
+    std::string sBlack(str.GetBlack());
+
+    {
+     std::pair<const std::string, int> Pair(sWhite, Players);
+     if (NameMap.insert(Pair).second)
+     {
+      Players++;
+      vNames.push_back(sWhite);
+     }
+    }
+    {
+     std::pair<const std::string, int> Pair(sBlack, Players);
+     if (NameMap.insert(Pair).second)
+     {
+      Players++;
+      vNames.push_back(sBlack);
+     }
+    }
+
+    int WhitePlayer = NameMap.find(sWhite)->second;
+    int BlackPlayer = NameMap.find(sBlack)->second;
+
+    rs.Append(WhitePlayer, BlackPlayer, r);
+   }
+  }
+
+  if (rs.GetGames() % 1000 == 0 || fTheEnd)
+  {
+   std::cerr << rs.GetGames() << " game(s) loaded, ";
+   std::cerr << Ignored << " game(s) with unknown result ignored.\r";
+  }
+
+  if (fTheEnd)
+  {
+   std::cerr << '\n';
+   break;
+  }
+ }
+}

data/ext/bayeselo/EloDataFromFile.h

@@ -0,0 +1,21 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// R�mi Coulom
+//
+// December, 2004
+//
+/////////////////////////////////////////////////////////////////////////////
+#ifndef EloDataFromFile_Declared
+#define EloDataFromFile_Declared
+
+#include <vector>
+#include <string>
+
+class CPGNLex;
+class CResultSet;
+
+void EloDataFromFile(CPGNLex &pgnlex,
+                     CResultSet &rs,
+                     std::vector<std::string> &vNames);
+
+#endif

data/ext/bayeselo/README

@@ -0,0 +1,8 @@
+bayeselo
+by Rémi Coulom
+http://remi.coulom.free.fr/Bayesian-Elo/
+
+To compile, "cd" into the BayesElo directory and "make".
+
+This software is protected under the terms of the GNU GPL
+See http://www.gnu.org/copyleft/gpl.html

data/ext/bayeselo/ReadLineToString.cpp

@@ -0,0 +1,32 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// ReadLineToString.cpp
+//
+// R�mi Coulom
+//
+// April, 2006
+//
+/////////////////////////////////////////////////////////////////////////////
+#include "ReadLineToString.h"
+
+#include <iostream>
+
+/////////////////////////////////////////////////////////////////////////////
+// Read a line to a string
+/////////////////////////////////////////////////////////////////////////////
+void ReadLineToString(std::string &s, std::istream &in)
+{
+ s.clear();
+ while (1)
+ {
+  char c;
+  if (in.get(c))
+  {
+   if (c == '\n')
+    break;
+   s += c;
+  }
+  else
+   break;
+ }
+}