extra-math/index.js

'use strict';

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);
}

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