all-up-in-your-elo 0.0.2

data/ext/bayeselo/CPredictionCUI.h

@@ -0,0 +1,50 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// CPredictionCUI.h
+//
+// Remi Coulom
+//
+// December, 2005
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef CPredictionCUI_Declared
+#define CPredictionCUI_Declared
+
+#include "consolui.h" // CConsoleUI
+#include "CResultSet.h"
+
+#include <vector>
+
+class CEloRatingCUI;
+
+class CPredictionCUI : public CConsoleUI // predcui
+{
+ private: //////////////////////////////////////////////////////////////////
+  static const char * const tszCommands[];
+
+  CEloRatingCUI &ercui;
+  std::vector<double> vbtvariance;
+
+  std::vector<double> velo;
+  std::vector<double> vStdDev;
+  CResultSet rs;
+  std::vector<std::string> vecName;
+
+  int Simulations;
+  int Rounds;
+  int tScore[3];
+  double ScoreMultiplier;
+
+ protected: ////////////////////////////////////////////////////////////////
+  virtual int ProcessCommand(const char *pszCommand,
+                             const char *pszParameters,
+                             std::istream &in,
+                             std::ostream &out);
+
+  virtual void PrintLocalPrompt(std::ostream &out);
+
+ public: ///////////////////////////////////////////////////////////////////
+  CPredictionCUI(CEloRatingCUI &ercuiInit, int openmode = OpenModal);
+};
+
+#endif

data/ext/bayeselo/CResultSet.cpp

