elo_demo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e726a1cf9b570c320a2db70e33cdb574fa3e6a49
+  data.tar.gz: e6feab4d422bd8db9f8a915406e55875184c120c
+SHA512:
+  metadata.gz: f422db78f8176d2ef7801552fcf460e749f73b1cdd435681dfaa733a80a091a206d582c342b59afaabde167b2ac114ad03f475b239d5022293cd39b253606644
+  data.tar.gz: 4539decaa860a62c0dd6192a7c2ef47b69d042de16f7ab053439d7dcdd80e0e933a942b4608aac8b21c766e91569a9beac2aebeef849109b4211a8b057980f9e

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.13.1

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+ruby '2.3.1'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 TODO: Write your name
+
+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,162 @@
+# Elo Rating Demonstration
+
+Most people do ranking wrong. In this small demonstration I have 10 players battling each other through 1,000 random matches.
+
+The most naive sorting would be to create a simple score (such as number of wins subtracted by number of loses). In this case, this is the simple ranking:
+
+```
+Ranking sorted by Points (wins - loses)
+    Name        Games  Wins  Loses  Points  Elo Rating
+  1 Kong          217   117    100     17         802
+  2 Samus         211   110    101      9         842
+  3 Wario         197   102     95      7         824
+  4 Luigi         186    95     91      4         841
+  5 Zelda         160    81     79      2         847
+  6 Pikachu       209   105    104      1         851
+  7 Yoshi         223   112    111      1         803
+  8 Mario         203   101    102     -1         820
+  9 Fox           208    95    113    -18         754
+ 10 Bowser        186    82    104    -22         785
+```
+
+Now we make Samus (2nd) wins from Wario (3rd) 10 times in a row, without no one else battling this time.
+
+```
+Ranking sorted by Points (wins - loses)
+    Name        Games  Wins  Loses  Points  Elo Rating
+  1 Samus         221   120    101     19         896
+  2 Kong          217   117    100     17         802
+  3 Luigi         186    95     91      4         841
+  4 Zelda         160    81     79      2         847
+  5 Pikachu       209   105    104      1         851
+  6 Yoshi         223   112    111      1         803
+  7 Mario         203   101    102     -1         820
+  8 Wario         207   102    105     -3         760
+  9 Fox           208    95    113    -18         754
+ 10 Bowser        186    82    104    -22         785
+```
+
+You can see that Samus went to the top of the ranking while poor Wario drastically dropped from 3rd to 8th place.
+
+This is very unfair as Wario was already weaker than then Samus so the odds of him winning were not high to begin with, and the penalty of trying against a stronger opponent made him drop a lot in the ranking.
+
+Let's try to make Kong (2nd) losing to Bowser (10th) 10 times.
+
+```
+Ranking sorted by Points (wins - loses)
+    Name        Games  Wins  Loses  Points  Elo Rating
+  1 Samus         221   120    101     19         896
+  2 Kong          227   117    110      7         732
+  3 Luigi         186    95     91      4         841
+  4 Zelda         160    81     79      2         847
+  5 Pikachu       209   105    104      1         851
+  6 Yoshi         223   112    111      1         803
+  7 Mario         203   101    102     -1         820
+  8 Wario         207   102    105     -3         760
+  9 Bowser        196    92    104    -12         845
+ 10 Fox           208    95    113    -18         754
+```
+
+Now even though Kong was supposed to have better odds for being stronger, he lost 10 times in a row but he's still at 2nd place.
+
+And Bowser, who performed an impressive winning streak of 10 wins agains the 2nd most stronger, still only jumped up one position in the ranking, to 9th place.
+
+Again, this is very unfair. And this is why simple counting methods such as absolute ammout of wins and loses are not used in real rankings.
+
+
+## Elo Rating Run
+
+Starting over with the exact 1,000 matches in the exact same order and win x lose scenario, we already arrive to a very different ranking than the first one:
+
+In the naive system, the current top player Pikachu was only in 6th, and Kong, who is at 8th here was considered the top player.
+
+```
+Ranking sorted by Elo Rating
+    Name        Games  Wins  Loses  Points  Elo Rating
+  1 Pikachu       209   105    104      1         851
+  2 Zelda         160    81     79      2         847
+  3 Samus         211   110    101      9         842
+  4 Luigi         186    95     91      4         841
+  5 Wario         197   102     95      7         824
+  6 Mario         203   101    102     -1         820
+  7 Yoshi         223   112    111      1         803
+  8 Kong          217   117    100     17         802
+  9 Bowser        186    82    104    -22         785
+ 10 Fox           208    95    113    -18         754
+```
+
+Now let's make Zelda (2nd) win from Samus (3rd) 10 times.
+
+They are almost evenly matched (almost same level in the ranking), so Zelda jumps to 1st place and Samus drops from 3rd to 9th.
+
+```
+Ranking sorted by Elo Rating
+    Name        Games  Wins  Loses  Points  Elo Rating
+  1 Zelda         170    91     79     12         904
+  2 Pikachu       209   105    104      1         851
+  3 Luigi         186    95     91      4         841
+  4 Wario         197   102     95      7         824
+  5 Mario         203   101    102     -1         820
+  6 Yoshi         223   112    111      1         803
+  7 Kong          217   117    100     17         802
+  8 Bowser        186    82    104    -22         785
+  9 Samus         221   110    111     -1         775
+ 10 Fox           208    95    113    -18         754
+```
+
+Now let's try the improbable scenario of Pikachu (2nd) losing to Fox (10th) 10 times.
+
+```
+Ranking sorted by Elo Rating
+    Name        Games  Wins  Loses  Points  Elo Rating
+  1 Zelda         170    91     79     12         904
+  2 Luigi         186    95     91      4         841
+  3 Fox           218   105    113     -8         829
+  4 Wario         197   102     95      7         824
+  5 Mario         203   101    102     -1         820
+  6 Yoshi         223   112    111      1         803
+  7 Kong          217   117    100     17         802
+  8 Bowser        186    82    104    -22         785
+  9 Samus         221   110    111     -1         775
+ 10 Pikachu       219   105    114     -9         766
+```
+
+They almost swapped positions because by the skill reflected in the ranking, Pikachu had a higher probability of winning against a 'weak' opponent such as Fox.
+
+But instead, Fox did an impressive winning streak, so he deserved jumping up from 10th to 3rd, and Pikachu suffered a severe penalty of dropping from 3rd to 10th for losing so many times.
+
+This is a much fair system where we use the probability of wins and loses.
+
+If a strong player does a match against a weaker player, he shouldn't jump up too much in the ranking while the weaker shouldn't drop down so much from the ranking, as it's all expected outcomes.
+
+Now, in the case of improbable matches where a stronger player loses against a weaker player, the stronger should drop down a lot more and the weaker should jump up a lot more as reward.
+
+This motivates the stronger player to play their best to stay up and the weaker to risk against stronger opponents to wield better rewards.
+
+That's what makes a more competitive environment for players.
+
+## Installation
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install elo_demo
+
+## Usage
+
+Just execute the scenario runner:
+
+    $ bin/run_demo
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/akitaonrails/elo_demo.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "elo_demo"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/run_demo

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "elo_demo"
+
+puts "##"
+puts "## NAIVE RUN"
+
+t = EloDemo::Tournment.new
+t.run!
+t.print_naive_ranking
+
+attempts = 10
+
+second_player = t.sorted_by_naive[1]
+third_player = t.sorted_by_naive[2]
+
+puts "#{second_player.name} (2nd) wins from #{third_player.name} (3rd) #{attempts} times"
+attempts.times do
+  t.mark_win(second_player, third_player)
+end
+
+t.print_naive_ranking
+
+second_player = t.sorted_by_naive[1]
+worst_player = t.sorted_by_naive.last
+
+puts "#{second_player.name} (2nd) loses to #{worst_player.name} (10th) #{attempts} times"
+attempts.times do
+  t.mark_win(worst_player, second_player)
+end
+
+t.print_naive_ranking
+
+fourth_player = t.sorted_by_naive[3]
+fifth_player = t.sorted_by_naive[4]
+
+puts "#{fourth_player.name} (4th) wins to #{fifth_player.name} (5th) #{attempts} times"
+attempts.times do
+  t.mark_win(fourth_player, fifth_player)
+end
+
+t.print_naive_ranking
+
+
+
+
+puts "##"
+puts "## ELO RUN"
+
+t = EloDemo::Tournment.new
+t.run!
+t.print_elo_ranking
+
+attempts = 10
+
+second_player = t.sorted_by_elo[1]
+third_player = t.sorted_by_elo[2]
+
+puts "#{second_player.name} (2nd) wins from #{third_player.name} (3rd) #{attempts} times"
+attempts.times do
+  t.mark_win(second_player, third_player)
+end
+
+t.print_elo_ranking
+
+second_player = t.sorted_by_elo[1]
+worst_player = t.sorted_by_elo.last
+
+puts "#{second_player.name} (2nd) loses to #{worst_player.name} (10th) #{attempts} times"
+attempts.times do
+  t.mark_win(worst_player, second_player)
+end
+
+t.print_elo_ranking
+
+fourth_player = t.sorted_by_elo[3]
+fifth_player = t.sorted_by_elo[4]
+
+puts "#{fourth_player.name} (4th) wins to #{fifth_player.name} (5th) #{attempts} times"
+attempts.times do
+  t.mark_win(fourth_player, fifth_player)
+end
+
+t.print_elo_ranking

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/elo_demo.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'elo_demo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "elo_demo"
+  spec.version       = EloDemo::VERSION
+  spec.authors       = ["Fabio Akita"]
+  spec.email         = ["boss@akitaonrails.com"]
+
+  spec.summary       = %q{This is a short demonstration of one of the most miunderstood topic in programming: ranking}
+  spec.description   = %q{This short demo will show what most people think of ranking and what the beginnings of a good ranking system actually look like}
+  spec.homepage      = "https://github.com/akitaonrails/elo_demo"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "elo", "~> 0.1.0"
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/elo_demo.rb

