@@ -1,12 +1,84 @@

 """Tools for dealing with bookmaker's odds and implied probabilities"""

+from fractions import Fraction

 from math import sqrt

-from typing import Sequence

+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 = {}

@@ -18,10 +90,6 @@ def add_method(name: str, f):

     return f

-def overround(odds: Sequence[float]) -> float:

-    return sum(odds) - 1

-

-

 def validate_odds(odds: Sequence[float]) -> None:

     if len(odds) < 2:

         raise ValueError(f"Expected at least 2 outcomes, but got {len(odds)}")

@@ -35,7 +103,7 @@ def validate_odds(odds: Sequence[float]) -> None:

 def adjust_odds(odds: Sequence[float], method="power") -> list[float]:

-    """Return true odds given bookmaker odds.

+    """Return fair odds given bookmaker odds.

     Parameters

     ----------

@@ -44,7 +112,8 @@ def adjust_odds(odds: Sequence[float], method="power") -> list[float]:

     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

+    are a number of models for distributing the overround among the outcomes

+    to recover the "fair odds" of each outcome.

     Notes

     -----

@@ -61,7 +130,7 @@ def adjust_odds(odds: Sequence[float], method="power") -> list[float]:

     except KeyError:

         raise ValueError(

             f"Unknown method '{method}', expected one of {list(_adjust_methods)}"

-        )

+        ) from None

     validate_odds(odds)

     return f(odds)