@danielsimonjr/mathts-functions 0.32.0 → 0.33.0

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export { config } from './config-api.js';
 export { to, toBest } from './typed/unit.js';
 export { evaluate, compileExpr, parse, parser, reviver, replacer } from './factories/evaluate.js';
 export { help } from './help.js';
+export { continuedFraction, eulerNumbers, stirlingS1, discreteLog, primitiveRoot, multiplicativeOrder, kroneckerSymbol, permutationsGen, combinationsGen, } from './numbertheory/extra.js';
 export { derivativeAt, valueAndDerivativeAt, gradientAt } from './grad-forward.js';
 export type { DualFn } from './grad-forward.js';
 export { gmean, hmean, moment, skewness, kurtosis, iqr, sem, zscore, cov, corrcoef, rankdata, spearman, kendallTau, linregress, pearsonr, spearmanr, kendalltau, kendallTauTest, ptp, variation, trimmedMean, describe, histogram, } from './descriptive-stats.js';
@@ -70,4 +71,9 @@ export { firwin, butter, lfilter, lfilterZi, filtfilt } from './signal-filter-ex
 export { haversine, EARTH_RADIUS_KM, slerp, quaternionMultiply, quaternionConjugate, quaternionNormalize, quaternionFromAxisAngle, quaternionRotate, quaternionToRotationMatrix, } from './geometry-extra.js';
 export { noncentralChi2CDF, noncentralFCDF, noncentralTCDF, circmean, circstd, circvar, vonMisesPDF, mcnemar, cochranQ, } from './stats/inference-extra2.js';
 export type { CircularOptions, McNemarOptions, McNemarResult, CochranQResult, } from './stats/inference-extra2.js';
