class CrashingTheDance::RpiCalculator::RPI

Attributes

games[R]
games_conference[R]
games_nonconference[R]
losses[R]
losses_conference[R]
losses_nonconference[R]
rpi_losses[R]
rpi_losses_conference[R]
rpi_losses_nonconference[R]
rpi_wins[R]
rpi_wins_conference[R]
rpi_wins_nonconference[R]
team[R]
wins[R]
wins_conference[R]
wins_nonconference[R]

Public Class Methods

new(team, games) click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 13
def initialize(team, games)
  @team = team
  initialize_games(games)
  initialize_rpi
  calculate_record
end

Public Instance Methods

calculate_conference_oowp(all_teams) click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 128
def calculate_conference_oowp(all_teams)
  if games_conference.count > 0
    sum_oowp = games_conference.inject(0.0) do |sum, game|
      opponent = all_teams.find { |t| game.opponent.eql? t.team }
      sum + opponent.owp
    end
    @oowp_conference = sum_oowp / games_conference.count.to_f
  end
end
calculate_conference_owp(games_by_team) click to toggle source

hate this repitition but not yet sure how to consolidate the logic is roughly the same, but they set separate instance variables

# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 117
def calculate_conference_owp(games_by_team)
  if games_conference.count > 0
    sum_owp = games_conference.inject(0.0) do |sum, game|
      sked = opponent_schedule game.opponent, games_by_team
      ow = sked.inject(0) { |wins, og| wins + og.wins }
      sum + (sked.empty? ? 0.0 : (ow.to_f / sked.count.to_f))
    end
    @owp_conference = sum_owp / games_conference.count.to_f
  end
end
calculate_nonconference_oowp(all_teams) click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 149
def calculate_nonconference_oowp(all_teams)
  if games_nonconference.count > 0
    sum_oowp = games_nonconference.inject(0.0) do |sum, game|
      opponent = all_teams.find { |t| game.opponent.eql? t.team }
      sum + opponent.owp
    end
    @oowp_nonconference = sum_oowp / games_nonconference.count.to_f
  end
end
calculate_nonconference_owp(games_by_team) click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 138
def calculate_nonconference_owp(games_by_team)
  if games_nonconference.count > 0
    sum_owp = games_nonconference.inject(0.0) do |sum, game|
      sked = opponent_schedule game.opponent, games_by_team
      ow = sked.inject(0) { |wins, og| wins + og.wins }
      sum + (sked.empty? ? 0.0 : (ow.to_f / sked.count.to_f))
    end
    @owp_nonconference = sum_owp / games_nonconference.count.to_f
  end
end
calculate_oowp(all_teams) click to toggle source

Now to calculate the opponents’ opponents winning percentage (OOWP), you simply average the OWPs for each of their opponents.

# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 104
def calculate_oowp(all_teams)
  if games.count > 0
    sum_oowp = games.inject(0.0) do |sum, game|
      opponent = all_teams.find { |t| game.opponent.eql? t.team }
      sum + opponent.owp
    end
    @oowp = sum_oowp / games.count.to_f
  end
end
calculate_owp(games_by_team) click to toggle source

To calculate opponent’s winning percentage (OWP), you remove games against the team in question. However, for the purpose of calculating OWP and OOWP, use standard WP.

# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 91
def calculate_owp(games_by_team)
  if games.count > 0
    sum_owp = games.inject(0.0) do |sum, game|
      sked = opponent_schedule game.opponent, games_by_team
      ow = sked.inject(0) { |wins, og| wins + og.wins }
      sum + (sked.empty? ? 0.0 : (ow.to_f / sked.count.to_f))
    end
    @owp = sum_owp / games.count.to_f
  end
end
oowp() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 56
def oowp
  @oowp
end
oowp_conference() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 64
def oowp_conference
  @oowp_conference
end
oowp_nonconference() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 72
def oowp_nonconference
  @oowp_nonconference
end
owp() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 52
def owp
  @owp
end
owp_conference() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 60
def owp_conference
  @owp_conference
end
owp_nonconference() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 68
def owp_nonconference
  @owp_nonconference
end
rpi() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 76
def rpi
  @rpi ||= calculate_rpi
