glicko2 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3264135c077789c8ce7d6f49a216c3ac50dafeb4
-  data.tar.gz: c621d811f861685e08a85c60d5252e4868231842
+  metadata.gz: 5b475b65a53c6af5c404f010b22a616f3f645617
+  data.tar.gz: d837d51c7cbc959b810140ea1139d4c654109a22
 SHA512:
-  metadata.gz: 8d34d1bab836561f0fefb5f58807387af31d7d21adfd31344b547b8d804f75ba16c8ffd5a45d6982a620aca49c9e8374fb5ed93744b9050dea158536c4be0b61
-  data.tar.gz: 27fbeaf711881f18500a5277f2a9571d71bad500976949f73e873c0196cd29347723b382597c8d54e5961ff2751128f6591babb088a1efa60bcdb542da65468a
+  metadata.gz: 560eba41bcbcc66ee5036a91be810b3916575c08d9ee5f03fa22514f42e779932ad3c41ecaa6b073f626eae8c36a8fdc07da9dc360a71797ec4ac8845dca2063
+  data.tar.gz: bf6ea3797d64d7735917ae1d25de400db48222ef581d40358e0e921138298edad882d79cc8d358445a7287d9e08b692f7fe3ab287253a3ee9b2b5c78095ed75b

data/README.md

@@ -35,7 +35,7 @@ period = Glicko2::RatingPeriod.from_objs [rating1, rating2]
 period.game([rating1, rating2], [1,2])
 
 # Generate the next rating period with updated players
-next_period = period.generate_next
+next_period = period.generate_next(0.5)
 
 # Update all Glicko ratings
 next_period.players.each { |p| p.update_obj }

data/glicko2.gemspec

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'glicko2/version'
@@ -17,5 +17,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
+  gem.add_development_dependency('bundler')
+  gem.add_development_dependency('rake')
   gem.add_development_dependency('minitest')
 end

data/lib/glicko2.rb

@@ -2,38 +2,15 @@ module Glicko2
   DEFAULT_VOLATILITY = 0.06
   DEFAULT_GLICKO_RATING = 1500.0
   DEFAULT_GLICKO_RATING_DEVIATION = 350.0
-  GLICKO_GRADIENT = 173.7178
 
-  DEFAULT_CONFIG = {:volatility_change => 0.5}.freeze
+  TOLERANCE = 5.0e-15
+
+  class DuplicatePlayerError < StandardError; end
 
   # Collection of helper methods
   class Util
-    GLICKO_INTERCEPT = DEFAULT_GLICKO_RATING
-
-    # Convert from the original Glicko scale to Glicko2 scale
-    #
-    # @param [Numeric] r Glicko rating
-    # @param [Numeric] rd Glicko rating deviation
-    # @return [Array<Numeric>]
-    def self.to_glicko2(r, rd)
-      [(r - GLICKO_INTERCEPT) / GLICKO_GRADIENT, rd / GLICKO_GRADIENT]
-    end
-
-    # Convert from the Glicko2 scale to the original Glicko scale
-    #
-    # @param [Numeric] m Glicko2 mean
-    # @param [Numeric] sd Glicko2 standard deviation
-    # @return [Array<Numeric>]
-    def self.to_glicko(m, sd)
-      [GLICKO_GRADIENT * m + GLICKO_INTERCEPT, GLICKO_GRADIENT * sd]
-    end
-
     # Convert from a rank, where lower numbers win against higher numbers,
     # into Glicko scores where wins are `1`, draws are `0.5` and losses are `0`.
-    #
-    # @param [Integer] rank players rank
-    # @param [Integer] other opponents rank
-    # @return [Numeric] Glicko score
     def self.ranks_to_score(rank, other)
       if rank < other
         1.0
@@ -43,10 +20,30 @@ module Glicko2
         0.0
       end
     end
+
+    # Illinois method is a version of the regula falsi method for solving an equation with one unknown
+    def self.illinois_method(a, b)
+      fa = yield a
+      fb = yield b
+      while (b - a).abs > TOLERANCE
+        c = a + (a - b) * fa / (fb - fa)
+        fc = yield c
+        if fc * fb < 0
+          a = b
+          fa = fb
+        else
+          fa /= 2.0
+        end
+        b = c
+        fb = fc
+      end
+      a
+    end
   end
 end
 
 require "glicko2/version"
