numeric

The largest Int, 2^63 - 1.

The smallest Int, -2^63.

The absolute value of x, or none for int_min(), whose absolute value is not an Int.

The sign of x: -1, 0 or 1.

The sign of x: -1.0, 1.0, or x itself for zeros (keeping -0.0) and NaN.

The greatest common divisor of every number in xs, never negative; 0 for an empty list or all zeros. Traps, like Int.gcd, only when the result would be 2^63 (only int_min() and zeros).

The least common multiple of a and b, never negative (0 if either is 0), or none when it doesn't fit in an Int.

The least common multiple of every number in xs, never negative: 1 for an empty list, 0 if any is 0, none when it doesn't fit in an Int.

The extended Euclidean algorithm: (g, x, y) with g = gcd(a, b) >= 0 and a * x + b * y == g. Neither argument may be int_min().

Whether a and b have no common divisor above 1.

Division rounded toward negative infinity, like Python's //: floor_div(-7, 2) == -4. Traps on int_min() / -1, like /.

The remainder that goes with floor_div, with the sign of b, like Python's %: floor_mod(-7, 2) == 1, floor_mod(7, -2) == -1.

Division rounded toward positive infinity: ceil_div(7, 2) == 4, ceil_div(-7, 2) == -3.

The Euclidean remainder: always in 0 .. |b|, whatever the signs: euclid_mod(-7, 3) == 2. This is the "mod that is never negative".

The Euclidean quotient: a == b * euclid_div(a, b) + euclid_mod(a, b).

(a + b) mod m in 0 .. m, without overflow for any Int inputs.

