@danielsimonjr/mathts-functions 0.64.2 → 0.64.3

package/dist/typed/arithmetic.d.ts

@@ -28,161 +28,161 @@ type i32 = number;
  * await add(float64A, float64B);               // Parallel array add
  * ```
  */
-export declare const add: import("typed-function").TypedFunction;
+export declare const add: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Polymorphic subtraction function with parallel execution for arrays
  */
-export declare const subtract: import("typed-function").TypedFunction;
+export declare const subtract: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Polymorphic multiplication function with parallel execution for arrays
  */
-export declare const multiply: import("typed-function").TypedFunction;
+export declare const multiply: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Polymorphic division function with parallel execution for arrays
  */
-export declare const divide: import("typed-function").TypedFunction;
+export declare const divide: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Unary negation with parallel array support
  */
-export declare const unaryMinus: import("typed-function").TypedFunction;
+export declare const unaryMinus: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Unary plus (identity)
  */
-export declare const unaryPlus: import("typed-function").TypedFunction;
+export declare const unaryPlus: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Absolute value with parallel array support
  */
-export declare const abs: import("typed-function").TypedFunction;
+export declare const abs: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Sign function
  */
-export declare const sign: import("typed-function").TypedFunction;
+export declare const sign: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Power function
  */
-export declare const pow: import("typed-function").TypedFunction;
+export declare const pow: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Square root with parallel array support
  */
-export declare const sqrt: import("typed-function").TypedFunction;
+export declare const sqrt: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Square with parallel array support
  */
-export declare const square: import("typed-function").TypedFunction;
+export declare const square: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Cube
  */
-export declare const cube: import("typed-function").TypedFunction;
+export declare const cube: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Cube root
  */
-export declare const cbrt: import("typed-function").TypedFunction;
+export declare const cbrt: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * N-th root
  */
-export declare const nthRoot: import("typed-function").TypedFunction;
+export declare const nthRoot: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Exponential function (e^x) with parallel array support
  */
-export declare const exp: import("typed-function").TypedFunction;
+export declare const exp: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Natural logarithm (ln x) with parallel array support
  */
-export declare const log: import("typed-function").TypedFunction;
+export declare const log: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Base-10 logarithm
  */
-export declare const log10: import("typed-function").TypedFunction;
+export declare const log10: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Base-2 logarithm
  */
-export declare const log2: import("typed-function").TypedFunction;
+export declare const log2: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * log(1 + x) with higher precision for small x
  */
-export declare const log1p: import("typed-function").TypedFunction;
+export declare const log1p: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * exp(x) - 1 with higher precision for small x
  */
-export declare const expm1: import("typed-function").TypedFunction;
+export declare const expm1: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Round to nearest integer
  */
-export declare const round: import("typed-function").TypedFunction;
+export declare const round: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Floor (round down)
  */
-export declare const floor: import("typed-function").TypedFunction;
+export declare const floor: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Ceiling (round up)
  */
-export declare const ceil: import("typed-function").TypedFunction;
+export declare const ceil: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Truncate (round toward zero)
  */
-export declare const fix: import("typed-function").TypedFunction;
+export declare const fix: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Modulo operation
  */
-export declare const mod: import("typed-function").TypedFunction;
+export declare const mod: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Greatest common divisor
  */
-export declare const gcd: import("typed-function").TypedFunction;
+export declare const gcd: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Least common multiple
  */
-export declare const lcm: import("typed-function").TypedFunction;
+export declare const lcm: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Extended greatest common divisor
  * Returns [gcd, x, y] where gcd = a*x + b*y (Bezout coefficients)
  */
-export declare const xgcd: import("typed-function").TypedFunction;
-export declare const norm: import("typed-function").TypedFunction;
+export declare const xgcd: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const norm: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Hyperbolic sine
  */
-export declare const sinh: import("typed-function").TypedFunction;
+export declare const sinh: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Hyperbolic cosine
  */
-export declare const cosh: import("typed-function").TypedFunction;
+export declare const cosh: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Hyperbolic tangent
  */
-export declare const tanh: import("typed-function").TypedFunction;
+export declare const tanh: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Check if values are equal
  */
-export declare const equal: import("typed-function").TypedFunction;
+export declare const equal: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Check if a < b
  */
-export declare const smaller: import("typed-function").TypedFunction;
+export declare const smaller: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Check if a > b
  */
-export declare const larger: import("typed-function").TypedFunction;
+export declare const larger: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Check if a <= b
  */
-export declare const smallerEq: import("typed-function").TypedFunction;
+export declare const smallerEq: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Check if a >= b
  */
-export declare const largerEq: import("typed-function").TypedFunction;
+export declare const largerEq: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Compare two values: -1, 0, or 1
  */
-export declare const compare: import("typed-function").TypedFunction;
+export declare const compare: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Minimum of values with parallel array support
  */
-export declare const min: import("typed-function").TypedFunction;
+export declare const min: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Maximum of values with parallel array support
  */
-export declare const max: import("typed-function").TypedFunction;
+export declare const max: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Sum with parallel array support
  */
@@ -199,12 +199,12 @@ export declare const max: import("typed-function").TypedFunction;
  * ~2-4x slower than `sum`, so it is opt-in. Reach for it when the result is a small difference of
  * large terms: conservation checks, residuals, long-running accumulators.
  */
-export declare const fsum: import("typed-function").TypedFunction;
-export declare const sum: import("typed-function").TypedFunction;
+export declare const fsum: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const sum: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Mean with parallel array support
  */
-export declare const mean: import("typed-function").TypedFunction;
+export declare const mean: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Variance normalization, matching mathjs's `variance(array, normalization)`:
  *   - 'unbiased'    → sum2 / (n - 1)   (sample variance; mathjs DEFAULT)
@@ -219,16 +219,16 @@ export type VarNormalization = 'unbiased' | 'uncorrected' | 'biased';
  * `parallelStatVariance` variant. An optional normalization argument selects
  * 'unbiased' | 'uncorrected' (population) | 'biased'. See VarNormalization.
  */
-export declare const variance: import("typed-function").TypedFunction;
+export declare const variance: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Standard deviation with parallel array support — sqrt of {@link variance};
  * defaults to **unbiased** and accepts the same normalization argument.
  */
-export declare const std: import("typed-function").TypedFunction;
+export declare const std: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Dot product with parallel array support
  */
-export declare const dot: import("typed-function").TypedFunction;
+export declare const dot: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel matrix multiplication
  * @param a First matrix as flat Float64Array (row-major)
@@ -267,51 +267,51 @@ export declare function shouldParallelize(elementCount: i32): boolean;
  */
 export declare function getComputePool(): ComputePool;
 export declare const typedArithmetic: {
-    add: import("typed-function").TypedFunction;
-    subtract: import("typed-function").TypedFunction;
-    multiply: import("typed-function").TypedFunction;
-    divide: import("typed-function").TypedFunction;
-    unaryMinus: import("typed-function").TypedFunction;
-    unaryPlus: import("typed-function").TypedFunction;
-    abs: import("typed-function").TypedFunction;
-    sign: import("typed-function").TypedFunction;
-    pow: import("typed-function").TypedFunction;
-    sqrt: import("typed-function").TypedFunction;
-    square: import("typed-function").TypedFunction;
-    cube: import("typed-function").TypedFunction;
-    cbrt: import("typed-function").TypedFunction;
-    nthRoot: import("typed-function").TypedFunction;
-    exp: import("typed-function").TypedFunction;
-    log: import("typed-function").TypedFunction;
-    log10: import("typed-function").TypedFunction;
-    log2: import("typed-function").TypedFunction;
-    log1p: import("typed-function").TypedFunction;
-    expm1: import("typed-function").TypedFunction;
-    round: import("typed-function").TypedFunction;
-    floor: import("typed-function").TypedFunction;
-    ceil: import("typed-function").TypedFunction;
-    fix: import("typed-function").TypedFunction;
-    mod: import("typed-function").TypedFunction;
-    gcd: import("typed-function").TypedFunction;
-    lcm: import("typed-function").TypedFunction;
-    xgcd: import("typed-function").TypedFunction;
-    norm: import("typed-function").TypedFunction;
-    sinh: import("typed-function").TypedFunction;
-    cosh: import("typed-function").TypedFunction;
-    tanh: import("typed-function").TypedFunction;
-    equal: import("typed-function").TypedFunction;
-    smaller: import("typed-function").TypedFunction;
-    larger: import("typed-function").TypedFunction;
-    smallerEq: import("typed-function").TypedFunction;
-    largerEq: import("typed-function").TypedFunction;
-    compare: import("typed-function").TypedFunction;
-    min: import("typed-function").TypedFunction;
-    max: import("typed-function").TypedFunction;
-    sum: import("typed-function").TypedFunction;
-    mean: import("typed-function").TypedFunction;
-    variance: import("typed-function").TypedFunction;
-    std: import("typed-function").TypedFunction;
-    dot: import("typed-function").TypedFunction;
+    add: import("@danielsimonjr/mathts-core").TypedFunction;
+    subtract: import("@danielsimonjr/mathts-core").TypedFunction;
+    multiply: import("@danielsimonjr/mathts-core").TypedFunction;
+    divide: import("@danielsimonjr/mathts-core").TypedFunction;
+    unaryMinus: import("@danielsimonjr/mathts-core").TypedFunction;
+    unaryPlus: import("@danielsimonjr/mathts-core").TypedFunction;
+    abs: import("@danielsimonjr/mathts-core").TypedFunction;
+    sign: import("@danielsimonjr/mathts-core").TypedFunction;
+    pow: import("@danielsimonjr/mathts-core").TypedFunction;
+    sqrt: import("@danielsimonjr/mathts-core").TypedFunction;
+    square: import("@danielsimonjr/mathts-core").TypedFunction;
+    cube: import("@danielsimonjr/mathts-core").TypedFunction;
+    cbrt: import("@danielsimonjr/mathts-core").TypedFunction;
+    nthRoot: import("@danielsimonjr/mathts-core").TypedFunction;
+    exp: import("@danielsimonjr/mathts-core").TypedFunction;
+    log: import("@danielsimonjr/mathts-core").TypedFunction;
+    log10: import("@danielsimonjr/mathts-core").TypedFunction;
+    log2: import("@danielsimonjr/mathts-core").TypedFunction;
+    log1p: import("@danielsimonjr/mathts-core").TypedFunction;
+    expm1: import("@danielsimonjr/mathts-core").TypedFunction;
+    round: import("@danielsimonjr/mathts-core").TypedFunction;
+    floor: import("@danielsimonjr/mathts-core").TypedFunction;
+    ceil: import("@danielsimonjr/mathts-core").TypedFunction;
+    fix: import("@danielsimonjr/mathts-core").TypedFunction;
+    mod: import("@danielsimonjr/mathts-core").TypedFunction;
+    gcd: import("@danielsimonjr/mathts-core").TypedFunction;
+    lcm: import("@danielsimonjr/mathts-core").TypedFunction;
+    xgcd: import("@danielsimonjr/mathts-core").TypedFunction;
+    norm: import("@danielsimonjr/mathts-core").TypedFunction;
+    sinh: import("@danielsimonjr/mathts-core").TypedFunction;
+    cosh: import("@danielsimonjr/mathts-core").TypedFunction;
+    tanh: import("@danielsimonjr/mathts-core").TypedFunction;
+    equal: import("@danielsimonjr/mathts-core").TypedFunction;
+    smaller: import("@danielsimonjr/mathts-core").TypedFunction;
+    larger: import("@danielsimonjr/mathts-core").TypedFunction;
+    smallerEq: import("@danielsimonjr/mathts-core").TypedFunction;
+    largerEq: import("@danielsimonjr/mathts-core").TypedFunction;
+    compare: import("@danielsimonjr/mathts-core").TypedFunction;
+    min: import("@danielsimonjr/mathts-core").TypedFunction;
+    max: import("@danielsimonjr/mathts-core").TypedFunction;
+    sum: import("@danielsimonjr/mathts-core").TypedFunction;
+    mean: import("@danielsimonjr/mathts-core").TypedFunction;
+    variance: import("@danielsimonjr/mathts-core").TypedFunction;
+    std: import("@danielsimonjr/mathts-core").TypedFunction;
+    dot: import("@danielsimonjr/mathts-core").TypedFunction;
     matmul: typeof matmul;
     transpose: typeof transpose;
     matvec: typeof matvec;

package/dist/typed/arithmetic.d.ts.map

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

package/dist/typed/bitwise.d.ts

@@ -29,20 +29,20 @@
  * await bitAnd(int32A, int32B);             // Parallel Int32Array AND
  * ```
  */
