all-up-in-your-elo 0.0.2

data/ext/bayeselo/pgnlex.h

@@ -0,0 +1,105 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// pgnlex.h
+//
+// CPGNLex class definition
+// (PGN lexical analysis)
+//
+// Remi Coulom
+//
+// August 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef PGNLEX_H
+#define PGNLEX_H
+
+#include <iostream>
+
+class CPGNLex //pgnlex
+{
+ private: //////////////////////////////////////////////////////////////////
+  std::istream *pistr;
+
+  int CurrChar;
+  int Token;
+  int Value;
+  enum {MaxPGNLine = 1024}; 
+  char szString[MaxPGNLine];
+  enum {ContextSize = 40};
+  char szContextBuffer[ContextSize + 1];
+  int ContextIndex;
+
+  int NextChar();
+
+ public: ///////////////////////////////////////////////////////////////////
+  //
+  // Tokens
+  // Note : these tokens do not conform strictly with standard.txt
+  //
+  // DIGIT = [0-9]
+  // LETTER = [a-zA-Z]
+  // SYMBOLCONTINUATION = LETTER U DIGIT U {_} U {+} U {#} U {=} U {:} U {-}
+  //
+  enum
+  {
+   TOK_BOF,             //  Beginning Of File
+   TOK_EOF,             //  End Of File
+   TOK_String,          //s '"'(ALLCHARACTERS U '\\' U '\"' - '\' - '"')*'"'
+   TOK_Integer,         //n DIGIT+
+   TOK_Period,          //  '.'
+   TOK_GameTermination, //n '0-1' U '1/2-1/2' U '1-0' U '*'
+   TOK_TagOpen,         //  '['
+   TOK_TagClose,        //  ']'
+   TOK_RAVOpen,         //  '('
+   TOK_RAVClose,        //  ')'
+   TOK_ReservedOpen,    //  '<'
+   TOK_ReservedClose,   //  '>'
+   TOK_NAG,             //n '$'DIGIT* U '?' U '!' U '!?' U '?!' U '!!' U '??'
+   TOK_Symbol,          //s LETTER(SYMBOLCONTINUATION)*
+   TOK_Comment,         //s '{'(ALLCHARACTERS - '}')*'}'
+   TOKs
+  };
+
+  //
+  // Constructor
+  //
+  CPGNLex();
+  CPGNLex(std::istream &istr);
+  
+  //
+  // Function to reset the input stream
+  //
+  
+  // Sets the current token to TOK_BOF
+  void Reset();
+  // Changes the input stream
+  void Reset(std::istream &istr);  
+
+  //
+  // Functions to read tokens
+  //
+
+  // Function to move to the next token
+  int ReadNextToken();
+  
+  // Access to the current token type
+  int GetToken() const {return Token;}
+  
+  // Access to the current token value
+  // This value is set when TOK_Integer, TOK_GameTermination, TOK_NAG read
+  int TokenValue() const;
+  
+  // Access to the current token string
+  // This value is set when a TOK_String or TOK_Symbol is read
+  const char *TokenString() const;
+  
+  // returns 0 if the searched token is found, 1 if eof is reached
+  int WaitForToken(int Searched);
+
+  //
+  // Get context (useful to display error messages)
+  //
+  void PrintContext(std::ostream &out) const;
+};
+
+#endif

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));
+// }