extra-math/index.mjs

function floor(x, pre = 1) {
    return Math.floor(x / pre) * pre;
}
function ceil(x, pre = 1) {
    return Math.ceil(x / pre) * pre;
}
function round(x, pre = 1) {
    return Math.round(x / pre) * pre;
}
function floorDiv(x, y) {
    return Math.floor(x / y);
}
function ceilDiv(x, y) {
    return Math.ceil(x / y);
}
function roundDiv(x, y) {
    return Math.round(x / y);
}
function rem(x, y) {
    return x % y;
}
function mod(x, y) {
    return x - y * Math.floor(x / y);
}
function modp(x, y) {
    return x - Math.abs(y) * Math.floor(x / Math.abs(y));
}
function constrain(x, min, max) {
    return Math.min(Math.max(x, min), max);
}
function normalize(x, r, R) {
    return (x - r) / (R - r);
}
function remap(x, r, R, t, T) {
    return t + ((x - r) / (R - r)) * (T - t);
}
function lerp(x, y, t) {
    return x + t * (y - x);
}
function isPow(x, n) {
    if (n === 0)
        return x === 0;
    var p = log(Math.abs(x), Math.abs(n));
    if (p !== Math.floor(p))
        return false;
    return x < 0 ? n < 0 && (p & 1) === 1 : n > 0 || (p & 1) === 0;
}
function prevPow(x, n) {
    if (x <= 1)
        return 0;
    var p = Math.floor(Math.log(x) / Math.log(n));
    return Math.pow(n, p);
}
function nextPow(x, n) {
    if (x <= 0)
        return 1;
    var p = Math.ceil(Math.log(x) / Math.log(n));
    return Math.pow(n, p);
}
function root(x, n) {
    if ((n & 1) === 0)
        return Math.pow(x, 1 / n);
    return Math.sign(x) * Math.pow(Math.abs(x), 1 / n);
}
function log(x, b = Math.E) {
    return Math.log(x) / Math.log(b);
}
function properDivisors(x) {
    var x = Math.abs(x), a = [];
    for (var i = 1; i < x; i++)
        if (x % i === 0)
            a.push(i);
    return a;
}
function aliquotSum(x) {
    var x = Math.abs(x), a = 0;
    for (var i = 0; i < x; i++)
        if (x % i === 0)
            a += i;
    return a;
}
function minPrimeFactor(x) {
    var x = Math.abs(x);
    if (x <= 1)
        return 0;
    if (x <= 3)
        return x;
    if (x % 2 === 0)
        return 2;
    if (x % 3 === 0)
        return 3;
    for (var i = 6, I = Math.sqrt(x) + 1; i <= I; i += 6) {
        if (x % (i - 1) === 0)
            return i - 1;
        if (x % (i + 1) === 0)
            return i + 1;
    }
    return x;
}
function maxPrimeFactor(x) {
    var x = Math.abs(x), a = 0;
    if (x <= 1)
        return 0;
    if (x <= 3)
        return x;
    for (; x % 2 === 0; a = 2)
        x /= 2;
    for (; x % 3 === 0; a = 3)
        x /= 3;
    for (var i = 6, I = Math.sqrt(x) + 1; x > 1 && i <= I; i += 6) {
        for (; x % (i - 1) == 0; a = i - 1)
            x /= i - 1;
        for (; x % (i + 1) == 0; a = i + 1)
            x /= i + 1;
    }
    if (x <= 1)
        return a;
    return x;
}
function primeFactors(x) {
    var x = Math.abs(x), a = [];
    if (x <= 1)
        return [];
    if (x <= 3)
        return [x];
    x = pushPrimeFactorTo$(a, x, 2);
    x = pushPrimeFactorTo$(a, x, 3);
    for (var i = 6, I = Math.sqrt(x) + 1; x > 1 && i <= I; i += 6) {
        x = pushPrimeFactorTo$(a, x, i - 1);
        x = pushPrimeFactorTo$(a, x, i + 1);
    }
    if (x > 1)
        a.push(x);
    return a;
}
function pushPrimeFactorTo$(a, x, f) {
    if (x % f !== 0)
        return x;
    do {
        x /= f;
    } while (x % f === 0);
    a.push(f);
    return x;
}
function primeExponentials(x) {
    var x = Math.abs(x), a = [];
    if (x <= 1)
        return [];
    if (x <= 3)
        return [[x, 1]];
    x = pushPrimeExponentialTo$(a, x, 2);
    x = pushPrimeExponentialTo$(a, x, 3);
    for (var i = 6, I = Math.sqrt(x) + 1; x > 1 && i <= I; i += 6) {
        x = pushPrimeExponentialTo$(a, x, i - 1);
        x = pushPrimeExponentialTo$(a, x, i + 1);
    }
    if (x > 1)
        a.push([x, 1]);
    return a;
}
function pushPrimeExponentialTo$(a, x, f) {
    if (x % f !== 0)
        return x;
    var e = 0;
    do {
        x /= f;
        ++e;
    } while (x % f === 0);
    a.push([f, e]);
    return x;
}
function isPrime(x) {
    return x !== 0 && minPrimeFactor(x) === Math.abs(x);
}
function gcd(...xs) {
    var a = xs[0] || 1;
    for (var i = 1, I = xs.length; i < I; i++)
        a = gcdPair(a, xs[i]);
    return a;
}
function gcdPair(x, y) {
    while (y !== 0) {
        var t = y;
        y = x % y;
        x = t;
    }
    return x;
}
function lcm(...xs) {
    var a = xs[0] || 1;
    for (var i = 1, I = xs.length; i < I; i++)
        a = a * xs[i] / gcdPair(a, xs[i]);
    return a;
}
function factorial(n, k = 0) {
    if (n < 0)
        return 0;
    for (var i = k + 1, a = 1; i <= n; i++)
        a *= i;
    return a;
}
function binomial(n, k) {
    if (k < 0 || k > Math.abs(n))
        return 0;
    if (n < 0)
        return Math.pow(-1, k) * binomial(-n, k);
    k = k > n - k ? n - k : k;
    for (var a = 1, i = 1; i <= k; i++, n--)
        a *= n / i;
    return a;
}
function multinomial(...ks) {
    var n = sum(...ks), a = 1;
    for (var i = 0, j = 0, I = ks.length; i < I;) {
        if (j <= 0)
            j = ks[i++];
        else
            a *= n-- / j--;
    }
    return a;
}
function degrees(x) {
    return x * (180 / Math.PI);
}
function radians(x) {
    return x * (Math.PI / 180);
}
function sum(...xs) {
    var a = 0;
    for (var x of xs)
        a += x;
    return a;
}
function product(...xs) {
    var a = 1;
    for (var x of xs)
        a *= x;
    return a;
}
function median(...xs) {
    if (xs.length === 0)
        return 0;
    xs.sort((a, b) => a - b);
    var i = xs.length >> 1;
    if ((xs.length & 1) === 1)
        return xs[i];
    return (xs[i - 1] + xs[i]) / 2;
}
function modes(...xs) {
    xs.sort((a, b) => a - b);
    var r = maxRepeat(xs);
    return getRepeats(xs, r);
}
function maxRepeat(xs) {
    var count = Math.min(xs.length, 1), max = count;
    for (var i = 1, I = xs.length; i < I; i++) {
        if (xs[i - 1] === xs[i])
            count++;
        else {
            max = Math.max(max, count);
            count = 1;
        }
    }
    return Math.max(max, count);
}
function getRepeats(xs, r) {
    var a = [];
    r--;
    for (var i = 0, I = xs.length - r; i < I; i++)
        if (xs[i] === xs[i + r])
            a.push(xs[i += r]);
    return a;
}
function range(...xs) {
    return [Math.min(...xs), Math.max(...xs)];
}
function variance(...xs) {
    if (xs.length === 0)
        return 0;
    var m = arithmeticMean(...xs), a = 0;
    for (var x of xs)
        a += (x - m) ** 2;
    return a / xs.length;
}
function arithmeticMean(...xs) {
    if (xs.length === 0)
        return 0;
    return sum(...xs) / xs.length;
}
function geometricMean(...xs) {
    var n = xs.length;
    return root(product(...xs), n);
}
function harmonicMean(...xs) {
    var n = xs.length;
    var p = product(...xs), q = 0;
    for (var x of xs)
        q += p / x;
    return n * p / q;
}
function quadriaticMean(...xs) {
    var n = xs.length, a = 0;
    for (var x of xs)
        a += x * x;
    return Math.sqrt(a / n);
}
function cubicMean(...xs) {
    var n = xs.length, a = 0;
    for (var x of xs)
        a += x ** 3;
    return Math.cbrt(a / n);
}

function magnitude(xs) {
    var a = 0;
    for (var i = 0, I = xs.length; i < I; i++)
        a += xs[i] ** 2;
    return Math.sqrt(a);
}
function distance(xs, ys) {
    var a = 0;
    for (var i = 0, I = xs.length; i < I; i++)
        a += (xs[i] - ys[i]) ** 2;
    return Math.sqrt(a);
}

export { properDivisors as aliquotParts, aliquotSum, arithmeticMean, binomial, ceil, ceilDiv, constrain as clamp, constrain, cubicMean, degrees, distance, factorial, floor, floorDiv, gcd, geometricMean, maxPrimeFactor as greatestPrimeFactor, harmonicMean, gcd as hcf, isPow, isPrime, lcm, minPrimeFactor as leastPrimeFactor, lerp, log, magnitude, remap as map, maxPrimeFactor, arithmeticMean as mean, median, minPrimeFactor, mod, modes, modp, multinomial, nextPow, normalize as norm, normalize, prevPow, primeExponentials, primeFactors, product, properDivisors, quadriaticMean, radians, range, rem, remap, root, quadriaticMean as rootMeanSquare, round, roundDiv, sum, variance };