-require "glicko2/normal_distribution"
+require "glicko2/rating"
 require "glicko2/player"
+require "glicko2/rater"
 require "glicko2/rating_period"

data/lib/glicko2/player.rb

@@ -1,190 +1,45 @@
 module Glicko2
-  # Calculates a new Glicko2 ranking based on a seed object and game outcomes.
-  #
-  # The example from the Glicko2 paper, where a player wins against the first
-  # opponent, but then looses against the next two:
-  #
-  #   Rating = Struct.new(:rating, :rating_deviation, :volatility)
-  #
-  #   player_seed = Rating.new(1500, 200, 0.06)
-  #   opponent1_seed = Rating.new(1400, 30, 0.06)
-  #   opponent2_seed = Rating.new(1550, 100, 0.06)
-  #   opponent3_seed = Rating.new(1700, 300, 0.06)
-  #
-  #   player = Glicko2::Player.from_obj(player_seed)
-  #   opponent1 = Glicko2::Player.from_obj(opponent1_seed)
-  #   opponent2 = Glicko2::Player.from_obj(opponent2_seed)
-  #   opponent3 = Glicko2::Player.from_obj(opponent3_seed)
-  #
-  #   new_player = player.generate_next([opponent1, opponent2, opponent3],
-  #                                     [1, 0, 0])
-  #   new_player.update_obj
-  #
-  #   puts player_seed
-  #
-  class Player < NormalDistribution
-    TOLERANCE = 0.0000001
-    MIN_SD = DEFAULT_GLICKO_RATING_DEVIATION / GLICKO_GRADIENT
-
-    attr_reader :volatility, :obj
+  # Player maps a seed object with a Glicko2 rating.
+  class Player
+    attr_reader :rating, :obj
 
     # Create a {Player} from a seed object, converting from Glicko
     # ratings to Glicko2.
     #
     # @param [#rating,#rating_deviation,#volatility] obj seed values object
     # @return [Player] constructed instance.
-    def self.from_obj(obj, config=DEFAULT_CONFIG)
-      mean, sd = Util.to_glicko2(obj.rating, obj.rating_deviation)
-      new(mean, sd, obj.volatility, obj, config)
+    def self.from_obj(obj)
+      rating = Rating.from_glicko_rating(obj.rating, obj.rating_deviation, obj.volatility)
+      new(rating, obj)
     end
 
-    # @param [Numeric] mean player mean
-    # @param [Numeric] sd player standard deviation
-    # @param [Numeric] volatility player volatility
-    # @param [#rating,#rating_deviation,#volatility] obj seed values object
-    def initialize(mean, sd, volatility, obj=nil, config=DEFAULT_CONFIG)
-      super(mean, sd)
-      @volatility = volatility
+    def initialize(rating, obj)
+      @rating = rating
       @obj = obj
