@fluixi/utils 1.0.0-alpha.53

package/dist/lib/maths/fn/advanced.js

@@ -0,0 +1,264 @@
+/**
+ * Advanced mathematical operations.
+ * @module AdvancedMathFunctions
+ */
+import { gcd, round } from './basic.js';
+/**
+ * Calculates the natural logarithm of a number.
+ * @param value - The number
+ * @returns The natural logarithm
+ * @throws {Error} If value is not positive
+ */
+export function ln(value) {
+    if (value <= 0) {
+        throw new Error('Natural logarithm is only defined for positive numbers');
+    }
+    return Math.log(value);
+}
+/**
+ * Calculates the base-10 logarithm of a number.
+ * @param value - The number
+ * @returns The base-10 logarithm
+ * @throws {Error} If value is not positive
+ */
+export function log10(value) {
+    if (value <= 0) {
+        throw new Error('Logarithm is only defined for positive numbers');
+    }
+    return Math.log10(value);
+}
+/**
+ * Calculates the base-2 logarithm of a number.
+ * @param value - The number
+ * @returns The base-2 logarithm
+ * @throws {Error} If value is not positive
+ */
+export function log2(value) {
+    if (value <= 0) {
+        throw new Error('Logarithm is only defined for positive numbers');
+    }
+    return Math.log2(value);
+}
+/**
+ * Calculates the logarithm of a number with a custom base.
+ * @param value - The number
+ * @param base - The logarithm base
+ * @returns The logarithm with specified base
+ * @throws {Error} If value or base is not positive
+ */
+export function log(value, base) {
+    if (value <= 0 || base <= 0) {
+        throw new Error('Logarithm is only defined for positive numbers and bases');
+    }
+    return Math.log(value) / Math.log(base);
+}
+/**
+ * Calculates the exponential function e^x.
+ * @param x - The exponent
+ * @returns e raised to the power x
+ */
+export function exp(x) {
+    return Math.exp(x);
+}
+/**
+ * Calculates the cube root of a number.
+ * @param value - The number
+ * @returns The cube root
+ */
+export function cbrt(value) {
+    return Math.cbrt(value);
+}
+/**
+ * Calculates the nth root of a number.
+ * @param value - The number
+ * @param n - The root degree
+ * @returns The nth root
+ * @throws {Error} If n is 0 or value is negative for even n
+ */
+export function nthRoot(value, n) {
+    if (n === 0) {
+        throw new Error('Cannot calculate 0th root');
+    }
+    if (value < 0 && n % 2 === 0) {
+        throw new Error('Cannot calculate even root of negative number');
+    }
+    const exponent = 1 / n;
+    return Math.sign(value) * Math.pow(Math.abs(value), exponent);
+}
+/**
+ * Solves a quadratic equation ax^2 + bx + c = 0.
+ * @param a - Coefficient of x^2
+ * @param b - Coefficient of x
+ * @param c - Constant term
+ * @returns Array of real roots (0, 1, or 2 roots)
+ */
+export function solveQuadratic(a, b, c) {
+    if (a === 0) {
+        // Linear equation
+        if (b === 0)
+            return [];
+        return [-c / b];
+    }
+    const discriminant = b * b - 4 * a * c;
+    if (discriminant < 0) {
+        return [];
+    }
+    else if (discriminant === 0) {
+        return [-b / (2 * a)];
+    }
+    else {
+        const sqrtDiscriminant = Math.sqrt(discriminant);
+        return [
+            (-b - sqrtDiscriminant) / (2 * a),
+            (-b + sqrtDiscriminant) / (2 * a)
+        ];
+    }
+}
+/**
+ * Evaluates a polynomial at a given x value.
+ * @param coefficients - Polynomial coefficients from highest to lowest degree
+ * @param x - The value to evaluate at
+ * @returns The polynomial value at x
+ */
+export function evaluatePolynomial(coefficients, x) {
+    let result = 0;
+    for (let i = 0; i < coefficients.length; i++) {
+        result = result * x + coefficients[i];
+    }
+    return result;
+}
+/**
+ * Simplifies a fraction to its lowest terms.
+ * @param fraction - The fraction to simplify
+ * @returns The simplified fraction
+ */
+export function simplifyFraction(fraction) {
+    const divisor = gcd(fraction.numerator, fraction.denominator);
+    return {
+        numerator: fraction.numerator / divisor,
+        denominator: fraction.denominator / divisor
+    };
+}
+/**
+ * Adds two fractions.
+ * @param a - First fraction
+ * @param b - Second fraction
+ * @returns The sum as a simplified fraction
+ */
+export function addFractions(a, b) {
+    const numerator = a.numerator * b.denominator + b.numerator * a.denominator;
+    const denominator = a.denominator * b.denominator;
+    return simplifyFraction({ numerator, denominator });
+}
+/**
+ * Multiplies two fractions.
+ * @param a - First fraction
+ * @param b - Second fraction
+ * @returns The product as a simplified fraction
+ */
+export function multiplyFractions(a, b) {
+    const numerator = a.numerator * b.numerator;
+    const denominator = a.denominator * b.denominator;
+    return simplifyFraction({ numerator, denominator });
+}
+/**
+ * Calculates the percentage of a number.
+ * @param value - The number
+ * @param percentage - The percentage (e.g., 25 for 25%)
+ * @param precision - The number of decimal places
+ * @returns The percentage of the number
+ */
+export const percentage = (value, total, precision = 2) => {
+    if (total === 0)
+        return 0;
+    const percent = (value / total) * 100;
+    return round(percent, precision);
+};
+/**
+ * Converts a number to a specified base (2-36)
+ *
+ * @param number - The number
+ */
+export const toBase = (number, base, minLength = 1) => {
+    if (base < 2 || base > 36) {
+        throw new Error('Base must be between 2 and 36');
+    }
+    const result = number.toString(base);
+    return result.padStart(minLength, '0');
+};
+/**
+ * Converts a number to ordinal string (1st, 2nd, 3rd, etc.)
+ *
+ * @param n - The number
+ */
+export const toOrdinal = (n) => {
+    const suffix = ['th', 'st', 'nd', 'rd'];
+    const v = n % 100;
+    return n + (suffix[(v - 20) % 10] || suffix[v] || suffix[0]);
+};
+/**
+ * Generates a sequence of numbers
+ *
+ * @param start - The starting number
+ * @param end - The ending number
+ * @param step - The step size
+ *
+ * @returns An array of numbers
+ */
+export const range = (start, end, step = 1) => {
+    const result = [];
+    if (step === 0)
+        return result;
+    if (step > 0) {
+        for (let i = start; i < end; i += step) {
+            result.push(i);
+        }
+    }
+    else {
+        for (let i = start; i > end; i += step) {
+            result.push(i);
+        }
+    }
+    return result;
+};
+/**
+ * Limits the number of decimal places without rounding
+ *
+ * @param value - The number
+ * @param decimalPlaces - The number of decimal places
+ *
+ * @returns The truncated number
+ */
+export const truncateDecimals = (value, decimalPlaces) => {
+    if (!Number.isFinite(value))
+        return value;
+    const factor = 10 ** decimalPlaces;
+    return Math.trunc(value * factor) / factor;
+};
+/**
+ * Normalizes a value to a 0-1 range based on min/max
+ *
+ * @param value - The number
+ * @param min - The minimum value
+ * @param max - The maximum value
+ *
+ * @returns The normalized value
+ */
+export const normalize = (value, min, max) => {
+    if (min === max)
+        return 0;
+    return (value - min) / (max - min);
+};
+/**
+ * Wraps a value within a range (like modulo for floats)
+ *
+ * @param value - The number
+ * @param min - The minimum value
+ * @param max - The maximum value
+ *
+ * @returns The wrapped value
+ */
+export const wrap = (value, min, max) => {
+    const range = max - min;
+    return ((((value - min) % range) + range) % range) + min;
+};

