oddsmaker 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1376d7ace6063ba0f7eaf60c8dc1b35d76bb505d
+  data.tar.gz: e01409a3acd1fdb92da2cce2223b35b6987832e3
+SHA512:
+  metadata.gz: d9184cc277ac8eaeb9d9a4fb1475c2c9a37341531ffd995f84e2ebf47d763bb7e736c15881379fefb9a69ec3473eb9ad76d75e293f436654ba45e2bd9fca985a
+  data.tar.gz: 92c6699135010fd0734d7edbbfa229c76af9b159c6a785121313fa836a037dc978b8ac7cbc05aaf1ad3d17b248cf498a5729e2db68bf5af6a45b2a49a70ea837

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,8 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.4
+  - 2.4.1
+  - ruby-head
+  - jruby-head
+before_install: gem install bundler -v 1.15.3

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Paul Hoffer
+
+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,99 @@
+# Oddsmaker
+
+Oddsmaker is to represent and manipulate betting odds. Multiple odds can be represented together, as a `Market`. A `Market` is able to calculate total probability and vig, and can also calculate true probabilities (total of 100%) and calculate overrounded odds (greater than 100%).
+
+Oddsmaker can handle American odds, decimal odds, fractional odds, and implied probability, and allows for easy conversion between all of those types.
+
+[SportsBookReview](https://www.sportsbookreview.com/picks/tools/odds-converter/) has an excellent page which explains the different types of odds and converts between them.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'oddsmaker'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install oddsmaker
+
+## Usage
+
+Let's start with a simple odd:
+
+```ruby
+# create an Odd
+odd = Oddsmaker::Odd.american(300)  # => <Oddsmaker::Odd::American @id=300, @value=300>
+odd = Oddsmaker::Odd.american('+300', 'underdog')  # optional 2nd param allows for identifying the odd
+odd       # => <Oddsmaker::Odd::American @id="underdog", @value=300>
+odd.name  # => "underdog"
+odd.value # => 300
+odd.to_s  # => "+300"
+
+# can convert between formats
+odd.decimal               # => <Oddsmaker::Odd::Decimal @id="underdog, @value=4.0>
+odd.fractional            # => <Oddsmaker::Odd::Fractional @id="underdog, @value=(3/1)>
+odd.implied_probability   # => <Oddsmaker::Odd::ImpliedProbability @id="underdog", @value=0.25>
+
+# easy creation any type of odd
+# any odd type can be compared as well
+Oddsmaker::Odd.american(300) == Oddsmaker::Odd.decimal(4)
+Oddsmaker::Odd.decimal(4) == Oddsmaker::Odd.fractional(3/1)
+Oddsmaker::Odd.fractional(3/1) == Oddsmaker::Odd.implied(25)
+Oddsmaker::Odd.implied(25) == Oddsmaker::Odd.american(300)
+
+Oddsmaker::Odd.american(300, 'underdog').to_json # => {"name":"underdog","american":300,"decimal":4.0,"fractional":"3/1","implied":0.25}
+```
+
+A collection of `Odd`s can be represented as a `Market`:
+
+```ruby
+# Create a Market with odds as the arguments
+market = Oddsmaker::Market.new(Oddsmaker::Odd.american(300), Oddsmaker::Odd.american(-400))
+market.total_probability    # => 1.05
+market.vig                  # => 0.04761904761904767 (equivalent to (1 - total_probability**-1))
+
+# get the odds without vig
+no_vig = market.without_vig   # => new market with the vig/overround removed
+no_vig.odds                   # => [#<Oddsmaker::Odd::American @id=300, @value=320>, #<Oddsmaker::Odd::American @id=-400, @value=-320>]
+no_vig.total_probability      # => 1.0
+no_vig.vig                    # => 0
+
+# apply an overround to have vigged odds
+vigged = no_vig.overround!(5) # => 5% overround, returns a new Market
+vigged.odds                   # => [#<Oddsmaker::Odd::American @id=300, @value=300>, #<Oddsmaker::Odd::American @id=-400, @value=-400>]
+vigged.total_probability      # => 1.05
+vigged.vig                    # => 0.04761904761904767
+
+vigged == market              # => true # equality comparison only cares about the odds' values. Name and ordering is not relevant
+```
+
+There is also functionality for calculating wagers:
+
+```ruby
+odd = Oddsmaker::Odd.american(300)  # => <Oddsmaker::Odd::American @id=300, @value=300>
+wager = odd.wager(100)              # => <Oddsmaker::Wager @amount=100, @odd=#<Oddsmaker::Odd::American @id=300, @value=300>>
+wager.amount                        # => 100
+wager.profit                        # => 300
+wager.return                        # => 400
+
+# odds are able to calculate their own profit for a wager amount
+odd.profit(100)                     # => 300
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/phoffer/oddsmaker.
+
+## 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,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "oddsmaker"
+
+# 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.
+
+require "pry"
+Pry.start

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/lib/oddsmaker.rb

@@ -0,0 +1,17 @@
+require 'bigdecimal'
+require "oddsmaker/version"
+require "oddsmaker/market"
+require "oddsmaker/odd"
+require "oddsmaker/wager"
+require "oddsmaker/odd/base"
+require "oddsmaker/odd/implied_probability"
+require "oddsmaker/odd/american"
+require "oddsmaker/odd/decimal"
+require "oddsmaker/odd/fractional"
+
+# Oddsmaker is to assist with the calculations involved with betting, especially sports betting.
+# Both a single odd and a set of odds can be represented and manipulated.
+# Additionally, wagers can be represented, allowing for flexibility in calculating profit/return.
+module Oddsmaker
+  
+end

data/lib/oddsmaker/market.rb

@@ -0,0 +1,115 @@
+module Oddsmaker
+  # Market is a container of multiple odds. This is useful to represent the full data of sports betting.
+  # A generic moneyline of +300/-400 can be represented by a market, containing both of the individual odds.
+  # This also allows for calculating the total probability, which will be over 100% if set by a sportsbook.
+  # Additional functions include the ability to determine the odds without vig (the book's profit),
+  # and the ability to calculate odds for a given overround (the total probability above 100%).
+  class Market
+    attr_reader :odds, :vigged, :name
+
+    def initialize(*odds, name: nil)
+      @name = name
+      @odds = odds.flatten
+    end
+
+    # Retrieve an odd by identifier.
+    # 
+    # @param id [String, Integer] Odd identifier. Defaults to provided value.
+    # @return [Odd]
+    def odd(id)
+      odds_hash[id]
+    end
+
+    # Total probability for a set of odds.
+    # This will be over 1 if set by a sportsbook.
+    # 
+    # @return [Float] Total probability, with 1.0 representing 100%
+    def total_probability
+      @total_probability ||= @odds.inject(0) { |total, odd| total + odd.implied_probability.value } # Change to #sum when 2.3 support can be dropped
+    end
+
+    # Calculate equivalent market without any overround (vig).
+    # 
+    # @return [Market] New market with total probability == 1.0
+    def without_vig
+      self.class.new(without_vig_odds)
+    end
+
+    # Calculate the odds without any overround (vig).
+    # 
+    # @return [<Odd>] Array of odds with the vig removed
+    def without_vig_odds
+      @without_vig_odds = if total_probability != 1.0
+        @odds.map { |odd| odd.without_vig(total_probability) }
+      else
+        @odds
+      end
+    end
+
+    # Total vig (maximum vig under balanced book scenario)
+    # 
+    # @return [Float]
+    def vig
+      1 - total_probability**-1
+    end
+
+    # Create market with an added overround amount
+    # 
+    # @param v [Integer] Overround percent
+    # @return [Market] New market with overrounded odds
+    def overround!(v = 5)
+      @vigged = self.class.new(overround_odds!(v))
+    end
+
+    # Calculate the odds with given overround
+    # 
+    # @param v [Integer] Overround percent
+    # @return [Array<Odd>] Overrounded odds
+    def overround_odds!(v = 5)
+      without_vig_odds.map { |odd| odd.overround!(v) }
+    end
+
+    # Compare equality to another market
+    # 
+    # @param other [Market]
+    # @return [Boolean]
+    def ==(other)
+      odds.sort == other.odds.sort
+    end
+
+    # Hash representation of a market.
+    # @return [Hash]
+    def to_h
+      full_odds = if self.total_probability != 1
+        no_vig = self.without_vig_odds
+        odds.map.with_index { |odd, index| odd.to_h.merge(actual: no_vig[index].implied_probability.value, without_vig: no_vig[index].value) }
+      else
+        odds.map(&:to_h)
+      end
+      {
+        name:               self.name,
+        total_probability:  self.total_probability,
+        vig:                self.vig,
+        odds:               full_odds,
+      }
+    end
+
+    # JSON representation of a market.
+    # @return [String]
+    def to_json
+      to_h.to_json
+    end
+
+    private
+
+    # Hash of odds by name or identifier
+    #
+    # @return [Hash{String=>Odd}]
+    def odds_hash
+      @odds_hash ||= @odds.map { |o| [o.id, o] }.to_h.tap do |hash|
+        raise 'Must use unique odds identifiers' if hash.size != @odds.size # TODO create custom error classes
+      end
+    end
+
+  end
+end

data/lib/oddsmaker/odd.rb

@@ -0,0 +1,60 @@
+module Oddsmaker
+  # Odds represent a single value that can be bet on.
+  # This can be represented and converted between the various forms it can take:
+  # 
+  # - Implied probability
+  # - Decimal odds
+  # - Fractional odds
+  # - American odds
+  # 
+  module Odd
+
+    # Create an implied probability with the given value.
+    # 
+    # @param value [Float, Integer] Probability value
+    # @param id [String] Identifier for this odd. Useful when multiple odds are used in a market
+    # @return [ImpliedProbability]
+    def self.implied(value, id = nil)
+      ImpliedProbability.new(value, id)
+    end
+
+    # Create American odds with the given value.
+    # 
+    # @param value [String, Integer] Odds value
+    # @param id [String] Identifier for this odd. Useful when multiple odds are used in a market
+    # @return [American]
+    def self.american(value, id = nil)
+      American.new(value, id)
+    end
+
+    # Create decimal odds with the given value.
+    # 
+    # @param value [Float, Integer] Odds value
+    # @param id [String] Identifier for this odd. Useful when multiple odds are used in a market
+    # @return [Decimal]
+    def self.decimal(value, id = nil)
+      Decimal.new(value, id)
+    end
+
+    # Create fractional odds with the given value.
+    # 
+    # @param value [String, Integer] Odds value
+    # @param id [String] Identifier for this odd. Useful when multiple odds are used in a market
+    # @return [Fractional]
+    def self.fractional(value, id = nil)
+      Fractional.new(value, id)
+    end
+
+    # Shortcut to creating a new odd based off hash params (i.e. request params).
+    # Requires one of `%w[american decimal fraction implied]` keys.
+    # Also accepts param `'name'`.
+    # 
+    # @return [Odd]
+    def self.new(params = {})
+      if (type = %w[american decimal fraction implied].detect { |type| params.key?(type) })
+        send(type, params[type], params['name'])
+      end
+    end
+
+  end
+end

data/lib/oddsmaker/odd/american.rb

@@ -0,0 +1,83 @@
+module Oddsmaker
+  module Odd
+    # American Odds class, handling both positive and negative odds.
+    # A negative value expresses the dollar amount that would need to be wagered in order to win $100.
+    # A positive number expresses the dollar amount that would be won from a $100 wager, excluding the original wager.
+    class American < Base
+
+      def initialize(value, id = nil)
+        @id    = id || value
+        @value = value.to_i
+      end
+
+      # Properly display both positive and negative odds.
+      # 
+      # @return [String]
+      def to_s
+        @value.positive? ? "+#{@value}" : @value.to_s
+      end
+
+      # Returns self. This creates a consistent API for all odds.
+      # 
+      # @return [self]
+      def american
+        self
+      end
+
+      # Convert to decimal odds, returning a new object.
+      # 
+      # @return [Decimal]
+      def decimal
+        @decimal ||= implied_probability.decimal
+      end
+
+      # Convert to fractional odds, returning a new object.
+      # 
+      # @return [Fractional]
+      def fractional
+        @fractional ||= Fractional.new(calculate_fractional, id)
+      end
+
+      private
+
+      # Allows for implied probability to create a vigged/unvigged odd and convert it back to source format.
+      def type
+        :american
+      end
+
+      # Calculate implied probability of an odd.
+      # 
+      # @return [Float]
+      def calculate_probability
+        calculate_probability ||= if @value.positive?
+          100.0 / (@value + 100)
+        else
+          -@value.to_f / (100 - @value)
+        end
+      end
+
+      # Calculate fractional representation of an odd.
+      # 
+      # @return [Float]
+      def calculate_fractional
+        calculate_fractional ||= if @value.positive?
+          @value / 100.rationalize
+        else
+          -100 / @value.rationalize
+        end
+      end
+
+      # Calculate profit for a wager.
+      # 
+      # @return [Float, Integer]
+      def calculate_profit(amount)
+        if @value.positive?
+          (amount/100.rationalize) * @value
+        else
+          -100/@value.rationalize * amount
+        end
+      end
+
+    end
+  end
+end

data/lib/oddsmaker/odd/base.rb

@@ -0,0 +1,100 @@
+module Oddsmaker
+  module Odd
+    # @abstract Base class to implement common functionality to various types of odds.
+    class Base
+      include Comparable
+      attr_reader :id, :value
+      alias :name :id # name is more common scenario, but anything works as an identifier
+
+      # Display odds as a string
+      # 
+      # @return [String]
+      def to_s
+        @value.to_s
+      end
+
+      # Calculates a new odd, removing the vig.
+      # 
+      # @return [Odd] Returns the same class as the original object
+      def without_vig(total_probability)
+        @without_vig = implied_probability.without_vig(total_probability).send(type)
+      end
+
+      # Calculates a new odd, with the given overround percentage.
+      # 
+      # @param v [Integer] Overround percentage (as whole number)
+      # @return [Odd] Returns the same class as the original object
+      def overround!(v)
+        implied_probability.overround!(v).send(type)
+      end
+
+      # Calculate implied probability.
+      # 
+      # @return [ImpliedProbability]
+      def implied_probability
+        @implied_probability ||= ImpliedProbability.new(calculate_probability, id)
+      end
+
+      # Multiplier is commonly used for parlay and other calculations.
+      # It's just decimal odds, but we define it to match common terminology.
+      # 
+      # @return [Float]
+      def multiplier
+        self.decimal.value
+      end
+
+      # Check two odds for equality.
+      # 
+      # @param other [Odd]
+      # @return [Boolean]
+      def ==(other)
+        implied_probability == other.implied_probability
+      end
+
+      # Compare two odds against each other.
+      # 
+      # @param other [Odd]
+      # @return [-1,0,1]
+      def <=>(other)
+        implied_probability <=> other.implied_probability
+      end
+
+      # Make a wager with this odd.
+      # 
+      # @param amount [Integer, Float] Amount wagered. Can be integer or float.
+      # @return [Wager]
+      def wager(amount)
+        Wager.new(amount, self)
+      end
+
+      # Calculate profit for an amount wagered.
+      # Convenient if a `Wager` object is unnecessary.
+      # 
+      # @param amount [Integer, Float] Amount wagered. Can be integer or float.
+      # @return [Float, Integer, Rational]
+      def profit(amount)
+        calculate_profit(amount)
+      end
+
+      # Represent odd as a hash.
+      # This will include all forms of the odd.
+      # @return [Hash]
+      def to_h
+        {
+          name:       self.name,
+          american:   self.american.value,
+          decimal:    self.decimal.value,
+          fractional: self.fractional.value,
+          implied:    self.implied_probability.value,
+        }
+      end
+
+      # JSON representation of the odd.
+      # @return [String]
+      def to_json
+        to_h.to_json
+      end
+
+    end
+  end
+end

data/lib/oddsmaker/odd/decimal.rb

@@ -0,0 +1,56 @@
+module Oddsmaker
+  module Odd
+    # Decimal odds express the amount that would be returned from a $1 wager, including the original wager amount.
+    # Decimal odds will always be greater than 1.0.
+    class Decimal < Base
+
+      def initialize(value, id = nil)
+        @id    = id || value
+        @value = value.to_f
+      end
+
+      # Returns self. This creates a consistent API for all odds.
+      # 
+      # @return [self]
+      def decimal
+        self
+      end
+
+      # Convert to American odds, returning a new object.
+      # 
+      # @return [American]
+      def american
+        @american ||= implied_probability.american
+      end
+
+      # Convert to fractional odds, returning a new object.
+      # 
+      # @return [Fractional]
+      def fractional
+        @fractional ||= implied_probability.fractional
+      end
+
+      private
+
+      # Allows for implied probability to create a vigged/unvigged odd and convert it back to source format.
+      def type
+        :decimal
+      end
+
+      # Calculate implied probability of an odd.
+      # 
+      # @return [Float]
+      def calculate_probability
+        1.0 / @value
+      end
+
+      # Calculate profit for a wager.
+      # 
+      # @return [Float, Integer]
+      def calculate_profit(amount)
+        (@value - 1) * amount
+      end
+
+    end
+  end
+end

data/lib/oddsmaker/odd/fractional.rb

@@ -0,0 +1,55 @@
+module Oddsmaker
+  module Odd
+    # Fractional odds express the fraction of a dollar that would be won from a $1 bet.
+    class Fractional < Base
+
+      def initialize(value, id = nil)
+        @id    = id || value
+        @value = value.is_a?(String) ? value.to_r : value.rationalize
+      end
+
+      # Returns self. This creates a consistent API for all odds.
+      # 
+      # @return [self]
+      def fractional
+        self
+      end
+
+      # Convert to American odds, returning a new object.
+      # 
+      # @return [American]
+      def american
+        @american ||= implied_probability.american
+      end
+
+      # Convert to decimal odds, returning a new object.
+      # 
+      # @return [Decimal]
+      def decimal
+        @decimal ||= implied_probability.decimal
+      end
+
+      private
+
+      # Allows for implied probability to create a vigged/unvigged odd and convert it back to source format.
+      def type
+        :fractional
+      end
+
+      # Calculate implied probability of an odd.
+      # 
+      # @return [Float]
+      def calculate_probability
+        @value.denominator.fdiv(@value.denominator + @value.numerator)
+      end
+
+      # Calculate profit for a wager.
+      # 
+      # @return [Float, Integer]
+      def calculate_profit(amount)
+        @value * amount
+      end
+
+    end
+  end
+end

data/lib/oddsmaker/odd/implied_probability.rb

@@ -0,0 +1,125 @@
+module Oddsmaker
+  module Odd
+    # Implied probability is the probability of an event, based on the odds for that event.
+    # Implied probability is what translates between various types of odds.
+    class ImpliedProbability < Base
+
+      def initialize(value, id = nil)
+        @id    = id || value
+        @value = value >= 1 ? value.fdiv(100) : value
+      end
+
+      # Calculates a new odd, removing the vig.
+      # 
+      # @return [ImpliedProbability]
+      def without_vig(total_probability)
+        self.class.new(@value / total_probability, id)
+      end
+
+      # Calculates a new odd, with the given overround percentage.
+      # 
+      # @param v [Integer] Overround percentage (as whole number)
+      # @return [ImpliedProbability]
+      def overround!(v)
+        self.class.new(@value * ((100 + v)/100.rationalize), id)
+      end
+
+      # Convert probability to percent.
+      # Optionally round the resulting decimal.
+      # 
+      # @param n [Integer] Number of decimal places for rounding.
+      def to_percent(n = nil)
+        n ? (@value * 100).round(n) : @value * 100
+      end
+
+      # Round decimal value.
+      # 
+      # @param n [Integer] Number of decimal places for rounding.
+      def round(n = 2)
+        @value.round(n)
+      end
+
+      # Check two odds for equality.
+      # 
+      # @param other [ImpliedProbability]
+      # @return [Boolean]
+      def ==(other)
+        if other.is_a?(self.class)
+          @value == other.value
+        else
+          @value == other.implied_probability.value
+        end
+      end
+
+      # Compare two odds against each other.
+      # 
+      # @param other [ImpliedProbability]
+      # @return [-1,0,1]
+      def <=>(other)
+        value <=> other.value
+      end
+
+      # Returns self. This creates a consistent API for all odds.
+      # 
+      # @return [self]
+      def implied_probability
+        self
+      end
+
+      # Convert to American odds, returning a new object.
+      # 
+      # @return [American]
+      def american
+        @american ||= American.new(calculate_american, id)
+      end
+
+      # Convert to decimal odds, returning a new object.
+      # 
+      # @return [Decimal]
+      def decimal
+        @decimal ||= Decimal.new(calculate_decimal, id)
+      end
+
+      # Convert to fractional odds, returning a new object.
+      # 
+      # @return [Fractional]
+      def fractional
+        @fractional ||= Fractional.new(calculate_fractional, id)
+      end
+
+      private
+
+      # Allows for implied probability to create a vigged/unvigged odd and convert it back to source format.
+      def type
+        :implied_probability
+      end
+
+      # Calculate American odds value.
+      # 
+      # @return [Integer, Float]
+      def calculate_american
+        value = @value.rationalize
+        if value >= 0.5
+          - ( value / (1 - value)) * 100
+        else
+          ((1 - value) / value ) * 100
+        end
+      end
+
+      # Calculate decimal odds value.
+      # 
+      # @return [Float]
+      def calculate_decimal
+        1.0 / @value
+      end
+
+      # Calculate fractional odds value.
+      # 
+      # @return [Rational]
+      def calculate_fractional
+        (1.0 / @value - 1).rationalize
+      end
+
+    end
+  end
+end

data/lib/oddsmaker/version.rb

@@ -0,0 +1,3 @@
+module Oddsmaker
+  VERSION = "0.1.0" # :nodoc:
+end

data/lib/oddsmaker/wager.rb

@@ -0,0 +1,44 @@
+module Oddsmaker
+  # Wager represents an odd and a wagered amount.
+  # Odds can directly calculate their profit, so this is just a convenience class.
+  class Wager
+    attr_reader :amount, :odd
+
+    def initialize(amount, odd)
+      @amount = amount
+      @odd = odd
+    end
+
+    # Calculate profit for a wager.
+    # 
+    # @return [Float, Integer]
+    def profit
+      @profit ||= odd.profit(@amount)
+    end
+
+    # Calculate return for a wager.
+    # Return is profit plus wager amount.
+    # 
+    # @return [Float, Integer]
+    def return
+      @return ||= profit + @amount
+    end
+
+    # Hash representation of the wager.
+    # @return [Hash]
+    def to_h
+      {
+        amount:  self.amount.to_f,
+        profit:  self.profit.to_f,
+        return:  self.return.to_f,
+        odd:     odd.to_h,
+      }
+    end
+
+    # JSON representation of the wager.
+    # @return [String]
+    def to_json
+      to_h.to_json
+    end
+  end
+end

data/oddsmaker.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "oddsmaker/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "oddsmaker"
+  spec.version       = Oddsmaker::VERSION
+  spec.authors       = ["Paul Hoffer"]
+  spec.email         = ["git@paulhoffer.com"]
+
+  spec.summary       = %q{Calculate and convert sportsbook betting odds, probabilities, wagers, and collections of odds.}
+  spec.description   = %q{Convert and manipulate sportsbook betting odds (American, decimal, fractional) and probabilities. Calculate wagering profit and return, and calculate total probability and vig for a collection of odds.}
+  spec.homepage      = "https://www.github.com/phoffer/oddsmaker"
+  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_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: oddsmaker
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Paul Hoffer
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: pry
+  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: Convert and manipulate sportsbook betting odds (American, decimal, fractional)
+  and probabilities. Calculate wagering profit and return, and calculate total probability
+  and vig for a collection of odds.
+email:
+- git@paulhoffer.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/oddsmaker.rb
+- lib/oddsmaker/market.rb
+- lib/oddsmaker/odd.rb
+- lib/oddsmaker/odd/american.rb
+- lib/oddsmaker/odd/base.rb
+- lib/oddsmaker/odd/decimal.rb
+- lib/oddsmaker/odd/fractional.rb
+- lib/oddsmaker/odd/implied_probability.rb
+- lib/oddsmaker/version.rb
+- lib/oddsmaker/wager.rb
+- oddsmaker.gemspec
+homepage: https://www.github.com/phoffer/oddsmaker
+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.6.11
+signing_key: 
+specification_version: 4
+summary: Calculate and convert sportsbook betting odds, probabilities, wagers, and
+  collections of odds.
+test_files: []