-      @config = config
-      @e = {}
-    end
-
-    # Calculate `g(phi)` as defined in the Glicko2 paper
-    #
-    # @return [Numeric]
-    def g
-      @g ||= 1 / Math.sqrt(1 + 3 * variance / Math::PI ** 2)
-    end
-
-    # Calculate `E(mu, mu_j, phi_j)` as defined in the Glicko2 paper
-    #
-    # @param [Player] other the `j` player
-    # @return [Numeric]
-    def e(other)
-      @e[other] ||= 1 / (1 + Math.exp(-other.g * (mean - other.mean)))
-    end
-
-    # Calculate the estimated variance of the team's/player's rating based only
-    # on the game outcomes.
-    #
-    # @param [Array<Player>] others other participating players.
-    # @return [Numeric]
-    def estimated_variance(others)
-      return 0.0 if others.length < 1
-      others.reduce(0) do |v, other|
-        e_other = e(other)
-        v + other.g ** 2 * e_other * (1 - e_other)
-      end ** -1
-    end
-
-    # Calculate the estimated improvement in rating by comparing the
-    # pre-period rating to the performance rating based only on game outcomes.
-    #
-    # @param [Array<Player>] others list of opponent players
-    # @param [Array<Numeric>] scores list of correlating scores (`0` for a loss,
-    #   `0.5` for a draw and `1` for a win).
-    # @return [Numeric]
-    def delta(others, scores)
-      others.zip(scores).reduce(0) do |d, (other, score)|
-        d + other.g * (score - e(other))
-      end * estimated_variance(others)
-    end
-
-    # Calculate `f(x)` as defined in the Glicko2 paper
-    #
-    # @param [Numeric] x
-    # @param [Numeric] d the result of calculating {#delta}
-    # @param [Numeric] v the result of calculating {#estimated_variance}
-    # @return [Numeric]
-    def f(x, d, v)
-      f_part1(x, d, v) - f_part2(x)
-    end
-
-    # Calculate the new value of the volatility
-    #
-    # @param [Numeric] d the result of calculating {#delta}
-    # @param [Numeric] v the result of calculating {#estimated_variance}
-    # @return [Numeric]
-    def volatility1(d, v)
-      a = Math::log(volatility ** 2)
-      if d > variance + v
-        b = Math.log(d - variance - v)
-      else
-        k = 1
-        k += 1 while f(a - k * @config[:volatility_change], d, v) < 0
-        b = a - k * @config[:volatility_change]
-      end
-      fa = f(a, d, v)
-      fb = f(b, d, v)
-      while (b - a).abs > TOLERANCE
-        c = a + (a - b) * fa / (fb - fa)
-        fc = f(c, d, v)
-        if fc * fb < 0
-          a = b
-          fa = fb
-        else
-          fa /= 2.0
-        end
-        b = c
-        fb = fc
-      end
-      Math.exp(a / 2.0)
-    end
-
-    # Create new {Player} with updated values.
-    #
-    # This method will not modify any objects that are passed into it.
-    #
-    # @param [Array<Player>] others list of opponent players
-    # @param [Array<Numeric>] scores list of correlating scores (`0` for a loss,
-    #   `0.5` for a draw and `1` for a win).
-    # @return [Player]
-    def generate_next(others, scores)
-      if others.length < 1
-        generate_next_without_games
-      else
-        generate_next_with_games(others, scores)
-      end
     end
 
     # Update seed object with this player's values
     def update_obj
-      @obj.rating, @obj.rating_deviation = Util.to_glicko(mean, sd)
+      mean, sd = rating.to_glicko_rating
+      @obj.rating = mean
+      @obj.rating_deviation = sd
       @obj.volatility = volatility
     end
 
-    def to_s
-      "#<Player mean=#{mean}, sd=#{sd}, volatility=#{volatility}, obj=#{obj}>"
+    def mean
+      rating.mean
     end
 
-    private
-
-    def generate_next_without_games
-      sd_pre = [Math.sqrt(variance + volatility ** 2), MIN_SD].min
-      self.class.new(mean, sd_pre, volatility, obj)
+    def sd
+      rating.sd
     end
 
-    def generate_next_with_games(others, scores)
-      _v = estimated_variance(others)
-      _d = delta(others, scores)
-      _volatility = volatility1(_d, _v)
-      sd_pre = [Math.sqrt(variance + volatility ** 2), MIN_SD].min
-      _sd = 1 / Math.sqrt(1 / sd_pre ** 2 + 1 / _v)
-      _mean = mean + _sd ** 2 * others.zip(scores).reduce(0) {
-        |x, (other, score)| x + other.g * (score - e(other))
-      }
-      self.class.new(_mean, _sd, _volatility, obj)
+    def volatility
+      rating.volatility
     end
 
-    def f_part1(x, d, v)
-      exp_x = Math.exp(x)
-      sd_sq = variance
-      (exp_x * (d ** 2 - sd_sq - v - exp_x)) / (2 * (sd_sq + v + exp_x) ** 2)
-    end
-
-    def f_part2(x)
-      (x - Math::log(volatility ** 2)) / @config[:volatility_change] ** 2
+    def to_s
+      "#<Player rating=#{rating}, obj=#{obj}>"
     end
   end
 end

data/lib/glicko2/rater.rb