package/dist/lib/maths/fn/advanced.mjs

@@ -0,0 +1 @@
+var c=(r,n=0,e="round")=>{if(e==="david")return f(r,n,e);if(!Number.isFinite(r))return r;if(n===0)return Math[e](r);if(n<0){let b=10**-n;return Math[e](r/b)*b}let t=10**n,o=Math.pow(2,-52),u=r*t,m=Math.sign(u)*o*Math.abs(u),i;switch(e){case"round":i=Math.round(u+m);break;case"ceil":i=Math.ceil(u-o);break;case"floor":i=Math.floor(u+o);break;case"trunc":i=u<0?Math.ceil(u):Math.floor(u);break;default:i=Math.round(u+m)}return i/t},f=(r,n=0,e="round")=>{let t=Math.abs(r),o=r<0?-1:1;if(n===0)return Math.round(t)*o;if(!Number.isFinite(t))return t*o;let u=10**n,m=t*u,i=Math.pow(2,-53),b=Math.sign(m)*i*Math.abs(m);return m+=b,Math.round(m)/u*o};function a(r,n){for(r=Math.abs(r),n=Math.abs(n);n!==0;){let e=n;n=r%n,r=e}return r}function l(r){if(r<=0)throw new Error("Natural logarithm is only defined for positive numbers");return Math.log(r)}function g(r){if(r<=0)throw new Error("Logarithm is only defined for positive numbers");return Math.log10(r)}function x(r){if(r<=0)throw new Error("Logarithm is only defined for positive numbers");return Math.log2(r)}function M(r,n){if(r<=0||n<=0)throw new Error("Logarithm is only defined for positive numbers and bases");return Math.log(r)/Math.log(n)}function w(r){return Math.exp(r)}function y(r){return Math.cbrt(r)}function F(r,n){if(n===0)throw new Error("Cannot calculate 0th root");if(r<0&&n%2===0)throw new Error("Cannot calculate even root of negative number");let e=1/n;return Math.sign(r)*Math.pow(Math.abs(r),e)}function N(r,n,e){if(r===0)return n===0?[]:[-e/n];let t=n*n-4*r*e;if(t<0)return[];if(t===0)return[-n/(2*r)];{let o=Math.sqrt(t);return[(-n-o)/(2*r),(-n+o)/(2*r)]}}function E(r,n){let e=0;for(let t=0;t<r.length;t++)e=e*n+r[t];return e}function s(r){let n=a(r.numerator,r.denominator);return{numerator:r.numerator/n,denominator:r.denominator/n}}function T(r,n){let e=r.numerator*n.denominator+n.numerator*r.denominator,t=r.denominator*n.denominator;return s({numerator:e,denominator:t})}function S(r,n){let e=r.numerator*n.numerator,t=r.denominator*n.denominator;return s({numerator:e,denominator:t})}var A=(r,n,e=2)=>{if(n===0)return 0;let t=r/n*100;return c(t,e)},q=(r,n,e=1)=>{if(n<2||n>36)throw new Error("Base must be between 2 and 36");return r.toString(n).padStart(e,"0")},R=r=>{let n=["th","st","nd","rd"],e=r%100;return r+(n[(e-20)%10]||n[e]||n[0])},L=(r,n,e=1)=>{let t=[];if(e===0)return t;if(e>0)for(let o=r;o<n;o+=e)t.push(o);else for(let o=r;o>n;o+=e)t.push(o);return t},j=(r,n)=>{if(!Number.isFinite(r))return r;let e=10**n;return Math.trunc(r*e)/e},k=(r,n,e)=>n===e?0:(r-n)/(e-n),C=(r,n,e)=>{let t=e-n;return((r-n)%t+t)%t+n};export{T as addFractions,y as cbrt,E as evaluatePolynomial,w as exp,l as ln,M as log,g as log10,x as log2,S as multiplyFractions,k as normalize,F as nthRoot,A as percentage,L as range,s as simplifyFraction,N as solveQuadratic,q as toBase,R as toOrdinal,j as truncateDecimals,C as wrap};