+export { hyp0f1, hyp1f1, hyp2f1, pFq } from './special/hypergeometric.js';
+export { polygamma, trigamma, jacobiP, gegenbauerC } from './special/polygamma-orthopoly.js';
+export { jacobiSN, jacobiCN, jacobiDN } from './special/jacobi-elliptic.js';
+export { rootsLegendre } from './numeric/gauss-nodes.js';
+export type { RootsLegendreResult } from './numeric/gauss-nodes.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -31837,9 +31837,9 @@ var dependencies187 = ["typed", "factorial"];
 var createPermutations = /* @__PURE__ */ factory(
   name187,
   dependencies187,
-  ({ typed: typed3, factorial: factorial4 }) => {
+  ({ typed: typed3, factorial: factorial5 }) => {
     return typed3(name187, {
-      "number | BigNumber": factorial4,
+      "number | BigNumber": factorial5,
       "number, number": function(n, k) {
         if (!isInteger(n) || n < 0) {
           throw new TypeError("Positive integer value expected in function permutations");
@@ -36105,7 +36105,7 @@ var dependencies224 = ["typed", "add", "divide", "multiply", "factorial", "isInt
 var createMultinomial = /* @__PURE__ */ factory(
   name224,
   dependencies224,
-  ({ typed: typed3, add: add2, divide: divide2, multiply: multiply2, factorial: factorial4, isInteger: isInteger3, isPositive: isPositive2 }) => {
+  ({ typed: typed3, add: add2, divide: divide2, multiply: multiply2, factorial: factorial5, isInteger: isInteger3, isPositive: isPositive2 }) => {
     return typed3(name224, {
       "Array | Matrix": function(a) {
         let sum3 = 0;
@@ -36115,9 +36115,9 @@ var createMultinomial = /* @__PURE__ */ factory(
             throw new TypeError("Positive integer value expected in function multinomial");
           }
           sum3 = add2(sum3, ai);
-          denom = multiply2(denom, factorial4(ai));
+          denom = multiply2(denom, factorial5(ai));
         });
-        return divide2(factorial4(sum3), denom);
+        return divide2(factorial5(sum3), denom);
       }
     });
   }
@@ -37174,7 +37174,7 @@ var createZeta = /* @__PURE__ */ factory(
     multiply: multiply2,
     pow: pow2,
     divide: divide2,
-    factorial: factorial4,
+    factorial: factorial5,
     equal: equal2,
     smallerEq: smallerEq2,
     isBounded: isBounded2,
@@ -37252,8 +37252,8 @@ var createZeta = /* @__PURE__ */ factory(
       let S = k;
       for (let j = k; smallerEq2(j, n); j = add2(j, 1)) {
         const factor2 = divide2(
-          multiply2(factorial4(add2(n, subtract2(j, 1))), pow2(4, j)),
-          multiply2(factorial4(subtract2(n, j)), factorial4(multiply2(2, j)))
+          multiply2(factorial5(add2(n, subtract2(j, 1))), pow2(4, j)),
+          multiply2(factorial5(subtract2(n, j)), factorial5(multiply2(2, j)))
         );
         S = add2(S, factor2);
       }
@@ -44400,6 +44400,262 @@ function help(search) {
   return new Help(doc);
 }
 
+// src/numbertheory/extra.ts
+function continuedFraction(x, maxTerms = 20) {
+  if (!Number.isFinite(x)) {
+    throw new Error("continuedFraction requires a finite number");
+  }
+  const terms = [];
+  let r = x;
+  for (let i = 0; i < maxTerms; i++) {
+    const a = Math.floor(r);
+    terms.push(a);
+    const frac = r - a;
+    if (frac < 1e-12) break;
+    r = 1 / frac;
+  }
+  return terms;
+}
+function binomialExact(n, k) {
+  if (k < 0 || k > n) return 0;
+  const kk = Math.min(k, n - k);
+  let result = 1;
+  for (let i = 0; i < kk; i++) {
+    result = result * (n - i) / (i + 1);
+  }
+  return Math.round(result);
+}
+function eulerNumbers(n) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error("eulerNumbers requires a non-negative integer");
+  }
+  const E = new Array(n + 1).fill(0);
+  E[0] = 1;
+  for (let m = 1; m <= n; m++) {
+    if (m % 2 === 1) {
+      E[m] = 0;
+      continue;
+    }
+    let sum3 = 0;
+    for (let k = 0; k < m / 2; k++) {
+      sum3 += binomialExact(m, 2 * k) * E[2 * k];
+    }
+    E[m] = -sum3;
+  }
+  return E;
+}
+function stirlingS1(n, k) {
+  if (!Number.isInteger(n) || !Number.isInteger(k) || n < 0 || k < 0) {
+    throw new Error("stirlingS1 requires non-negative integers");
+  }
+  if (k > n) return 0;
+  const s = Array.from({ length: n + 1 }, () => new Array(n + 1).fill(0));
+  s[0][0] = 1;
+  for (let i = 1; i <= n; i++) {
+    for (let j = 0; j <= i; j++) {
+      const prevDiag = j > 0 ? s[i - 1][j - 1] : 0;
+      const prevSame = s[i - 1][j];
+      s[i][j] = prevDiag - (i - 1) * prevSame;
+    }
+  }
+  return s[n][k];
+}
+function modPowBig(base, exp2, mod2) {
+  let b = (base % mod2 + mod2) % mod2;
+  let e = exp2;
+  let result = 1n;
+  while (e > 0n) {
+    if (e & 1n) result = result * b % mod2;
+    b = b * b % mod2;
+    e >>= 1n;
+  }
+  return result;
+}
+function modInverseBig(a, mod2) {
+  let oldR = a;
+  let r = mod2;
+  let oldS = 1n;
+  let s = 0n;
+  while (r !== 0n) {
+    const q = oldR / r;
+    [oldR, r] = [r, oldR - q * r];
+    [oldS, s] = [s, oldS - q * s];
+  }
+  return (oldS % mod2 + mod2) % mod2;
+}
+function discreteLog(g, h, p) {
+  if (!Number.isInteger(g) || !Number.isInteger(h) || !Number.isInteger(p) || p < 2) {
+    throw new Error("discreteLog requires integer g, h and a modulus p >= 2");
+  }
+  const P2 = BigInt(p);
+  const G = (BigInt(g) % P2 + P2) % P2;
+  const H = (BigInt(h) % P2 + P2) % P2;
+  const m = BigInt(Math.max(1, Math.ceil(Math.sqrt(p - 1))));
+  const table = /* @__PURE__ */ new Map();
+  let cur = 1n;
+  for (let j = 0n; j < m; j++) {
+    const key = cur.toString();
+    if (!table.has(key)) table.set(key, j);
+    cur = cur * G % P2;
+  }
+  const gm = modPowBig(G, m, P2);
+  const gInvM = modInverseBig(gm, P2);
+  let gamma2 = H;
+  for (let i = 0n; i < m; i++) {
+    const key = gamma2.toString();
+    const j = table.get(key);
+    if (j !== void 0) {
+      return Number(i * m + j);
+    }
+    gamma2 = gamma2 * gInvM % P2;
+  }
+  return -1;
+}
+function distinctPrimeFactors(nIn) {
+  let n = nIn;
+  const primes = [];
+  for (let d = 2; d * d <= n; d++) {
+    if (n % d === 0) {
+      primes.push(d);
+      while (n % d === 0) n /= d;
+    }
+  }
+  if (n > 1) primes.push(n);
+  return primes;
+}
+function primitiveRoot(p) {
+  if (!Number.isInteger(p) || p < 2) {
+    throw new Error("primitiveRoot requires an integer p >= 2");
+  }
+  if (p === 2) return 1;
+  const phi = p - 1;
+  const phiFactors = distinctPrimeFactors(phi);
+  const P2 = BigInt(p);
+  for (let g = 2; g < p; g++) {
+    let isRoot = true;
+    for (const q of phiFactors) {
+      if (modPowBig(BigInt(g), BigInt(phi / q), P2) === 1n) {
+        isRoot = false;
+        break;
+      }
+    }
+    if (isRoot) return g;
+  }
+  throw new Error("primitiveRoot: no primitive root found (p may not be prime)");
+}
+function gcdInt(aIn, bIn) {
+  let a = Math.abs(aIn);
+  let b = Math.abs(bIn);
+  while (b !== 0) {
+    [a, b] = [b, a % b];
+  }
+  return a;
+}
+function multiplicativeOrder(a, n) {
+  if (!Number.isInteger(a) || !Number.isInteger(n) || n < 1) {
+    throw new Error("multiplicativeOrder requires integers with modulus n >= 1");
+  }
+  const amod = (a % n + n) % n;
+  if (gcdInt(amod, n) !== 1) return -1;
+  if (n === 1) return 1;
+  let cur = amod;
+  let k = 1;
+  while (cur !== 1) {
+    cur = cur * amod % n;
+    k++;
+  }
+  return k;
+}
+function kroneckerTwo(a) {
+  if (a % 2 === 0) return 0;
+  const r = (a % 8 + 8) % 8;
+  return r === 1 || r === 7 ? 1 : -1;
+}
+function kroneckerSymbol(a, n) {
+  if (!Number.isInteger(a) || !Number.isInteger(n)) {
+    throw new Error("kroneckerSymbol requires integers");
+  }
+  if (n === 0) {
+    return Math.abs(a) === 1 ? 1 : 0;
+  }
+  let sign3 = 1;
+  let nn = n;
+  if (nn < 0) {
+    nn = -nn;
+    if (a < 0) sign3 = -1;
+  }
+  let v = 0;
+  while (nn % 2 === 0) {
+    nn /= 2;
+    v++;
+  }
+  if (v > 0) {
+    const k2 = kroneckerTwo(a);
+    if (k2 === 0) return 0;
+    sign3 *= Math.pow(k2, v);
+  }
+  if (nn === 1) return sign3;
+  let aa = (a % nn + nn) % nn;
+  let N = nn;
+  let jac = 1;
+  while (aa !== 0) {
+    while (aa % 2 === 0) {
+      aa /= 2;
+      if (N % 8 === 3 || N % 8 === 5) jac = -jac;
+    }
+    [aa, N] = [N, aa];
+    if (aa % 4 === 3 && N % 4 === 3) jac = -jac;
+    aa = aa % N;
+  }
+  return sign3 * (N === 1 ? jac : 0);
+}
+function combinationsGen(arr8, k) {
+  const n = arr8.length;
+  if (!Number.isInteger(k) || k < 0 || k > n) {
+    throw new Error("combinationsGen: k must be an integer in [0, arr.length]");
+  }
+  const result = [];
+  const combo = [];
+  function backtrack(start) {
+    if (combo.length === k) {
+      result.push(combo.slice());
+      return;
+    }
+    for (let i = start; i < n; i++) {
+      combo.push(arr8[i]);
+      backtrack(i + 1);
+      combo.pop();
+    }
+  }
+  backtrack(0);
+  return result;
+}
+function permutationsGen(arr8, k = arr8.length) {
+  const n = arr8.length;
+  if (!Number.isInteger(k) || k < 0 || k > n) {
+    throw new Error("permutationsGen: k must be an integer in [0, arr.length]");
+  }
+  const result = [];
+  const used = new Array(n).fill(false);
+  const perm = [];
+  function backtrack() {
+    if (perm.length === k) {
+      result.push(perm.slice());
+      return;
+    }
+    for (let i = 0; i < n; i++) {
+      if (used[i]) continue;
+      used[i] = true;
+      perm.push(arr8[i]);
+      backtrack();
+      perm.pop();
+      used[i] = false;
+    }
+  }
+  backtrack();
+  return result;
+}
+
 // src/grad-forward.ts
 import { Dual as Dual3 } from "@danielsimonjr/mathts-core";
 function derivativeAt(fn, x0) {
@@ -47170,6 +47426,190 @@ function cochranQ(data) {
   const pValue = 1 - chiSquaredCDF(Q2, dof);
   return { Q: Q2, pValue, dof };
 }
+
+// src/special/hypergeometric.ts
+var MAX_TERMS = 500;
+var RELTOL = 1e-16;
+function pFq(a, b, z) {
+  let sum3 = 1;
+  let term = 1;
+  for (let n = 0; n < MAX_TERMS; n++) {
+    let ratio = z / (n + 1);
+    for (const ai of a) ratio *= ai + n;
+    for (const bj of b) ratio /= bj + n;
+    term *= ratio;
+    sum3 += term;
+    if (Math.abs(term) < RELTOL * Math.abs(sum3)) break;
+  }
+  return sum3;
+}
+function hyp0f1(b, z) {
+  return pFq([], [b], z);
+}
+function hyp1f1(a, b, z) {
+  return pFq([a], [b], z);
+}
+function hyp2f1(a, b, c, z) {
+  if (Math.abs(z) >= 1) {
+    throw new Error("hyp2f1: |z| must be < 1 (analytic continuation not yet implemented)");
+  }
+  return pFq([a, b], [c], z);
+}
+
+// src/special/polygamma-orthopoly.ts
+var SHIFT_THRESHOLD = 12;
+var BERNOULLI_EVEN = [1 / 6, -1 / 30, 1 / 42, -1 / 30];
+function factorial4(n) {
+  let result = 1;
+  for (let i = 2; i <= n; i++) result *= i;
+  return result;
+}
+function polygamma(n, x) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error("polygamma: n must be a nonnegative integer");
+  }
+  if (n === 0) {
+    return digamma(x);
+  }
+  if (x <= 0 && Number.isInteger(x)) {
+    return NaN;
+  }
+  const sign3 = n % 2 === 1 ? 1 : -1;
+  const nFactorial = factorial4(n);
+  let recurrenceSum = 0;
+  let shifted = x;
+  while (shifted < SHIFT_THRESHOLD) {
+    recurrenceSum += 1 / Math.pow(shifted, n + 1);
+    shifted += 1;
+  }
+  let bracket = factorial4(n - 1) / Math.pow(shifted, n) + nFactorial / (2 * Math.pow(shifted, n + 1));
+  for (let j = 1; j <= BERNOULLI_EVEN.length; j++) {
+    const twoJ = 2 * j;
+    const term = BERNOULLI_EVEN[j - 1] * factorial4(twoJ + n - 1) / factorial4(twoJ) / Math.pow(shifted, twoJ + n);
+    bracket += term;
+  }
+  return sign3 * (nFactorial * recurrenceSum + bracket);
+}
+function trigamma(x) {
+  return polygamma(1, x);
+}
+function jacobiP(n, alpha, beta2, x) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error("jacobiP: n must be a nonnegative integer");
+  }
+  if (n === 0) return 1;
+  let pPrev = 1;
+  let pCurr = alpha + 1 + (alpha + beta2 + 2) * (x - 1) / 2;
+  if (n === 1) return pCurr;
+  for (let k = 2; k <= n; k++) {
+    const a1 = 2 * k * (k + alpha + beta2) * (2 * k + alpha + beta2 - 2);
+    const a2 = (2 * k + alpha + beta2 - 1) * ((2 * k + alpha + beta2) * (2 * k + alpha + beta2 - 2) * x + alpha * alpha - beta2 * beta2);
+    const a3 = 2 * (k + alpha - 1) * (k + beta2 - 1) * (2 * k + alpha + beta2);
+    const pNext = (a2 * pCurr - a3 * pPrev) / a1;
+    pPrev = pCurr;
+    pCurr = pNext;
+  }
+  return pCurr;
+}
+function gegenbauerC(n, alpha, x) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error("gegenbauerC: n must be a nonnegative integer");
+  }
+  if (n === 0) return 1;
+  let cPrev = 1;
+  let cCurr = 2 * alpha * x;
+  if (n === 1) return cCurr;
+  for (let k = 2; k <= n; k++) {
+    const cNext = (2 * x * (k + alpha - 1) * cCurr - (k + 2 * alpha - 2) * cPrev) / k;
+    cPrev = cCurr;
+    cCurr = cNext;
+  }
+  return cCurr;
+}
+
+// src/special/jacobi-elliptic.ts
+var MAX_AGM_ITERATIONS = 12;
+var AGM_TOLERANCE = 1e-16;
+function jacobiElliptic(u, m) {
+  if (m < 0 || m > 1) {
+    throw new Error("jacobiElliptic: m (=k^2) must be in [0, 1]");
+  }
+  if (m === 0) {
+    return { sn: Math.sin(u), cn: Math.cos(u), dn: 1 };
+  }
+  if (m === 1) {
+    const sn2 = Math.tanh(u);
+    const sech2 = 1 / Math.cosh(u);
+    return { sn: sn2, cn: sech2, dn: sech2 };
+  }
+  const a = [1];
+  const b = [Math.sqrt(1 - m)];
+  const c = [Math.sqrt(m)];
+  let n = 0;
+  while (n < MAX_AGM_ITERATIONS && Math.abs(c[n]) > AGM_TOLERANCE) {
+    a.push((a[n] + b[n]) / 2);
+    b.push(Math.sqrt(a[n] * b[n]));
+    c.push((a[n] - b[n]) / 2);
+    n++;
+  }
+  let phi = Math.pow(2, n) * a[n] * u;
+  for (let i = n; i >= 1; i--) {
+    phi = (phi + Math.asin(c[i] / a[i] * Math.sin(phi))) / 2;
+  }
+  const sn = Math.sin(phi);
+  const cn = Math.cos(phi);
+  const dn = Math.sqrt(1 - m * sn * sn);
+  return { sn, cn, dn };
+}
+function jacobiSN(u, m) {
+  return jacobiElliptic(u, m).sn;
+}
+function jacobiCN(u, m) {
+  return jacobiElliptic(u, m).cn;
+}
+function jacobiDN(u, m) {
+  return jacobiElliptic(u, m).dn;
+}
+
+// src/numeric/gauss-nodes.ts
+var NEWTON_MAX_ITERATIONS = 100;
+var NEWTON_TOLERANCE = 1e-15;
+function legendrePair(n, x) {
+  let pPrev = 1;
+  let pCurr = x;
+  if (n === 0) return [1, x];
+  for (let k = 2; k <= n; k++) {
+    const pNext = ((2 * k - 1) * x * pCurr - (k - 1) * pPrev) / k;
+    pPrev = pCurr;
+    pCurr = pNext;
+  }
+  return [pCurr, pPrev];
+}
+function rootsLegendre(n) {
+  if (!Number.isInteger(n) || n < 1) {
+    throw new Error("rootsLegendre: n must be a positive integer");
+  }
+  const nodes = [];
+  const weights = [];
+  for (let i = 0; i < n; i++) {
+    let x = Math.cos(Math.PI * (i + 0.75) / (n + 0.5));
+    let pn = 0;
+    let dpn = 0;
+    for (let iter = 0; iter < NEWTON_MAX_ITERATIONS; iter++) {
+      const [pCurr, pPrev] = legendrePair(n, x);
+      pn = pCurr;
+      dpn = n * (x * pCurr - pPrev) / (x * x - 1);
+      const dx = pn / dpn;
+      x -= dx;
+      if (Math.abs(dx) < NEWTON_TOLERANCE) break;
+    }
+    nodes.push(x);
+    weights.push(2 / ((1 - x * x) * dpn * dpn));
+  }
+  nodes.reverse();
+  weights.reverse();
+  return { nodes, weights };
+}
 export {
   ARRAY_WORKER_THRESHOLD,
   CAS_BATCH_THRESHOLD,
@@ -47302,6 +47742,7 @@ export {
   collect,
   column,
   combinations,
+  combinationsGen,
   combinationsWithRep,
   combine,
   companion,
@@ -47319,6 +47760,7 @@ export {
   config,
   conj,
   connectedComponents,
+  continuedFraction,
   convexHull,
   convexHull3D,
   convolve,
@@ -47377,6 +47819,7 @@ export {
   digamma,
   directionalDerivative,
   disableGpu,
+  discreteLog,
   discreteUniformDist,
   discriminant,
   distance,
@@ -47424,6 +47867,7 @@ export {
   erfc,
   erfcScalar,
   erfi,
+  eulerNumbers,
   eulerPhi,
   evaluate,
   eventDetection,
@@ -47553,6 +47997,7 @@ export {
   gaussQuad,
   gaussianKDE,
   gcd,
+  gegenbauerC,
   generalizedEig,
   geometricPMF,
   getAssumptions,
@@ -47592,6 +48037,9 @@ export {
   histogram,
   hmean,
   hotellingT2,
+  hyp0f1,
+  hyp1f1,
+  hyp2f1,
   hypergeometricDist,
   hypot,
   idct,
@@ -47631,6 +48079,10 @@ export {
   isPositive,
   isPrime,
   isZero,
+  jacobiCN,
+  jacobiDN,
+  jacobiP,
+  jacobiSN,
   jacobiSymbol,
   jacobian,
   jarqueBera,
@@ -47650,6 +48102,7 @@ export {
   kolmogorovSmirnov2Test,
   kolmogorovSmirnovTest,
   kron,
+  kroneckerSymbol,
   kruskalWallis,
   kurtosis,
   lagrangeInterp,
@@ -47756,6 +48209,7 @@ export {
   multinomial,
   multipleComparison,
   multipleTest,
+  multiplicativeOrder,
   multiply,
   multiplyScalar,
   multivariateNormal,
@@ -47799,6 +48253,7 @@ export {
   or,
   orth,
   outer,
+  pFq,
   pacf,
   padeApproximant,
   pageRank,
@@ -47840,6 +48295,7 @@ export {
   periodogram,
   permutationTest,
   permutations,
+  permutationsGen,
   pickRandom,
   piecewise,
   pinv,
@@ -47856,6 +48312,7 @@ export {
   polyFit,
   polyadd,
   polyder,
+  polygamma,
   polygonArea,
   polygonPerimeter,
   polymul,
@@ -47871,6 +48328,7 @@ export {
   prime,
   primeFactors,
   primePi,
+  primitiveRoot,
   principalComponentAnalysis,
   print,
   prod,
@@ -47920,6 +48378,7 @@ export {
   risingFactorial,
   romberg,
   root,
+  rootsLegendre,
   rotate,
   rotateVector2D,
   rotateVector3D,
@@ -47991,6 +48450,7 @@ export {
   std,
   stefanBoltzmann,
   stiffODESolver,
+  stirlingS1,
   stirlingS2,
   string,
   stronglyConnectedComponents,
@@ -48040,6 +48500,7 @@ export {
   trigExpand,
   trigReduce,
   trigToExp,
+  trigamma,
   tril,
   trimmedMean,
   triu,

package/dist/numbertheory/extra.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Number-theory fills — closes gaps left by the existing combinatorics/number-theory
+ * surface (`typed/combinatorics.ts`): continued fractions, Euler numbers, the signed
+ * Stirling numbers of the first kind, discrete logarithm (BSGS), primitive roots,
+ * multiplicative order, the Kronecker symbol, and lexicographic
+ * permutation/combination *enumerators* (the existing `permutations`/`combinations`
+ * only return counts, not the tuples themselves).
+ *
+ * Plain exported functions (not `mathTyped` dispatch) — all take/return `number`
+ * or generic arrays, matching the style of `descriptive-stats.ts`.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Simple continued fraction expansion `[a0, a1, a2, ...]` of `x`, where
+ * `a_i = floor(r)` and `r <- 1 / (r - a_i)`.
+ *
+ * Stops after `maxTerms` (default 20) or once the fractional part is smaller
+ * than `1e-12` (the remaining value is effectively an integer).
+ *
+ * @param x - The number to expand
+ * @param maxTerms - Maximum number of terms to compute (default 20)
+ * @returns The sequence of partial-quotient terms
+ *
+ * @example
+ * continuedFraction(3.245, 5) // => [3, 4, 12, 4, ...]
+ */
+export declare function continuedFraction(x: number, maxTerms?: number): number[];
+/**
+ * Euler numbers `E_0..E_n` (the coefficients in the secant Maclaurin series).
+ *
+ * `E_0 = 1`; all odd-index Euler numbers are 0; for even `m > 0`:
+ * `E_m = -sum_{k=0}^{m/2-1} C(m, 2k) * E_{2k}`.
+ *
+ * @param n - Non-negative integer: compute E_0 through E_n
+ * @returns Array of length `n + 1`: `[E_0, E_1, ..., E_n]`
+ *
+ * @example
+ * eulerNumbers(6) // => [1, 0, -1, 0, 5, 0, -61]
+ */
+export declare function eulerNumbers(n: number): number[];
+/**
+ * Signed Stirling number of the first kind `s(n, k)`.
+ *
+ * Recurrence: `s(n, k) = s(n-1, k-1) - (n-1)*s(n-1, k)`, with `s(0, 0) = 1`
+ * and `s(n, 0) = 0` for `n > 0`.
+ *
+ * @param n - Non-negative integer
+ * @param k - Non-negative integer, `0 <= k <= n`
+ * @returns The signed Stirling number `s(n, k)`
+ *
+ * @example
+ * stirlingS1(5, 2) // => -50
+ */
+export declare function stirlingS1(n: number, k: number): number;
+/**
+ * Discrete logarithm via baby-step giant-step: the smallest `x >= 0` such
+ * that `g^x === h (mod p)`, or `-1` if none exists within `[0, p-1]`.
+ *
+ * Uses `BigInt` internally for modular exponentiation/inversion to avoid
+ * overflow. `m = ceil(sqrt(p-1))` baby steps are stored in a map; the giant
+ * steps multiply by `g^(-m) mod p` each round.
+ *
+ * @param g - Base
+ * @param h - Target
+ * @param p - Prime modulus
+ * @returns The smallest non-negative `x` with `g^x === h (mod p)`, or `-1`
+ *
+ * @example
+ * discreteLog(2, 3, 5) // => 3   (2^3 = 8 === 3 mod 5)
+ */
+export declare function discreteLog(g: number, h: number, p: number): number;
+/**
+ * Smallest primitive root modulo a prime `p`.
+ *
+ * For each candidate `g = 2, 3, ...`, `g` is a primitive root iff
+ * `g^((p-1)/q) !== 1 (mod p)` for every prime factor `q` of `p - 1`.
+ *
+ * @param p - An odd prime (p = 2 returns 1 trivially)
+ * @returns The smallest primitive root modulo p
+ *
+ * @example
+ * primitiveRoot(7) // => 3
+ */
+export declare function primitiveRoot(p: number): number;
+/**
+ * Multiplicative order of `a` modulo `n`: the smallest `k > 0` with
+ * `a^k === 1 (mod n)`. Returns `-1` if `gcd(a, n) !== 1` (no order exists).
+ *
+ * @param a - Integer
+ * @param n - Positive integer modulus
+ * @returns The multiplicative order, or -1 if undefined
+ *
+ * @example
+ * multiplicativeOrder(2, 7) // => 3
+ */
+export declare function multiplicativeOrder(a: number, n: number): number;
+/**
+ * Kronecker symbol `(a|n)`, generalizing the Jacobi symbol `(a|n)` (odd
+ * positive `n`) to all integers `n`.
+ *
+ * - `(a|0) = 1` if `|a| = 1`, else `0`.
+ * - Sign of `n` is extracted first: `(a|-1) = -1` if `a < 0`, else `1`.
+ * - Factors of 2 are extracted from `n` using `(a|2)`: `0` if `a` even,
+ *   `1` if `a === ±1 (mod 8)`, `-1` if `a === ±3 (mod 8)`.
+ * - The remaining odd part is evaluated via the standard Jacobi reciprocity
+ *   recursion.
+ *
+ * @param a - Integer
+ * @param n - Integer
+ * @returns -1, 0, or 1
+ *
+ * @example
+ * kroneckerSymbol(2, 3) // => -1
+ */
+export declare function kroneckerSymbol(a: number, n: number): number;
+/**
+ * Enumerate all length-`k` combinations of `arr` (index-order subsequences,
+ * i.e. lexicographic order for a sorted input) as an array of tuples.
+ *
+ * @param arr - Source array
+ * @param k - Combination length
+ * @returns All `C(arr.length, k)` combinations, in lexicographic order
+ *
+ * @example
+ * combinationsGen([1, 2, 3], 2) // => [[1,2],[1,3],[2,3]]
+ */
+export declare function combinationsGen<T>(arr: readonly T[], k: number): T[][];
+/**
+ * Enumerate all length-`k` permutations (ordered arrangements) of `arr`
+ * as an array of tuples, in lexicographic order of index selection.
+ * `k` defaults to `arr.length` (full permutations).
+ *
+ * @param arr - Source array
+ * @param k - Permutation length (default: `arr.length`)
+ * @returns All `n! / (n-k)!` permutations, in lexicographic order
+ *
+ * @example
+ * permutationsGen([1, 2, 3], 2) // => 6 tuples: [1,2],[1,3],[2,1],[2,3],[3,1],[3,2]
+ */
+export declare function permutationsGen<T>(arr: readonly T[], k?: number): T[][];
+//# sourceMappingURL=extra.d.ts.map

package/dist/numbertheory/extra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extra.d.ts","sourceRoot":"","sources":["../../src/numbertheory/extra.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,SAAK,GAAG,MAAM,EAAE,CAcpE;AAiBD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBhD;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAevD;AAqCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CA+BnE;AAoBD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAmB/C;AAeD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAehE;AAaD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CA0C5D;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,CAoBtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,GAAE,MAAmB,GAAG,CAAC,EAAE,EAAE,CAwBnF"}

package/dist/numeric/gauss-nodes.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Gauss-Legendre quadrature nodes and weights.
+ *
+ * `rootsLegendre(n)` finds the n roots of the degree-n Legendre polynomial
+ * P_n via Newton's method (initial guess from the standard asymptotic
+ * approximation), then derives the corresponding quadrature weights. This is
+ * the classical fixed-node table underlying Gauss-Legendre quadrature on
+ * [-1, 1]; callers needing a custom node count (rather than the library's
+ * built-in fixed-order `integrate`/`gaussLegendre` routines) use this
+ * directly.
+ *
+ * @packageDocumentation
+ */
+/** Result of {@link rootsLegendre}: nodes ascending on [-1, 1] with matching weights. */
+export interface RootsLegendreResult {
+    nodes: number[];
+    weights: number[];
+}
+/**
+ * n-point Gauss-Legendre quadrature nodes and weights on [-1, 1].
+ *
+ * Nodes are the roots of the degree-n Legendre polynomial P_n, refined by
+ * Newton's method from the standard asymptotic initial guess
+ * `cos(pi*(i+0.75)/(n+0.5))`. Weights are `2 / ((1-x_i^2) * P'_n(x_i)^2)`.
+ *
+ * @param n - Number of quadrature points (positive integer)
+ * @returns Nodes (ascending) and matching weights
+ *
+ * @example
+ * rootsLegendre(3)
+ * // { nodes: [-0.7745966692, 0, 0.7745966692],
+ * //   weights: [0.5555555556, 0.8888888889, 0.5555555556] }
+ */
+export declare function rootsLegendre(n: number): RootsLegendreResult;
+//# sourceMappingURL=gauss-nodes.d.ts.map

package/dist/numeric/gauss-nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gauss-nodes.d.ts","sourceRoot":"","sources":["../../src/numeric/gauss-nodes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,yFAAyF;AACzF,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAuBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,mBAAmB,CA+B5D"}

package/dist/special/hypergeometric.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Hypergeometric functions.
+ *
+ * Implements the generalized hypergeometric series pFq via the ascending
+ * Pochhammer-ratio method: each term is generated from the previous one by
+ * multiplying by the ratio of rising factorials,
+ *
+ *   term_{n+1} / term_n = ( prod_i (a_i + n) / prod_j (b_j + n) ) * z / (n + 1)
+ *
+ * accumulating until the term becomes negligible relative to the running sum
+ * (|term| < 1e-16 * |sum|) or a hard iteration cap is hit. This incremental
+ * form avoids recomputing factorials/Pochhammer symbols from scratch at each
+ * order and is numerically well-behaved for the convergent regimes documented
+ * per function below.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Generalized hypergeometric function pFq(a; b; z), computed via the
+ * ascending Pochhammer-ratio series:
+ *
+ *   pFq(a_1..a_p; b_1..b_q; z) = sum_{n=0}^inf
+ *     ( prod_i (a_i)_n / prod_j (b_j)_n ) * z^n / n!
+ *
+ * This is the generic engine that hyp0f1/hyp1f1/hyp2f1 delegate to. No
+ * convergence-region check is performed here (that is the caller's
+ * responsibility, see hyp2f1's |z| < 1 guard) — the series is simply summed
+ * until it converges to machine precision or MAX_TERMS is reached.
+ *
+ * @param a - Upper (numerator) parameters
+ * @param b - Lower (denominator) parameters
+ * @param z - Argument
+ * @returns pFq(a; b; z)
+ */
+export declare function pFq(a: number[], b: number[], z: number): number;
+/**
+ * Confluent hypergeometric limit function 0F1(; b; z):
+ *
+ *   hyp0f1(b, z) = sum_{n=0}^inf z^n / ((b)_n n!)
+ *
+ * Entire in z (converges for all finite z, real or otherwise real-valued
+ * here); related to the Bessel functions.
+ *
+ * @param b - Parameter
+ * @param z - Argument
+ * @returns 0F1(; b; z)
+ *
+ * @example
+ * hyp0f1(2, 0.5) // ~1.2717234563
+ */
+export declare function hyp0f1(b: number, z: number): number;
+/**
+ * Kummer's confluent hypergeometric function 1F1(a; b; z) (Kummer's M):
+ *
+ *   hyp1f1(a, b, z) = sum_{n=0}^inf ( (a)_n / (b)_n ) * z^n / n!
+ *
+ * Entire in z. The direct ascending series targets moderate |z| — for large
+ * |z| the series requires many terms and loses accuracy to cancellation
+ * (particularly when a and b have opposite signs); an asymptotic expansion
+ * would be needed for large |z| but is not implemented here.
+ *
+ * @param a - Numerator parameter
+ * @param b - Denominator parameter
+ * @param z - Argument
+ * @returns 1F1(a; b; z)
+ *
+ * @example
+ * hyp1f1(1, 2, 0.5) // ~1.2974425414
+ */
+export declare function hyp1f1(a: number, b: number, z: number): number;
+/**
+ * Gauss's hypergeometric function 2F1(a, b; c; z):
+ *
+ *   hyp2f1(a, b, c, z) = sum_{n=0}^inf ( (a)_n (b)_n / (c)_n ) * z^n / n!
+ *
+ * The ascending series converges only for |z| < 1. Analytic continuation
+ * beyond the unit disk (e.g. via connection formulas or a transformation to
+ * 1-z) is not yet implemented.
+ *
+ * @param a - First numerator parameter
+ * @param b - Second numerator parameter
+ * @param c - Denominator parameter
+ * @param z - Argument, must satisfy |z| < 1
+ * @returns 2F1(a, b; c; z)
+ * @throws {Error} If |z| >= 1
+ *
+ * @example
+ * hyp2f1(1, 2, 3, 0.5) // ~1.5451774445
+ */
+export declare function hyp2f1(a: number, b: number, c: number, z: number): number;
+//# sourceMappingURL=hypergeometric.d.ts.map

package/dist/special/hypergeometric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hypergeometric.d.ts","sourceRoot":"","sources":["../../src/special/hypergeometric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgB/D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKzE"}

package/dist/special/jacobi-elliptic.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Jacobi elliptic functions sn, cn, dn.
+ *
+ * Uses the parameter convention `m = k^2` (matching scipy's
+ * `scipy.special.ellipj(u, m)` and mpmath's `ellipfun(..., u, m)`), not the
+ * modulus-angle convention some texts use.
+ *
+ * Computed via the descending Landen transformation / arithmetic-geometric
+ * mean (AGM) method (Abramowitz & Stegun 16.4, the Bulirsch algorithm):
+ * build the AGM sequences
+ *
+ *   a_0 = 1, b_0 = sqrt(1 - m), c_0 = sqrt(m)
+ *   a_{i+1} = (a_i + b_i) / 2
+ *   b_{i+1} = sqrt(a_i * b_i)
+ *   c_{i+1} = (a_i - b_i) / 2
+ *
+ * until c_N is negligible, then descend the amplitude
+ *
+ *   phi_N = 2^N * a_N * u
+ *   phi_{i-1} = (phi_i + asin((c_i / a_i) * sin(phi_i))) / 2   for i = N..1
+ *
+ * so that sn(u,m) = sin(phi_0), cn(u,m) = cos(phi_0),
+ * dn(u,m) = sqrt(1 - m * sn^2(u,m)).
+ *
+ * @packageDocumentation
+ */
+/**
+ * Jacobi elliptic function sn(u, m), parameter convention m = k^2.
+ *
+ * @param u - Argument
+ * @param m - Parameter m = k^2, must be in [0, 1]
+ * @returns sn(u, m)
+ *
+ * @example
+ * jacobiSN(0.5, 0.3) // ~0.4742156227
+ */
+export declare function jacobiSN(u: number, m: number): number;
+/**
+ * Jacobi elliptic function cn(u, m), parameter convention m = k^2.
+ *
+ * @param u - Argument
+ * @param m - Parameter m = k^2, must be in [0, 1]
+ * @returns cn(u, m)
+ *
+ * @example
+ * jacobiCN(0.5, 0.3) // ~0.8804087364
+ */
+export declare function jacobiCN(u: number, m: number): number;
+/**
+ * Jacobi elliptic function dn(u, m), parameter convention m = k^2.
+ *
+ * @param u - Argument
+ * @param m - Parameter m = k^2, must be in [0, 1]
+ * @returns dn(u, m)
+ *
+ * @example
+ * jacobiDN(0.5, 0.3) // ~0.9656789647
+ */
+export declare function jacobiDN(u: number, m: number): number;
+//# sourceMappingURL=jacobi-elliptic.d.ts.map

package/dist/special/jacobi-elliptic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jacobi-elliptic.d.ts","sourceRoot":"","sources":["../../src/special/jacobi-elliptic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAwDH;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD"}

package/dist/special/polygamma-orthopoly.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Polygamma functions and classical orthogonal polynomials.
+ *
+ * `polygamma(n, x)` is the n-th derivative of the digamma function,
+ * ψ^(n)(x) = d^n/dx^n ψ(x). It is computed by shifting the argument up via
+ * the standard recurrence
+ *
+ *   ψ^(n)(x) = ψ^(n)(x + m) + (-1)^(n+1) n! * sum_{k=0}^{m-1} 1/(x+k)^(n+1)
+ *
+ * until x + m is large enough (>= SHIFT_THRESHOLD) for the asymptotic
+ * (Bernoulli) expansion (DLMF 5.15.8) to converge to machine precision:
+ *
+ *   psi^(n)(X) ~ (-1)^(n-1) * [ (n-1)!/X^n + n!/(2 X^(n+1))
+ *                 + sum_j B_{2j} * (2j+n-1)! / ((2j)! * X^(2j+n)) ]
+ *
+ * Since (-1)^(n+1) = (-1)^(n-1), both pieces share the same overall sign.
+ *
+ * `jacobiP` and `gegenbauerC` are evaluated with their standard stable
+ * three-term recurrences (DLMF 18.9.2 and 18.9.1 respectively), matching the
+ * pattern already used for `chebyshevT` / `hermiteH` / `laguerreL` /
+ * `legendreP`.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Polygamma function ψ^(n)(x): the n-th derivative of the digamma function.
+ *
+ * `polygamma(0, x)` delegates to `digamma(x)`. For `n >= 1`, x is shifted up
+ * via the standard recurrence until it is large enough for the Bernoulli
+ * asymptotic expansion to converge.
+ *
+ * @param n - Derivative order (nonnegative integer)
+ * @param x - Argument (must not be a nonpositive integer, where ψ^(n) has poles)
+ * @returns ψ^(n)(x)
+ *
+ * @example
+ * polygamma(1, 2) // ~0.6449340668 (trigamma(2))
+ * polygamma(2, 1) // ~-2.4041138063
+ */
+export declare function polygamma(n: number, x: number): number;
+/**
+ * Trigamma function ψ'(x) = ψ^(1)(x): the first derivative of the digamma
+ * function. Equivalent to `polygamma(1, x)`.
+ *
+ * @param x - Argument
+ * @returns ψ'(x)
+ *
+ * @example
+ * trigamma(2) // ~0.6449340668 (= zeta(2) - 1 = pi^2/6 - 1)
+ */
+export declare function trigamma(x: number): number;
+/**
+ * Jacobi polynomial P_n^(alpha,beta)(x), evaluated via the standard
+ * three-term recurrence (DLMF 18.9.2).
+ *
+ * @param n - Degree (nonnegative integer)
+ * @param alpha - Parameter alpha (> -1)
+ * @param beta - Parameter beta (> -1)
+ * @param x - Evaluation point
+ * @returns P_n^(alpha,beta)(x)
+ *
+ * @example
+ * jacobiP(2, 1, 1, 0.5) // 0.1875
+ */
+export declare function jacobiP(n: number, alpha: number, beta: number, x: number): number;
+/**
+ * Gegenbauer (ultraspherical) polynomial C_n^(alpha)(x), evaluated via the
+ * standard three-term recurrence (DLMF 18.9.1).
+ *
+ * @param n - Degree (nonnegative integer)
+ * @param alpha - Parameter alpha (> -1/2, alpha != 0)
+ * @param x - Evaluation point
+ * @returns C_n^(alpha)(x)
+ *
+ * @example
+ * gegenbauerC(2, 1, 1) // 3 (C_2^(1)(x) = 4x^2 - 1)
+ */
+export declare function gegenbauerC(n: number, alpha: number, x: number): number;
+//# sourceMappingURL=polygamma-orthopoly.d.ts.map

package/dist/special/polygamma-orthopoly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygamma-orthopoly.d.ts","sourceRoot":"","sources":["../../src/special/polygamma-orthopoly.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAiBH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAkCtD;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAqBjF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgBvE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",