@@ -0,0 +1,44 @@
+module Glicko2
+  # A Rater calculates a new Rating based on actual game outcomes.
+  class Rater
+    attr_reader :rating
+
+    def initialize(rating)
+      @rating = rating
+      @v_pre = 0.0
+      @delta_pre = 0.0
+    end
+
+    # Add an outcome against the rating
+    def add(other_rating, score)
+      g, e = other_rating.gravity_expected_score(rating.mean)
+      @v_pre += g**2 * e * (1 - e)
+      @delta_pre += g * (score - e)
+    end
+
+    # Rate calculates Rating as at the start of the following period based on game outcomes
+    def rate(tau)
+      v = @v_pre**-1
+      delta2 = @delta_pre**2
+      sd2 = rating.sd**2
+      a = Math.log(rating.volatility**2)
+      f = lambda do |x|
+        expX = Math.exp(x)
+        (expX * (delta2 - sd2 - v - expX)) / (2 * (sd2 + v + expX)**2) - (x - a) / tau**2
+      end
+      if delta2 > sd2 + v
+        b = Math.log(delta2 - sd2 - v)
+      else
+        k = 1
+        k += 1 while f.call(a - k * tau) < 0
+        b = a - k * tau
+      end
+      a = Util.illinois_method(a, b, &f)
+      volatility = Math.exp(a / 2.0)
+      sd_pre = Math.sqrt(sd2 + volatility**2)
+      sd = 1 / Math.sqrt(1.0 / sd_pre**2 + 1 / v)
+      mean = rating.mean + sd**2 * @delta_pre
+      Rating.new(mean, sd, volatility)
+    end
+  end
+end

data/lib/glicko2/rating.rb

@@ -0,0 +1,35 @@
+module Glicko2
+  # A Rating of a player.
+  class Rating
+    GLICKO_GRADIENT = 173.7178
+    GLICKO_INTERCEPT = DEFAULT_GLICKO_RATING
+
+    attr_reader :mean, :sd, :volatility
+
+    def initialize(mean, sd, volatility=nil)
+      @mean = mean
+      @sd = sd
+      @volatility = volatility || DEFAULT_VOLATILITY
+    end
+
+    # Creates a Rating from the Glicko scale.
+    def self.from_glicko_rating(r, rd, volatility=nil)
+      new((r - GLICKO_INTERCEPT) / GLICKO_GRADIENT, rd / GLICKO_GRADIENT, volatility)
+    end
+
+    # Converts to the Glicko scale.
+    def to_glicko_rating
+      [GLICKO_GRADIENT * mean + GLICKO_INTERCEPT, GLICKO_GRADIENT * sd]
+    end
+
+    # Calculate `g(phi)` and `E(mu, mu_j, phi_j)` as defined in the Glicko2 paper
+    def gravity_expected_score(other_mean)
+      g = 1 / Math.sqrt(1 + 3 * sd**2 / Math::PI**2)
+      [g, 1 / (1 + Math.exp(-g * (other_mean - mean)))]
+    end
+
+    def to_s
+      "#<Rating mean=#{mean}, sd=#{sd}, volatility=#{volatility}>"
+    end
+  end
+end

data/lib/glicko2/rating_period.rb

@@ -9,16 +9,20 @@ module Glicko2
     # @param [Array<Player>] players
     def initialize(players)
       @players = players
-      @games = Hash.new { |h, k| h[k] = [] }
-      @cache = players.reduce({}) { |memo, player| memo[player.obj] = player; memo }
+      @cache = players.reduce({}) do |memo, player|
+        raise DuplicatePlayerError unless memo[player.obj].nil?
+        memo[player.obj] = player
+        memo
+      end
+      @raters = players.map { |p| Rater.new(p.rating) }
     end
 
     # Create rating period from list of seed objects
     #
     # @param [Array<#rating,#rating_deviation,#volatility>] objs seed value objects
     # @return [RatingPeriod]
-    def self.from_objs(objs, config=DEFAULT_CONFIG)
-      new(objs.map { |obj| Player.from_obj(obj, config) })
+    def self.from_objs(objs)
+      new(objs.map { |obj| Player.from_obj(obj) })
     end
 
     # Register a game with this rating period
