@rgsoft/math/dist/index.d.ts

Yet another JS math library

/**
 * Converts an integer to its string representation on a given base
 * @param { number } n Number
 * @param { number } b Base
 * @returns { string }
 */
declare function toBase(n: number, b: number): string;
/**
 * Converts a string representing a number in a certain base to an integer
 * @param { string } d Digits
 * @param { number } b Base
 * @returns { string }
 */
declare function fromBase(d: string, b: number): number;

/**
 * Calculates the factorial of a positive integer
 * @param { number } n Number to calculate from
 * @param { number } m (Optional) Number to calculate to
 * @returns { number }
 */
declare function factorial(n: number, m?: number): number;
/**
 * Calculates the combination of n taking by k.
 * @param { number } n
 * @param { number } k
 * @returns { number }
 */
declare function combination(n: number, k: number): number;
/**
 * Calculates the permutation of n taking by k.
 * @param { number } n
 * @param { number } k
 * @returns { number }
 */
declare function permutation(n: number, k: number): number;

declare class Complex {
    readonly a: number;
    readonly b: number;
    private _mag?;
    constructor(a: number, b: number);
    /**
     *
     * @param { number | Complex} n
     */
    add(n: number | Complex): Complex;
    /**
     *
     * @param { number | Complex} n
     */
    sub(n: number | Complex): Complex;
    /**
     *
     * @param { number | Complex} n
        */
    mult(n: number | Complex): Complex;
    /**
     *
     * @param { number | Complex} n
     */
    div(n: number | Complex): Complex;
    sqrt(): Complex;
    conjugate(): Complex;
    toString(): string;
    /**
     * @returns { number }
     */
    get mag(): number;
}

declare class Vector {
    private _x;
    private _y;
    private _mag?;
    private _angle?;
    /**
     *
     * @param { number } x
     * @param { number } y
     */
    constructor(x: number, y: number);
    private resetValues;
    /**
     * @returns { number }
     */
    get mag(): number;
    /**
     * @param { number } value
     */
    set mag(value: number);
    /**
     * @returns { number }
     */
    get angle(): number;
    /**
     * @returns { number }
     */
    get x(): number;
    /**
     * @param { number } value
     */
    set x(value: number);
    /**
     * @returns { number }
     */
    get y(): number;
    /**
     * @param { number } value
     */
    set y(value: number);
    /**
     *
     * @returns { Vector }
     */
    normalize(): Vector;
    /**
     *
     * @param { number} num
     * @returns { Vector }
     */
    mult(num: number): Vector;
    /**
     *
     * @param { number} num
     * @returns { Vector }
     */
    div(num: number): Vector;
    /**
     * @param {Vector} v
     * @returns {number}
     */
    dot(v: Vector): number;
    /**
     *
     * @param { Vector } vector
     * @returns { Vector }
     */
    add(vector: Vector): Vector;
    /**
     *
     * @param { Vector } vector
     * @returns { Vector }
     */
    sub(vector: Vector): Vector;
    /**
     *
     * @param { Vector } vector
     * @returns { number }
     */
    dist(vector: Vector): number;
    /**
     *
     * @param { Vector } vector
     * @returns { boolean }
     */
    equals(vector: Vector): boolean;
    /**
     *
     * @param { Vector } vector
     * @returns { number }
     */
    angleTo(vector: Vector): number;
    /**
     * Calculates the projection on another vector
     * @param { Vector } vector
     * @returns { Vector }
     */
    projection(vector: Vector): Vector;
    /**
     * @returns { Vector }
     */
    copy(): Vector;
    transpose(): void;
    /**
     *
     * @param { number } mag
     */
    limit(mag: number): void;
    /**
     *
     * @param { number } angle
     * @returns { Vector }
     */
    static fromAngle(angle: number): Vector;
    /**
     *
     * @param { Vector } v
     * @param { Vector } w
     * @returns { Vector }
     */
    static add(v: Vector, w: Vector): Vector;
    /**
     *
     * @param { Vector } v
     * @param { Vector } w
     * @returns { Vector }
     */
    static sub(v: Vector, w: Vector): Vector;
    /**
     *
     * @param { Vector } v
     * @param { number } n
     * @returns { Vector }
     */
    static mult(v: Vector, n: number): Vector;
    /**
     *
     * @param { Vector } v
     * @param { number } n
     * @returns { Vector }
     */
    static div(v: Vector, n: number): Vector;
}

