all-up-in-your-elo 0.0.2

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

data/ext/bayeselo/readstr.cpp

@@ -0,0 +1,51 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// readstr.cpp
+//
+// ReadString function
+//
+// Remi Coulom
+//
+// june, 1998
+//
+////////////////////////////////////////////////////////////////////////////
+#include <iostream>
+
+using namespace std;
+
+#include "readstr.h"
+
+////////////////////////////////////////////////////////////////////////////
+// Function : Reads a string from a stream
+// Return   : Length of the string read, -1 if EOF
+////////////////////////////////////////////////////////////////////////////
+int ReadString(istream &is, char *pszBuffer, int Size)
+{
+ int i;
+
+ if (is.eof())
+  return -1;
+
+ for(i = 0; i < Size; i++)
+ {
+  int c;
+  c = is.peek();
+
+  if (c == std::char_traits<char>::eof() || is.fail())
+  {
+   pszBuffer[i] = 0;
+   return -1;
+  }
+
+  is.get();
+  if (c == '\n')
+  {
+   pszBuffer[i] = 0;
+   return i;
+  }
+  else
+   pszBuffer[i] = c;
+ }
+
+ return i;
+}

data/ext/bayeselo/readstr.h

@@ -0,0 +1,19 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// readstr.h
+//
+// ReadString function
+//
+// Remi Coulom
+//
+// june, 1998
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef READSTR_H
+#define READSTR_H
+
+#include <iostream>
+
+int ReadString(std::istream &is, char *pszBuffer, int Size);
+
+#endif

data/ext/bayeselo/square.h

@@ -0,0 +1,61 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// square.h
+//
+// CSquare class definition
+//
+// Remi Coulom
+//
+// june 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef SQUARE_H
+#define SQUARE_H
+
+class CSquare // sq
+{
+ private: //////////////////////////////////////////////////////////////////
+  int sq;
+
+ public: ///////////////////////////////////////////////////////////////////
+  enum
+  {
+   a1, b1, c1, d1, e1, f1, g1, h1,
+   a2, b2, c2, d2, e2, f2, g2, h2,
+   a3, b3, c3, d3, e3, f3, g3, h3,
+   a4, b4, c4, d4, e4, f4, g4, h4,
+   a5, b5, c5, d5, e5, f5, g5, h5,
+   a6, b6, c6, d6, e6, f6, g6, h6,
+   a7, b7, c7, d7, e7, f7, g7, h7,
+   a8, b8, c8, d8, e8, f8, g8, h8
+  };
+
+  enum
+  {
+   Left  = -1,
+   Right = +1,
+   Up    = +8,
+   Down  = -8
+  };
+
+  CSquare() {}
+  CSquare(int i) {sq = i;}
+  CSquare(const char *psz) {sq = psz[0] - 'a' + 8 * (psz[1] - '1');}
+                
+  operator int() const {return sq;}
+  const CSquare &operator +=(int i) {sq += i; return *this;}
+  const CSquare &operator -=(int i) {sq -= i; return *this;}
+  const CSquare &operator ++() {sq++; return *this;}
+
+  int GetRank() const {return sq / 8;}
+  int GetFile() const {return sq % 8;}
+  int IsWhite() const {return ((sq / 8) + (sq % 8)) & 1;}
+  void MakeString(char *psz)
+  {
+   psz[0] = 'a' + GetFile();
+   psz[1] = '1' + GetRank();
+   psz[2] = 0;
+  }
+};
+
+#endif

data/ext/bayeselo/str.cpp

