@fluixi/utils 1.0.0-alpha.53

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

@@ -0,0 +1,343 @@
+/**
+ * Basic mathematical operations.
+ * @module BasicMathFunctions
+ */
+/**
+ * Adds two numbers.
+ * @param a - First operand
+ * @param b - Second operand
+ * @returns The sum of a and b
+ */
+export function add(a, b) {
+    return a + b;
+}
+/**
+ * Subtracts two numbers.
+ * @param a - First operand
+ * @param b - Second operand
+ * @returns The difference of a and b (a - b)
+ */
+export function subtract(a, b) {
+    return a - b;
+}
+/**
+ * Divides two numbers.
+ * @param a - Dividend
+ * @param b - Divisor
+ * @returns The quotient of a divided by b
+ * @throws {Error} If b is 0
+ */
+export const divide = (dividend, divisor, fallback) => {
+    if (divisor === 0) {
+        return fallback !== undefined ? fallback : NaN;
+    }
+    return dividend / divisor;
+};
+/**
+ * Calculates the modulo/remainder.
+ * @param a - Dividend
+ * @param b - Divisor
+ * @returns The remainder of a divided by b
+ */
+export function modulo(a, b) {
+    return a % b;
+}
+/**
+ * Calculates the power of a number.
+ * @param base - The base number
+ * @param exponent - The exponent
+ * @returns base raised to the power of exponent
+ */
+export function power(base, exponent) {
+    return Math.pow(base, exponent);
+}
+/**
+ * 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 function sqrt(value) {
+    if (value < 0) {
+        throw new Error('Cannot calculate square root of negative number');
+    }
+    return Math.sqrt(value);
+}
+/**
+ * Calculates the absolute value of a number.
+ * @param value - The number
+ * @returns The absolute value
+ */
+export function abs(value) {
+    return Math.abs(value);
+}
+/**
+ * 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 const round = (value, precision = 0, mode = 'round') => {
+    if (mode === 'david')
+        return roundUsingDavidGay(value, precision, mode);
+    if (!Number.isFinite(value))
+        return value;
+    if (precision === 0)
+        return Math[mode](value);
+    // Handle negative precision (rounding to tens, hundreds, etc.)
+    if (precision < 0) {
+        const factor = 10 ** -precision;
+        return Math[mode](value / factor) * factor;
+    }
+    // For positive precision, use a robust method
+    const factor = 10 ** precision;
+    // Add epsilon correction to handle floating point errors
+    const epsilon = Math.pow(2, -52); // Machine epsilon
+    const adjusted = value * factor;
+    const correction = Math.sign(adjusted) * epsilon * Math.abs(adjusted);
+    let rounded;
+    switch (mode) {
+        case 'round':
+            rounded = Math.round(adjusted + correction);
+            break;
+        case 'ceil':
+            rounded = Math.ceil(adjusted - epsilon);
+            break;
+        case 'floor':
+            rounded = Math.floor(adjusted + epsilon);
+            break;
+        case 'trunc':
+            rounded = adjusted < 0 ? Math.ceil(adjusted) : Math.floor(adjusted);
+            break;
+        default:
+            rounded = Math.round(adjusted + correction);
+    }
+    return rounded / factor;
+};
+const roundUsingDavidGay = (_value, precision = 0, mode = 'round') => {
+    let value = Math.abs(_value);
+    const multiplicator = _value < 0 ? -1 : 1;
+    if (precision === 0) {
+        return Math.round(value) * multiplicator;
+    }
+    if (!Number.isFinite(value)) {
+        return value * multiplicator;
+    }
+    // Use the banker's rounding variant which is more accurate
+    const factor = 10 ** precision;
+    // This method handles the 1.005 case correctly
+    // First, shift the decimal point to the right
+    let shifted = value * factor;
+    // Apply a small epsilon to handle floating point errors
+    // The epsilon is scaled by the magnitude of the number
+    const epsilon = Math.pow(2, -53); // Machine epsilon for double precision
+    const correction = Math.sign(shifted) * epsilon * Math.abs(shifted);
+    // Round with correction
+    shifted += correction;
+    // Use Math.round (or could use banker's rounding: Math.round((shifted + Number.EPSILON) * factor) / factor)
+    const rounded = Math.round(shifted);
+    // Shift the decimal point back
+    return (rounded / factor) * multiplicator;
+};
+/**
+ * Rounds a number up to the nearest integer.
+ * @param value - The number to round up
+ * @returns The ceiling integer
+ */
+export const ceil = (value, precision = 0) => {
+    return round(value, precision, 'ceil');
+};
+/**
+ * Rounds a number down to the nearest integer.
+ * @param value - The number to round down
+ * @returns The floored integer
+ */
+export const floor = (value, precision = 0) => {
+    return round(value, precision, 'floor');
+};
+/**
+ * Truncates the decimal part of a number.
+ * @param value - The number to truncate
+ * @returns The truncated integer
+ */
+export const trunc = (value, precision = 0) => {
+    return round(value, precision, 'trunc');
+};
+/**
+ * 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 const clamp = (value, min, max) => {
+    if (min > max)
+        [min, max] = [max, min]; // Swap if min > max
+    return value < min ? min : value > max ? max : value;
+};
+// export function clamp(value: number, min: number, max: number): number {
+//   return Math.max(min, Math.min(max, value));
+// }
+/**
+ * Returns the sign of a number: -1, 0, or 1.
+ * @param value - The number
+ * @returns The sign of the number
+ */
+export function sign(value) {
+    if (value > 0)
+        return 1;
+    if (value < 0)
+        return -1;
+    return 0;
+}
+/**
+ * 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 function factorial(n) {
+    if (!Number.isInteger(n) || n < 0) {
+        throw new Error('Factorial is only defined for non-negative integers');
+    }
+    if (n === 0 || n === 1)
+        return 1;
+    let result = 1;
+    for (let i = 2; i <= n; i++) {
+        result *= i;
+    }
+    return result;
+}
+/**
+ * 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 function gcd(a, b) {
+    a = Math.abs(a);
+    b = Math.abs(b);
+    while (b !== 0) {
+        const temp = b;
+        b = a % b;
+        a = temp;
+    }
+    return a;
+}
+/**
+ * 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 function lcm(a, b) {
+    return Math.abs(a * b) / gcd(a, b);
+}
+/**
+ * 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 function lerp(start, end, t) {
+    return start + (end - start) * clamp(t, 0, 1);
+}
+/**
+ * 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 const invLerp = (start, end, value) => {
+    // return (value - start) / (end - start);
+    return clamp((value - start) / (end - start), 0, 1);
+};
+/**
+ * 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 const mapRange = (value, inMin, inMax, outMin, outMax) => {
+    const t = invLerp(inMin, inMax, value);
+    return lerp(outMin, outMax, t);
+};
+/**
+ * Returns the minimum of two or more numbers.
+ * @param values - Numbers to compare
+ * @returns The smallest number
+ */
+export function min(...values) {
+    return Math.min(...values);
+}
+/**
+ * Returns the maximum of two or more numbers.
+ * @param values - Numbers to compare
+ * @returns The largest number
+ */
+export function max(...values) {
+    return Math.max(...values);
+}
+/**
+ * Calculates the average of numbers.
+ * @param values - Numbers to average
+ * @returns The average
+ */
+export const average = (...numbers) => {
+    if (!Array.isArray(numbers) || numbers.length === 0)
+        return 0;
+    let total = 0;
+    let count = 0;
+    for (const num of numbers) {
+        if (Number.isFinite(num)) {
+            total += num;
+            count++;
+        }
+    }
+    return count === 0 ? 0 : total / count;
+};
+/**
+ * Calculates the sum of numbers.
+ * @param values - Numbers to sum
+ * @returns The sum
+ */
+export const sum = (...numbers) => {
+    if (!Array.isArray(numbers))
+        return 0;
+    return numbers.reduce((acc, val) => acc + (Number.isFinite(val) ? val : 0), 0);
+};
+/**
+ * Calculates the median of an array of numbers
+ * @param numbers - Array of numbers
+ * @returns The median
+ * Optimized: Sorts only when necessary
+ */
+export const median = (...numbers) => {
+    if (!Array.isArray(numbers) || numbers.length === 0)
+        return 0;
+    const validNumbers = numbers.filter(Number.isFinite);
+    if (validNumbers.length === 0)
+        return 0;
+    validNumbers.sort((a, b) => a - b);
+    const mid = Math.floor(validNumbers.length / 2);
+    return validNumbers.length % 2 === 0
+        ? (validNumbers[mid - 1] + validNumbers[mid]) / 2
+        : validNumbers[mid];
+};
+/**
+ * Calculates the product of numbers.
+ * @param values - Numbers to multiply
+ * @returns The product
+ */
+export function product(...values) {
+    return values.reduce((prod, val) => prod * val, 1);
+}

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