@@ -26,11 +30,10 @@ module Glicko2
     # @param [Array<#rating,#rating_deviation,#volatility>] game_seeds ratings participating in a game
     # @param [Array<Integer>] ranks corresponding ranks
     def game(game_seeds, ranks)
-      game_seeds.zip(ranks).each do |seed, rank|
-        game_seeds.zip(ranks).each do |other, other_rank|
-          next if seed == other
-          @games[player(seed)] << [player(other),
-                                 Util.ranks_to_score(rank, other_rank)]
+      game_seeds.each_with_index do |iseed, i|
+        game_seeds.each_with_index do |jseed, j|
+          next if i == j
+          @raters[i].add(player(jseed).rating, Util.ranks_to_score(ranks[i], ranks[j]))
         end
       end
     end
@@ -38,15 +41,10 @@ module Glicko2
     # Generate a new {RatingPeriod} with a new list of updated {Player}
     #
     # @return [RatingPeriod]
-    def generate_next
+    def generate_next(tau)
       p = []
-      @players.each do |player|
-        games = @games[player]
-        if games.length > 0
-          p << player.generate_next(*games.transpose)
-        else
-          p << player.generate_next([], [])
-        end
+      @raters.each_with_index do |rater, i|
+        p << Player.new(rater.rate(tau), @players[i].obj)
       end
       self.class.new(p)
     end

data/lib/glicko2/version.rb

@@ -1,3 +1,3 @@
 module Glicko2
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/spec/minitest_helper.rb

@@ -1,3 +1,4 @@
-require 'minitest/benchmark'
 require 'minitest/autorun'
 require 'glicko2'
+
+Rating = Struct.new(:rating, :rating_deviation, :volatility)

data/spec/player_spec.rb

@@ -1,7 +1,5 @@
 require 'minitest_helper'
 
-Rating = Struct.new(:rating, :rating_deviation, :volatility)
-
 describe Glicko2::Player do
   before do
     @player = Glicko2::Player.from_obj(Rating.new(1500, 200, 0.06))
@@ -20,7 +18,7 @@ describe Glicko2::Player do
     end
 
     it "must create player from an object as example 1" do
-      @player1.mean.must_be_close_to -0.5756, 0.0001
+      @player1.mean.must_be_close_to(-0.5756, 0.0001)
       @player1.sd.must_be_close_to 0.1727, 0.0001
       @player1.volatility.must_equal 0.06
     end
@@ -37,82 +35,4 @@ describe Glicko2::Player do
       @player3.volatility.must_equal 0.06
     end
   end
-
-  describe "#g" do
-    it "must be close to example 1" do
-      @player1.g.must_be_close_to 0.9955, 0.0001
-    end
-
-    it "must be close to example 2" do
-      @player2.g.must_be_close_to 0.9531, 0.0001
-    end
-
-    it "must be close to example 3" do
-      @player3.g.must_be_close_to 0.7242, 0.0001
-    end
-  end
-
-  describe "#e" do
-    it "must be close to example 1" do
-      @player.e(@player1).must_be_close_to 0.639
-    end
-
-    it "must be close to example 2" do
-      @player.e(@player2).must_be_close_to 0.432
-    end
-
-    it "must be close to example 3" do
-      @player.e(@player3).must_be_close_to 0.303
-    end
-  end
-
-  describe "#estimated_variance" do
-    it "must be close to example" do
-      @player.estimated_variance(@others).must_be_close_to 1.7785
-    end
-  end
-
-  describe "#delta" do
-    it "must be close to example" do
-      @player.delta(@others, @scores).must_be_close_to -0.4834
-    end
-  end
-
-  describe "#generate_next" do
-    it "must be close to example" do
-      p = @player.generate_next(@others, @scores)
-      p.mean.must_be_close_to -0.2069, 0.0001
-      p.sd.must_be_close_to 0.8722, 0.0001
-      p.volatility.must_be_close_to 0.05999, 0.00001
-    end
-
-    it "must allow players that did not play and games" do
-      p = @player.generate_next([], [])
-      p.mean.must_equal @player.mean
-      p.volatility.must_equal @player.volatility
-      p.sd.must_be_close_to Math.sqrt(@player.sd ** 2 + @player.volatility ** 2)
-    end
-
-    it "must not decay rating deviation above default" do
-      @player = Glicko2::Player.from_obj(Rating.new(1500, Glicko2::DEFAULT_GLICKO_RATING_DEVIATION, 0.06))
-      p = @player.generate_next([], [])
-      p.update_obj
-      p.obj.rating_deviation.must_equal Glicko2::DEFAULT_GLICKO_RATING_DEVIATION
-    end
-
-    bench_performance_linear "default" do |n|
-      @player.generate_next(@others * n, @scores * n)
-    end
-  end
-
-  describe "#update_obj" do
-    it "must update object to be close to example" do
-      p = @player.generate_next(@others, @scores)
-      p.update_obj
-      obj = p.obj
-      obj.rating.must_be_close_to 1464.06, 0.01
-      obj.rating_deviation.must_be_close_to 151.52, 0.01
-      obj.volatility.must_be_close_to 0.05999, 0.00001
-    end
-  end
 end