package/dist/lib/maths/fn/basic.cjs

@@ -0,0 +1 @@
+"use strict";var a=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var M=Object.prototype.hasOwnProperty;var g=(r,n)=>{for(var e in n)a(r,e,{get:n[e],enumerable:!0})},x=(r,n,e,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let u of l(n))!M.call(r,u)&&u!==e&&a(r,u,{get:()=>n[u],enumerable:!(t=p(n,u))||t.enumerable});return r};var w=r=>x(a({},"__esModule",{value:!0}),r);var K={};g(K,{abs:()=>R,add:()=>y,average:()=>z,ceil:()=>q,clamp:()=>s,divide:()=>T,factorial:()=>D,floor:()=>j,gcd:()=>f,invLerp:()=>h,lcm:()=>G,lerp:()=>d,mapRange:()=>I,max:()=>U,median:()=>H,min:()=>L,modulo:()=>A,power:()=>F,product:()=>J,round:()=>c,sign:()=>C,sqrt:()=>S,subtract:()=>N,sum:()=>B,trunc:()=>E});module.exports=w(K);function y(r,n){return r+n}function N(r,n){return r-n}var T=(r,n,e)=>n===0?e!==void 0?e:NaN:r/n;function A(r,n){return r%n}function F(r,n){return Math.pow(r,n)}function S(r){if(r<0)throw new Error("Cannot calculate square root of negative number");return Math.sqrt(r)}function R(r){return Math.abs(r)}var c=(r,n=0,e="round")=>{if(e==="david")return k(r,n,e);if(!Number.isFinite(r))return r;if(n===0)return Math[e](r);if(n<0){let m=10**-n;return Math[e](r/m)*m}let t=10**n,u=Math.pow(2,-52),o=r*t,i=Math.sign(o)*u*Math.abs(o),b;switch(e){case"round":b=Math.round(o+i);break;case"ceil":b=Math.ceil(o-u);break;case"floor":b=Math.floor(o+u);break;case"trunc":b=o<0?Math.ceil(o):Math.floor(o);break;default:b=Math.round(o+i)}return b/t},k=(r,n=0,e="round")=>{let t=Math.abs(r),u=r<0?-1:1;if(n===0)return Math.round(t)*u;if(!Number.isFinite(t))return t*u;let o=10**n,i=t*o,b=Math.pow(2,-53),m=Math.sign(i)*b*Math.abs(i);return i+=m,Math.round(i)/o*u},q=(r,n=0)=>c(r,n,"ceil"),j=(r,n=0)=>c(r,n,"floor"),E=(r,n=0)=>c(r,n,"trunc"),s=(r,n,e)=>(n>e&&([n,e]=[e,n]),r<n?n:r>e?e:r);function C(r){return r>0?1:r<0?-1:0}function D(r){if(!Number.isInteger(r)||r<0)throw new Error("Factorial is only defined for non-negative integers");if(r===0||r===1)return 1;let n=1;for(let e=2;e<=r;e++)n*=e;return n}function f(r,n){for(r=Math.abs(r),n=Math.abs(n);n!==0;){let e=n;n=r%n,r=e}return r}function G(r,n){return Math.abs(r*n)/f(r,n)}function d(r,n,e){return r+(n-r)*s(e,0,1)}var h=(r,n,e)=>s((e-r)/(n-r),0,1),I=(r,n,e,t,u)=>{let o=h(n,e,r);return d(t,u,o)};function L(...r){return Math.min(...r)}function U(...r){return Math.max(...r)}var z=(...r)=>{if(!Array.isArray(r)||r.length===0)return 0;let n=0,e=0;for(let t of r)Number.isFinite(t)&&(n+=t,e++);return e===0?0:n/e},B=(...r)=>Array.isArray(r)?r.reduce((n,e)=>n+(Number.isFinite(e)?e:0),0):0,H=(...r)=>{if(!Array.isArray(r)||r.length===0)return 0;let n=r.filter(Number.isFinite);if(n.length===0)return 0;n.sort((t,u)=>t-u);let e=Math.floor(n.length/2);return n.length%2===0?(n[e-1]+n[e])/2:n[e]};function J(...r){return r.reduce((n,e)=>n*e,1)}

