Calculadora de ELO

elo_calculator.rb

# Calculo del coeficiente K
#
# Ejemplo de uso:
#
# Si la cantidad de partidas es menor a 15 => k = 25
# Si el elo es menor a 1400 => k = 25
# Si el elo es menor a 2000 => k = 20
# De otra forma, k = 15
#   EloCalculator.set_kfactor_rule :games => true, :lt => 15,   :k => 25
#   EloCalculator.set_kfactor_rule :elo   => true, :lt => 1400, :k => 25
#   EloCalculator.set_kfactor_rule :elo   => true, :lt => 2000, :k => 20
#   EloCalculator.set_kfactor_rule :default => 15
class EloCalculator

  
  def self.set_kfactor_rule( options )
    check_options options
    kfactor_rules << options
  end
  
  def self.kfactor_rules
    @k ||= []
  end
  
  def  self.kfactor_reset
    @k = []
  end

  def self.get_kfactor( elo, games )
    k_default = 32
    kfactor_rules.each{ |rule|
      if rule[:elo] && rule[:gt] && elo > rule[:gt]
        return rule[:k]
      elsif rule[:elo] && rule[:lt] && elo < rule[:lt]
        return rule[:k]
      elsif rule[:games] && rule[:gt] && games > rule[:gt]
        return rule[:k]
      elsif rule[:games] && rule[:lt] && games < rule[:lt]
        return rule[:k]
      elsif rule[:default]
        k_default = rule[:default]
      end
    }
    return k_default

  end

  def self.calculate( elo_a, games_a, elo_b, games_b )
    wA = 1.0 / ( 1 + 10 ** ( ( elo_b - elo_a ) / 400.0 ) )
    wB = 1.0 / ( 1 + 10 ** ( ( elo_a - elo_b ) / 400.0 ) )
    k = get_kfactor( elo_a, games_a ).to_f
    new_a = { :win  => elo_a + k * ( 1.0 - wA ),
              :draw => elo_a + k * ( 0.5 - wA ),
              :lose => elo_a + k * (     - wA ),
              :win_diff  => k * ( 1.0 - wA ),
              :draw_diff => k * ( 0.5 - wA ),
              :lose_diff => k * (     - wA ) }
              
    k = get_kfactor( elo_b, games_b ).to_f
    new_b = { :win  => elo_b + k * ( 1.0 - wB ),
              :draw => elo_b + k * ( 0.5 - wB ),
              :lose => elo_b + k * (     - wB ),
              :win_diff  => k * ( 1.0 - wB ),
              :draw_diff => k * ( 0.5 - wB ),
              :lose_diff => k * (     - wB ) }
    [ new_a, new_b ]
  end

  private
  def  self.check_options( options )
    # valid = [ :elo, :gt, :lt, :games, :k ]
    has_operand  = false
    has_operator = false
    has_k  = false
    options.keys.each{ |k|
      # raise "#{k} option unknown" unless valid.include?( k )
      if k == :k
        has_k  = true
      elsif [:gt,:lt].include? k
        has_operator = true
      elsif [:elo,:games].include? k
        has_operand  = true
      elsif k == :default
        has_k        = true
        has_operand  = true
        has_operator = true
      else
        raise "#{k} option unknown"  # SQ
      end
    }

    raise "K not defined " unless has_k
    raise "Operand (Elo or games) not defined " unless has_operand
    raise "Operator (gt or lt) not defined " unless has_operator
  end

end

elo_calculator_example.rb

# Definicion de las reglas para el cálculo de ELO
# para Opengames.

# Si la cantidad de juegos es menor que 15, el coeficiente es 50
EloCalculator.set_kfactor_rule :games => true, :lt => 15,   :k => 50

# Si el Elo es menor que 1400, el K es 50
EloCalculator.set_kfactor_rule :elo   => true, :lt => 1400, :k => 50

# Si el Elo es menor que 1700, el K es 40
EloCalculator.set_kfactor_rule :elo   => true, :lt => 1700, :k => 40

# Si el Elo es menor que 2000, el K es 30
EloCalculator.set_kfactor_rule :elo   => true, :lt => 2000, :k => 30

# Si el Elo es menor que 2300, el K es 25   
  EloCalculator.set_kfactor_rule :elo   => true, :lt => 2300, :k => 25

# En cualquier otro caso (Elos mayores a 2300), el K es 15
EloCalculator.set_kfactor_rule :default => 15