-export declare const bitAnd: import("typed-function").TypedFunction;
-export declare const bitOr: import("typed-function").TypedFunction;
-export declare const bitXor: import("typed-function").TypedFunction;
-export declare const bitNot: import("typed-function").TypedFunction;
-export declare const leftShift: import("typed-function").TypedFunction;
-export declare const rightArithShift: import("typed-function").TypedFunction;
-export declare const rightLogShift: import("typed-function").TypedFunction;
+export declare const bitAnd: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const bitOr: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const bitXor: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const bitNot: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const leftShift: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const rightArithShift: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const rightLogShift: import("@danielsimonjr/mathts-core").TypedFunction;
 export declare const typedBitwise: {
-    bitAnd: import("typed-function").TypedFunction;
-    bitOr: import("typed-function").TypedFunction;
-    bitXor: import("typed-function").TypedFunction;
-    bitNot: import("typed-function").TypedFunction;
-    leftShift: import("typed-function").TypedFunction;
-    rightArithShift: import("typed-function").TypedFunction;
-    rightLogShift: import("typed-function").TypedFunction;
+    bitAnd: import("@danielsimonjr/mathts-core").TypedFunction;
+    bitOr: import("@danielsimonjr/mathts-core").TypedFunction;
+    bitXor: import("@danielsimonjr/mathts-core").TypedFunction;
+    bitNot: import("@danielsimonjr/mathts-core").TypedFunction;
+    leftShift: import("@danielsimonjr/mathts-core").TypedFunction;
+    rightArithShift: import("@danielsimonjr/mathts-core").TypedFunction;
+    rightLogShift: import("@danielsimonjr/mathts-core").TypedFunction;
 };
 //# sourceMappingURL=bitwise.d.ts.map

