elo4m 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b674afae937af9be30bd785e2599a8ae39cf5851
+  data.tar.gz: 15de3862089257038b5373a6eeeecc4fecae9f3e
+SHA512:
+  metadata.gz: 2b206cf3720564da2889244f32dc94ae6f51c8eb931c6f54ac629c267c4a831c338cf0fd1f67a55357f6190471d17876e8b24239e91606c6c53be6ab4a4ec19c
+  data.tar.gz: 7a5b3c4b7fa98a3c0b71a50979d8f9153c72e0c153f4a5c951680dbeaa4259419a5b13c9f017fe17c475142603bafd5db5f42a13827feff1b79d998359d032ac

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in elo4m.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Daiki Taniguchi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,68 @@
+# Elo4m
+
+### Elo for Multi Player Games
+
+From [Wikipedia](http://en.wikipedia.org/wiki/Elo_rating_system):
+
+The Elo rating system is a method for calculating the relative skill levels of
+players in two-player games such as chess and Go. It is named after its creator
+Arpad Elo, a Hungarian-born American physics professor.
+
+But Elo was designed for two player games.
+This is for multi player games.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'elo4m'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install elo4m
+
+## Usage
+
+```ruby
+# :rating => player's rating before game.
+# :rank => game result. if you win first prize, this is 1.
+# :new_rating => new rating applied elo raitng.
+
+players = [
+  Elo4m::Player.new(:rating, :rank),
+  Elo4m::Player.new(:rating, :rank)
+]
+game = Elo4m::Game.new(players)
+game.run
+  #=> [:new_rating, :new_rating]  
+```
+
+## Example
+
+```ruby
+players = [
+  Elo4m::Player.new(1613, 4),
+  Elo4m::Player.new(1609, 2),
+  Elo4m::Player.new(1477, 4),
+  Elo4m::Player.new(1388, 6),
+  Elo4m::Player.new(1586, 5),
+  Elo4m::Player.new(1720, 1)
+]
+game = Elo4m::Game.new(players)
+game.run
+  #=> [1601, 1646, 1499, 1350, 1533, 1762]  
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/kidach1/elo4m/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/elo4m.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'elo4m/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "elo4m"
+  spec.version       = Elo4m::VERSION
+  spec.authors       = ["kidach1"]
+  spec.email         = ["daiki.taniguchi@aktsk.jp"]
+  spec.summary       = %q{For calculating the relative skill levels of players in multi-player games.}
+  spec.description   = %q{For calculating the relative skill levels of players in multi-player games.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_dependency "gnuplot"
+end

data/lib/elo4m/configuration.rb

@@ -0,0 +1,50 @@
+module Elo4m
+  class Configuration
+    attr_accessor :default_k_factor
+    attr_accessor :default_rating
+
+    def initialize #:nodoc:
+      @default_rating     = 1000
+      @default_k_factor   = 15
+    end
+
+    # Add a K-factor rule. The first argument is the k-factor value.
+    # The block should return a boolean that determines if this K-factor rule applies.
+    # The first rule that applies is the one determining the K-factor.
+    #
+    # The block is instance_eval'ed into the player, so you can access all it's
+    # properties directly. The K-factor is recalculated every time a match is played.
+    #
+    # By default, the FIDE settings are used (see: +use_FIDE_settings+). To implement
+    # that yourself, you could write:
+    #
+    #   Elo.configure do |config|
+    #     config.k_factor(10) { pro? or pro_rating? }
+    #     config.k_factor(25) { starter? }
+    #     config.default_k_factor = 15
+    #   end
+    #
+    def k_factor(factor, &rule)
+      k_factors << { :factor => factor, :rule => rule }
+    end
+
+    def applied_k_factors #:nodoc:
+      apply_fide_k_factors if use_FIDE_settings
+      k_factors
+    end
+
+    private
+
+    def k_factors
+      @k_factors ||= []
+    end
+
+    def apply_fide_k_factors
+      unless @applied_fide_k_factors
+        k_factor(10) { pro? or pro_rating? }
+        k_factor(25) { starter? }
+        @applied_fide_k_factors = true
+      end
+    end
+  end
+end

data/lib/elo4m/game.rb

@@ -0,0 +1,71 @@
+module Elo4m
+  class Game
+    # http://en.wikipedia.org/wiki/Elo_rating_system#Mathematical_details
+
+    include Helper
+    attr_accessor :player_cnt
+    K_FACTOR = 32
+
+    def initialize(players)
+      self.player_cnt = players.length
+      define_attr_player
+      players.each.with_index(1) do |player, i|
+        send("player#{i}=", player)
+      end
+    end
+
+    def run
+      self.player_cnt.times.map.with_index(1) do |_, i|
+        Rating.new(
+          result: score_sum(i),
+          old_rating: instance_variable_get("@player#{i}").rating,
+          expected: expected_sum(i),
+          k_factor: K_FACTOR
+        ).new_rating
+      end
+    end
+
+    private
+
+    def define_attr_player
+      self.player_cnt.times.with_index(1) do |_, i|
+        self.class.send :define_method, "player#{i}=" do |value|
+          instance_variable_set("@player#{i}", value)
+        end
+      end
+    end
+
+    def score_sum(player_number)
+      my_ranking = instance_variable_get("@player#{player_number}").ranking
+      score = 0
+      self.player_cnt.times.with_index(1) do |_, i|
+        next if i == player_number
+        score += ranking2score(my_ranking, instance_variable_get("@player#{i}").ranking)
+      end
+      score
+    end
+
+    def ranking2score(my_ranking, other_ranking)
+      if my_ranking < other_ranking
+        1
+      elsif my_ranking > other_ranking
+        0
+      else
+        0.5
+      end
+    end
+
+    def expected_sum(player_number)
+      my_rating = instance_variable_get("@player#{player_number}").rating
+      es = 0
+      self.player_cnt.times.with_index(1) do |_, i|
+        next if i == player_number
+        es += Rating.new(
+          old_rating: my_rating,
+          other_rating: instance_variable_get("@player#{i}").rating
+        ).expected_al.round(3)
+      end
+      es
+    end
+  end
+end

data/lib/elo4m/helper.rb

@@ -0,0 +1,23 @@
+module Elo4m
+  module Helper
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # Every object can be initialized with a hash,
+    # almost, but not quite, entirely unlike ActiveRecord.
+    def initialize(attributes = {})
+      attributes.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+      self.class.all << self
+    end
+
+    module ClassMethods
+      # Provides a list of all instantiated objects of the class.
+      def all
+        @all ||= []
+      end
+    end
+  end
+end

data/lib/elo4m/player.rb

@@ -0,0 +1,12 @@
+module Elo4m
+  class Player
+    include Helper
+    attr_accessor :rating
+    attr_accessor :ranking
+
+    def initialize(rating, ranking)
+      self.rating = rating
+      self.ranking = ranking
+    end
+  end
+end

data/lib/elo4m/rating.rb

@@ -0,0 +1,35 @@
+module Elo4m
+  class Rating
+    include Helper
+
+    attr_reader :other_rating
+    attr_reader :old_rating
+    attr_reader :k_factor
+    attr_reader  :expected
+
+    def new_rating
+      (old_rating.to_f + change).to_i
+    end
+
+    # The expected score is the probably outcome of the match, depending
+    # on the difference in rating between the two players.
+    def expected_al
+      1.0 / ( 1.0 + ( 10.0 ** ((other_rating.to_f - old_rating.to_f) / 400.0) ) )
+    end
+
+    private
+
+    def result
+      @result.to_f
+    end
+
+    def valid_result?
+      (0..1).include? @result
+    end
+
+    def change
+      expected = self.expected.nil? ? expected_al : self.expected
+      k_factor.to_f * ( result.to_f - expected )
+    end
+  end
+end

data/lib/elo4m/version.rb

@@ -0,0 +1,3 @@
+module Elo4m
+  VERSION = "0.0.1"
+end

data/lib/elo4m.rb

@@ -0,0 +1,16 @@
+require "elo4m/version"
+require "elo4m/helper"
+require "elo4m/configuration"
+require "elo4m/game"
+require "elo4m/player"
+require "elo4m/rating"
+
+module Elo4m
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.configure(&block)
+    yield(config)
+  end
+end

data/spec/elo_spec.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require "elo4m"
+
+describe "Elo" do
+  after do
+    Elo4m.instance_eval { @config = nil }
+  end
+
+=begin
+
+Elo rating system - Wikipedia, the free encyclopedia
+http://en.wikipedia.org/wiki/Elo_rating_system#Mathematical_details
+
+  R_A^' = R_A + K(S_A - E_A).
+  This update can be performed after each game or each tournament, or after any suitable rating period.
+  An example may help clarify. Suppose Player A has a rating of 1613, and plays in a five-round tournament.
+  He or she loses to a player rated 1609, draws with a player rated 1477, defeats a player rated 1388,
+  defeats a player rated 1586, and loses to a player rated 1720. The player's actual score is (0 + 0.5 + 1 + 1 + 0) = 2.5.
+  The expected score, calculated according to the formula above, was (0.506 + 0.686 + 0.785 + 0.539 + 0.351) = 2.867.
+  Therefore the player's new rating is (1613 + 32×(2.5 − 2.867)) = 1601, assuming that a K-factor of 32 is used.
+
+=end
+  describe 'wikipedia-way' do
+    let(:players) do [
+      Elo4m::Player.new(1613, 4),
+      Elo4m::Player.new(1609, 2),
+      Elo4m::Player.new(1477, 4),
+      Elo4m::Player.new(1388, 6),
+      Elo4m::Player.new(1586, 6),
+      Elo4m::Player.new(1720, 2) ]
+    end
+
+    it do
+      game = Elo4m::Game.new(players)
+      expect(game.run.first).to eq(1601)
+    end
+  end
+
+  # describe 'for multi player' do
+  #   let(:game) do
+  #     [
+  #       {user: 'alice', result: 0, rating: 1609},
+  #       {user: 'alice', result: 0.5, rating: 1477},
+  #       {user: 'alice', result: 1, rating: 1388},
+  #       {user: 'alice', result: 1, rating: 1586},
+  #       {user: 'alice', result: 0, rating: 1720},
+  #     ]
+  #   end
+  #   let(:my_rating) { 1613 }
+  #   let(:k_factor) { 32 }
+  #
+  #   before do
+  #     # test  = Elo4m::Player.new(rating: 1500)
+  #     # test.add_game_results(r)
+  #   end
+  #
+  #   describe 'kochi-way' do
+  #     it do
+  #       # ---------------------------
+  #       #  kochi way
+  #       # ---------------------------
+  #
+  #       res_kochi = game.inject(0.0) do |r, c|
+  #         e = Elo4m::Rating.new(
+  #           result: c[:result],
+  #           old_rating: my_rating,
+  #           other_rating: c[:rating],
+  #           k_factor: k_factor
+  #         ).new_rating
+  #         r += e
+  #       end / game.size
+  #
+  #       expect(res_kochi).to eq(1610)
+  #     end
+  #   end
+  #   describe 'wikipedia-way' do
+  #     it do
+  #       # ---------------------------
+  #       #  wikipedia way
+  #       # ---------------------------
+  #
+  #       result_sum = game.inject(0.0) {|r, c| r += c[:result]}
+  #       expected_sum = game.inject(0.0) do |r, c|
+  #         e = Elo4m::Rating.new(old_rating: my_rating, other_rating: c[:rating]).expected_al
+  #         r += e
+  #       end
+  #       res_wiki = Elo4m::Rating.new(
+  #         result: result_sum,
+  #         old_rating: my_rating,
+  #         expected: expected_sum,
+  #         k_factor: k_factor
+  #       ).new_rating
+  #
+  #       expect(res_wiki).to eq(1601)
+  #     end
+  #   end
+  # end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require "elo4m"
+require "rspec"

data/spec/test.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require "elo4m"
+
+def players(my_rating)
+  my_rank, other_ratings = rand_rank_ratings(my_rating)
+  other_ratings.map do |k, v|
+    Elo4m::Player.new(k, v)
+  end.unshift Elo4m::Player.new(my_rating, my_rank)
+end
+
+def rand_rank_ratings(my_rating)
+  i = 1
+  ratings = []
+  while ratings.flatten.length != 6
+    ratings = 5.times.map { rand(my_rating-30..my_rating+30) }
+    ratings.push my_rating
+  end
+  rank_rating = ratings.sort.reverse.each_with_object({}) do |(k, v), h|
+    h[k] = i
+    i += 1
+  end
+  # => {1522=>1, 1521=>2, 1520=>3, 1506=>4, 1500=>5, 1490=>6}
+
+  rand_rank_ratings = Hash[rank_rating.to_a.shuffle]
+  my_rank = rand_rank_ratings[my_rating]
+
+  rand_rank_ratings.delete(my_rating)
+  return my_rank, rand_rank_ratings
+end
+
+require 'gnuplot'
+
+j = 0
+def execute(my_rating, j)
+  return my_rating if j == 300
+  ps = players(my_rating)
+  game = Elo4m::Game.new(ps)
+  new_rating = game.run.first
+  j += 1
+  execute(new_rating, j)
+end
+
+res = []
+1000.times do |i|
+  p i
+  res << execute(1500, 0)
+end
+p res = res.sort
+
+Gnuplot.open do |gp|
+  Gnuplot::Plot.new( gp ) do |plot|
+    plot.title  'elo'
+    plot.ylabel 'x'
+    plot.xlabel 'y'
+    plot.set "size ratio 1"
+    plot.terminal("png")
+    plot.output("y_eq_x2.png")
+    plot.set "linestyle 1 linecolor rgbcolor 'blue' linetype 1"
+    x = res
+    y = 1..1000
+
+    plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+      ds.with = "lines ls 1"
+      ds.linewidth = 4
+      ds.notitle
+    end
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: elo4m
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- kidach1
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gnuplot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: For calculating the relative skill levels of players in multi-player
+  games.
+email:
+- daiki.taniguchi@aktsk.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- elo4m.gemspec
+- lib/elo4m.rb
+- lib/elo4m/configuration.rb
+- lib/elo4m/game.rb
+- lib/elo4m/helper.rb
+- lib/elo4m/player.rb
+- lib/elo4m/rating.rb
+- lib/elo4m/version.rb
+- spec/elo_spec.rb
+- spec/spec_helper.rb
+- spec/test.rb
+- y_eq_x2.png
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: For calculating the relative skill levels of players in multi-player games.
+test_files:
+- spec/elo_spec.rb
+- spec/spec_helper.rb
+- spec/test.rb
+has_rdoc: