compact-glicko2 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3839ca7a4bcb2fab2a76e939cd8134f9f7205d14
+  data.tar.gz: 4ce1c41078fae71cce47432ecc9624b36acfeb33
+SHA512:
+  metadata.gz: 4c5a4e20d4efabaf002dbac6f68e279ebcb7036b29dade5956907ba54bf04a1349d6468c1405919e5bc638250d7ccef65917c26d1221ecb96fa604f7778f730b
+  data.tar.gz: d6fc172b730199abc8ca5613096d93e8553e3c0a85df85c9987fd1b412a661d29fd0f5aa281393f551236093aac2c52d1f92c318c66ed1525651164fbd449f7f

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.ruby-version
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 James Fargher
+
+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,54 @@
+# Glicko2
+
+Implementation of Glicko2 ratings.
+
+Based on Mark Glickman's paper http://www.glicko.net/glicko/glicko2.pdf
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'glicko2'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install glicko2
+
+## Usage
+
+```ruby
+require 'glicko2'
+
+# Objects to store Glicko ratings
+Rating = Struct.new(:rating, :rating_deviation, :volatility)
+rating1 = Rating.new(1400, 30, 0.06)
+rating2 = Rating.new(1550, 100, 0.06)
+
+# Rating period with all participating ratings
+period = Glicko2::RatingPeriod.from_objs [rating1, rating2]
+
+# Register a game where rating1 wins against rating2
+period.game([rating1, rating2], [1,2])
+
+# Generate the next rating period with updated players
+next_period = period.generate_next
+
+# Update all Glicko ratings
+next_period.players.each { |p| p.update_obj }
+
+# Output updated Glicko ratings
+puts rating1
+puts rating2
+```
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << 'spec'
+  t.pattern = "spec/*_spec.rb"
+end

data/glicko2.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'glicko2/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "compact-glicko2"
+  gem.version       = Glicko2::VERSION
+  gem.authors       = ["James Fargher", "Andrej Antas"]
+  gem.email         = ["proglottis@gmail.com", "andrej@antas.cz"]
+  gem.description   = %q{Implementation of Glicko2 ratings with compact rule}
+  gem.summary       = %q{Implementation of Glicko2 ratings with compact rule}
+  gem.homepage      = "https://github.com/redrick/glicko2"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency('bundler', '~> 1.3')
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('minitest', '~> 4.7.5')
+end

data/lib/glicko2.rb

@@ -0,0 +1,34 @@
+module Glicko2
+  DEFAULT_VOLATILITY = 0.06
+  DEFAULT_GLICKO_RATING = 1500.0
+  DEFAULT_GLICKO_RATING_DEVIATION = 350.0
+
+  DEFAULT_CONFIG = {:volatility_change => 0.5}.freeze
+
+  class DuplicatePlayerError < StandardError; end
+
+  # Collection of helper methods
+  class Util
+    # 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
+      elsif rank == other
+        0.5
+      else
+        0.0
+      end
+    end
+  end
+end
+
+require "glicko2/version"
+require "glicko2/normal_distribution"
+require "glicko2/rating"
+require "glicko2/player"
+require "glicko2/rating_period"

data/lib/glicko2/normal_distribution.rb

@@ -0,0 +1,64 @@
+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
+    include Comparable
+
+    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 <=>(other)
+      mean <=> other.mean
+    end
+
+    def to_s
+      "#<NormalDistribution mean=#{mean}, sd=#{sd}>"
+    end
+  end
+end

data/lib/glicko2/player.rb

@@ -0,0 +1,111 @@
+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
+    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=nil)
+      rating = Rating.from_glicko_rating(obj.rating, obj.rating_deviation,
+                                         obj.volatility, config)
+      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(rating, obj=nil)
+      @rating = rating
+      @obj = obj
+    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.compact.length < 1
+        generate_next_without_games
+      else
+        others = others.compact.map{ |other| other.rating }
+        generate_next_with_games(others, scores)
+      end
+    end
+
+    # Update seed object with this player's values
+    def update_obj
+      glicko_rating = rating.to_glicko_rating
+      @obj.rating = glicko_rating.mean
+      @obj.rating_deviation = glicko_rating.standard_deviation
+      @obj.volatility = volatility
+    end
+
+    def mean
+      rating.mean
+    end
+
+    def standard_deviation
+      rating.standard_deviation
+    end
+    alias_method :sd, :standard_deviation
+
+    def volatility
+      rating.volatility
+    end
+
+    def to_s
+      "#<Player rating=#{rating}, obj=#{obj}>"
+    end
+
+    private
+
+    def generate_next_without_games
+      next_rating = Rating.new(mean, rating.standard_deviation_pre,
+                               volatility, rating.config)
+      self.class.new(next_rating, obj)
+    end
+
+    def generate_next_with_games(others, scores)
+      rating = generate_next_rating(others, scores)
+      self.class.new(rating, obj)
+    end
+
+    def generate_next_rating(others, scores)
+      _v = rating.estimated_variance(others)
+      _volatility = rating.next_volatility(others, scores, _v)
+      _sd = rating.next_standard_deviation(_v)
+      _mean = rating.next_mean(others, scores, _sd)
+      Rating.new(_mean, _sd, _volatility, rating.config)
+    end
+  end
+end

