"""Tools for dealing with bookmaker's odds and implied probabilities"""
from fractions import Fraction
from math import sqrt
from typing import Optional, Sequence
import scipy.optimize
import toolz
def overround(p: Sequence[float]) -> float:
"""Return the overround, given a sequence of implied probabilities."""
return sum(p) - 1
def from_american(odds: int) -> float:
"""Return implied probability, given American odds."""
odds = round(odds)
if abs(odds) < 100:
raise ValueError(f"Invalid American odds {odds}")
if odds > 0:
return 100 / (100 + odds)
else:
odds = -odds
return odds / (100 + odds)
def to_american(p: float, ndigits: Optional[int] = None) -> int:
"""Return American odds, given an implied probability.
Parameters
----------
p
Implied probability
ndigits
The number of digits to which to round the result. The default
is to round to the nearest integer (American odds are not usually
quoted to more decimal places), but this may be adjusted if
more precision is needed (and the result will be a floating
point number).
"""
if p < 0.5:
a = 100 / p - 100
else:
a = -(100 * p) / (1 - p)
return round(a, ndigits)
def from_euro(odds: float) -> float:
"""Return implied probability, given Euro/Decimal odds."""
return 1 / odds
def to_euro(p: float) -> float:
"""Return Euro/Decimal odds, given an implied probability."""
return 1 / p
def from_british(odds: Fraction) -> float:
"""Return implied probability, given British odds."""
return float(1 / (odds + 1))
def to_british(p: float, largest_denominator: int = 100) -> Fraction:
"""Return British odds, given an implied probability.
Parameters
----------
p
Implied probability
largest_denominator
The largest denominator to use when representing the result.
The smaller this number the more accuracy is lost.
"""
return Fraction(1 / p - 1).limit_denominator(largest_denominator)
from_decimal = from_euro
to_decimal = to_euro
# -- Adjusting implied probabilities to true probabilities
_adjust_methods = {}
@toolz.curry
def add_method(name: str, f):
_adjust_methods[name] = f
return f
def validate_odds(odds: Sequence[float]) -> None:
if len(odds) < 2:
raise ValueError(f"Expected at least 2 outcomes, but got {len(odds)}")
if any(x >= 1 for x in odds):
raise ValueError(f"Expected all outcomes to have an implied probability < 1")
r = overround(odds)
if r < 0:
raise ValueError(f"Odds {odds} have a negative overround ({r})")
elif r > 0.5:
raise ValueError(f"Odds {odds} have excessive overround ({r})")
def adjust_odds(odds: Sequence[float], method="power") -> list[float]:
"""Return fair odds given bookmaker odds.
Parameters
----------
odds
The odds of each outcome, given as implied probabilites.
The implied probabilities associated with the odds quoted by a bookmaker
sum to a number > 1. This excess is the "overround" of the odds. There
are a number of models for distributing the overround among the outcomes
to recover the "fair odds" of each outcome.
Notes
-----
All implemented methods are based on the descriptions in the paper by
S. Clarke in the references section.
References
----------
S. Clarke, S. Kovalchik, M. Ingram
Adjusting Bookmaker's odds to Allow for Overround.
"""
try:
f = _adjust_methods[method]
except KeyError:
raise ValueError(
f"Unknown method '{method}', expected one of {list(_adjust_methods)}"
) from None
validate_odds(odds)
return f(odds)
@add_method("additive")
def adjust_odds_additive(odds: Sequence[float]) -> list[float]:
"""Adjust bookmaker odds using the additive method.
In this method the overround is assumed to be split equality between
the different outcomes, regardless of their relative implied probabilities.
"""
y = overround(odds) / len(odds)
return [x - y for x in odds]
@add_method("multiplicative")
def adjust_odds_multiplicative(odds: Sequence[float]) -> list[float]:
"""Adjust bookmaker odds using the multiplicative method.
In this method the overround is assumed to be split among the
different outcomes in proportion to their implied probabilities.
"""
s = sum(odds)
r = overround(odds)
return [x - (r * x / s) for x in odds]
@add_method("power")
def adjust_odds_power(odds: Sequence[float]) -> list[float]:
"""Adjust bookmaker odds using the power method.
In this method the true probabilities are assumed to be
related to the implied probabilities by a power law,
i.e. p_i = π_i^k, for some fixed k. The k is then
chosen such that the true probabilities sum to 1.
Notes
-----
The 'k' parameter for the power method is computed by
solving the nonlinear equation Σ_i π_i^k = 1 using
a root-finding algorithm.
References
----------
S.R. Clarke
Adjusting true odds to allow for vigorish
"""
# This bracketing interval should be sufficient for reasonable overrounds
# (not > 50%) and reasonable distribution of implied probability between
# the different outcomes.
try:
k = scipy.optimize.root_scalar(
lambda k: sum(x ** k for x in odds) - 1,
bracket=[0.9, 3],
xtol=1e-14,
).root
except ValueError as e:
if "different signs" in str(e):
raise ValueError(f"Bracketing interval too small for odds {odds}") from None
return [x ** k for x in odds]
@add_method("shin")
def adjust_odds_shin(odds):
"""Adjust bookmaker odds using the Shin method.
In this method we assume a fraction z of sharp bettors
and adjust the true probabilities accordingly.
Notes
-----
The 'z' parameter for the Shin method is computed
by solving a nonlinear equation using a root-finding algorithm.
References
----------
H.S. Shin
Prices of State Contingent Claims with Insider Traders
and the Favorite-Longshot Bias
"""
s = sum(odds)
n = len(odds)
def residual(z):
return (
sum(sqrt(z ** 2 + 4 * (1 - z) * pi ** 2 / s) for pi in odds)
- 2
- (n - 2) * z
)
# 'z' is in the interval [0, 1). We set the upper limit for the
# bracketing interval to just below 1 to exclude a (spurious) solution at z=1.
try:
z = scipy.optimize.root_scalar(residual, bracket=[0, 0.999], xtol=1e-14).root
except ValueError:
raise ValueError(f"Shin method failed to converge for odds {odds}") from None
return [
(sqrt(z ** 2 + 4 * (1 - z) * pi ** 2 / s) - z) / (2 * (1 - z)) for pi in odds
]