nhb-toolbox/dist/esm/number/basics.js

A versatile collection of smart, efficient, and reusable utility functions, classes and types for everyday development needs.

import { isNumber, isUndefined } from '../guards/primitives.js';
import { _find2NumbersHCF, _find2NumbersLCM } from './helpers.js';
import { normalizeNumber } from './utilities.js';
export const getRandomNumber = (options) => {
    const { min = 0, max = 100, includeMin = true, includeMax = true } = options || {};
    let minimum = min, maximum = max;
    if (min > max) {
        [minimum, maximum] = [max, min];
        return getRandomNumber({
            min: minimum,
            max: maximum,
            includeMin,
            includeMax,
        });
    }
    if (min === max) {
        return min;
    }
    if (includeMin && includeMax) {
        return Math.floor(Math.random() * (max - min + 1)) + min;
    }
    if (!includeMin && !includeMax) {
        return Math.floor(Math.random() * (max - min - 1)) + min + 1;
    }
    if (includeMin && !includeMax) {
        return Math.floor(Math.random() * (max - min)) + min;
    }
    if (!includeMin && includeMax) {
        return Math.floor(Math.random() * (max - min)) + min + 1;
    }
    return 0;
};
export const convertToDecimal = (input, options) => {
    const { decimalPlaces = 2, isString = false } = options || {};
    const parsed = normalizeNumber(input);
    if (isUndefined(parsed)) {
        throw new TypeError(`Invalid numeric input!`, {
            cause: `${input} cannot be converted to a number.`,
        });
    }
    return (isString ? parsed.toFixed(decimalPlaces) : Number(parsed.toFixed(decimalPlaces)));
};
export const calculateHCF = (...numbers) => {
    const converted = numbers?.map(Number);
    if (converted?.length === 0)
        return 0;
    let hcf = converted[0];
    for (let i = 1; i < converted?.length; i++) {
        hcf = _find2NumbersHCF(hcf, converted[i]);
    }
    return hcf;
};
export const calculateLCM = (...numbers) => {
    const converted = numbers?.map(Number);
    if (converted?.length === 0)
        return 0;
    let lcm = converted[0];
    for (let i = 1; i < converted?.length; i++) {
        lcm = _find2NumbersLCM(lcm, converted[i]);
    }
    return lcm;
};
export function factorial(int) {
    const num = normalizeNumber(int);
    if (!isNumber(num) || num < 0 || !Number.isInteger(num)) {
        return undefined;
    }
    else if (num === 0 || num === 1) {
        return 1;
    }
    else {
        return num * (factorial(num - 1) ?? 1);
    }
}
export function getFactors(int) {
    const num = normalizeNumber(int);
    if (!isNumber(num) || num <= 0 || !Number.isInteger(num))
        return [];
    if (num === 1)
        return [1];
    const factors = new Set([1, num]);
    const sqrt = Math.floor(Math.sqrt(num));
    for (let i = 2; i <= sqrt; i++) {
        if (num % i === 0) {
            factors.add(i);
            factors.add(num / i);
        }
    }
    return [...factors].sort((a, b) => a - b);
}
export function sumDigits(num) {
    return Math.abs(Number(num))
        .toString()
        .split('')
        .reduce((sum, digit) => sum + Number(digit), 0);
}
export function sumNumbers(...numbers) {
    return numbers?.map((num) => Number(num))?.reduce((sum, number) => sum + number, 0);
}
export function reverseNumber(num) {
    const reversed = parseInt(Math.abs(Number(num)).toString().split('').reverse().join(''), 10);
    return Number(num) < 0 ? -reversed : reversed;
}
export function getAverage(...numbers) {
    let sum = 0;
    let count = 0;
    for (const n of numbers) {
        const num = Number(n);
        if (isNumber(num)) {
            sum += num;
            count++;
        }
    }
    return count === 0 ? NaN : Math.round((sum / count) * 1000) / 1000;
}
export function roundNumber(number, roundTo = 2) {
    const factor = 10 ** roundTo;
    const num = isNumber(number) ? number : Number(number);
    return Math.round(num * factor) / factor;
}