@@ -0,0 +1,245 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// R�mi Coulom
+//
+// December, 2004
+//
+/////////////////////////////////////////////////////////////////////////////
+#include "CResultSet.h"
+#include "debug.h"
+#include "random.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// Subset constructor for one player
+/////////////////////////////////////////////////////////////////////////////
+CResultSet::CResultSet(const CResultSet &rs, int Player)
+{
+ Reset();
+ for (int i = 0; i < rs.GetGames(); i++)
+  if (rs.GetWhite(i) == Player || rs.GetBlack(i) == Player)
+   Append(rs.GetWhite(i), rs.GetBlack(i), rs.GetResult(i));
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Subset constructor for a pair of players (+pack)
+/////////////////////////////////////////////////////////////////////////////
+CResultSet::CResultSet(const CResultSet &rs, int Player1, int Player2)
+{
+ Reset();
+ for (int i = 0; i < rs.GetGames(); i++)
+ {
+  if (rs.GetWhite(i) == Player1 && rs.GetBlack(i) == Player2)
+   Append(0, 1, rs.GetResult(i));
+  if (rs.GetWhite(i) == Player2 && rs.GetBlack(i) == Player1)
+   Append(1, 0, rs.GetResult(i));
+ }
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Count games of a player
+/////////////////////////////////////////////////////////////////////////////
+int CResultSet::CountGames(unsigned Player) const
+{
+ int Result = 0;
+ for (int i = GetGames(); --i >= 0;)
+  if (vWhite[i] == Player || vBlack[i] == Player)
+   Result++;
+ return Result;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Reset to empty set
+/////////////////////////////////////////////////////////////////////////////
+void CResultSet::Reset()
+{
+ vWhite.clear();
+ vBlack.clear();
+ vResult.clear();
+ Players = 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Add a result
+/////////////////////////////////////////////////////////////////////////////
+void CResultSet::Append(unsigned w, unsigned b, unsigned r)
+{
+ FATAL(r > 2);
+
+ vWhite.push_back(w);
+ vBlack.push_back(b);
+ vResult.push_back(r);
+
+ if (w >= Players)
+  Players = w + 1;
+ if (b >= Players)
+  Players = b + 1;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Remove a game
+/////////////////////////////////////////////////////////////////////////////
+void CResultSet::RemoveGame(int Index)
+{
+ int Games = GetGames();
+ vWhite[Index] = vWhite[Games - 1];
+ vBlack[Index] = vBlack[Games - 1];
+ vResult[Index] = vResult[Games - 1];
+ vWhite.resize(Games - 1);
+ vBlack.resize(Games - 1);
+ vResult.resize(Games - 1);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Remove games by a player
+/////////////////////////////////////////////////////////////////////////////
+void CResultSet::RemovePlayer(unsigned Player)
+{
+ for (int i = GetGames(); --i >= 0;)
+  if (vWhite[i] == Player || vBlack[i] == Player)
+   RemoveGame(i);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Remove games by player who have played less than Threshold games
+/////////////////////////////////////////////////////////////////////////////
+void CResultSet::RemoveRarePlayers(int Threshold)
+{
+ std::vector<int> vPlayersToRemove;
+ for (int i = GetPlayers(); --i >= 0;)
+  if (CountGames(i) < Threshold)
+   vPlayersToRemove.push_back(i);
+ for (int i = vPlayersToRemove.size(); --i >= 0;)
+  RemovePlayer(vPlayersToRemove[i]);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Pack players
+/////////////////////////////////////////////////////////////////////////////
+void CResultSet::PackPlayers(std::vector<std::string> &vName)
+{
+ //
+ // Find Players that have games
+ //
+ std::vector<int> vTranslation(Players);
+ std::vector<int> vReverseTranslation(Players);
+ int NewPlayers = 0;
+ for (unsigned i = 0; i < Players; i++)
+ {
+  vTranslation[i] = NewPlayers;
+  if (CountGames(i))
+  {
+   vReverseTranslation[NewPlayers] = i;
+   NewPlayers++;
+  }
+ }
+
+ //
+ // Change player numbers
+ //
+ for (int i = GetGames(); --i >= 0;)
+ {
+  vWhite[i] = vTranslation[vWhite[i]];
+  vBlack[i] = vTranslation[vBlack[i]];
+ }
+ Players = NewPlayers;
+
+ //
+ // Reorder player names
+ //
+ std::vector<std::string> vNewName(NewPlayers);
+ for (int i = NewPlayers; --i >= 0;)
+  vNewName[i] = vName[vReverseTranslation[i]];
+ vName = vNewName;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Extract a subset (used for cross-validation)
+/////////////////////////////////////////////////////////////////////////////
+void CResultSet::Extract(CResultSet &rs1, CResultSet &rs2, unsigned Seed) const
+{
+ CRandom<unsigned> rnd(Seed);
+ for (int i = 0; i < GetGames(); i++)
+ {
+  if (rnd.NewValue() & 1)
+   rs1.Append(GetWhite(i), GetBlack(i), GetResult(i));
+  else
+   rs2.Append(GetWhite(i), GetBlack(i), GetResult(i));
+ }
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Connect (return the new number of Player)
+/////////////////////////////////////////////////////////////////////////////
+int CResultSet::Connect(unsigned Player,
+                        int ForbiddenResult,
+                        std::vector<std::string> &vecName)
+{
+ if (Player >= GetPlayers())
+  return Player;
+
+ std::vector<int> vConnected(GetPlayers());
+ std::fill(vConnected.begin(), vConnected.end(), 0);
+
+ //
+ // Loop to find connected players
+ //
+ vConnected[Player] = 1;
+ while(1)
+ {
+  int Additions = 0;
+
+  for (int i = GetGames(); --i >= 0;)
+   if (vConnected[GetWhite(i)] == 1 &&
+       vConnected[GetBlack(i)] == 0 &&
+       GetResult(i) != ForbiddenResult)
+   {
+    vConnected[GetBlack(i)] = 1;
+    Additions++;
+   }
+   else if (vConnected[GetWhite(i)] == 0 &&
+            vConnected[GetBlack(i)] == 1 &&
+            GetResult(i) != 2 - ForbiddenResult)
+   {
+    vConnected[GetWhite(i)] = 1;
+    Additions++;
+   }
+
+  if (Additions == 0)
+   break;
+ }
+
+ //
+ // Compute translation of player numbers
+ //
+ std::vector<int> vTranslation(GetPlayers());
+ std::vector<int> vReverseTranslation(GetPlayers());
+
+ int Players = 0;
+ for (unsigned i = 0; i < GetPlayers(); i++)
+ {
+  vTranslation[i] = Players;
+  vReverseTranslation[Players] = i;
+  Players += vConnected[i];
+ }
+
+ //
+ // Build new vector of player names
+ //
+ std::vector<std::string> vecNewName(Players);
+ for (int i = Players; --i >= 0;)
+  vecNewName[i] = vecName[vReverseTranslation[i]];
+ vecName = vecNewName;
+
+ //
+ // Build new set of results
+ //
+ CResultSet rsNew;
+ for (int i = 0; i < GetGames(); i++)
+  if (vConnected[GetWhite(i)] && vConnected[GetBlack(i)])
+   rsNew.Append(vTranslation[GetWhite(i)],
+                vTranslation[GetBlack(i)],
+                GetResult(i));
+ *this = rsNew;
+
+ return vTranslation[Player];
+}

data/ext/bayeselo/CResultSet.h

@@ -0,0 +1,50 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// R�mi Coulom
+//
+// December, 2004
+//
+/////////////////////////////////////////////////////////////////////////////
+#ifndef CResultSet_Declared
+#define CResultSet_Declared
+
+#include <vector>
+#include <string>
+
+class CResultSet // rs
+{
+ private: //////////////////////////////////////////////////////////////////
+  std::vector<unsigned> vWhite;
+  std::vector<unsigned> vBlack;
+  std::vector<unsigned> vResult;
+
+  unsigned Players;
+
+ public: ///////////////////////////////////////////////////////////////////
+  CResultSet(): Players(0) {}
+  CResultSet(const CResultSet &rs, int Player);
+  CResultSet(const CResultSet &rs, int Player1, int Player2);
+
+  unsigned GetPlayers() const {return Players;}
+  int GetGames() const {return vResult.size();}
+  int CountGames(unsigned Player) const;
+
+  int GetWhite(int i) const {return vWhite[i];}
+  int GetBlack(int i) const {return vBlack[i];}
+  int GetResult(int i) const {return vResult[i];}
+
+  void Reset();
+  void Append(unsigned w, unsigned b, unsigned r);
+  void RemoveGame(int Index);
+  void RemovePlayer(unsigned Player);
+  void RemoveRarePlayers(int Threshold);
+
+  void PackPlayers(std::vector<std::string> &vName);
+
+  void Extract(CResultSet &rs1, CResultSet &rs2, unsigned Seed) const;
+  int Connect(unsigned Player,
+              int ForbiddenResult,
+              std::vector<std::string> &vecName);
+};
+
+#endif

data/ext/bayeselo/CResultSetCUI.cpp

@@ -0,0 +1,355 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Remi Coulom
+//
+// December, 2004
+//
+////////////////////////////////////////////////////////////////////////////
+#include "CResultSetCUI.h"
+#include "CResultSet.h"
+#include "CCondensedResults.h"
+#include "CEloRatingCUI.h"
+#include "EloDataFromFile.h"
+#include "pgnlex.h"
+#include "pgn.h"
+#include "debug.h"
+
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <algorithm>
+#include <fstream>
+
+////////////////////////////////////////////////////////////////////////////
+// Constructor
+////////////////////////////////////////////////////////////////////////////
+CResultSetCUI::CResultSetCUI(CResultSet &rsInit,
+                             std::vector<std::string> &vecNameInit,
+                             CConsoleUI *pcui,
+                             int openmode) :
+ CConsoleUI(pcui, openmode),
+ rs(rsInit),
+ vecName(vecNameInit)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Local prompt
+////////////////////////////////////////////////////////////////////////////
+void CResultSetCUI::PrintLocalPrompt(std::ostream &out)
+{
+ out << "ResultSet";
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Command strings
+////////////////////////////////////////////////////////////////////////////
+const char * const CResultSetCUI::tszCommands[] =
+{
+ "?",
+ "players",
+ "names",
+ "results",
+ "pgn",
+ "reset",
+ "addplayer",
+ "addresult",
+ "removeresult",
+ "removeplayer",
+ "removerare",
+ "pack",
+ "readpgn",
+ "gen",
+ "connect",
+ "elo",
+ 0
+};
+
+////////////////////////////////////////////////////////////////////////////
+// Compute player width
+////////////////////////////////////////////////////////////////////////////
+unsigned CResultSetCUI::ComputePlayerWidth() const
+{
+ unsigned Result = 14;
+ for (int i = vecName.size(); --i >= 0;)
+  if (vecName[i].size() > Result)
+   Result = vecName[i].length();
+ return Result;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Process commands
+////////////////////////////////////////////////////////////////////////////
+int CResultSetCUI::ProcessCommand(const char *pszCommand,
+                                  const char *pszParameters,
+                                  std::istream &in,
+                                  std::ostream &out)
+{
+ enum
+ {
+  IDC_Help,
+  IDC_Players,
+  IDC_Names,
+  IDC_Results,
+  IDC_PGN,
+  IDC_Reset,
+  IDC_AddPlayer,
+  IDC_AddResult,
+  IDC_RemoveResult,
+  IDC_RemovePlayer,
+  IDC_RemoveRare,
+  IDC_Pack,
+  IDC_ReadPGN,
+  IDC_Gen,
+  IDC_Connect,
+  IDC_Elo
+ };
+
+ switch (ArrayLookup(pszCommand, tszCommands))
+ {
+  case IDC_Help: ///////////////////////////////////////////////////////////
+   CConsoleUI::ProcessCommand(pszCommand, pszParameters, in, out);
+   out << "ResultSet commands\n";
+   out << "~~~~~~~~~~~~~~~~~~\n";
+   out << "players ......... list players\n";
+   out << "names ........... alphabetical list of player names\n";
+   out << "results ......... list game results\n";
+   out << "pgn ............. write results in PGN format\n";
+   out << '\n';
+   out << "reset ........... reset results and players\n";
+   out << "addplayer <pn> .. add one player with name <pn>\n";
+   out << "addresult w b r . add result (w = white, b = black, r = result)\n";
+   out << "                   r = 0 (b wins), 1 (draw), or 2 (w wins)\n";
+   out << "removeresult n .. remove result number\n";
+   out << "removeplayer n .. remove games of player n\n";
+   out << "removerare n .... remove games of players with less than n games\n";
+   out << "pack ............ pack players (remove players with 0 games)\n";
+   out << "readpgn <file>... read PGN file\n";
+   out << "connect [p] [fr]  remove players not connected to p [fr=forbidden result]\n";
+   out << '\n';
+   out << "elo ............. open Elo-estimation interface\n";
+   out << '\n';
+  break;
+
+  case IDC_Players: ////////////////////////////////////////////////////////
+  {
+   CCondensedResults crs(rs);
+   std::ios::fmtflags f = out.flags();
+   int PlayerWidth = ComputePlayerWidth();
+
+   out.setf(std::ios::right, std::ios::adjustfield);
+   out << std::setw(4) << "Num." << ' ';
+   out.setf(std::ios::left, std::ios::adjustfield);
+   out << std::setw(PlayerWidth) << "Name" << ' ';
+   out.setf(std::ios::right, std::ios::adjustfield);
+   out << std::setw(6) << "games" << ' ';
+   out << std::setw(7) << "score" << ' ';
+   out << '\n';
+
+   for (unsigned i = 0; i < vecName.size(); i++)
+   {
+    out.setf(std::ios::right, std::ios::adjustfield);
+    out << std::setw(4) << i << ' ';
+    out.setf(std::ios::left, std::ios::adjustfield);
+    out << std::setw(PlayerWidth) << vecName[i] << ' ';
+    out.setf(std::ios::right, std::ios::adjustfield);
+    if (i < unsigned(crs.GetPlayers()))
+    {
+     out << std::setw(6) << crs.CountGames(i) << ' ';
+     out << std::setw(7) << double(crs.Score(i)) / 2 << ' ';
+    }
+    else
+    {
+     out << std::setw(6) << 0 << ' ';
+     out << std::setw(7) << 0 << ' ';
+    }
+    out << '\n';
+   }
+
+   out.flags(f);
+  }
+  break;
+
+  case IDC_Names: //////////////////////////////////////////////////////////
+  {
+   std::vector<std::string> vecSorted = vecName;
+   std::sort(vecSorted.begin(), vecSorted.end());
+   for (unsigned i = 0; i < vecSorted.size(); i++)
+    out << vecSorted[i] << '\n';
+  }
+  break;
+
+  case IDC_Results: ////////////////////////////////////////////////////////
+  {
+   std::ios::fmtflags f = out.flags();
+   int PlayerWidth = ComputePlayerWidth();
+
+   out.setf(std::ios::right, std::ios::adjustfield);
+   out << std::setw(6) << "Game";
+   out << std::setw(6) << "White";
+   out.setf(std::ios::left, std::ios::adjustfield);
+   out << std::setw(PlayerWidth + 1) << " Name of White";
+   out.setf(std::ios::right, std::ios::adjustfield);
+   out << std::setw(6) << "Black";
+   out.setf(std::ios::left, std::ios::adjustfield);
+   out << std::setw(PlayerWidth + 1) << " Name of Black";
+   out.setf(std::ios::right, std::ios::adjustfield);
+   out << std::setw(7) << "Result";
+   out << '\n';
+   for (int i = 0; i < rs.GetGames(); i++)
+   {
+    out.setf(std::ios::right, std::ios::adjustfield);
+    out << std::setw(6) << i;
+    out << std::setw(6) << rs.GetWhite(i);
+    out.setf(std::ios::left, std::ios::adjustfield);
+    out << ' ' << std::setw(PlayerWidth) << vecName[rs.GetWhite(i)];
+    out.setf(std::ios::right, std::ios::adjustfield);
+    out << std::setw(6) << rs.GetBlack(i);
+    out.setf(std::ios::left, std::ios::adjustfield);
+    out << ' ' << std::setw(PlayerWidth) << vecName[rs.GetBlack(i)];
+    out.setf(std::ios::right, std::ios::adjustfield);
+    out << std::setw(7);
+    switch(rs.GetResult(i))
+    {
+     case 0: out << "0-1"; break;
+     case 1: out << "1/2"; break;
+     case 2: out << "1-0"; break;
+     case 3: out << " * "; break;
+    }
+    out << '\n';
+   }
+
+   out.flags(f);
+  }
+  break;
+
+  case IDC_PGN: ////////////////////////////////////////////////////////////
+  {
+   for (int i = 0; i < rs.GetGames(); i++)
+   {
+    CPGN::WriteTag(CPGN::TAG_White, vecName[rs.GetWhite(i)].c_str(), out);
+    CPGN::WriteTag(CPGN::TAG_Black, vecName[rs.GetBlack(i)].c_str(), out);
+    CPGN::WriteTag(CPGN::TAG_Result, CPGN::tszResult[rs.GetResult(i)], out);
+    out << CPGN::tszResult[rs.GetResult(i)] << "\n\n";
+   }
+  }
+  break;
+
+  case IDC_Reset: //////////////////////////////////////////////////////////
+   rs.Reset();
+   vecName.clear();
+  break;
+
+  case IDC_AddPlayer: //////////////////////////////////////////////////////
+   vecName.push_back(pszParameters);
+  break;
+
+  case IDC_AddResult: //////////////////////////////////////////////////////
+  {
+   unsigned White = 0;
+   unsigned Black = 0;
+   unsigned Result = 0;
+   std::istringstream(pszParameters) >> White >> Black >> Result;
+   if (White < vecName.size() && Black < vecName.size())
+    if (Result <= 2)
+     rs.Append(White, Black, Result);
+    else
+     out << "Error: no such result\n";
+   else
+    out << "Error: no such player\n";
+  }
+  break;
+
+  case IDC_RemoveResult: ///////////////////////////////////////////////////
+  {
+   int n = -1;
+   std::istringstream(pszParameters) >> n;
+   if (n >= 0 && n < rs.GetGames())
+    rs.RemoveGame(n);
+   else
+    out << "error: bad result number\n";
+  }
+  break;
+
+  case IDC_RemovePlayer: ///////////////////////////////////////////////////
+  {
+   int n = -1;
+   std::istringstream(pszParameters) >> n;
+   if (n >= 0)
+    rs.RemovePlayer(n);
+  }
+  break;
+
+  case IDC_RemoveRare: /////////////////////////////////////////////////////
+  {
+   int n = -1;
+   std::istringstream(pszParameters) >> n;
+   rs.RemoveRarePlayers(n);
+  }
+  break;
+
+  case IDC_Pack: ///////////////////////////////////////////////////////////
+   rs.PackPlayers(vecName);
+  break;
+
+  case IDC_ReadPGN: ////////////////////////////////////////////////////////
+  {
+   std::ifstream ifs(pszParameters);
+   CPGNLex pgnlex(ifs);
+   EloDataFromFile(pgnlex, rs, vecName);
+  }
+  break;
+
+  case IDC_Gen: ////////////////////////////////////////////////////////////
+  {
+   int Games = 0;
+   std::vector<double> velo;
+   std::istringstream is(pszParameters);
+   is >> Games;
+   out << Games << " games\n";
+   while(!is.eof())
+   {
+    double elo = 0;
+    is >> elo;
+    velo.push_back(elo);
+    out << elo << ' ';
+   }
+   out << '\n';
+
+   rs.Reset();
+   vecName.clear();
+   vecName.push_back("player 1");
+   vecName.push_back("player 2");
+   for (int i = 1000; --i >= 0;)
+   {
+    rs.Append(0, 1, 2);
+    rs.Append(1, 0, 1);
+   }
+  }
+  break;
+
+  case IDC_Connect: ////////////////////////////////////////////////////////
+  {
+   int Player = 0;
+   int ForbiddenResult = 3;
+   std::istringstream(pszParameters) >> Player >> ForbiddenResult;
+   int NewPlayer = rs.Connect(Player, ForbiddenResult, vecName);
+   out << rs.GetPlayers() << " players left\n";
+   if (NewPlayer != Player)
+    out << "Player " << Player << " is now " << NewPlayer << '\n';
+  }
+  break;
+
+  case IDC_Elo: ////////////////////////////////////////////////////////////
+  {
+   CEloRatingCUI ercui(rs, vecName, this);
+   ercui.MainLoop(in, out);
+  }
+  break;
+
+  default: /////////////////////////////////////////////////////////////////
+   return CConsoleUI::ProcessCommand(pszCommand, pszParameters, in, out);
+ }
+
+ return PC_Continue;
+}