data/spec/rater_spec.rb

@@ -0,0 +1,22 @@
+require 'minitest_helper'
+
+class TestRater < Minitest::Test
+  def setup
+    @rating = Glicko2::Rating.from_glicko_rating(1500, 200)
+    @rating1 = Glicko2::Rating.from_glicko_rating(1400, 30)
+    @rating2 = Glicko2::Rating.from_glicko_rating(1550, 100)
+    @rating3 = Glicko2::Rating.from_glicko_rating(1700, 300)
+    @rater = Glicko2::Rater.new(@rating)
+  end
+
+  def test_rate_matches_example
+    @rater.add(@rating1, 1.0)
+    @rater.add(@rating2, 0.0)
+    @rater.add(@rating3, 0.0)
+    rating = @rater.rate(0.5)
+
+    assert_in_delta(-0.2069, rating.mean, 0.00005)
+    assert_in_delta(0.8722, rating.sd, 0.00005)
+    assert_in_delta(0.05999, rating.volatility, 0.00005)
+  end
+end

data/spec/rating_period_spec.rb

@@ -10,12 +10,20 @@ describe Glicko2::RatingPeriod do
     @period = Glicko2::RatingPeriod.from_objs(@players)
   end
 
+  describe "#initialize" do
+    it "must raise if two players are identical" do
+      proc {
+        Glicko2::RatingPeriod.from_objs([@player, @player])
+      }.must_raise Glicko2::DuplicatePlayerError
+    end
+  end
+
   describe "#generate_next" do
     it "must be close to example" do
       @period.game([@player, @player1], [1, 2])
       @period.game([@player, @player2], [2, 1])
       @period.game([@player, @player3], [2, 1])
-      @period.generate_next.players.each { |p| p.update_obj }
+      @period.generate_next(0.5).players.each(&:update_obj)
       obj = @player
       obj.rating.must_be_close_to 1464.06, 0.01
       obj.rating_deviation.must_be_close_to 151.52, 0.01
@@ -24,14 +32,7 @@ describe Glicko2::RatingPeriod do
 
     it "must process non-competing players" do
       @period.game([@player, @player1], [1, 2])
-      @period.generate_next
-    end
-
-    bench_performance_linear "default" do |n|
-      n.times do
-        @period.game(@players.sample(2), [1, 2])
-      end
-      @period.generate_next
+      @period.generate_next 0.5
     end
   end
 end

data/spec/rating_spec.rb

@@ -0,0 +1,30 @@
+require 'minitest_helper'
+
+describe Glicko2::Rating do
+  before do
+    @rating = Glicko2::Rating.from_glicko_rating(1500, 200)
+    @rating1 = Glicko2::Rating.from_glicko_rating(1400, 30)
+    @rating2 = Glicko2::Rating.from_glicko_rating(1550, 100)
+    @rating3 = Glicko2::Rating.from_glicko_rating(1700, 300)
+  end
+
+  describe "#gravity_expected_score" do
+    it "must be close to example 1" do
+      g, e = @rating1.gravity_expected_score(@rating.mean)
+      g.must_be_close_to 0.9955, 0.0001
+      e.must_be_close_to 0.639, 0.001
+    end
+
+    it "must be close to example 2" do
+      g, e = @rating2.gravity_expected_score(@rating.mean)
+      g.must_be_close_to 0.9531, 0.0001
+      e.must_be_close_to 0.432, 0.001
+    end
+
+    it "must be close to example 3" do
+      g, e = @rating3.gravity_expected_score(@rating.mean)
+      g.must_be_close_to 0.7242, 0.0001
+      e.must_be_close_to 0.303, 0.001
+    end
+  end
+end

data/spec/util_spec.rb

@@ -1,17 +1,16 @@
 require 'minitest_helper'
 
-describe Glicko2::Util do
-  describe ".ranks_to_score" do
-    it "must return 1.0 when rank is less" do
-      Glicko2::Util.ranks_to_score(1, 2).must_equal 1.0
-    end
-
-    it "must return 0.5 when rank is equal" do
-      Glicko2::Util.ranks_to_score(1, 1).must_equal 0.5
-    end
+class TestUtil < Minitest::Test
+  def test_ranks_to_score
+    assert_equal 1.0, Glicko2::Util.ranks_to_score(1, 2)
+    assert_equal 0.5, Glicko2::Util.ranks_to_score(1, 1)
+    assert_equal 0.0, Glicko2::Util.ranks_to_score(2, 1)
+  end
 
-    it "must return 0.0 when rank is more" do
-      Glicko2::Util.ranks_to_score(2, 1).must_equal 0.0
+  def test_illinois_method
+    result = Glicko2::Util.illinois_method(0.0, 1.0) do |x|
+      Math.cos(x) - x**3
     end
+    assert_in_delta 0.865474033101614, result, Glicko2::TOLERANCE
   end
 end

metadata

@@ -1,27 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: glicko2
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - James Fargher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-04 00:00:00.000000000 Z
+date: 2017-02-09 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  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: minitest
   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'
 description: Implementation of Glicko2 ratings
@@ -31,21 +59,23 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - glicko2.gemspec
 - lib/glicko2.rb
-- lib/glicko2/normal_distribution.rb
 - lib/glicko2/player.rb
+- lib/glicko2/rater.rb
+- lib/glicko2/rating.rb
 - lib/glicko2/rating_period.rb
 - lib/glicko2/version.rb
 - spec/minitest_helper.rb
-- spec/normal_distribution_spec.rb
 - spec/player_spec.rb
+- spec/rater_spec.rb
 - spec/rating_period_spec.rb
+- spec/rating_spec.rb
 - spec/util_spec.rb
 homepage: https://github.com/proglottis/glicko2
 licenses: []
@@ -56,24 +86,24 @@ 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.0.0
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Implementation of Glicko2 ratings
 test_files:
 - spec/minitest_helper.rb
-- spec/normal_distribution_spec.rb
 - spec/player_spec.rb
+- spec/rater_spec.rb
 - spec/rating_period_spec.rb
+- spec/rating_spec.rb
 - spec/util_spec.rb
-has_rdoc: 

data/lib/glicko2/normal_distribution.rb

@@ -1,58 +0,0 @@
-module Glicko2
-  # Glicko ratings are represented with a rating and rating deviation. For this
-  # gem it is assumed that ratings are normally distributed where rating and
-  # rating deviation correspond to mean and standard deviation.
-  class NormalDistribution
-    attr_reader :mean, :standard_deviation
-    alias_method :sd, :standard_deviation
-
-    def initialize(mean, standard_deviation)
-      @mean = mean
-      @standard_deviation = standard_deviation
-    end
-
-    # Calculate the distribution variance
-    #
-    # @return [Numeric]
-    def variance
-      standard_deviation ** 2.0
-    end
-
-    # Calculate the sum
-    #
-    # @param [NormalDistribution] other
-    # @return [NormalDistribution]
-    def +(other)
-      self.class.new(mean + other.mean, Math.sqrt(variance + other.variance))
-    end
-
-    # Calculate the difference
-    #
-    # @param [NormalDistribution] other
-    # @return [NormalDistribution]
-    def -(other)
-      self.class.new(mean - other.mean, Math.sqrt(variance + other.variance))
-    end
-
-    # Calculate the probability density at `x`
-    #
-    # @param [Numeric] x
-    # @return [Numeric]
-    def pdf(x)
-      1.0 / (sd * Math.sqrt(2.0 * Math::PI)) *
-        Math.exp(-(x - mean) ** 2.0 / 2.0 * variance)
-    end
-
-    # Calculate the cumulative distribution at `x`
-    #
-    # @param [Numeric] x
-    # @return [Numeric]
-    def cdf(x)
-      0.5 * (1.0 + Math.erf((x - mean) / (sd * Math.sqrt(2.0))))
-    end
-
-    def to_s
-      "#<NormalDistribution mean=#{mean}, sd=#{sd}>"
-    end
-  end
-end

