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

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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.calculateLCM = exports.calculateHCF = exports.convertToDecimal = exports.getRandomNumber = void 0;
exports.factorial = factorial;
exports.getFactors = getFactors;
exports.sumDigits = sumDigits;
exports.sumNumbers = sumNumbers;
exports.reverseNumber = reverseNumber;
exports.getAverage = getAverage;
exports.roundNumber = roundNumber;
const primitives_1 = require("../guards/primitives");
const helpers_1 = require("./helpers");
const utilities_1 = require("./utilities");
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 (0, exports.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;
};
exports.getRandomNumber = getRandomNumber;
const convertToDecimal = (input, options) => {
    const { decimalPlaces = 2, isString = false } = options || {};
    const parsed = (0, utilities_1.normalizeNumber)(input);
    if ((0, primitives_1.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)));
};
exports.convertToDecimal = convertToDecimal;
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 = (0, helpers_1._find2NumbersHCF)(hcf, converted[i]);
    }
    return hcf;
};
exports.calculateHCF = calculateHCF;
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 = (0, helpers_1._find2NumbersLCM)(lcm, converted[i]);
    }
    return lcm;
};
exports.calculateLCM = calculateLCM;
function factorial(int) {
    const num = (0, utilities_1.normalizeNumber)(int);
    if (!(0, primitives_1.isNumber)(num) || num < 0 || !Number.isInteger(num)) {
        return undefined;
    }
    else if (num === 0 || num === 1) {
        return 1;
    }
    else {
        return num * (factorial(num - 1) ?? 1);
    }
}
function getFactors(int) {
    const num = (0, utilities_1.normalizeNumber)(int);
    if (!(0, primitives_1.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);
}
function sumDigits(num) {
    return Math.abs(Number(num))
        .toString()
        .split('')
        .reduce((sum, digit) => sum + Number(digit), 0);
}
function sumNumbers(...numbers) {
    return numbers?.map((num) => Number(num))?.reduce((sum, number) => sum + number, 0);
}
function reverseNumber(num) {
    const reversed = parseInt(Math.abs(Number(num)).toString().split('').reverse().join(''), 10);
    return Number(num) < 0 ? -reversed : reversed;
}
function getAverage(...numbers) {
    let sum = 0;
    let count = 0;
    for (const n of numbers) {
        const num = Number(n);
        if ((0, primitives_1.isNumber)(num)) {
            sum += num;
            count++;
        }
    }
    return count === 0 ? NaN : Math.round((sum / count) * 1000) / 1000;
}
function roundNumber(number, roundTo = 2) {
    const factor = 10 ** roundTo;
    const num = (0, primitives_1.isNumber)(number) ? number : Number(number);
    return Math.round(num * factor) / factor;
}