end
rpi_conference() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 80
def rpi_conference
  @rpi_conference ||= calculate_rpi_conference
end
rpi_nonconference() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 84
def rpi_nonconference
  @rpi_nonconference ||= calculate_rpi_nonconference
end
rpi_win_percentage() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 28
def rpi_win_percentage
  if games.count > 0
    rpi_wins / (rpi_wins + rpi_losses)
  else
    0.0
  end
end
rpi_win_percentage_conference() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 36
def rpi_win_percentage_conference
  if games_conference.count > 0
    rpi_wins_conference / (rpi_wins_conference + rpi_losses_conference)
  else
    0.0
  end
end
rpi_win_percentage_nonconference() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 44
def rpi_win_percentage_nonconference
  if games_nonconference.count > 0
    rpi_wins_nonconference / (rpi_wins_nonconference + rpi_losses_nonconference)
  else
    0.0
  end
end
win_percentage() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 20
def win_percentage
  if games.count > 0
    wins.to_f / (wins.to_f + losses.to_f)
  else
    0.0
  end
end

Private Instance Methods

calculate_record() click to toggle source

w/l is commonly used, so can we extract it to a module?

# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 199
def calculate_record
  initialize_wl
  initialize_wl_conference
  initialize_wl_nonconference
  games.each do |game|
    calculate_wl game
    calculate_wl_conference game
    calculate_wl_nonconference game
  end
end
calculate_rpi() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 179
def calculate_rpi
  0.25 * rpi_win_percentage + 0.5 * owp + 0.25 * oowp
end
calculate_rpi_conference() click to toggle source

these are common, how can we consolidate?

# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 184
def calculate_rpi_conference
  0.25 * rpi_win_percentage_conference + 0.5 * owp_conference + 0.25 * oowp_conference
end
calculate_rpi_nonconference() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 188
def calculate_rpi_nonconference
  0.25 * rpi_win_percentage_nonconference + 0.5 * owp_nonconference + 0.25 * oowp_nonconference
end
calculate_wl(game) click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 225
def calculate_wl(game)
    @wins       += 1 if game.win?
    @losses     += 1 if game.loss?
    @rpi_wins   += game.rpi_wins
    @rpi_losses += game.rpi_losses
end
calculate_wl_conference(game) click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 232
def calculate_wl_conference(game)
  if game.conference?
    @wins_conference       += 1 if game.win?
    @losses_conference     += 1 if game.loss?
    @rpi_wins_conference   += game.rpi_wins
    @rpi_losses_conference += game.rpi_losses
  end
end
calculate_wl_nonconference(game) click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 241
def calculate_wl_nonconference(game)
  unless game.conference?
    @wins_nonconference       += 1 if game.win?
    @losses_nonconference     += 1 if game.loss?
    @rpi_wins_nonconference   += game.rpi_wins
    @rpi_losses_nonconference += game.rpi_losses
  end
end
initialize_games(games) click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 161
def initialize_games(games)
  @games = games
  @games_conference = games.select { |game| game.conference? }
  @games_nonconference = games.reject { |game| game.conference? }
end
initialize_rpi() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 167
def initialize_rpi
  @owp = 0.0
  @oowp = 0.0
  @owp_conference = 0.0
  @oowp_conference = 0.0
  @owp_nonconference = 0.0
  @oowp_nonconference = 0.0
  @rpi = nil
  @rpi_conference = nil
  @rpi_nonconference = nil
end
initialize_wl() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 210
def initialize_wl
  @wins = @rpi_wins = 0
  @losses = @rpi_losses = 0
end
initialize_wl_conference() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 215
def initialize_wl_conference
  @wins_conference = @rpi_wins_conference = 0
  @losses_conference = @rpi_losses_conference = 0
end
initialize_wl_nonconference() click to toggle source
# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 220
def initialize_wl_nonconference
  @wins_nonconference = @rpi_wins_nonconference = 0
  @losses_nonconference = @rpi_losses_nonconference = 0
end
opponent_schedule(opponent, games_by_team) click to toggle source

filters out games against this team

# File lib/crashing_the_dance/rpi_calculator/rpi.rb, line 193
def opponent_schedule(opponent, games_by_team)
 all = games_by_team[opponent] || []
 all.reject { |game| game.opponent.eql? team }
end