@@ -0,0 +1 @@
+function l(r,n){return r+n}function M(r,n){return r-n}var g=(r,n,e)=>n===0?e!==void 0?e:NaN:r/n;function x(r,n){return r%n}function w(r,n){return Math.pow(r,n)}function y(r){if(r<0)throw new Error("Cannot calculate square root of negative number");return Math.sqrt(r)}function N(r){return Math.abs(r)}var c=(r,n=0,e="round")=>{if(e==="david")return s(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,o=Math.pow(2,-52),u=r*t,i=Math.sign(u)*o*Math.abs(u),b;switch(e){case"round":b=Math.round(u+i);break;case"ceil":b=Math.ceil(u-o);break;case"floor":b=Math.floor(u+o);break;case"trunc":b=u<0?Math.ceil(u):Math.floor(u);break;default:b=Math.round(u+i)}return b/t},s=(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,i=t*u,b=Math.pow(2,-53),m=Math.sign(i)*b*Math.abs(i);return i+=m,Math.round(i)/u*o},T=(r,n=0)=>c(r,n,"ceil"),A=(r,n=0)=>c(r,n,"floor"),F=(r,n=0)=>c(r,n,"trunc"),a=(r,n,e)=>(n>e&&([n,e]=[e,n]),r<n?n:r>e?e:r);function S(r){return r>0?1:r<0?-1:0}function R(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 k(r,n){return Math.abs(r*n)/f(r,n)}function d(r,n,e){return r+(n-r)*a(e,0,1)}var h=(r,n,e)=>a((e-r)/(n-r),0,1),q=(r,n,e,t,o)=>{let u=h(n,e,r);return d(t,o,u)};function j(...r){return Math.min(...r)}function E(...r){return Math.max(...r)}var C=(...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},D=(...r)=>Array.isArray(r)?r.reduce((n,e)=>n+(Number.isFinite(e)?e:0),0):0,G=(...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,o)=>t-o);let e=Math.floor(n.length/2);return n.length%2===0?(n[e-1]+n[e])/2:n[e]};function I(...r){return r.reduce((n,e)=>n*e,1)}export{N as abs,l as add,C as average,T as ceil,a as clamp,g as divide,R as factorial,A as floor,f as gcd,h as invLerp,k as lcm,d as lerp,q as mapRange,E as max,G as median,j as min,x as modulo,w as power,I as product,c as round,S as sign,y as sqrt,M as subtract,D as sum,F as trunc};

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

