elo-ratings 0.0.0

data/ext/bayeselo/rb_bayeselo.cpp

@@ -0,0 +1,76 @@
+// #include <ruby.h>
+#include "rice/Class.hpp"
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+#include "CBradleyTerry.h"
+#include "CCondensedResults.h"
+#include "CCDistribution.h"
+#include "CResultSet.h"
+
+
+using namespace Rice;
+
+class CBayeselo
+{
+    public:
+        CBayeselo();
+        void Append(unsigned w, unsigned b, unsigned r);
+        int GetPlayers();
+        int GetElo(int i);
+        float CountGames(int i);
+    private:
+        CResultSet rs;
+};
+
+CBayeselo::CBayeselo()
+{
+}
+
+void CBayeselo::Append(unsigned w, unsigned b, unsigned r) {
+    rs.Append(w, b, r);
+}
+
+int CBayeselo::GetPlayers() {
+    return rs.GetPlayers();
+}
+
+
+int CBayeselo::GetElo(int i) {
+    CCondensedResults crs(rs);
+    crs.AddPrior(2.0); // CEloRating constructor
+    CBradleyTerry bt(crs);
+    
+    //IDC_MM
+    int fThetaW = 0;
+    int fThetaD = 0;
+    bt.MinorizationMaximization(fThetaW, fThetaD);
+    
+    // advantage 0
+    int eloAdvantage = 0;
+    bt.SetAdvantage(eloAdvantage);
+    
+    // RoundDouble(double x)
+    double x = bt.GetElo(i);
+    if (x > 0)
+     return int(x+0.5);
+    else
+     return int(x-0.5);
+}
+
+float CBayeselo::CountGames(int i) {
+    return rs.CountGames(i);
+}
+
+extern "C"
+void Init_bayeselo()
+{
+    Rice::Module mBayeselo = define_module("Bayeselo");
+    
+    Data_Type<CBayeselo> c_bayeselo =
+            define_class_under<CBayeselo>(mBayeselo, "CBayeselo")
+            .define_constructor(Constructor<CBayeselo>())
+            .define_method("get_players", &CBayeselo::GetPlayers)
+            .define_method("append", &CBayeselo::Append)
+            .define_method("get_elo", &CBayeselo::GetElo)
+            .define_method("count_games", &CBayeselo::CountGames);
+}

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/bayeselo.rb

@@ -0,0 +1,6 @@
+Dir[File.dirname(__FILE__) + '/bayeselo/*.rb'].each {|file| require file }
+
+require File.dirname(__FILE__) + '/../ext/bayeselo/bayeselo'
+
+module Bayeselo
+end

data/lib/bayeselo/bayeselo.rb

@@ -0,0 +1,11 @@
+class Bayeselo
+  def initialize
+    @c_bayeselo = CBayeselo.new
+    @players = []
+  end
+  
+  def add_game players={}
+    players[:winner]
+    players[:loser]
+  end
+end