elo-ratings 0.0.0

data/ext/bayeselo/pgnstr.cpp

@@ -0,0 +1,126 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// pgnstr.cpp
+//
+// PGN input/output functions
+//
+// Remi Coulom
+//
+// August, 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#include <iostream>
+#include <sstream>
+#include <cstring>
+
+#include "pgn.h"
+#include "str.h"      // CSTR
+#include "date.h"     // CDate
+#include "player.h"   // CPlayer
+#include "pgnlex.h"   // CPGNLex
+
+//
+// Tag identifiers
+//
+const char * const CPGN::tszTag[] =
+{
+ "Event",
+ "Site",
+ "Date",
+ "Round",
+ "White",
+ "Black",
+ "Result",
+ "SetUp",
+ "FEN"
+};
+
+//
+// Result strings (CSTR for the enumeration)
+//
+const char * const CPGN::tszResult[] = {"0-1", "1/2-1/2", "1-0", "*"};
+
+////////////////////////////////////////////////////////////////////////////
+// WriteString
+////////////////////////////////////////////////////////////////////////////
+static void WriteString(const char *psz, std::ostream &ostr)
+{
+ ostr << '"';
+ for(; *psz; psz++)
+  if (*psz == '"' || *psz == '\\')
+   ostr << '\\' << *psz;
+  else
+   ostr << *psz;
+ ostr << '"';
+}
+
+////////////////////////////////////////////////////////////////////////////
+// WriteTag
+////////////////////////////////////////////////////////////////////////////
+void CPGN::WriteTag(int Tag, const char *psz, std::ostream &ostr)
+{
+ ostr << '[' << tszTag[Tag] << ' ';
+ WriteString(psz, ostr);
+ ostr << "]\n";
+}
+
+////////////////////////////////////////////////////////////////////////////
+// ReadTAG
+////////////////////////////////////////////////////////////////////////////
+static int ReadTAG(CPGNLex &pgnlex)
+{
+ int i;
+
+ if (pgnlex.WaitForToken(CPGNLex::TOK_Symbol))
+  return CPGN::TAGs;
+
+ for (i = CPGN::TAGs; --i >= 0;)
+  if (!strcmp(pgnlex.TokenString(), CPGN::tszTag[i]))
+   break;
+
+ if (pgnlex.WaitForToken(CPGNLex::TOK_TagClose))
+  return CPGN::TAGs;
+
+ return i;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// ReadSTR
+////////////////////////////////////////////////////////////////////////////
+int CPGN::ReadSTR(CSTR &str, CPGNLex &pgnlex)
+{
+ if (pgnlex.WaitForToken(CPGNLex::TOK_TagOpen))
+  return 1;
+
+ int TAGS = 0;
+ do
+ {
+  TAGS++;
+  switch (ReadTAG(pgnlex))
+  {
+   case TAG_Event: str.SetEvent(pgnlex.TokenString()); break;
+   case TAG_Site:  str.SetSite(pgnlex.TokenString());  break;
+   case TAG_Date:  str.SetDate(pgnlex.TokenString());  break;
+   case TAG_Round: str.SetRound(pgnlex.TokenString()); break;
+   case TAG_White: str.SetWhite(pgnlex.TokenString()); break;
+   case TAG_Black: str.SetBlack(pgnlex.TokenString()); break;
+   case TAG_Result:
+   {
+    int j;
+
+    for (j = CSTR::Results; --j >= 0;)
+     if (!strcmp(pgnlex.TokenString(), tszResult[j]))
+      break;
+
+    if (j >= 0)
+     str.SetResult(j);
+   }
+   break;
+   default:
+    TAGS--;
+  }
+ }
+ while (pgnlex.ReadNextToken() == CPGNLex::TOK_TagOpen && TAGS < 7);
+
+ return 0;
+}

data/ext/bayeselo/piece.h

@@ -0,0 +1,44 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// piece.h
+//
+// CPiece class definition
+//
+// Remi Coulom
+//
+// june 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef PIECE_H
+#define PIECE_H
+
+class CPiece // piece
+{
+ private: //////////////////////////////////////////////////////////////////
+  int piece;
+  static char tcPiece[];
+
+ public: ///////////////////////////////////////////////////////////////////
+  enum
+  {
+   King   = 0x00,
+   Queen  = 0x01,
+   Rook   = 0x02,
+   Bishop = 0x04,
+   Knight = 0x06,
+   Pawn   = 0x08,
+   Black  = 0x10,
+   Undef  = 0x20,
+   Empty  = 0xff
+  };
+
+  CPiece(int pieceValue) {piece = pieceValue;};
+  CPiece(const char *pcPiece);
+  
+  operator int() const {return piece;};
+  int GetNature() const {return piece & 0x0f;};
+  int GetColor() const {return (piece & 0x30) >> 4;};
+  char GetChar() const;
+};
+
+#endif

data/ext/bayeselo/player.h

@@ -0,0 +1,31 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// player.h
+//
+// CPlayer class definition
+//
+// Remi Coulom
+//
+// june 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef PLAYER_H
+#define PLAYER_H
+
+class CPlayer // player
+{
+ private: //////////////////////////////////////////////////////////////////
+  int player;
+
+ public: ///////////////////////////////////////////////////////////////////
+  enum
+  {
+   White = 0,
+   Black = 1
+  };
+
+  CPlayer(int i) {player = i;}
+  int Opponent() const {return player ^ Black;}
+};
+
+#endif

data/ext/bayeselo/position.h

@@ -0,0 +1,89 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// position.h
+//
+// CPosition class definition
+//
+// Remi Coulom
+//
+// june 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef POSITION_H
+#define POSITION_H
+
+class CMove;
+class CHashCodeComputer;
+
+class CPosition // pos
+{
+ private: //////////////////////////////////////////////////////////////////
+  static CHashCodeComputer hcc;
+
+  unsigned char tpiece[64];
+  unsigned char player;
+  char fBlackOO;
+  char fWhiteOO;
+  char fBlackOOO;
+  char fWhiteOOO;
+  unsigned char sqEnPassant;
+  int nhmReversible;
+  int nm;
+
+  int IsAttackedDir(int sqFrom, int piece1, int piece2, int DirFlag) const;
+
+ public: ///////////////////////////////////////////////////////////////////
+  //
+  // Default constructor to prevent uninitialized data
+  //
+  CPosition();
+  
+  //
+  // Test for equality
+  //
+  int operator==(const CPosition &pos) const;
+  int operator!=(const CPosition &pos) const {return !operator==(pos);}
+
+  //
+  // Gets
+  //
+  int GetPiece(int sq) const {return tpiece[sq];}
+  int GetPlayer() const {return player;}
+  int GetOpponent() const {return player ^ 1;}
+  int GetBlackOO() const {return fBlackOO;}
+  int GetWhiteOO() const {return fWhiteOO;}
+  int GetBlackOOO() const {return fBlackOOO;}
+  int GetWhiteOOO() const {return fWhiteOOO;}
+  int GetEnPassant() const {return sqEnPassant;}
+  int GetReversible() const {return nhmReversible;}
+  int GetMoves() const {return nm;}
+
+  int IsAttacked(int sq, int player) const;
+  int Check() const;
+  int IsLegal() const;
+  void Symmetrical(CPosition &pos) const;
+
+  //
+  // Sets
+  //
+  void SetPiece(int sq, int piece) {tpiece[sq] = piece;}
+  void SetPlayer(int playerNew) {player = playerNew;}
+  void SetBlackOO(int f) {fBlackOO = f;}
+  void SetWhiteOO(int f) {fWhiteOO = f;}
+  void SetBlackOOO(int f) {fBlackOOO = f;}
+  void SetWhiteOOO(int f) {fWhiteOOO = f;}
+  void SetEnPassant(int sq) {sqEnPassant = sq;}
+  void SetReversible(int nhm) {nhmReversible = nhm;}
+  void SetMoves(int nmNew) {nm = nmNew;}
+
+  void Reset();
+  void Clear();
+  void PlayMove(CMove move);
+
+  //
+  // Access to the hashcode computer
+  //
+  static const CHashCodeComputer &GetHashCodeComputer() {return hcc;}
+};
+
+#endif

data/ext/bayeselo/random.cpp

@@ -0,0 +1,114 @@
+// ////////////////////////////////////////////////////////////////////////////
+// //
+// // random.cpp
+// //
+// // CRandom class
+// //
+// // Remi Coulom
+// //
+// // August 1996
+// //
+// ////////////////////////////////////////////////////////////////////////////
+// #include <cmath>
+// 
+// ////////////////////////////////////////////////////////////////////////////
+// // New seed
+// ////////////////////////////////////////////////////////////////////////////
+// template<class TYPE>
+// void CRandom<TYPE>::Seed(TYPE ulSeed)
+// {
+//  Index1 = 23;
+//  Index2 = 54;
+//  fNextGaussian = 0;
+// 
+//  //
+//  // The array is initialized with random values
+//  //
+//  {
+//   for (int i = 55; --i >= 0;)
+//    tulArray[i] = ulSeed = (ulSeed * 7) + 123456789L;
+//  }
+// 
+//  //
+//  // These are scrambled a little
+//  //
+//  {
+//   for (int i = 200; --i >= 0;)
+//    NewValue();
+//  }
+// }
+// 
+// ////////////////////////////////////////////////////////////////////////////
+// // Next double (??? very bad)
+// ////////////////////////////////////////////////////////////////////////////
+// template<class TYPE>
+// double CRandom<TYPE>::NextDouble()
+// {
+//  return double(NewValue() & 0x7fffffff) / double(1U << 31);
+// }
+// 
+// ////////////////////////////////////////////////////////////////////////////
+// // Next N(0,1)
+// ////////////////////////////////////////////////////////////////////////////
+// template<class TYPE>
+// double CRandom<TYPE>::NextGaussian()
+// {
+//  if (fNextGaussian)
+//  {
+//   fNextGaussian = 0;
+//   return NextGaussianValue;
+//  }
+//  else
+//  {
+//   fNextGaussian = 1;
+//   double x, y, n2;
+//   do
+//   {
+//    x = 2 * NextDouble() - 1;
+//    y = 2 * NextDouble() - 1;
+//    n2 = x * x + y * y;
+//   }
+//   while (n2 >= 1 || n2 == 0);
+//   double m = std::sqrt(-2 * std::log(n2) / n2);
+//   NextGaussianValue = y * m;
+//   return x * m;
+//  }
+// }
+// 
+// ////////////////////////////////////////////////////////////////////////////
+// // Exponential law
+// ////////////////////////////////////////////////////////////////////////////
+// template<class TYPE>
+// double CRandom<TYPE>::NextExponential()
+// {
+//  double x;
+//  do
+//   x = NextDouble();
+//  while (x == 0);
+//  return -std::log(x);
+// }
+// 
+// ////////////////////////////////////////////////////////////////////////////
+// // Binary I/O
+// ////////////////////////////////////////////////////////////////////////////
+// #include <iostream>
+// 
+// template<class TYPE>
+// void CRandom<TYPE>::BinaryWrite(std::ostream &out) const
+// {
+//  out.write((const char *)&Index1, sizeof(Index1));
+//  out.write((const char *)&Index2, sizeof(Index2));
+//  out.write((const char *)tulArray, sizeof(tulArray));
+//  out.write((const char *)&fNextGaussian, sizeof(fNextGaussian));
+//  out.write((const char *)&NextGaussianValue, sizeof(NextGaussianValue));
+// }
+// 
+// template<class TYPE>
+// void CRandom<TYPE>::BinaryRead(std::istream &in)
+// {
+//  in.read((char *)&Index1, sizeof(Index1));
+//  in.read((char *)&Index2, sizeof(Index2));
+//  in.read((char *)tulArray, sizeof(tulArray));
+//  in.read((char *)&fNextGaussian, sizeof(fNextGaussian));
+//  in.read((char *)&NextGaussianValue, sizeof(NextGaussianValue));
+// }

data/ext/bayeselo/random.h

@@ -0,0 +1,63 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// random.h
+//
+// CRandom class declaration
+// (Algorithm from "The Art Of Computer Programming")
+//
+// Remi Coulom
+//
+// August 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef RANDOM_H
+#define RANDOM_H
+
+#include <iosfwd>
+
+template<class TYPE>
+class CRandom // rnd
+{
+ private: //////////////////////////////////////////////////////////////////
+  int Index1;
+  int Index2;
+  TYPE tulArray[55];
+
+  int fNextGaussian;
+  double NextGaussianValue;
+
+ public: ///////////////////////////////////////////////////////////////////
+  CRandom(TYPE n = 0) : fNextGaussian(0) {Seed(n);}
+
+  //
+  // Seed
+  //
+  void Seed(TYPE ulSeed);
+
+  //
+  // Random number generation
+  //
+  TYPE NewValue()
+  {
+   if (--Index1 < 0)
+    Index1 = 54;
+
+   if (--Index2 < 0)
+    Index2 = 54;
+
+   return tulArray[Index2] += tulArray[Index1];
+  }
+  double NextDouble();
+  double NextGaussian();
+  double NextExponential();
+
+  //
+  // Binary I/O
+  //
+  void BinaryWrite(std::ostream &out) const;
+  void BinaryRead(std::istream &in);
+};
+
+#include "random.cpp"
+
+#endif