@@ -0,0 +1,81 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// str.cpp
+//
+// CSTR class
+// (Seven Tag Roster)
+//
+// Remi Coulom
+//
+// june 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#include <cstring>
+
+#include "debug.h"
+#include "str.h"
+
+////////////////////////////////////////////////////////////////////////////
+// Safe copy of a string to another string with limited size
+////////////////////////////////////////////////////////////////////////////
+static void SafeCopy(char *pszDest, const char *pszOrig, int Size)
+{
+ strncpy(pszDest, pszOrig, Size);
+ pszDest[Size - 1] = 0;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Default constructor
+////////////////////////////////////////////////////////////////////////////
+CSTR::CSTR()
+{
+ Reset();
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Reset function
+////////////////////////////////////////////////////////////////////////////
+void CSTR::Reset()
+{
+ *szEvent = 0;
+ *szSite  = 0;
+ *szRound = 0;
+ *szWhite = 0;
+ *szBlack = 0;
+ Result   = Unknown;
+ date = CDate::Today();
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Functions to set strings
+////////////////////////////////////////////////////////////////////////////
+void CSTR::SetEvent(const char *psz)
+{
+ SafeCopy(szEvent, psz, sizeof szEvent);
+}
+
+void CSTR::SetSite(const char *psz)
+{
+ SafeCopy(szSite, psz, sizeof szSite);
+}
+
+void CSTR::SetRound(const char *psz)
+{
+ SafeCopy(szRound, psz, sizeof szRound);
+}
+
+void CSTR::SetWhite(const char *psz)
+{
+ SafeCopy(szWhite, psz, sizeof szWhite);
+}
+
+void CSTR::SetBlack(const char *psz)
+{
+ SafeCopy(szBlack, psz, sizeof szBlack);
+}
+
+void CSTR::SetResult(int i)
+{
+ ASSERT(i >= BlackWins && i <= Unknown);
+ Result = i;
+}

data/ext/bayeselo/str.h

@@ -0,0 +1,71 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// str.h
+//
+// CSTR class definition
+// (Seven Tag Roster)
+//
+// R�mi Coulom
+//
+// june 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef STR_H
+#define STR_H
+
+#include "date.h" // CDate
+
+class CSTR // str
+{
+ private: //////////////////////////////////////////////////////////////////
+  char szEvent[64];
+  char szSite[64];
+  CDate date;
+  char szRound[32];
+  char szWhite[64];
+  char szBlack[64];
+  int Result;
+
+ public: ///////////////////////////////////////////////////////////////////
+  //
+  // Possible Results
+  //
+  enum
+  {
+   BlackWins, // 0-1
+   Draw,      // 1/2-1/2
+   WhiteWins, // 1-0
+   Unknown,   // *
+   Results
+  };
+
+  //
+  // Default constructor, to prevent dangerous uninitialized data
+  //
+  CSTR();
+
+  //
+  // Sets
+  //
+  void Reset();
+  void SetResult(int i);
+  void SetDate(const CDate &dateNew) {date = dateNew;}
+  void SetEvent(const char *psz);
+  void SetSite(const char *psz);
+  void SetRound(const char *psz);
+  void SetWhite(const char *psz);
+  void SetBlack(const char *psz);
+
+  //
+  // Gets
+  //
+  int GetResult() const {return Result;}
+  const CDate &GetDate () const {return date;}
+  const char *GetEvent() const {return szEvent;}
+  const char *GetSite () const {return szSite;}
+  const char *GetRound() const {return szRound;}
+  const char *GetWhite() const {return szWhite;}
+  const char *GetBlack() const {return szBlack;}
+};
+
+#endif

data/ext/bayeselo/version.cpp

@@ -0,0 +1,30 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// version.cpp
+//
+// CVersion class
+//
+// Remi Coulom
+//
+// May, 1997
+//
+////////////////////////////////////////////////////////////////////////////
+#include "version.h"
+
+#include "version_number.h"
+
+const char CVersion::szVersion[] = VERSION;
+const char CVersion::szCopyright[] = 
+"version "VERSION", Copyright (C) 1997-2010 Remi Coulom.\n"
+"compiled "__DATE__" "__TIME__".\n"
+"This program comes with ABSOLUTELY NO WARRANTY.\n"
+"This is free software, and you are welcome to redistribute it\n"
+"under the terms and conditions of the GNU General Public License.\n"
+"See http://www.gnu.org/copyleft/gpl.html for details.\n";
+
+const char CVersion::szBinary[] = 
+"version "VERSION".\n"
+"Copyright 1997-2010 by Remi Coulom. All Rights Reserved.\n"
+"Permission is granted to freely use and distribute this program,\n"
+"provided that no charge is made for it and it is distributed unmodified\n"
+"This program comes with ABSOLUTELY NO WARRANTY.\n";

data/ext/bayeselo/version.h

@@ -0,0 +1,28 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// version.h
+//
+// CVersion class declaration
+//
+// Remi Coulom
+//
+// May, 1997
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef VERSION_H
+#define VERSION_H
+
+class CVersion
+{
+ private: //////////////////////////////////////////////////////////////////
+  static const char szVersion[];
+  static const char szCopyright[];
+  static const char szBinary[];
+  
+ public: ///////////////////////////////////////////////////////////////////
+  static const char *GetVersion() {return szVersion;}
+  static const char *GetCopyright() {return szCopyright;}
+  static const char *GetBinaryCopyright() {return szBinary;}
+};
+
+#endif

data/ext/bayeselo/version_number.h

@@ -0,0 +1 @@
+#define VERSION "0057"

data/lib/elo_ratings.rb

@@ -0,0 +1,9 @@
+Dir[File.dirname(__FILE__) + '/elo_ratings/*.rb'].each {|file| require file }
+
+require File.dirname(__FILE__) + '/../ext/bayeselo/elo_ratings'
+
+module EloRatings
+  Draw = 1
+  Player1Win = 2
+  Player2Win = 0
+end

data/lib/elo_ratings/c_bayeselo.rb

@@ -0,0 +1,5 @@
+module EloRatings
+  class CBayeselo
+    # methods provided by rb_bayeselo.cpp
+  end
+end

data/lib/elo_ratings/results.rb

@@ -0,0 +1,41 @@
+module EloRatings
+  class Results
+    def initialize
+      @c_bayeselo = CBayeselo.new
+      @players = []
+    end
+  
+    def add_game player_1, player_2, result
+      @c_bayeselo.append index_for!(player_1), index_for!(player_2), result
+    end
+    
+    def count_games_for player
+      return 0 if !exists? player
+      @c_bayeselo.count_games(index_for(player)).to_i
+    end
+    
+    def elo_for player
+      return nil if !exists? player
+      @c_bayeselo.get_elo index_for(player)
+    end
+    
+    protected
+    
+    def exists? player
+      !!index_for(player)
+    end
+    
+    def index_for player
+      @players.index player
+    end
+    
+    def index_for! player
+      index = index_for player
+      if index.nil?
+        index = @players.length
+        @players << player
+      end
+      index
+    end
+  end
+end