@@ -0,0 +1 @@
+"use strict";var s=Object.defineProperty;var c=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var w=Object.prototype.hasOwnProperty;var E=(e,r)=>{for(var o in r)s(e,o,{get:r[o],enumerable:!0})},P=(e,r,o,a)=>{if(r&&typeof r=="object"||typeof r=="function")for(let l of d(r))!w.call(e,l)&&l!==o&&s(e,l,{get:()=>r[l],enumerable:!(a=c(r,l))||a.enumerable});return e};var I=e=>P(s({},"__esModule",{value:!0}),e);var W={};E(W,{addComplex:()=>S,argumentComplex:()=>b,complexEquals:()=>z,conjugateComplex:()=>O,cosComplex:()=>A,createComplex:()=>i,divideComplex:()=>v,expComplex:()=>$,fromPolarComplex:()=>x,getImag:()=>k,getReal:()=>Z,isZeroComplex:()=>R,lnComplex:()=>L,magnitudeComplex:()=>g,multiplyComplex:()=>h,negateComplex:()=>D,powerComplex:()=>F,reciprocalComplex:()=>T,sinComplex:()=>j,sqrtComplex:()=>q,subtractComplex:()=>y,toPolarComplex:()=>M});module.exports=I(W);var N=2*Math.PI;function n(e){return Math.abs(e)<1e-10}function p(e,r){return Math.abs(e-r)<1e-10}function t(e){return{real:n(e.real)?0:e.real,imag:n(e.imag)?0:e.imag}}function u(e,r){if(typeof e!="number"||!Number.isFinite(e))throw new Error(`${r} must be a finite number, got ${e}`)}function m(e,r="Complex number"){if(!e||typeof e!="object")throw new Error(`${r} must be an object`);u(e.real,`${r}.real`),u(e.imag,`${r}.imag`)}function i(e,r=0){return u(e,"real"),u(r,"imag"),t({real:e,imag:r})}function z(e,r){return m(e,"First complex number"),m(r,"Second complex number"),p(e.real,r.real)&&p(e.imag,r.imag)}function S(e,r){return m(e,"First complex number"),m(r,"Second complex number"),t({real:e.real+r.real,imag:e.imag+r.imag})}function y(e,r){return m(e,"First complex number"),m(r,"Second complex number"),t({real:e.real-r.real,imag:e.imag-r.imag})}function h(e,r){return m(e,"First complex number"),m(r,"Second complex number"),t({real:e.real*r.real-e.imag*r.imag,imag:e.real*r.imag+e.imag*r.real})}function v(e,r){m(e,"Numerator complex number"),m(r,"Denominator complex number");let o=r.real*r.real+r.imag*r.imag;if(n(o))throw new Error("Cannot divide by zero or near-zero complex number");return t({real:(e.real*r.real+e.imag*r.imag)/o,imag:(e.imag*r.real-e.real*r.imag)/o})}function g(e){m(e);let r=Math.sqrt(e.real*e.real+e.imag*e.imag);return n(r)?0:r}function O(e){return m(e),t({real:e.real,imag:-e.imag})}function b(e){return m(e),n(e.real)&&n(e.imag)?0:Math.atan2(e.imag,e.real)}function M(e){return m(e),{magnitude:g(e),angle:b(e)}}function x(e,r){if(u(e,"magnitude"),u(r,"angle"),e<-1e-10)throw new Error("Magnitude must be non-negative");let o=r%N;o>Math.PI&&(o-=N),o<=-Math.PI&&(o+=N);let a=Math.max(0,e);return t({real:a*Math.cos(o),imag:a*Math.sin(o)})}function q(e){if(m(e),n(e.real)&&n(e.imag)){let f=i(0,0);return[f,f]}let r=g(e),o=b(e),a=Math.sqrt(r),l=o/2,C=l+Math.PI;return[x(a,l),x(a,C)]}function F(e,r){if(m(e),u(r,"exponent"),n(r))return i(1,0);if(p(r,1))return i(e.real,e.imag);if(p(r,2))return h(e,e);if(n(e.real)&&n(e.imag)){if(r>0)return i(0,0);if(r<0)throw new Error("Cannot raise zero to a negative power")}let o=M(e),a=Math.pow(o.magnitude,r),l=a<-1e-10?Math.abs(a):Math.max(0,a),C=o.angle*r;return x(l,C)}function L(e){m(e);let r=g(e);if(n(r))throw new Error("Cannot take logarithm of zero or near-zero complex number");let o=b(e);return t({real:Math.log(r),imag:o})}function $(e){m(e);let r=Math.exp(e.real);return t({real:r*Math.cos(e.imag),imag:r*Math.sin(e.imag)})}function j(e){return m(e),t({real:Math.sin(e.real)*Math.cosh(e.imag),imag:Math.cos(e.real)*Math.sinh(e.imag)})}function A(e){return m(e),t({real:Math.cos(e.real)*Math.cosh(e.imag),imag:-Math.sin(e.real)*Math.sinh(e.imag)})}function R(e){return m(e),n(e.real)&&n(e.imag)}function Z(e){return m(e),e.real}function k(e){return m(e),e.imag}function D(e){return m(e),t({real:-e.real,imag:-e.imag})}function T(e){m(e);let r=e.real*e.real+e.imag*e.imag;if(n(r))throw new Error("Cannot calculate reciprocal of zero or near-zero complex number");return t({real:e.real/r,imag:-e.imag/r})}

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