data/lib/glicko2/rating.rb

@@ -0,0 +1,150 @@
+module Glicko2
+  class Rating < NormalDistribution
+    GLICKO_GRADIENT = 173.7178
+    GLICKO_INTERCEPT = DEFAULT_GLICKO_RATING
+    MIN_SD = DEFAULT_GLICKO_RATING_DEVIATION / GLICKO_GRADIENT
+    TOLERANCE = 0.0000001
+
+    attr_reader :volatility, :config
+
+    def initialize(mean, sd, volatility=nil, config=nil)
+      super(mean, sd)
+      @volatility = volatility || DEFAULT_VOLATILITY
+      @config = config || DEFAULT_CONFIG
+      @e = {}
+    end
+
+    def self.from_glicko_rating(r, rd, volatility=nil, config=nil)
+      new((r - GLICKO_INTERCEPT) / GLICKO_GRADIENT, rd / GLICKO_GRADIENT,
+          volatility, config)
+    end
+
+    def to_glicko_rating
+      NormalDistribution.new(GLICKO_GRADIENT * mean + GLICKO_INTERCEPT,
+                             GLICKO_GRADIENT * sd)
+    end
+
+    # Calculate `g(phi)` as defined in the Glicko2 paper
+    #
+    # @return [Numeric]
+    def gravity
+      @gravity ||= 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 expected_fractional_score(other)
+      @e[other] ||= 1 / (1 + Math.exp(-other.gravity * (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 = expected_fractional_score(other)
+        v + other.gravity ** 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.gravity * (score - expected_fractional_score(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 pre-game standard deviation
+    #
+    # This slightly increases the standard deviation in case the player has
+    # been stagnant for a rating period.
+    def standard_deviation_pre
+      [Math.sqrt(variance + volatility ** 2), MIN_SD].min
+    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 next_volatility(others, scores, v)
+      d, a, b = next_volatility_setup(others, scores, v)
+      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
+
+    def next_standard_deviation(v)
+      1 / Math.sqrt(1 / standard_deviation_pre ** 2 + 1 / v)
+    end
+
+    def next_mean(others, scores, next_sd)
+      others.zip(scores).reduce(0) { |x, (other, score)|
+        x + other.gravity * (score - expected_fractional_score(other))
+      } * next_sd ** 2.0 + mean
+    end
+
+    def to_s
+      "#<Rating mean=#{mean}, sd=#{sd}, volatility=#{volatility}>"
+    end
+
+    private
+
+    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
+    end
+
+    def next_volatility_setup(others, scores, v)
+      d = delta(others, scores)
+      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
+      [d, a, b]
+    end
+
+  end
+end

data/lib/glicko2/rating_period.rb

@@ -0,0 +1,70 @@
+module Glicko2
+  # Glicko ratings are calculated in bulk at the end of arbitrary, but fixed
+  # length, periods named rating periods. Where a period is fixed to be long
+  # enough that the average number of games that each player has played in is
+  # about 5 to 10 games. It could be weekly, monthly or more as required.
+  class RatingPeriod
+    attr_reader :players
+
+    # @param [Array<Player>] players
+    def initialize(players)
+      @players = players
+      @games = Hash.new { |h, k| h[k] = [] }
+      @cache = players.reduce({}) do |memo, player|
+        raise DuplicatePlayerError if memo[player.obj] != nil
+        memo[player.obj] = player
+        memo
+      end
+    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) })
+    end
+
+    # Register a game with this rating period
+    #
+    # @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)]
+        end
+      end
+    end
+
+    # Generate a new {RatingPeriod} with a new list of updated {Player}
+    #
+    # @return [RatingPeriod]
+    def generate_next
+      p = []
+      @players.each do |player|
+        games = @games[player]
+        if games.compact.length > 0
+          p << player.generate_next(*games.transpose)
+        else
+          p << player.generate_next([], [])
+        end
+      end
+      self.class.new(p)
+    end
+
+    # Fetch the player associated with a seed object
+    #
+    # @param [#rating,#rating_deviation,#volatility] obj seed object
+    # @return [Player]
+    def player(obj)
+      @cache[obj]
+    end
+
+    def to_s
+      "#<RatingPeriod players=#{@players}"
+    end
+  end
+end

data/lib/glicko2/version.rb

@@ -0,0 +1,3 @@
+module Glicko2
+  VERSION = "0.1.3"
+end

data/spec/minitest_helper.rb

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

data/spec/normal_distribution_spec.rb

@@ -0,0 +1,98 @@
+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
+
+  describe "#<=>" do
+    let(:dist1) { Glicko2::NormalDistribution.new(10.0, 0.5) }
+    let(:dist2) { Glicko2::NormalDistribution.new(5.0, 1.0) }
+
+    it "must compare the same mean" do
+      (dist1 <=> dist1).must_equal 0
+      (dist2 <=> dist2).must_equal 0
+    end
+
+    it "must compare against smaller mean" do
+      (dist1 <=> dist2).must_equal 1
+    end
+
+    it "must compare against larger mean" do
+      (dist2 <=> dist1).must_equal -1
+    end
+
+    describe "Comparable" do
+      it "must compare" do
+        (dist1 == dist1).must_equal true
+        (dist2 == dist2).must_equal true
+        (dist1 > dist2).must_equal true
+        (dist1 < dist2).must_equal false
+        (dist2 > dist1).must_equal false
+        (dist2 < dist1).must_equal true
+      end
+    end
+  end
+end

data/spec/player_spec.rb

@@ -0,0 +1,76 @@
+require 'minitest_helper'
+
+describe Glicko2::Player do
+  before do
+    @player = Glicko2::Player.from_obj(Rating.new(1500, 200, 0.06))
+    @player1 = Glicko2::Player.from_obj(Rating.new(1400, 30, 0.06))
+    @player2 = Glicko2::Player.from_obj(Rating.new(1550, 100, 0.06))
+    @player3 = Glicko2::Player.from_obj(Rating.new(1700, 300, 0.06))
+    @others = [@player1, @player2, @player3]
+    @scores = [1, 0, 0]
+  end
+
+  describe ".from_obj" do
+    it "must create player from an object as example" do
+      @player.mean.must_be_close_to 0, 0.0001
+      @player.sd.must_be_close_to 1.1513, 0.0001
+      @player.volatility.must_equal 0.06
+    end
+
+    it "must create player from an object as example 1" do
+      @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
+
+    it "must create player from an object as example 2" do
+      @player2.mean.must_be_close_to 0.2878, 0.0001
+      @player2.sd.must_be_close_to 0.5756, 0.0001
+      @player2.volatility.must_equal 0.06
+    end
+
+    it "must create player from an object as example 3" do
+      @player3.mean.must_be_close_to 1.1513, 0.0001
+      @player3.sd.must_be_close_to 1.7269, 0.0001
+      @player3.volatility.must_equal 0.06
+    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/rating_period_spec.rb

@@ -0,0 +1,45 @@
+require 'minitest_helper'
+
+describe Glicko2::RatingPeriod do
+  before do
+    @player = Rating.new(1500, 200, 0.06)
+    @player1 = Rating.new(1400, 30, 0.06)
+    @player2 = Rating.new(1550, 100, 0.06)
+    @player3 = Rating.new(1700, 300, 0.06)
+    @players = [@player, @player1, @player2, @player3]
+    @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 }
+      obj = @player
+      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
+
+    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
+    end
+  end
+end

data/spec/rating_spec.rb

@@ -0,0 +1,53 @@
+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)
+    @others = [@rating1, @rating2, @rating3]
+    @scores = [1, 0, 0]
+  end
+
+  describe "#gravity" do
+    it "must be close to example 1" do
+      @rating1.gravity.must_be_close_to 0.9955, 0.0001
+    end
+
+    it "must be close to example 2" do
+      @rating2.gravity.must_be_close_to 0.9531, 0.0001
+    end
+
+    it "must be close to example 3" do
+      @rating3.gravity.must_be_close_to 0.7242, 0.0001
+    end
+  end
+
+  describe "#expected_fractional_score" do
+    it "must be close to example 1" do
+      @rating.expected_fractional_score(@rating1).must_be_close_to 0.639
+    end
+
+    it "must be close to example 2" do
+      @rating.expected_fractional_score(@rating2).must_be_close_to 0.432
+    end
+
+    it "must be close to example 3" do
+      @rating.expected_fractional_score(@rating3).must_be_close_to 0.303
+    end
+  end
+
+  describe "#estimated_variance" do
+    it "must be close to example" do
+      @rating.estimated_variance(@others).must_be_close_to 1.7785
+    end
+  end
+
+  describe "#delta" do
+    it "must be close to example" do
+      @rating.delta(@others, @scores).must_be_close_to -0.4834
+    end
+  end
+
+end

data/spec/util_spec.rb

@@ -0,0 +1,17 @@
+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
+
+    it "must return 0.0 when rank is more" do
+      Glicko2::Util.ranks_to_score(2, 1).must_equal 0.0
+    end
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: compact-glicko2
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- James Fargher
+- Andrej Antas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: 4.7.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.7.5
+description: Implementation of Glicko2 ratings with compact rule
+email:
+- proglottis@gmail.com
+- andrej@antas.cz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- glicko2.gemspec
+- lib/glicko2.rb
+- lib/glicko2/normal_distribution.rb
+- lib/glicko2/player.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/rating_period_spec.rb
+- spec/rating_spec.rb
+- spec/util_spec.rb
+homepage: https://github.com/redrick/glicko2
+licenses: []
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Implementation of Glicko2 ratings with compact rule
+test_files:
+- spec/minitest_helper.rb
+- spec/normal_distribution_spec.rb
+- spec/player_spec.rb
+- spec/rating_period_spec.rb
+- spec/rating_spec.rb
+- spec/util_spec.rb