cfmath 1.0.0rc1__py3-none-any.whl

cfmath/__init__.py

@@ -0,0 +1,84 @@
+"""cfmath — continued fractions library."""
+
+try:
+    from ._version import __version__
+except ImportError:  # pragma: no cover
+    __version__ = "dev"
+
+from .archyperbolic import Arccosh, Arcsinh, Arctanh
+from .arctrig import Arccos, Arcsin, Arctan, ArctrigMode
+from .constants import Apery, Catalan, E, EulerGamma, Khinchin, Phi, Pi, Plastic, Tau
+from .convergents import convergent, convergent_pair, convergent_pairs, convergents
+from .core import CF
+from .debug import CountingIterator, describe_source_tree, digits_with_debug
+from .exponential import Exp
+from .gosper import cf_add, cf_div, cf_homographic, cf_max, cf_min, cf_mul, cf_sub
+from .gosper_cf import GosperBi, GosperGeneric, GosperMono
+from .hyperbolic import Cosh, Sinh, Tanh
+from .logarithm import Ln, Log, Log2, Log10
+from .polyratio import PolyTransform
+from .power import Cuberoot, Nthroot, Pow, PowCF, PowInterval, PowIntExponent, PowMode, PowMP
+from .quadratic import Sqrt
+from .special import Gamma, Zeta
+from .trig import Cos, Sin, Tan, TrigMode
+
+__all__ = [
+    "CF",
+    "convergent",
+    "convergent_pair",
+    "convergent_pairs",
+    "convergents",
+    "cf_add",
+    "cf_sub",
+    "cf_mul",
+    "cf_div",
+    "GosperMono",
+    "GosperBi",
+    "GosperGeneric",
+    "PolyTransform",
+    "cf_homographic",
+    "cf_min",
+    "cf_max",
+    "Sqrt",
+    "Phi",
+    "E",
+    "Pi",
+    "Tau",
+    "Cuberoot",
+    "Nthroot",
+    "Log2",
+    "Ln",
+    "Sin",
+    "Cos",
+    "Tan",
+    "TrigMode",
+    "Arcsin",
+    "Arccos",
+    "Arctan",
+    "ArctrigMode",
+    "Sinh",
+    "Cosh",
+    "Tanh",
+    "Arctanh",
+    "Arcsinh",
+    "Arccosh",
+    "Exp",
+    "EulerGamma",
+    "Catalan",
+    "Apery",
+    "Log",
+    "Log10",
+    "Pow",
+    "PowMode",
+    "PowIntExponent",
+    "PowCF",
+    "PowMP",
+    "PowInterval",
+    "Gamma",
+    "Zeta",
+    "Plastic",
+    "Khinchin",
+    "CountingIterator",
+    "describe_source_tree",
+    "digits_with_debug",
+]

cfmath/_backend.py