(a * b) mod m in 0 .. m, without overflow for any Int inputs (it uses BigInt when the product doesn't fit).

base ^ exp mod m in 0 .. m, by square and multiply; mod_pow(x, 0, m) is 1 mod m.

The inverse of a modulo m: x in 0 .. m with a * x mod m == 1 mod m, or none when a and m are not coprime.

The integer square root: the largest r with r * r <= n.

The integer k-th root: the largest r >= 0 with r ^ k <= n.

The integer cube root, rounded toward negative infinity, for any n: icbrt(27) == 3, icbrt(26) == 2, icbrt(-9) == -3.

base ^ exp, or none if it overflows. checked_pow(0, 0) == some(1). For exact big powers use big(base).pow(exp).

Whether n is the square of an Int (0 and 1 are; negatives are not).

The largest exponent k >= 2 and its base b with b ^ k == n, or none. Negative n can only be odd powers (-8 is (-2, 3)); 0, 1 and -1 give none, since every exponent fits.

Whether n is b ^ k for some Int b and k >= 2 (see perfect_power).

Whether n is a positive power of two (1, 2, 4, ...).

The smallest power of two >= n (1 for n <= 1), or none above 2^62.

The digits of |n| in base, most significant first; [0] for 0. Works for int_min().

The sum of the decimal digits of |n|.

The number of digits of |n| in base (1 for 0).

The repeated digit sum of |n| down to one decimal digit (0 for 0, else 1 to 9).

The number with these digits in base, most significant first, or none if a digit is outside 0 .. base or the value overflows. from_digits([], b) == some(0).

n written in base 2 to 36 with lowercase letters and a leading - when negative: to_radix(255, 16) == "ff", to_radix(-5, 2) == "-101".

Parses s as an Int in base 2 to 36: an optional + or -, then one or more digits in either case. No spaces, prefixes or separators. none on anything else or on overflow.

How to round a value that falls between two candidates. The Half modes only differ on exact ties; the others look only at whether anything is discarded. HalfUp ties toward +infinity (2.5 to 3, -2.5 to -2); HalfDown ties toward -infinity; HalfEven ties to the even neighbour (banker's rounding); HalfAwayFromZero ties away from zero (school rounding, Java's HALF_UP); HalfTowardZero ties toward zero (Java's HALF_DOWN); Up rounds away from zero; Down toward zero (truncation); Ceiling toward +infinity; Floor toward -infinity.

a / b rounded to an Int with mode (the exact quotient decides, with no overflow in the comparison): div_round(7, 2, HalfEven) == 4, div_round(-7, 2, Floor) == -4. Traps on int_min() / -1, like /.

n rounded to a multiple of step with mode, or none if that multiple overflows: round_int_to_multiple(17, 5, HalfEven) == some(15).

x rounded to places decimal places (negative places round to tens, hundreds, ...) with mode. The rounding is exact on the shortest decimal that prints as x (its .str), so round_to(2.675, 2, HalfAwayFromZero) == 2.68 even though the binary double is slightly below 2.675; the result is the double nearest to the rounded decimal. NaN, infinities and zeros come back unchanged, and a value already short enough is returned as it is.

x rounded to a multiple of step with mode: round_to_multiple(7.3, 0.5, HalfEven) == 7.5. Like round_to, it works exactly on the shortest decimals that print as x and step, so round_to_multiple(0.3, 0.1, Floor) == 0.3 (where (0.3 / 0.1).floor is 2), and returns the double nearest the exact multiple. NaN and infinities come back unchanged; a multiple too large for F64 is an infinity.

The value t of the way from a to b: a at 0, b at 1, extrapolating outside (lerp(10.0, 20.0, 0.25) == 12.5). Exact at both ends.

Where v lies between a and b (0 at a, 1 at b), or none when a == b.

v mapped linearly from the range in_lo .. in_hi to out_lo .. out_hi (not clamped), or none when the input range is empty.

The smooth Hermite step from 0 at edge0 to 1 at edge1 (GLSL smoothstep), clamped to 0 and 1 outside; when the edges are equal it is a hard step at edge0.

Whether a and b are close, as Python's math.isclose: |a - b| <= max(rel_tol * max(|a|, |b|), abs_tol). NaN is close to nothing (not even NaN), an infinity only to itself, and 0.0 and -0.0 are close. Use an abs_tol above 0 to compare with zero.

approx_equal(a, b, 1e-9, 0.0), Python's default.

Degrees to radians.

Radians to degrees.

x wrapped into the half-open range lo .. hi, as an angle or a ring buffer index would wrap: wrap(370.0, 0.0, 360.0) == 10.0, wrap(-1.0, 0.0, 360.0) == 359.0. NaN and the infinities give NaN.

An angle in degrees normalized to 0 .. 360.

An angle in radians normalized to -pi .. pi.

Whether n is prime. Deterministic for every Int: trial division by the primes below 40, then Miller-Rabin with the first twelve prime bases, which has no false positives below 3.3 * 10^24.

Every prime up to and including limit, in order, by the sieve of Eratosthenes. The limit is capped at 10,000,000 (664,579 primes) to keep the memory bounded.

The smallest prime greater than n, or none when that is above int_max() (the largest Int prime is 9223372036854775783).

The largest prime less than n, or none when n <= 2.

The prime factors of n with multiplicity, in increasing order: prime_factors(360) == [2, 2, 2, 3, 3, 5], prime_factors(1) == []. Trial division by the primes below 1000, then Pollard's rho (with Miller-Rabin to stop), so any Int factors in well under a second natively.

The factorization of n as (prime, exponent) pairs in increasing order of prime: factorize(360) == [(2, 3), (3, 2), (5, 1)], factorize(1) == [].

Every positive divisor of n, in increasing order: divisors(12) == [1, 2, 3, 4, 6, 12].

Euler's totient: how many of 1 ..= n are coprime to n.

n!, exactly. n is capped at 100,000 (456,574 digits).

n! as an Int, or none above 20!.

The binomial coefficient "n choose k", exactly: 0 when k < 0 or k > n. Takes min(k, n - k) BigInt steps.

"n choose k" as an Int, or none if it overflows; 0 when k < 0 or k > n.

The number of ordered arrangements of k items out of n, n! / (n - k)!, exactly; 0 when k < 0 or k > n.

perm(n, k) as an Int, or none if it overflows.

The multinomial coefficient (k1 + k2 + ...)! / (k1! k2! ...), exactly; 1 for an empty list.

The nth Catalan number, comb(2n, n) / (n + 1): 1, 1, 2, 5, 14, 42, ...

The nth Fibonacci number (F(0) = 0, F(1) = 1), exactly, by fast doubling.

The nth Fibonacci number as an Int, or none above F(92).

The Int list as F64s, to feed the statistics functions.

The sum of xs, or none if it overflows (the builtin sum traps instead).

The product of xs (1 for an empty list), or none if it overflows.

The sum of xs with Neumaier's compensated summation, which keeps the rounding error of long or cancelling sums near one ulp: compensated_sum([1e100, 1.0, -1e100]) == 1.0 where sum gives 0.0. Infinities and NaN give what a plain sum gives. 0.0 for an empty list.

The product of xs (1.0 for an empty list).

The running compensated sums: cumulative_sum([1.0, 2.0, 3.0]) == [1.0, 3.0, 6.0].

The arithmetic mean, or none for an empty list. Uses the compensated sum, and rescales when the sum of finite values would overflow, so mean([1e308, 1e308]) == some(1e308).

The mean of xs weighted by ws, or none if the lengths differ, the list is empty, a weight is negative or the weights sum to 0.

The geometric mean, or none for an empty list or a negative value; 0.0 if any value is 0.

The harmonic mean, or none for an empty list or a negative value; 0.0 if any value is 0 (as Python's statistics.harmonic_mean).

The median (the mean of the two middle values for an even count), or none for an empty list.

The lower of the two middle values (the middle one for an odd count), or none if empty.

The higher of the two middle values (the middle one for an odd count), or none if empty.

The most common value, the first one seen on ties, or none for an empty list. Works for any type; values compare with == (so NaN counts as equal to NaN).

Every most common value, in first-seen order; [] for an empty list.

The population variance (divided by n), or none for an empty list. Welford's algorithm.

The sample variance (divided by n - 1), or none for fewer than two values.

The population standard deviation, or none for an empty list.

The sample standard deviation, or none for fewer than two values.

How a quantile is read off the sorted data (h is the 0-based position (n - 1) * p): Linear interpolates at h (R-7, the default of NumPy, Excel PERCENTILE.INC and Python's method="inclusive"); Exclusive interpolates at (n + 1) * p - 1, clamped to the data (R-6, Python's default method="exclusive", Excel PERCENTILE.EXC); Lower and Higher take the element at floor(h) or ceil(h); Midpoint averages those two; Nearest takes the element nearest h, ties to even (NumPy's "nearest"); NearestRank takes the element at rank ceil(p * n) (the classical nearest-rank method, never interpolated).

The p quantile (0 to 1) of xs by method, or none for an empty list; NaN if xs holds a NaN. quantile(xs, 0.5, Linear) is the median.

The p percentile (0 to 100) with linear interpolation (Linear), or none if empty.

The n - 1 cut points that divide xs into n groups of equal probability, as Python's statistics.quantiles(xs, n=n, method=...) (pass Exclusive for its default): n = 4 gives the quartiles. none for an empty list.

The interquartile range, Q3 - Q1 with Linear quantiles, or none for an empty list.

The largest value minus the smallest, or none for an empty list.

The z-score of each value, (x - mean) / pstdev, or none for an empty list or one whose values are all equal.

Each value scaled to 0 .. 1 by (x - min) / (max - min), or none for an empty list or one whose values are all equal.

The sample covariance (divided by n - 1), as Python's statistics.covariance, or none if the lengths differ or there are fewer than two pairs.

Pearson's correlation coefficient in -1 to 1, or none if the lengths differ, there are fewer than two pairs, or either series is constant.

The rank of each value, 1 for the smallest, with ties given the average of their ranks (ranks([10.0, 20.0, 10.0]) == [1.5, 3.0, 1.5]), as used by Spearman's correlation.

Spearman's rank correlation (Pearson's on the ranks, ties averaged), or none as for correlation.

The least squares line through a set of points: y = slope * x + intercept, and r_squared, the share of the variance in y it explains (1.0 when y is constant and the fit is exact).

Simple linear regression of ys on xs by ordinary least squares, or none if the lengths differ, there are fewer than two points, or every x is the same.

One histogram bin: the values v with lo <= v < hi (the last bin also takes hi).

bins equal-width bins from lo to hi, counting the values of xs inside that range; values outside it and NaN are not counted.

bins equal-width bins spanning the smallest to the largest finite value of xs; [] when there is none. When every value is the same, one bin [v, v] holds them all.

The trailing simple moving average over window values: one result per full window, so xs.len - window + 1 results ([] when xs is shorter than the window).

The exponential moving average with smoothing factor alpha (0 < alpha <= 1), seeded with the first value: e[0] = x[0], e[i] = alpha * x[i] + (1 - alpha) * e[i - 1].