package/dist/typed/bitwise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bitwise.d.ts","sourceRoot":"","sources":["../../src/typed/bitwise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AA2FH;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,wCAmCjB,CAAC;AAMH,eAAO,MAAM,KAAK,wCAgChB,CAAC;AAMH,eAAO,MAAM,MAAM,wCAgCjB,CAAC;AAMH,eAAO,MAAM,MAAM,wCAuBjB,CAAC;AAMH,eAAO,MAAM,SAAS,wCAwCpB,CAAC;AAMH,eAAO,MAAM,eAAe,wCAwC1B,CAAC;AAMH,eAAO,MAAM,aAAa,wCAwCxB,CAAC;AAMH,eAAO,MAAM,YAAY;;;;;;;;CAQxB,CAAC"}
+{"version":3,"file":"bitwise.d.ts","sourceRoot":"","sources":["../../src/typed/bitwise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AA2FH;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,oDAmCjB,CAAC;AAMH,eAAO,MAAM,KAAK,oDAgChB,CAAC;AAMH,eAAO,MAAM,MAAM,oDAgCjB,CAAC;AAMH,eAAO,MAAM,MAAM,oDAuBjB,CAAC;AAMH,eAAO,MAAM,SAAS,oDAwCpB,CAAC;AAMH,eAAO,MAAM,eAAe,oDAwC1B,CAAC;AAMH,eAAO,MAAM,aAAa,oDAwCxB,CAAC;AAMH,eAAO,MAAM,YAAY;;;;;;;;CAQxB,CAAC"}

package/dist/typed/combinatorics.d.ts

@@ -31,7 +31,7 @@
  * fibonacci(10) // => 55
  * fibonacci(20) // => 6765
  */
-export declare const fibonacci: import("typed-function").TypedFunction;
+export declare const fibonacci: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Compute the nth Lucas number.
  *
@@ -50,7 +50,7 @@ export declare const fibonacci: import("typed-function").TypedFunction;
  * lucas(1)  // => 1
  * lucas(10) // => 123
  */
-export declare const lucas: import("typed-function").TypedFunction;
+export declare const lucas: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Compute the double factorial n!!.
  *
@@ -69,7 +69,7 @@ export declare const lucas: import("typed-function").TypedFunction;
  * doubleFactorial(6) // => 48 (6*4*2)
  * doubleFactorial(0) // => 1
  */
-export declare const doubleFactorial: import("typed-function").TypedFunction;
+export declare const doubleFactorial: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Compute the rising factorial (Pochhammer symbol).
  *
@@ -86,7 +86,7 @@ export declare const doubleFactorial: import("typed-function").TypedFunction;
  * risingFactorial(3, 4) // => 3*4*5*6 = 360
  * risingFactorial(1, 5) // => 1*2*3*4*5 = 120 = 5!
  */
-export declare const risingFactorial: import("typed-function").TypedFunction;
+export declare const risingFactorial: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Compute the falling factorial.
  *
@@ -102,7 +102,7 @@ export declare const risingFactorial: import("typed-function").TypedFunction;
  * fallingFactorial(5, 3) // => 5*4*3 = 60
  * fallingFactorial(5, 5) // => 5*4*3*2*1 = 120 = 5!
  */
-export declare const fallingFactorial: import("typed-function").TypedFunction;
+export declare const fallingFactorial: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Compute the subfactorial (number of derangements).
  *
@@ -119,7 +119,7 @@ export declare const fallingFactorial: import("typed-function").TypedFunction;
  * subfactorial(2) // => 1
  * subfactorial(5) // => 44
  */
-export declare const subfactorial: import("typed-function").TypedFunction;
+export declare const subfactorial: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Return the nth prime number (1-indexed).
  *
@@ -134,7 +134,7 @@ export declare const subfactorial: import("typed-function").TypedFunction;
  * prime(4)  // => 7
  * prime(10) // => 29
  */
-export declare const prime: import("typed-function").TypedFunction;
+export declare const prime: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Return the smallest prime number strictly greater than n.
  *
@@ -146,7 +146,7 @@ export declare const prime: import("typed-function").TypedFunction;
  * nextPrime(7)  // => 11
  * nextPrime(10) // => 11
  */
-export declare const nextPrime: import("typed-function").TypedFunction;
+export declare const nextPrime: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Prime counting function pi(n): number of primes <= n.
  *
@@ -157,7 +157,7 @@ export declare const nextPrime: import("typed-function").TypedFunction;
  * primePi(10) // => 4 (primes: 2, 3, 5, 7)
  * primePi(1)  // => 0
  */
-export declare const primePi: import("typed-function").TypedFunction;
+export declare const primePi: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Return the prime factorization of n as an array of prime factors
  * (with repetition, sorted ascending).
@@ -170,7 +170,7 @@ export declare const primePi: import("typed-function").TypedFunction;
  * primeFactors(60)  // => [2, 2, 3, 5]
  * primeFactors(7)   // => [7]
  */
-export declare const primeFactors: import("typed-function").TypedFunction;
+export declare const primeFactors: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Return all positive divisors of n, sorted ascending.
  *
@@ -181,7 +181,7 @@ export declare const primeFactors: import("typed-function").TypedFunction;
  * divisors(12) // => [1, 2, 3, 4, 6, 12]
  * divisors(7)  // => [1, 7]
  */
-export declare const divisors: import("typed-function").TypedFunction;
+export declare const divisors: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Euler's totient function phi(n): count of integers 1..n coprime to n.
  *
@@ -193,7 +193,7 @@ export declare const divisors: import("typed-function").TypedFunction;
  * eulerPhi(10) // => 4 (1, 3, 7, 9)
  * eulerPhi(12) // => 4 (1, 5, 7, 11)
  */
-export declare const eulerPhi: import("typed-function").TypedFunction;
+export declare const eulerPhi: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Sum of the kth powers of divisors of n: sigma_k(n).
  *
@@ -209,7 +209,7 @@ export declare const eulerPhi: import("typed-function").TypedFunction;
  * divisorSigma(12, 0)  // => 6 (number of divisors)
  * divisorSigma(12, 2)  // => 210
  */
-export declare const divisorSigma: import("typed-function").TypedFunction;
+export declare const divisorSigma: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Carmichael function lambda(n): smallest positive integer m such that
  * a^m === 1 (mod n) for all a coprime to n.
@@ -222,7 +222,7 @@ export declare const divisorSigma: import("typed-function").TypedFunction;
  * carmichaelLambda(8)  // => 2
  * carmichaelLambda(15) // => 4
  */
-export declare const carmichaelLambda: import("typed-function").TypedFunction;
+export declare const carmichaelLambda: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Mobius function mu(n).
  *
@@ -239,7 +239,7 @@ export declare const carmichaelLambda: import("typed-function").TypedFunction;
  * moebiusMu(4)  // => 0 (4 = 2^2, squared factor)
  * moebiusMu(30) // => -1 (30 = 2*3*5, three distinct primes)
  */
-export declare const moebiusMu: import("typed-function").TypedFunction;
+export declare const moebiusMu: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Jacobi symbol (a/n), a generalization of the Legendre symbol.
  *
@@ -254,7 +254,7 @@ export declare const moebiusMu: import("typed-function").TypedFunction;
  * jacobiSymbol(5, 21) // => 1
  * jacobiSymbol(7, 15) // => -1
  */
-export declare const jacobiSymbol: import("typed-function").TypedFunction;
+export declare const jacobiSymbol: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Solve a system of simultaneous congruences using the Chinese Remainder Theorem.
  *
@@ -269,7 +269,7 @@ export declare const jacobiSymbol: import("typed-function").TypedFunction;
  * chineseRemainder([2, 3, 2], [3, 5, 7]) // => 23
  * // x === 2 (mod 3), x === 3 (mod 5), x === 2 (mod 7)
  */
-export declare const chineseRemainder: import("typed-function").TypedFunction;
+export declare const chineseRemainder: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Compute the nth Lucas number L(n).
  *
@@ -287,7 +287,7 @@ export declare const chineseRemainder: import("typed-function").TypedFunction;
  * lucasL(5)  // => 11
  * lucasL(10) // => 123
  */
-export declare const lucasL: import("typed-function").TypedFunction;
+export declare const lucasL: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Number of integer partitions of n.
  *
@@ -304,7 +304,7 @@ export declare const lucasL: import("typed-function").TypedFunction;
  * partitions(4) // => 5 (4, 3+1, 2+2, 2+1+1, 1+1+1+1)
  * partitions(5) // => 7
  */
-export declare const partitions: import("typed-function").TypedFunction;
+export declare const partitions: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Compute the nth harmonic number H(n) = 1 + 1/2 + 1/3 + ... + 1/n.
  *
@@ -315,7 +315,7 @@ export declare const partitions: import("typed-function").TypedFunction;
  * harmonicNumber(1) // => 1
  * harmonicNumber(4) // => 2.0833... (1 + 1/2 + 1/3 + 1/4)
  */
-export declare const harmonicNumber: import("typed-function").TypedFunction;
+export declare const harmonicNumber: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Return the digits of n in the given base as an array (most significant first).
  *
@@ -329,5 +329,5 @@ export declare const harmonicNumber: import("typed-function").TypedFunction;
  * integerDigits(10, 2)   // => [1, 0, 1, 0]
  * integerDigits(0)       // => [0]
  */
-export declare const integerDigits: import("typed-function").TypedFunction;
+export declare const integerDigits: import("@danielsimonjr/mathts-core").TypedFunction;
 //# sourceMappingURL=combinatorics.d.ts.map

package/dist/typed/combinatorics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"combinatorics.d.ts","sourceRoot":"","sources":["../../src/typed/combinatorics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAQH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,SAAS,wCAsCpB,CAAC;AAMH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK,wCAuChB,CAAC;AAMH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,eAAe,wCAa1B,CAAC;AAMH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,wCAa1B,CAAC;AAMH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,wCAa3B,CAAC;AAMH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,wCAoBvB,CAAC;AAUH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK,wCAiBhB,CAAC;AAyBH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,wCAWpB,CAAC;AAmBH;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,wCAOlB,CAAC;AAMH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,wCAgBvB,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,wCAenB,CAAC;AAMH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,wCAgBnB,CAAC;AAMH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,wCAOvB,CAAC;AAuBH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,wCA0B3B,CAAC;AA8BH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,SAAS,wCAmBpB,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,wCA0BvB,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,wCA6B3B,CAAC;AAwBH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,MAAM,wCAcjB,CAAC;AAMH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,wCAerB,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,wCAWzB,CAAC;AAMH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,wCAOxB,CAAC"}
+{"version":3,"file":"combinatorics.d.ts","sourceRoot":"","sources":["../../src/typed/combinatorics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAQH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,SAAS,oDAsCpB,CAAC;AAMH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK,oDAuChB,CAAC;AAMH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,eAAe,oDAa1B,CAAC;AAMH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,oDAa1B,CAAC;AAMH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,oDAa3B,CAAC;AAMH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,oDAoBvB,CAAC;AAUH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK,oDAiBhB,CAAC;AAyBH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,oDAWpB,CAAC;AAmBH;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,oDAOlB,CAAC;AAMH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,oDAgBvB,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,oDAenB,CAAC;AAMH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,oDAgBnB,CAAC;AAMH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,oDAOvB,CAAC;AAuBH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,oDA0B3B,CAAC;AA8BH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,SAAS,oDAmBpB,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,oDA0BvB,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,oDA6B3B,CAAC;AAwBH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,MAAM,oDAcjB,CAAC;AAMH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,oDAerB,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,oDAWzB,CAAC;AAMH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,oDAOxB,CAAC"}

package/dist/typed/complex.d.ts

@@ -32,7 +32,7 @@
  * arg([1, -1, new Complex(0, 1)])  // [0, Math.PI, Math.PI / 2]
  * ```
  */
-export declare const arg: import("typed-function").TypedFunction;
+export declare const arg: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Compute the complex conjugate of a value.
  * For a complex number `a + bi`, the conjugate is `a - bi`.
@@ -48,7 +48,7 @@ export declare const arg: import("typed-function").TypedFunction;
  * conj([new Complex(1, 2), 3])   // [Complex(1, -2), 3]
  * ```
  */
-export declare const conj: import("typed-function").TypedFunction;
+export declare const conj: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Get the imaginary part of a complex number.
  * For a complex number `a + bi`, the function returns `b`.
@@ -63,7 +63,7 @@ export declare const conj: import("typed-function").TypedFunction;
  * im([new Complex(1, 2), 3])  // [2, 0]
  * ```
  */
-export declare const im: import("typed-function").TypedFunction;
+export declare const im: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Get the real part of a complex number.
  * For a complex number `a + bi`, the function returns `a`.
@@ -78,14 +78,14 @@ export declare const im: import("typed-function").TypedFunction;
  * re([new Complex(1, 2), 3])  // [1, 3]
  * ```
  */
-export declare const re: import("typed-function").TypedFunction;
+export declare const re: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * All typed complex helper functions.
  */
 export declare const typedComplex: {
-    arg: import("typed-function").TypedFunction;
-    conj: import("typed-function").TypedFunction;
-    im: import("typed-function").TypedFunction;
-    re: import("typed-function").TypedFunction;
+    arg: import("@danielsimonjr/mathts-core").TypedFunction;
+    conj: import("@danielsimonjr/mathts-core").TypedFunction;
+    im: import("@danielsimonjr/mathts-core").TypedFunction;
+    re: import("@danielsimonjr/mathts-core").TypedFunction;
 };
 //# sourceMappingURL=complex.d.ts.map