@@ -0,0 +1,259 @@
+"""Shared infrastructure for cfmath implementations.
+
+Provides:
+  _HAS_MPMATH            — True if mpmath is importable
+  _lazy_cf(fn)           — wrap a batch-compute function into a lazy CF
+  _extract_cf_terms      — extract CF terms from an mpmath value until precision runs out
+  _mpmath_cf(fn)         — precision-automatic lazy CF from an mpmath value function
+  _mpmath_cf_for_cf_arg  — apply an mpmath function to a CF argument via convergent approx
+  _coerce_trig_arg       — validate and coerce int/Fraction inputs
+"""
+
+from __future__ import annotations
+
+from fractions import Fraction
+from typing import Any, Callable, Iterator
+
+from .core import CF
+
+try:
+    import mpmath as _mpmath  # noqa: F401 — side-effect: validates import
+
+    _HAS_MPMATH = True
+except ImportError:
+    _HAS_MPMATH = False
+
+
+def _lazy_cf(
+    compute: Callable[[int], list[int]],
+    initial: int = 60,
+    batch: int = 50,
+    debug_source: Any | None = None,
+) -> CF:
+    """Build a lazily-extending CF from a batch-compute function.
+
+    ``compute(n)`` must return a list of at least *n* CF term integers.
+    The first call uses *initial* terms; when those run out, it recomputes
+    with *batch* more terms each time.
+    """
+    terms = compute(initial)
+    static = terms[:10]
+    rest = iter(terms[10:])
+
+    def _more() -> Iterator[int]:
+        yield from rest
+        offset = len(terms)
+        while True:
+            more = compute(offset + batch)
+            yield from more[offset:]
+            offset = len(more)
+
+    cf = CF(static, _source=_more())
+    if debug_source is not None:
+        cf._debug_source = debug_source
+    return cf
+
+
+def _annotate_cf(cf: CF, debug_source: Any | None) -> CF:
+    """Attach debugging provenance to a CF and return it."""
+    if debug_source is not None:
+        cf._debug_source = debug_source
+    return cf
+
+
+def _extract_cf_terms(x: Any, guard_bits: int = 64) -> list[int]:
+    """Extract CF terms from an mpmath value until precision is exhausted.
+
+    After k extraction steps the effective precision is approximately
+    ``mp.prec - 2*log2(q_k)`` bits, where q_k is the k-th convergent denominator.
+    We stop before a step would push ``2*log2(q)`` past ``mp.prec - guard_bits``.
+
+    We track ``log2(q)`` cheaply via the identity
+    ``log2(q_{k+1}) ≈ log2(q_k) + log2(1/frac_k)``
+    (since ``a_{k+1} = floor(1/frac_k) ≈ 1/frac_k``).
+
+    This naturally accounts for large terms: π's term-4 value of 292 costs ~8 bits
+    without any per-constant tuning, and also catches exhaustion by many
+    moderate-sized terms (which a simple ``frac < threshold`` check misses).
+    """
+    import mpmath
+
+    available = float(mpmath.mp.prec - guard_bits)
+    log_q = 0.0  # tracks log2 of the convergent denominator
+    terms: list[int] = []
+    while True:
+        a = int(mpmath.floor(x))
+        frac = x - a
+        terms.append(a)
+        if frac == 0:
+            break
+        # Track log2 of the convergent denominator with mpmath, not float(frac).
+        # A huge partial quotient makes frac underflow a double to 0.0, which
+        # would stop extraction even when mpmath still has the precision to go on
+        # (and escalating dps wouldn't help — float underflows at any dps).
+        # mpmath.log of a tiny frac is a moderate number; the precision check
+        # below — comparing the cost against available bits — is the real and
+        # only stopping rule.
+        log_q -= float(mpmath.log(frac, 2))  # log2(1/frac) = -log2(frac)
+        if 2.0 * log_q > available:
+            break
+        x = 1 / frac
+    return terms
+
+
+def _mpmath_cf(
+    value_fn: Callable[[], Any],
+    initial_dps: int = 100,
+    scale: float = 2.0,
+    guard_bits: int = 64,
+    debug_source: Any | None = None,
+) -> CF:
+    """Build a lazy CF from an mpmath value function with automatic precision management.
+
+    ``value_fn()`` is called with ``mp.dps`` already set; it should return the
+    mpmath value to convert (e.g. ``lambda: mpmath.euler``).
+
+    Always maintains two consecutive precision levels (lo and hi = lo × scale).
+    Only terms where lo and hi agree are emitted — the first disagreement is the
+    empirical precision boundary, so no per-constant tuning is needed and marginal
+    terms are automatically filtered.  When the consumer asks for more terms, hi
+    becomes the new lo and a fresh hi is computed at the next level.
+    """
+    import mpmath
+
+    def _get(dps: int) -> list[int]:
+        mpmath.mp.dps = dps
+        return _extract_cf_terms(value_fn(), guard_bits)
+
+    def _agree_up_to(a: list[int], b: list[int]) -> int:
+        """First index where a and b differ, or min(len(a), len(b)) if all agree."""
+        for i, (x, y) in enumerate(zip(a, b)):
+            if x != y:
+                return i
+        return min(len(a), len(b))
+
+    # Bootstrap: compute at two consecutive levels, emit only agreed terms.
+    lo = _get(initial_dps)
+    hi = _get(int(initial_dps * scale))
+    first_valid = _agree_up_to(lo, hi)
+
+    static = hi[: min(10, first_valid)] if first_valid else hi[:1]
+
+    def _source() -> Iterator[int]:
+        cur_lo = hi
+        cur_dps = int(initial_dps * scale)
+        emitted = len(static)
+
+        yield from cur_lo[emitted:first_valid]
+        emitted = first_valid
+
+        while True:
+            cur_dps = int(cur_dps * scale)
+            cur_hi = _get(cur_dps)
+            new_valid = _agree_up_to(cur_lo, cur_hi)
+
+            if new_valid < emitted:
+                raise ArithmeticError(
+                    f"CF term {new_valid} changed from {cur_lo[new_valid]} to "
+                    f"{cur_hi[new_valid]} at {cur_dps} dps — previously emitted "
+                    f"term is wrong"
+                )
+
+            new_terms = cur_hi[emitted:new_valid]
+            if new_terms:
+                yield from new_terms
+                emitted = new_valid
+
+            cur_lo = cur_hi
+
+    cf = CF(static, _source=_source())
+    if debug_source is not None:
+        cf._debug_source = debug_source
+    return cf
+
+
+def _cf_terms_from_interval_approximator(
+    interval_at_precision: Callable[[int], tuple[Fraction, Fraction]],
+    n_terms: int,
+    initial: int = 16,
+    max_precision: int = 1 << 16,
+) -> list[int]:
+    """Return CF terms once rational intervals prove them.
+
+    The caller supplies ``interval_at_precision(p)``, which must return
+    rational bounds ``lo <= x <= hi``.  This helper extracts simple-CF terms
+    only while both endpoints force the same next integer.  If the interval
+    straddles an integer boundary or zero after subtracting a term, the helper
+    doubles precision and starts over.
+    """
+    precision = initial
+    while precision <= max_precision:
+        lo, hi = interval_at_precision(precision)
+        if lo > hi:
+            lo, hi = hi, lo
+
+        terms: list[int] = []
+        while len(terms) < n_terms:
+            if lo == hi:
+                terms.extend(CF.from_rational(lo).terms)
+                return terms[:n_terms]
+
+            a_lo = lo.numerator // lo.denominator
+            a_hi = hi.numerator // hi.denominator
+            if a_lo != a_hi:
+                break
+
+            a = a_lo
+            terms.append(a)
+            lo -= a
+            hi -= a
+
+            if lo == hi == 0:
+                return terms
+            if lo <= 0 <= hi:
+                break
+
+            lo, hi = Fraction(1, hi), Fraction(1, lo)
+            if lo > hi:
+                lo, hi = hi, lo
+
+        if len(terms) >= n_terms:
+            return terms[:n_terms]
+        precision *= 2
+
+    raise ValueError(f"could not pin {n_terms} CF terms by precision {max_precision}")
+
+
+def _mpmath_cf_for_cf_arg(x: CF, fn: Callable[[Any], Any]) -> CF:
+    """Return CF for fn(x) where x is a CF, using dual-precision verification.
+
+    Approximates x by a convergent deep enough that the rational-approximation
+    error is negligible relative to the mpmath working precision, then emits CF
+    terms via _mpmath_cf's agree-at-two-levels protocol.
+
+    fn must accept a single mpmath.mpf and return an mpmath value (e.g.
+    mpmath.sin, mpmath.cosh, mpmath.atan).
+    """
+    import mpmath
+
+    from .convergents import convergent
+
+    def _value_fn() -> Any:
+        dps = mpmath.mp.dps
+        depth = max(5 * dps, 60)
+        try:
+            approx = convergent(x, depth)
+        except IndexError:
+            approx = x.to_fraction()
+        return fn(mpmath.mpf(approx.numerator) / mpmath.mpf(approx.denominator))
+
+    return _mpmath_cf(_value_fn)
+
+
+def _coerce_trig_arg(x: int | Fraction) -> Fraction:
+    """Validate and coerce a trig/hyperbolic function argument to Fraction."""
+    if isinstance(x, int):
+        return Fraction(x)
+    if isinstance(x, Fraction):
+        return x
+    raise TypeError(f"expected int or Fraction, got {type(x).__name__}")

