math.gcd-lcm

@dataclass(frozen=True)
class GcdLcm:
    """Both answers together; each is never negative."""

    #: greatest common divisor; gcd(0, 0) is 0
    gcd: int
    #: least common multiple; 0 when either input is 0
    lcm: int

def gcd_lcm(a: int, b: int) -> GcdLcm

from fune.math.gcd_lcm import gcd_lcm  # math.gcd-lcm@^2

from .math_gcd_lcm_gcd import gcd  ← gcd, another function of this group · built into the same file, even by a slim install
from .math_gcd_lcm_lcm import lcm  ← lcm, another function of this group · built into the same file, even by a slim install
from .math_gcd_lcm_types import GcdLcm


def gcd_lcm(a: int, b: int) -> GcdLcm:
    """Greatest common divisor and least common multiple of two integers.

    Both are returned together because a caller needing one nearly always
    needs the other (common denominators, repeating schedules).
    """
    return GcdLcm(gcd=gcd(a, b), lcm=lcm(a, b))

def gcd(a: int, b: int) -> int

from fune.math.gcd_lcm import gcd  # math.gcd-lcm@^2

_MAX_SAFE = 9007199254740991


def _check_safe(name: str, value: int) -> None:
    if isinstance(value, bool) or not isinstance(value, int):
        raise TypeError("%s must be an integer, received %r" % (name, value))
    if value > _MAX_SAFE or value < -_MAX_SAFE:
        # Python would happily go further, but TypeScript cannot, and the three
        # languages must give the same answer or the same error.
        raise ValueError("%s is outside the safe integer range (±9007199254740991)" % (name,))


def gcd_wide(a: int, b: int) -> int:
    """Euclid's algorithm with no range limit. Never negative; gcd_wide(0, 0) is 0.

    Exported for fraction arithmetic (math.rational), which reduces products
    that are already past 2^53 before it checks them.
    """
    x, y = abs(a), abs(b)
    while y != 0:
        x, y = y, x % y
    return x


def gcd(a: int, b: int) -> int:
    """Greatest common divisor, never negative; gcd(0, n) is |n| and gcd(0, 0) is 0."""
    _check_safe("a", a)
    _check_safe("b", b)
    return gcd_wide(a, b)

def lcm(a: int, b: int) -> int

from fune.math.gcd_lcm import lcm  # math.gcd-lcm@^2

from .math_gcd_lcm_gcd import gcd  ← gcd, another function of this group · built into the same file, even by a slim install

_MAX_SAFE = 9007199254740991


def lcm(a: int, b: int) -> int:
    """Least common multiple, never negative; 0 when either input is 0."""
    g = gcd(a, b)
    if g == 0:
        return 0
    # Divide before multiplying: a * b overflows long before the lcm does.
    result = abs(a) // g * abs(b)
    if result > _MAX_SAFE:
        raise ValueError("the lcm of %d and %d exceeds 2^53 - 1" % (a, b))
    return result

Install

fune build

With that line in your source, in a Python project (language python in fune.project), fune build resolves it and nothing else, pins them in fune.lock, downloads only the Python package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add math.gcd-lcm

That builds the whole group. To build only what you call, and whatever it uses inside the group:

fune add math.gcd-lcm --only gcdLcm

The manifest, vectors and README with only the Python implementation. Install it without the registry with fune add ./math.gcd-lcm-2.0.0-python.fune, or fetch it from a terminal with fune pull math.gcd-lcm@2.0.0:python.

The whole function, every language, is one file too: math.gcd-lcm-2.0.0.fune, 19,234 bytes, sha256 b4ff66bde30ed40b4e53d980014fb8902c3854539d276a87c0c083ba74f7a1bb. It installs into a project of any language.

# fune: before math.gcd-lcm.gcdLcm
# fune: before math.gcd-lcm.gcd
# fune: before math.gcd-lcm.lcm

# fune: after math.gcd-lcm.gcdLcm
# fune: after math.gcd-lcm.gcd
# fune: after math.gcd-lcm.lcm

# fune: step math.gcd-lcm.<fn> after <n|label>

More from the author

The lcm is computed as `|a| / gcd * |b|`, dividing first. The textbook `a * b / gcd` overflows a 64-bit integer, and loses digits in a JavaScript number, long before the answer itself is large; one of the vectors is a case where it does.

Inputs and results are limited to ±(2^53 - 1), the range where a JavaScript number is still an exact integer, so the three languages agree on every answer. An input outside it, or an lcm beyond it, is an error.

This is a group of three functions: `gcdLcm(a, b)` returns both answers, `gcd(a, b)` and `lcm(a, b)` one each. `lcm` uses `gcd`, and `gcdLcm` uses both, so `require math.gcd-lcm ^2.0.0 only=gcd` installs the gcd alone.

`gcdWide(a, b)`, a gcd over wide integers (TypeScript `bigint`, Python `int`, Rust `i128`) with no range limit, is still exported from the `gcd` file for fraction arithmetic that reduces products already past 2^53. It is a helper, not a published function: the registry's type vocabulary has no wide integer (`int` is a JavaScript number and an `i64`), so it has no `fn` line and no vectors of its own, and it is exercised through `gcd`'s vectors. Its signature and behaviour are exactly those of 1.0.0.

## What changed from 1.0.0

1.0.0 was one function, `gcdLcm`, with `gcd`, `lcm` and `gcdWide` exported alongside it but unpinned: no signature in the manifest and no vectors, so nothing held the three languages to the same answer for them. 2.0.0 is a group: `gcd` and `lcm` are published functions with their own signatures, files and vectors, and `gcdLcm` keeps every 1.0.0 vector.

No answer changed. The Rust adapters now refuse a fractional argument with the same "must be an integer" wording as TypeScript and Python, which only affects the vectors. It is a new major version because the package's shape and public surface changed: it installs as one module per function plus the group module (`math_gcd_lcm` still re-exports every function and `gcdWide`), a project can take only some of it, and the Python module no longer exports its `MAX_SAFE` constant. Dependents stay on `^1.0.0` until they move deliberately; 1.0.0 is unchanged.

Files