declare class Line {
    readonly m: number;
    readonly a: number;
    constructor(m: number, a: number);
    static fromPoints(p: Vector, q: Vector): Line;
    static mediatrix(p: Vector, q: Vector): Line;
    /**
     * Calculates a line intersection point with another
     * @param { Line } line
     * @returns { Vector }
     */
    intersectionPoint(line: Line): Vector;
}

declare function mod(n: number, m: number): number;
/**
 * Gets the greatest common divisor
 * @param { number } a
 * @param { number } b
 */
declare function gcd(a: number, b: number): number;
/**
 * Gets least common multiple
 * @param { number } a
 * @param { number } b
 */
declare function lcm(a: number, b: number): number;
/**
 * Checks if a number is prime
 * @param { number } n
 * @returns { boolean }
 */
declare function prime(n: number): boolean;
/**
 * Get the prime factorization of a positive integer
 * @param { number } n
 * @returns { number[][] }
 */
declare function factors(n: number): number[][];
/**
 * Gets the totient of a posite integer
 * @param { number } m
 * @returns { number }
 */
declare function totient(m: number): number;
/**
 * Generates de Collatz sequence
 * @param { number } n
 * @param { number } limit
 * @returns { number }
 */
declare function collatz(n: number, limit?: number): number[];
/**
 * Gets the digital roots of a positive integer
 * @param { number } n
 * @returns { number }
 */
declare function digitalRoots(n: number): number;

declare function erf(z: number): number;

interface PDF {
    getAccumulated(x: number): number;
    getMean(): number;
    getValue(): number;
}

declare class Exponential implements PDF {
    private readonly mean;
    private readonly m;
    constructor(mean: number);
    getAccumulated(x: number): number;
    getValue(): number;
    getMean(): number;
}

declare class Gaussian implements PDF {
    readonly m: number;
    readonly v: number;
    readonly stdDev: number;
    constructor(m?: number, v?: number);
    getAccumulated(x: number): number;
    inverseCFD(p: number): number;
    getMean(): number;
    getValue(): number;
}

declare class Uniform implements PDF {
    readonly min: number;
    readonly max: number;
    constructor(min: number, max: number);
    getAccumulated(x: number): number;
    getMean(): number;
    getValue(): number;
}

interface PMF {
    getAccumulated(x: number): number;
    getValue(): number;
    probability(x: number): number;
}

declare class Binomial implements PMF {
    private readonly n;
    private readonly p;
    private readonly probabilities;
    private readonly accumulative;
    constructor(n: number, p: number);
    getAccumulated(x: number): number;
    getValue(): number;
    probability(x: number): number;
}

declare class NegativeBinomial implements PMF {
    private readonly r;
    private readonly p;
    private readonly accumulative;
    constructor(r: number, p: number);
    getAccumulated(x: number): number;
    getValue(): number;
    probability(x: number): number;
}

declare class Poisson implements PMF {
    private readonly l;
    private readonly accumulative;
    constructor(l: number);
    getAccumulated(x: number): number;
    getValue(): number;
    probability(x: number): number;
}

declare class Segment {
    readonly p: Vector;
    readonly q: Vector;
    constructor(p: Vector, q: Vector);
    /**
     *
     * @param { Vector } r
     * @returns { boolean }
     */
    isOnSegment(r: Vector): boolean;
    /**
     * To find orientation of ordered triplet (p, q, r).
     * The function returns following values
     * 0 when p, q and r are collinear; -1 when clockwise, 1 counterclockwise
     *
     * @param { Vector } p
     * @param { Vector } q
     * @param { Vector } r
     * @returns { number }
     */
    private getOrientation;
    /**
     *
     * Returns true if intersects with this segment
     *
     * @param { Segment } segment
     * @returns { boolean }
     */
    intersects(segment: Segment): boolean;
}

export { Binomial, Complex, Exponential, Gaussian, Line, NegativeBinomial, Poisson, Segment, Uniform, Vector, collatz, combination, digitalRoots, erf, factorial, factors, fromBase, gcd, lcm, mod, permutation, prime, toBase, totient };