cfmath/_poly.py

@@ -0,0 +1,98 @@
+"""Integer polynomial arithmetic over ascending-degree coefficient lists.
+
+A polynomial is a list of int coefficients, lowest degree first: ``[c0, c1, c2]``
+means ``c0 + c1*x + c2*x**2``.  The zero polynomial is ``[0]``.
+
+Two callers share these primitives, and they pull in opposite directions.  The
+``PolyTransform`` algebra in ``polyratio`` reduces by GCD, so it needs a *canonical*
+form: no trailing zeros, leading coefficient nonzero, otherwise degree counts and
+pseudo-remainders go wrong.  The meta-CF rebuild path in ``gosper`` only ever
+evaluates the polynomials it builds, so trailing zeros are invisible to it but
+the products are many and low-degree, where a scalar/monomial fast path pays off.
+
+``add``/``sub``/``mul`` therefore strip their results (satisfying the first caller)
+and ``mul`` keeps the fast paths (satisfying the second).  Stripping is
+evaluation-invariant, so the rebuild path is unaffected by it.
+"""
+
+from __future__ import annotations
+
+from math import gcd
+
+
+def strip(p: list[int]) -> list[int]:
+    """Drop trailing zero coefficients, keeping at least the constant term."""
+    while len(p) > 1 and p[-1] == 0:
+        p = p[:-1]
+    return p
+
+
+def content(p: list[int]) -> int:
+    """Return the GCD of the coefficients (1 for the zero polynomial).
+
+    This is the GCD of a set of integers, so it does not care about coefficient
+    order; descending-degree callers (power's Nthroot engine) may use it too.
+    """
+    g = 0
+    for c in p:
+        g = gcd(g, abs(c))
+    return g or 1
+
+
+def primitive(p: list[int]) -> list[int]:
+    """Divide out the content, leaving a primitive polynomial."""
+    g = content(p)
+    return [c // g for c in p]
+
+
+def add(p: list[int], q: list[int]) -> list[int]:
+    """Add two polynomials."""
+    n = max(len(p), len(q))
+    return strip([(p[i] if i < len(p) else 0) + (q[i] if i < len(q) else 0) for i in range(n)])
+
+
+def sub(p: list[int], q: list[int]) -> list[int]:
+    """Subtract q from p."""
+    n = max(len(p), len(q))
+    return strip([(p[i] if i < len(p) else 0) - (q[i] if i < len(q) else 0) for i in range(n)])
+
+
+def mul(p: list[int], q: list[int]) -> list[int]:
+    """Multiply two polynomials.
+
+    Scalar and single-term (monomial) operands are common in the meta-CF rebuild
+    path and get direct fast paths; the general case skips zero coefficients.
+    """
+    if len(p) == 1:
+        k = p[0]
+        if k == 0:
+            return [0]
+        if k == 1:
+            return strip(list(q))
+        return strip([k * c for c in q])
+    if len(q) == 1:
+        k = q[0]
+        if k == 0:
+            return [0]
+        if k == 1:
+            return strip(list(p))
+        return strip([k * c for c in p])
+
+    nonzero_p = [i for i, c in enumerate(p) if c != 0]
+    if len(nonzero_p) == 1:
+        shift = nonzero_p[0]
+        k = p[shift]
+        return strip([0] * shift + [k * c for c in q])
+
+    nonzero_q = [i for i, c in enumerate(q) if c != 0]
+    if len(nonzero_q) == 1:
+        shift = nonzero_q[0]
+        k = q[shift]
+        return strip([0] * shift + [k * c for c in p])
+
+    out = [0] * (len(p) + len(q) - 1)
+    for i in nonzero_p:
+        ci = p[i]
+        for j in nonzero_q:
+            out[i + j] += ci * q[j]
+    return strip(out)

cfmath/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.0.0rc1'
+__version_tuple__ = version_tuple = (1, 0, 0, 'rc1')
+
+__commit_id__ = commit_id = 'gaa80809af'

cfmath/archyperbolic.py

@@ -0,0 +1,240 @@
+"""Inverse hyperbolic functions as continued fractions."""
+
+from __future__ import annotations
+
+from fractions import Fraction
+
+from ._backend import _HAS_MPMATH, _annotate_cf, _coerce_trig_arg, _lazy_cf, _mpmath_cf_for_cf_arg
+from .core import CF
+
+# ---------------------------------------------------------------------------
+# Decimal backends
+# ---------------------------------------------------------------------------
+
+
+def _arcsinh_terms_from_decimal(x_num: int, x_den: int, n_terms: int) -> list[int]:
+    """Compute n_terms CF terms of arcsinh(x_num/x_den).
+
+    Uses arcsinh(x) = ln(x + sqrt(x²+1)) computed entirely in Decimal.
+    Works for all real x.
+    """
+    import decimal
+
+    from .logarithm import _decimal_ln2
+
+    prec = n_terms * 5 + 80
+    ctx = decimal.Context(prec=prec, rounding=decimal.ROUND_FLOOR)
+    with decimal.localcontext(ctx):
+        eps = decimal.Decimal(10) ** (-(prec - 10))
+
+        def _two_atanh(t: decimal.Decimal) -> decimal.Decimal:
+            t2 = t * t
+            term = t
+            val = t
+            k = 1
+            while True:
+                term *= t2
+                delta = term / decimal.Decimal(2 * k + 1)
+                val += delta
+                if abs(delta) < eps:
+                    break
+                k += 1
+            return 2 * val
+
+        x = decimal.Decimal(x_num) / decimal.Decimal(x_den)
+        inner = x + (x * x + 1).sqrt()
+
+        ln2 = _decimal_ln2(prec)
+        n = 0
+        reduced = inner
+        while reduced >= 2:
+            reduced /= 2
+            n += 1
+        while reduced < decimal.Decimal("0.5"):
+            reduced *= 2
+            n -= 1
+
+        ln_val = decimal.Decimal(n) * ln2 + _two_atanh((reduced - 1) / (reduced + 1))
+
+        terms: list[int] = []
+        for _ in range(n_terms):
+            a = int(ln_val.to_integral_value(rounding=decimal.ROUND_FLOOR))
+            terms.append(a)
+            frac = ln_val - a
+            if frac <= eps:
+                break
+            ln_val = decimal.Decimal(1) / frac
+
+    return terms
+
+
+def _arccosh_terms_from_decimal(x_num: int, x_den: int, n_terms: int) -> list[int]:
+    """Compute n_terms CF terms of arccosh(x_num/x_den).
+
+    Uses arccosh(x) = ln(x + sqrt(x²-1)) computed entirely in Decimal.
+    Requires x ≥ 1.
+    """
+    import decimal
+
+    from .logarithm import _decimal_ln2
+
+    prec = n_terms * 5 + 80
+    ctx = decimal.Context(prec=prec, rounding=decimal.ROUND_FLOOR)
+    with decimal.localcontext(ctx):
+        eps = decimal.Decimal(10) ** (-(prec - 10))
+
+        def _two_atanh(t: decimal.Decimal) -> decimal.Decimal:
+            t2 = t * t
+            term = t
+            val = t
+            k = 1
+            while True:
+                term *= t2
+                delta = term / decimal.Decimal(2 * k + 1)
+                val += delta
+                if abs(delta) < eps:
+                    break
+                k += 1
+            return 2 * val
+
+        x = decimal.Decimal(x_num) / decimal.Decimal(x_den)
+        inner = x + (x * x - 1).sqrt()
+
+        if inner <= eps:
+            return [0]
+
+        ln2 = _decimal_ln2(prec)
+        n = 0
+        reduced = inner
+        while reduced >= 2:
+            reduced /= 2
+            n += 1
+        while reduced < decimal.Decimal("0.5"):
+            reduced *= 2
+            n -= 1
+
+        ln_val = decimal.Decimal(n) * ln2 + _two_atanh((reduced - 1) / (reduced + 1))
+
+        terms: list[int] = []
+        for _ in range(n_terms):
+            a = int(ln_val.to_integral_value(rounding=decimal.ROUND_FLOOR))
+            terms.append(a)
+            frac = ln_val - a
+            if frac <= eps:
+                break
+            ln_val = decimal.Decimal(1) / frac
+
+    return terms
+
+
+# ---------------------------------------------------------------------------
+# mpmath backends
+# ---------------------------------------------------------------------------
+
+
+def _arcsinh_terms_mpmath(x_num: int, x_den: int, n_terms: int) -> list[int]:
+    """Compute n_terms CF terms of arcsinh(x_num/x_den) using mpmath."""
+    import mpmath
+
+    mpmath.mp.dps = n_terms * 5 + 80
+    val = mpmath.asinh(mpmath.mpf(x_num) / mpmath.mpf(x_den))
+    terms: list[int] = []
+    for _ in range(n_terms):
+        a = int(mpmath.floor(val))
+        terms.append(a)
+        val = 1 / (val - a)
+    return terms
+
+
+def _arccosh_terms_mpmath(x_num: int, x_den: int, n_terms: int) -> list[int]:
+    """Compute n_terms CF terms of arccosh(x_num/x_den) using mpmath."""
+    import mpmath
+
+    mpmath.mp.dps = n_terms * 5 + 80
+    val = mpmath.acosh(mpmath.mpf(x_num) / mpmath.mpf(x_den))
+    terms: list[int] = []
+    for _ in range(n_terms):
+        a = int(mpmath.floor(val))
+        terms.append(a)
+        val = 1 / (val - a)
+    return terms
+
+
+def _arctanh_terms_mpmath(x_num: int, x_den: int, n_terms: int) -> list[int]:
+    """Compute n_terms CF terms of arctanh(x_num/x_den) using mpmath."""
+    import mpmath
+
+    mpmath.mp.dps = n_terms * 5 + 80
+    val = mpmath.atanh(mpmath.mpf(x_num) / mpmath.mpf(x_den))
+    terms: list[int] = []
+    for _ in range(n_terms):
+        a = int(mpmath.floor(val))
+        terms.append(a)
+        val = 1 / (val - a)
+    return terms
+
+
+# ---------------------------------------------------------------------------
+# Public functions
+# ---------------------------------------------------------------------------
+
+
+def Arctanh(x: int | Fraction | CF) -> CF:
+    """Inverse hyperbolic tangent of x, as a continued fraction.
+
+    For int/Fraction, uses arctanh(x) = ln((1+x)/(1-x)) / 2 (|x| < 1 required).
+    For CF input, uses the mpmath dual-precision convergent approach.
+    """
+    if isinstance(x, CF):
+        import mpmath
+
+        return _mpmath_cf_for_cf_arg(x, mpmath.atanh)
+    x = _coerce_trig_arg(x)
+    if abs(x) >= 1:
+        raise ValueError(f"Arctanh argument must satisfy |x| < 1, got {x}")
+    if x == 0:
+        return _annotate_cf(CF.from_int(0), ("Arctanh", x))
+    ratio = (Fraction(1) + x) / (Fraction(1) - x)
+    from .logarithm import Ln
+
+    return _annotate_cf(Ln(ratio) / CF.from_int(2), ("Arctanh", x))
+
+
+def Arcsinh(x: int | Fraction | CF) -> CF:
+    """Inverse hyperbolic sine of x, as a continued fraction.
+
+    For int/Fraction, uses arcsinh(x) = ln(x + sqrt(x²+1)).
+    For CF input, uses the mpmath dual-precision convergent approach.
+    """
+    if isinstance(x, CF):
+        import mpmath
+
+        return _mpmath_cf_for_cf_arg(x, mpmath.asinh)
+    x = _coerce_trig_arg(x)
+    if x == 0:
+        return _annotate_cf(CF.from_int(0), ("Arcsinh", x))
+    num, den = x.numerator, x.denominator
+    if _HAS_MPMATH:
+        return _lazy_cf(lambda n: _arcsinh_terms_mpmath(num, den, n), debug_source=("Arcsinh", x))
+    return _lazy_cf(lambda n: _arcsinh_terms_from_decimal(num, den, n), debug_source=("Arcsinh", x))
+
+
+def Arccosh(x: int | Fraction | CF) -> CF:
+    """Inverse hyperbolic cosine of x, as a continued fraction.
+
+    For int/Fraction, uses arccosh(x) = ln(x + sqrt(x²-1)) (x ≥ 1 required).
+    For CF input, uses the mpmath dual-precision convergent approach.
+    """
+    if isinstance(x, CF):
+        import mpmath
+
+        return _mpmath_cf_for_cf_arg(x, mpmath.acosh)
+    x = _coerce_trig_arg(x)
+    if x < 1:
+        raise ValueError(f"Arccosh argument must satisfy x ≥ 1, got {x}")
+    if x == 1:
+        return _annotate_cf(CF.from_int(0), ("Arccosh", x))
+    num, den = x.numerator, x.denominator
+    if _HAS_MPMATH:
+        return _lazy_cf(lambda n: _arccosh_terms_mpmath(num, den, n), debug_source=("Arccosh", x))
+    return _lazy_cf(lambda n: _arccosh_terms_from_decimal(num, den, n), debug_source=("Arccosh", x))