@@ -0,0 +1,87 @@
+require "elo_demo/version"
+require "elo"
+
+module EloDemo
+  class Player
+    attr_accessor :name, :games_played, :wins, :loses, :elo_player
+    def initialize(options = {})
+      self.name = options[:name]
+      self.games_played = options[:games_played] || 0
+      self.wins = options[:wins] || 0
+      self.loses = options[:loses] || 0
+      self.elo_player = Elo::Player.new
+    end
+  end
+
+  class Tournment
+    attr_reader :players
+    NAMES = %w[Mario Luigi Zelda Bowser Yoshi Wario Fox Pikachu Kong Samus Kirby]
+
+    def initialize
+      srand(666)
+
+      @players = []
+      10.times do |i|
+        @players << Player.new(name: NAMES[i])
+      end
+    end
+
+    def run!
+      1000.times do
+        player_0 = @players[rand(1..players.size) - 1]
+        player_1 = @players[rand(1..players.size) - 1]
+        game = [player_0, player_1]
+        winner = game[rand(0..1)]
+
+        if player_0.name == winner.name
+          mark_win(player_0, player_1)
+        else
+          mark_win(player_1, player_0)
+        end
+      end
+    end
+
+    def mark_win(p1, p2)
+      p1.games_played += 1
+      p2.games_played += 1
+      p1.wins += 1
+      p2.loses += 1
+      p1.elo_player.wins_from(p2.elo_player)
+    end
+
+    def print_ranking
+      print_naive_ranking
+      print_elo_ranking
+    end
+
+    def print_naive_ranking
+      puts "Ranking sorted by Points (wins - loses)"
+      puts "    #{"Name".ljust(10)}  Games  Wins  Loses  Points  Elo Rating"
+      sorted_by_naive.each_with_index do |p, index|
+        print_line p, index + 1
+      end
+      puts ""
+    end
+
+    def print_elo_ranking
+      puts "Ranking sorted by Elo Rating"
+      puts "    #{"Name".ljust(10)}  Games  Wins  Loses  Points  Elo Rating"
+      sorted_by_elo.each_with_index do |p, index|
+        print_line p, index + 1
+      end
+      puts ""
+    end
+
+    def sorted_by_naive
+      players.sort_by { |p| p.wins - p.loses }.reverse
+    end
+
+    def sorted_by_elo
+      players.sort_by { |p| p.elo_player.rating }.reverse
+    end
+
+    def print_line(p, index)
+      puts "#{index.to_s.rjust(3)} #{p.name.ljust(10)}  #{p.games_played.to_s.rjust(5)}  #{p.wins.to_s.rjust(4)}  #{p.loses.to_s.rjust(5)}  #{(p.wins - p.loses).to_s.rjust(5)}  #{p.elo_player.rating.to_s.rjust(10)}"
+    end
+  end
+end

data/lib/elo_demo/version.rb

@@ -0,0 +1,3 @@
+module EloDemo
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: elo_demo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Fabio Akita
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-11-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: elo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !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: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: This short demo will show what most people think of ranking and what
+  the beginnings of a good ranking system actually look like
+email:
+- boss@akitaonrails.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/run_demo
+- bin/setup
+- elo_demo.gemspec
+- lib/elo_demo.rb
+- lib/elo_demo/version.rb
+homepage: https://github.com/akitaonrails/elo_demo
+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.5.1
+signing_key: 
+specification_version: 4
+summary: 'This is a short demonstration of one of the most miunderstood topic in programming:
+  ranking'
+test_files: []