@obliczeniowo/elementary/math/index.d.ts

Library made in Angular version 20

interface MinMax {
    min: number;
    max: number;
}

type Operations = string | number | boolean | Operations[];
declare class ElementaryMath {
    /**
     * Calc modulo of two decimal places numbers
     */
    static fmod(value: number, base: number): number;
    static radiansToDegrees(angle: number): number;
    static degreesToRadians(angle: number): number;
    static minmax(value: number, min: number, max: number): number;
    static getMinMax(array: number[]): MinMax;
    /**
     * Check if string is number
     * @param n number/string to check if number
     * @param fully if true will tests if string contain only number format like:
     *
     * -1432
     * -123.45
     * -123.45e10
     * -123.45e-10
     * 123.45e-10
     * 123.45e10
     * 123.45
     * 123
     *
     * format 123.45e is not proper number so it is not consider as number, as well as:
     *
     * 123 some string
     * some string 123
     * 123..
     * 123.123.
     * 123e-10e-10
     *
     * @returns true if is number (not NaN or infinity)
     */
    static isNumeric(n: string | number, fully?: boolean): boolean;
    static precision(value: number): number;
    static average(values: number[]): number;
    static standardDeviation(values: number[]): number;
    static averageAndStandardDeviation(values: number[]): {
        middle: number;
        standardDeviation: number;
    };
    static normalization(values: number[]): number[];
    /**
     * Calc how many times each unique value exist in table of numbers
     * @param values numeric values to count
     * @returns Map object to collect counted times numeric values as key: value, value: count
     *
     * @example
     *
     * countUnique([10, 10, 10, 20, 20, 30])
     *
     * return: Map(3) { 10 → 3, 20 → 2, 30 → 1 }
     */
    static countUnique(values: number[]): Map<number, number>;
    /**
     * Calc weighted average
     * @param values values table
     * @param weights weights table
     * @returns calculated average if values.length === weights.length, else NaN
     */
    static averageWeighted(values: number[], weights: number[]): number;
    /**
     * Pick up n% position of sorted array of numbers
     * @param percentages table of percentage as for example [10, 20, 30, 40, 50]
     * @param values table of numeric values [5, 10, 15, 20, 20, 20, 20, 20, 50, 60]
     * @returns for given above inputs [10, 15, 20, 20, 20]
     */
    static percentagesByPosition(percentages: number[], values: number[]): number[];
    /**
     * Calc sum of values and divide all elements by it and multiply by multiplier
     * @param values vector of numbers [100, 200, 300, 400, 1000]
     * @param multiply by default 100 to get percentages
     * @returns for given input [5, 10, 15, 20, 50] as percentages
     */
    static percentagesBySum(values: number[], multiply?: number): number[];
    /**
     * Find abs max value in values numbers vector and divide each value by it and multiply by 100
     * @param values example: [10, 20, 30, 200, 40, 20, -400]
     * @param multiply multiplier example: 100
     * @returns [2.5, 5, 7.5, 50, 10, 5, -100]
     */
    static percentageByAbsMax(values: number[], multiply?: number): number[];
    /**
     * Find max value in values numbers vector and divide each value by it and multiply by 100
     * @param values example: [10, 20, 30, 200, 40, 20, -400]
     * @param multiply multiplier example: 100
     * @returns [5, 10, 15, 100, 20, 10, -200]
     */
    static percentageByMax(values: number[], multiply?: number): number[];
    static sum(values: number[]): number;
    static absMax(a: number, b: number): number;
    static calculate<T = string | number | boolean>(val: Operations, variables: {
        [name: string]: number;
    }): T;
}

export { ElementaryMath };
export type { MinMax, Operations };