data/spec/normal_distribution_spec.rb

@@ -1,69 +0,0 @@
-require 'minitest_helper'
-
-describe Glicko2::NormalDistribution do
-  describe "#variance" do
-    it "must return the square of the standard deviation" do
-      Glicko2::NormalDistribution.new(1.0, 1.0).variance.must_equal 1.0 ** 2.0
-      Glicko2::NormalDistribution.new(1.0, 2.0).variance.must_equal 2.0 ** 2.0
-      Glicko2::NormalDistribution.new(1.0, 10.0).variance.must_equal 10.0 ** 2.0
-    end
-  end
-
-  describe "#+" do
-    let(:dist1) { Glicko2::NormalDistribution.new(10.0, 0.5) }
-    let(:dist2) { Glicko2::NormalDistribution.new(5.0, 1.0) }
-
-    it "must sum the means" do
-      (dist1 + dist2).mean.must_equal 15.0
-    end
-
-    it "must sqrt the sum of the variances" do
-      (dist1 + dist2).sd.must_equal Math.sqrt(0.5 ** 2.0 + 1.0 ** 2.0)
-    end
-  end
-
-  describe "#-" do
-    let(:dist1) { Glicko2::NormalDistribution.new(10.0, 0.5) }
-    let(:dist2) { Glicko2::NormalDistribution.new(5.0, 1.0) }
-
-    it "must subtract the means" do
-      (dist1 - dist2).mean.must_equal 5.0
-    end
-
-    it "must sqrt the sum of the variances" do
-      (dist1 - dist2).sd.must_equal Math.sqrt(0.5 ** 2.0 + 1.0 ** 2.0)
-    end
-  end
-
-  describe "#pdf" do
-    describe "standard normal" do
-      let(:dist) { Glicko2::NormalDistribution.new(0.0, 1.0) }
-
-      it "must calculate PDF at x" do
-        dist.pdf(-5.0).must_be_close_to 0.00000149, 0.00000001
-        dist.pdf(-2.5).must_be_close_to 0.01752830, 0.00000001
-        dist.pdf(-1.0).must_be_close_to 0.24197072, 0.00000001
-        dist.pdf(0.0).must_be_close_to 0.39894228, 0.00000001
-        dist.pdf(1.0).must_be_close_to 0.24197072, 0.00000001
-        dist.pdf(2.5).must_be_close_to 0.01752830, 0.00000001
-        dist.pdf(5.0).must_be_close_to 0.00000149, 0.00000001
-      end
-    end
-  end
-
-  describe "#cdf" do
-    describe "standard normal" do
-      let(:dist) { Glicko2::NormalDistribution.new(0.0, 1.0) }
-
-      it "must calculate CDF at x" do
-        dist.cdf(-5.0).must_be_close_to 0.00000029, 0.00000001
-        dist.cdf(-2.5).must_be_close_to 0.00620967, 0.00000001
-        dist.cdf(-1.0).must_be_close_to 0.15865525, 0.00000001
-        dist.cdf(0.0).must_be_close_to 0.50000000, 0.00000001
-        dist.cdf(1.0).must_be_close_to 0.84134475, 0.00000001
-        dist.cdf(2.5).must_be_close_to 0.99379033, 0.00000001
-        dist.cdf(5.0).must_be_close_to 0.99999971, 0.00000001
-      end
-    end
-  end
-end