package/dist/lib/maths/fn/basic.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Basic mathematical operations.
+ * @module BasicMathFunctions
+ */
+import type { RoundingMode, Sign } from '../types/basic.js';
+/**
+ * Adds two numbers.
+ * @param a - First operand
+ * @param b - Second operand
+ * @returns The sum of a and b
+ */
+export declare function add(a: number, b: number): number;
+/**
+ * Subtracts two numbers.
+ * @param a - First operand
+ * @param b - Second operand
+ * @returns The difference of a and b (a - b)
+ */
+export declare function subtract(a: number, b: number): number;
+/**
+ * Divides two numbers.
+ * @param a - Dividend
+ * @param b - Divisor
+ * @returns The quotient of a divided by b
+ * @throws {Error} If b is 0
+ */
+export declare const divide: <T = number>(dividend: number, divisor: number, fallback?: T) => number | T;
+/**
+ * Calculates the modulo/remainder.
+ * @param a - Dividend
+ * @param b - Divisor
+ * @returns The remainder of a divided by b
+ */
+export declare function modulo(a: number, b: number): number;
+/**
+ * Calculates the power of a number.
+ * @param base - The base number
+ * @param exponent - The exponent
+ * @returns base raised to the power of exponent
+ */
+export declare function power(base: number, exponent: number): number;
+/**
+ * Calculates the square root of a number.
+ * @param value - The number
+ * @returns The square root of the number
+ * @throws {Error} If value is negative
+ */
+export declare function sqrt(value: number): number;
+/**
+ * Calculates the absolute value of a number.
+ * @param value - The number
+ * @returns The absolute value
+ */
+export declare function abs(value: number): number;
+/**
+ * Robust rounding using David Gay's dtoa algorithm approach
+ * @param value - The value to round
+ * @param precision - Decimal precision (default: 0)
+ * @returns Rounded number
+ * @example
+ * round(1.005, 2) // 1.01
+ * round(123.456, -1) // 120
+ */
+export declare const round: (value: number, precision?: number, mode?: RoundingMode) => number;
+/**
+ * Rounds a number up to the nearest integer.
+ * @param value - The number to round up
+ * @returns The ceiling integer
+ */
+export declare const ceil: (value: number, precision?: number) => number;
+/**
+ * Rounds a number down to the nearest integer.
+ * @param value - The number to round down
+ * @returns The floored integer
+ */
+export declare const floor: (value: number, precision?: number) => number;
+/**
+ * Truncates the decimal part of a number.
+ * @param value - The number to truncate
+ * @returns The truncated integer
+ */
+export declare const trunc: (value: number, precision?: number) => number;
+/**
+ * Clamps a value between a minimum and maximum.
+ * @param value - The value to clamp
+ * @param min - The minimum allowed value
+ * @param max - The maximum allowed value
+ * @returns The clamped value
+ */
+export declare const clamp: (value: number, min: number, max: number) => number;
+/**
+ * Returns the sign of a number: -1, 0, or 1.
+ * @param value - The number
+ * @returns The sign of the number
+ */
+export declare function sign<T extends number>(value: T): Sign<T>;
+/**
+ * Calculates the factorial of a non-negative integer.
+ * @param n - The integer
+ * @returns The factorial of n
+ * @throws {Error} If n is negative or not an integer
+ */
+export declare function factorial(n: number): number;
+/**
+ * Calculates the greatest common divisor (GCD) of two numbers.
+ * @param a - First number
+ * @param b - Second number
+ * @returns The GCD of a and b
+ */
+export declare function gcd(a: number, b: number): number;
+/**
+ * Calculates the least common multiple (LCM) of two numbers.
+ * @param a - First number
+ * @param b - Second number
+ * @returns The LCM of a and b
+ */
+export declare function lcm(a: number, b: number): number;
+/**
+ * Linearly interpolates between two values.
+ * @param start - The starting value
+ * @param end - The ending value
+ * @param t - The interpolation factor (0 to 1)
+ * @returns The interpolated value
+ */
+export declare function lerp(start: number, end: number, t: number): number;
+/**
+ * Inverse linear interpolation.
+ * @param start - The starting value
+ * @param end - The ending value
+ * @param value - The value to interpolate
+ * @returns The interpolation factor (0 to 1)
+ */
+export declare const invLerp: (start: number, end: number, value: number) => number;
+/**
+ * Maps a value from one range to another
+ * @param value - The value to map
+ * @param inMin - The minimum value of the input range
+ * @param inMax - The maximum value of the input range
+ * @param outMin - The minimum value of the output range
+ * @param outMax - The maximum value of the output range
+ * @returns The mapped value
+ * Optimized: Uses lerp and invLerp
+ */
+export declare const mapRange: (value: number, inMin: number, inMax: number, outMin: number, outMax: number) => number;
+/**
+ * Returns the minimum of two or more numbers.
+ * @param values - Numbers to compare
+ * @returns The smallest number
+ */
+export declare function min(...values: number[]): number;
+/**
+ * Returns the maximum of two or more numbers.
+ * @param values - Numbers to compare
+ * @returns The largest number
+ */
+export declare function max(...values: number[]): number;
+/**
+ * Calculates the average of numbers.
+ * @param values - Numbers to average
+ * @returns The average
+ */
+export declare const average: (...numbers: number[]) => number;
+/**
+ * Calculates the sum of numbers.
+ * @param values - Numbers to sum
+ * @returns The sum
+ */
+export declare const sum: (...numbers: number[]) => number;
+/**
+ * Calculates the median of an array of numbers
+ * @param numbers - Array of numbers
+ * @returns The median
+ * Optimized: Sorts only when necessary
+ */
+export declare const median: (...numbers: number[]) => number;
+/**
+ * Calculates the product of numbers.
+ * @param values - Numbers to multiply
+ * @returns The product
+ */
+export declare function product(...values: number[]): number;
+//# sourceMappingURL=basic.d.ts.map

package/dist/lib/maths/fn/basic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic.d.ts","sourceRoot":"","sources":["../../../../src/lib/maths/fn/basic.ts"],"names":[],"mappings":"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"}