@@ -0,0 +1,153 @@
+/**
+ * Complex number operations.
+ * @module ComplexFunctions
+ */
+import type { ComplexNumber } from '../types/advanced.js';
+/**
+ * Creates a complex number with validation and normalization.
+ * @param real - Real part
+ * @param imag - Imaginary part
+ * @returns Validated and normalized complex number
+ */
+export declare function createComplex(real: number, imag?: number): ComplexNumber;
+/**
+ * Checks if two complex numbers are approximately equal.
+ * @param a - First complex number
+ * @param b - Second complex number
+ * @returns True if numbers are approximately equal
+ */
+export declare function complexEquals(a: ComplexNumber, b: ComplexNumber): boolean;
+/**
+ * Adds two complex numbers.
+ * @param a - First complex number
+ * @param b - Second complex number
+ * @returns The sum as a complex number
+ */
+export declare function addComplex(a: ComplexNumber, b: ComplexNumber): ComplexNumber;
+/**
+ * Subtracts two complex numbers.
+ * @param a - First complex number
+ * @param b - Second complex number
+ * @returns The difference as a complex number (a - b)
+ */
+export declare function subtractComplex(a: ComplexNumber, b: ComplexNumber): ComplexNumber;
+/**
+ * Multiplies two complex numbers.
+ * @param a - First complex number
+ * @param b - Second complex number
+ * @returns The product as a complex number
+ */
+export declare function multiplyComplex(a: ComplexNumber, b: ComplexNumber): ComplexNumber;
+/**
+ * Divides two complex numbers.
+ * @param a - Numerator complex number
+ * @param b - Denominator complex number
+ * @returns The quotient as a complex number
+ * @throws {Error} If dividing by zero or near-zero complex number
+ */
+export declare function divideComplex(a: ComplexNumber, b: ComplexNumber): ComplexNumber;
+/**
+ * Calculates the magnitude (absolute value) of a complex number.
+ * @param c - The complex number
+ * @returns The magnitude (non-negative)
+ */
+export declare function magnitudeComplex(c: ComplexNumber): number;
+/**
+ * Calculates the conjugate of a complex number.
+ * @param c - The complex number
+ * @returns The complex conjugate
+ */
+export declare function conjugateComplex(c: ComplexNumber): ComplexNumber;
+/**
+ * Calculates the argument (angle) of a complex number in radians.
+ * @param c - The complex number
+ * @returns The principal argument in radians (-π, π]
+ */
+export declare function argumentComplex(c: ComplexNumber): number;
+/**
+ * Converts a complex number to polar form.
+ * @param c - The complex number
+ * @returns Polar representation {magnitude, angle}
+ */
+export declare function toPolarComplex(c: ComplexNumber): {
+    magnitude: number;
+    angle: number;
+};
+/**
+ * Converts polar form to a complex number.
+ * @param magnitude - The magnitude (must be non-negative)
+ * @param angle - The angle in radians
+ * @returns The complex number
+ * @throws {Error} If magnitude is negative
+ */
+export declare function fromPolarComplex(magnitude: number, angle: number): ComplexNumber;
+/**
+ * Calculates the square root of a complex number.
+ * @param c - The complex number
+ * @returns Array of two complex square roots (principal and secondary)
+ */
+export declare function sqrtComplex(c: ComplexNumber): [ComplexNumber, ComplexNumber];
+/**
+ * Calculates the power of a complex number with a real exponent.
+ * @param c - The complex number
+ * @param exponent - The exponent (real number)
+ * @returns The complex number raised to the power
+ */
+export declare function powerComplex(c: ComplexNumber, exponent: number): ComplexNumber;
+/**
+ * Calculates the natural logarithm of a complex number.
+ * @param c - The complex number
+ * @returns The principal value of natural logarithm as a complex number
+ * @throws {Error} If the complex number is zero or near-zero
+ */
+export declare function lnComplex(c: ComplexNumber): ComplexNumber;
+/**
+ * Calculates the exponential of a complex number.
+ * @param c - The complex number
+ * @returns The exponential as a complex number
+ */
+export declare function expComplex(c: ComplexNumber): ComplexNumber;
+/**
+ * Calculates the sine of a complex number.
+ * @param c - The complex number
+ * @returns The sine as a complex number
+ */
+export declare function sinComplex(c: ComplexNumber): ComplexNumber;
+/**
+ * Calculates the cosine of a complex number.
+ * @param c - The complex number
+ * @returns The cosine as a complex number
+ */
+export declare function cosComplex(c: ComplexNumber): ComplexNumber;
+/**
+ * Checks if a complex number is zero (or effectively zero).
+ * @param c - The complex number to check
+ * @returns True if the complex number is effectively zero
+ */
+export declare function isZeroComplex(c: ComplexNumber): boolean;
+/**
+ * Returns the real part of a complex number.
+ * @param c - The complex number
+ * @returns The real part
+ */
+export declare function getReal(c: ComplexNumber): number;
+/**
+ * Returns the imaginary part of a complex number.
+ * @param c - The complex number
+ * @returns The imaginary part
+ */
+export declare function getImag(c: ComplexNumber): number;
+/**
+ * Negates a complex number.
+ * @param c - The complex number
+ * @returns The negated complex number
+ */
+export declare function negateComplex(c: ComplexNumber): ComplexNumber;
+/**
+ * Calculates the reciprocal of a complex number.
+ * @param c - The complex number
+ * @returns The reciprocal (1/c)
+ * @throws {Error} If the complex number is zero or near-zero
+ */
+export declare function reciprocalComplex(c: ComplexNumber): ComplexNumber;
+//# sourceMappingURL=complex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complex.d.ts","sourceRoot":"","sources":["../../../../src/lib/maths/fn/complex.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAmE1D;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,MAAU,GAAG,aAAa,CAI3E;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,OAAO,CAOzE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa,CAQ5E;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,GACf,aAAa,CAQf;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,GACf,aAAa,CAQf;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,GACf,aAAa,CAcf;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAKzD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAOhE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAQxD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,aAAa,GAAG;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAOA;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,aAAa,CAmBf;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,aAAa,GAAG,CAAC,aAAa,EAAE,aAAa,CAAC,CAmB5E;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,aAAa,EAChB,QAAQ,EAAE,MAAM,GACf,aAAa,CAoCf;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAgBzD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAS1D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAQ1D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAQ1D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,aAAa,GAAG,OAAO,CAGvD;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAGhD;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAGhD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAM7D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAcjE"}