@danielsimonjr/mathts-functions 0.2.10 → 0.2.11

package/dist/index.js

@@ -5057,36 +5057,102 @@ function ellipticEDispatch(ms) {
   }
   return ellipticEJS(ms);
 }
+var _SF_GAMMA = 0.5772156649015329;
+var _SF_2_PI = 0.6366197723675814;
+var _SF_1_PI = 0.3183098861837907;
+var _BESSEL_SERIES_MAX = 13;
+function _besselHankel(nu, x, wantY) {
+  const mu = 4 * nu * nu;
+  let P2 = 1;
+  let Q2 = 0;
+  let a = 1;
+  let xk = 1;
+  let prevMag = Infinity;
+  for (let k = 1; k <= 40; k++) {
+    const t1 = 2 * k - 1;
+    a = a * (mu - t1 * t1) / (8 * k);
+    xk *= x;
+    const t = a / xk;
+    if (Math.abs(t) > prevMag) break;
+    prevMag = Math.abs(t);
+    const m4 = k & 3;
+    const s = m4 === 1 || m4 === 0 ? 1 : -1;
+    if ((k & 1) === 1) Q2 += s * t;
+    else P2 += s * t;
+  }
+  const chi = x - (nu * 0.5 + 0.25) * Math.PI;
+  const amp = Math.sqrt(2 / (Math.PI * x));
+  return wantY ? amp * (P2 * Math.sin(chi) + Q2 * Math.cos(chi)) : amp * (P2 * Math.cos(chi) - Q2 * Math.sin(chi));
+}
+function _besselJ0Series(x) {
+  const z = -0.25 * x * x;
+  let term = 1;
+  let sum2 = 1;
+  for (let k = 1; k <= 80; k++) {
+    term *= z / (k * k);
+    sum2 += term;
+    if (Math.abs(term) <= Math.abs(sum2) * 1e-17) break;
+  }
+  return sum2;
+}
+function _besselJ1Series(x) {
+  const z = -0.25 * x * x;
+  let term = 1;
+  let sum2 = 1;
+  for (let k = 1; k <= 80; k++) {
+    term *= z / (k * (k + 1));
+    sum2 += term;
+    if (Math.abs(term) <= Math.abs(sum2) * 1e-17) break;
+  }
+  return 0.5 * x * sum2;
+}
+function _besselY0Series(x) {
+  const z = 0.25 * x * x;
+  let u = 1;
+  let h = 0;
+  let s = 0;
+  let sign3 = 1;
+  for (let k = 1; k <= 80; k++) {
+    u *= z / (k * k);
+    h += 1 / k;
+    s += sign3 * h * u;
+    sign3 = -sign3;
+    if (k > 2 && Math.abs(h * u) <= Math.abs(s) * 1e-17) break;
+  }
+  return _SF_2_PI * ((Math.log(0.5 * x) + _SF_GAMMA) * _besselJ0Series(x) + s);
+}
+function _besselY1Series(x) {
+  const z = -0.25 * x * x;
+  let v = 0.5 * x;
+  let hk = 0;
+  let hk1 = 1;
+  let s = (hk + hk1) * v;
+  for (let k = 1; k <= 80; k++) {
+    v *= z / (k * (k + 1));
+    hk += 1 / k;
+    hk1 += 1 / (k + 1);
+    s += (hk + hk1) * v;
+    if (k > 2 && Math.abs((hk + hk1) * v) <= Math.abs(s) * 1e-17) break;
+  }
+  return _SF_2_PI * (Math.log(0.5 * x) + _SF_GAMMA) * _besselJ1Series(x) - _SF_2_PI / x - _SF_1_PI * s;
+}
 function _besselJ0(x) {
-  x = Math.abs(x);
-  if (x < 8) {
-    const y2 = x * x;
-    const a12 = 57568490574 + y2 * (-13362590354 + y2 * (6516196407e-1 + y2 * (-1121442418e-2 + y2 * (77392.33017 + y2 * -184.9052456))));
-    const a22 = 57568490411 + y2 * (1029532985 + y2 * (9494680718e-3 + y2 * (59272.64853 + y2 * (267.8532712 + y2))));
-    return a12 / a22;
-  }
-  const z = 8 / x;
-  const y = z * z;
-  const xx = x - 0.785398164;
-  const a1 = 1 + y * (-0.001098628627 + y * (2734510407e-14 + y * (-2073370639e-15 + y * 2093887211e-16)));
-  const a2 = -0.01562499995 + y * (1430488765e-13 + y * (-6911147651e-15 + y * (7621095161e-16 - y * 934935152e-16)));
-  return Math.sqrt(0.636619772 / x) * (Math.cos(xx) * a1 - z * Math.sin(xx) * a2);
+  const ax = Math.abs(x);
+  return ax <= _BESSEL_SERIES_MAX ? _besselJ0Series(ax) : _besselHankel(0, ax, false);
 }
 function _besselJ1(x) {
+  const ax = Math.abs(x);
   const sign3 = x < 0 ? -1 : 1;
-  x = Math.abs(x);
-  if (x < 8) {
-    const y2 = x * x;
-    const a12 = x * (72362614232 + y2 * (-7895059235 + y2 * (2423968531e-1 + y2 * (-2972611439e-3 + y2 * (15704.4826 + y2 * -30.16036606)))));
-    const a22 = 144725228442 + y2 * (2300535178 + y2 * (1858330474e-2 + y2 * (99447.43394 + y2 * (376.9991397 + y2))));
-    return sign3 * a12 / a22;
-  }
-  const z = 8 / x;
-  const y = z * z;
-  const xx = x - 2.356194491;
-  const a1 = 1 + y * (183105e-8 + y * (-3516396496e-14 + y * (2457520174e-15 - y * 2404127372e-16)));
-  const a2 = 0.04687499995 + y * (-2002690873e-13 + y * (8449199096e-15 + y * (-8820898866e-16 + y * 1057874125e-16)));
-  return sign3 * Math.sqrt(0.636619772 / x) * (Math.cos(xx) * a1 - z * Math.sin(xx) * a2);
+  const val = ax <= _BESSEL_SERIES_MAX ? _besselJ1Series(ax) : _besselHankel(1, ax, false);
+  return sign3 * val;
+}
+function _besselY0(x) {
+  if (x <= 0) return NaN;
+  return x <= _BESSEL_SERIES_MAX ? _besselY0Series(x) : _besselHankel(0, x, true);
+}
+function _besselY1(x) {
+  if (x <= 0) return NaN;
+  return x <= _BESSEL_SERIES_MAX ? _besselY1Series(x) : _besselHankel(1, x, true);
 }
 function _besselJn(n, x) {
   const ni = Math.abs(Math.round(n));
@@ -5094,7 +5160,7 @@ function _besselJn(n, x) {
   if (ni === 0) return sign3 * _besselJ0(x);
   if (ni === 1) return sign3 * _besselJ1(x);
   if (Math.abs(x) < 1e-15) return 0;
-  if (ni <= 20 || Math.abs(x) > ni) {
+  if (Math.abs(x) > ni) {
     let jPrev = _besselJ0(x);
     let jCurr2 = _besselJ1(x);
     for (let k = 1; k < ni; k++) {
@@ -5114,42 +5180,12 @@ function _besselJn(n, x) {
     const jPrev = 2 * (k + 1) / x * jCurr - jNext;
     jNext = jCurr;
     jCurr = jPrev;
-    if (k === ni) resultVal = jNext;
+    if (k === ni) resultVal = jCurr;
     if (k % 2 === 0) sum2 += jCurr;
   }
   sum2 = 2 * sum2 - jCurr;
   return sign3 * (resultVal / sum2);
 }
-function _besselY0(x) {
-  if (x <= 0) return NaN;
-  if (x < 8) {
-    const y2 = x * x;
-    const a12 = -2957821389 + y2 * (7062834065 + y2 * (-5123598036e-1 + y2 * (1087988129e-2 + y2 * (-86327.92757 + y2 * 228.4622733))));
-    const a22 = 40076544269 + y2 * (7452499648e-1 + y2 * (7189466438e-3 + y2 * (47447.2647 + y2 * (226.1030244 + y2))));
-    return a12 / a22 + 0.636619772 * _besselJ0(x) * Math.log(x);
-  }
-  const z = 8 / x;
-  const y = z * z;
-  const xx = x - 0.785398164;
-  const a1 = 1 + y * (-0.001098628627 + y * (2734510407e-14 + y * (-2073370639e-15 + y * 2093887211e-16)));
-  const a2 = -0.01562499995 + y * (1430488765e-13 + y * (-6911147651e-15 + y * (7621095161e-16 - y * 934935152e-16)));
-  return Math.sqrt(0.636619772 / x) * (Math.sin(xx) * a1 + z * Math.cos(xx) * a2);
-}
-function _besselY1(x) {
-  if (x <= 0) return NaN;
-  if (x < 8) {
-    const y2 = x * x;
-    const a12 = x * (-4900604943e3 + y2 * (127527439e4 + y2 * (-51534381390 + y2 * (7349264551e-1 + y2 * (-4237922726e-3 + y2 * 8511.937935)))));
-    const a22 = 2490985738e4 + y2 * (424441966400 + y2 * (3733650367 + y2 * (2245904002e-2 + y2 * (102042.605 + y2 * (354.9632885 + y2)))));
-    return a12 / a22 + 0.636619772 * (_besselJ1(x) * Math.log(x) - 1 / x);
-  }
-  const z = 8 / x;
-  const y = z * z;
-  const xx = x - 2.356194491;
-  const a1 = 1 + y * (183105e-8 + y * (-3516396496e-14 + y * (2457520174e-15 - y * 2404127372e-16)));
-  const a2 = 0.04687499995 + y * (-2002690873e-13 + y * (8449199096e-15 + y * (-8820898866e-16 + y * 1057874125e-16)));
-  return Math.sqrt(0.636619772 / x) * (Math.sin(xx) * a1 + z * Math.cos(xx) * a2);
-}
 function _besselYn(n, x) {
   if (x <= 0) return NaN;
   const ni = Math.abs(Math.round(n));
@@ -5167,16 +5203,14 @@ function _besselYn(n, x) {
 }
 var _AI0 = 0.3550280538878172;
 var _AI_PRIME0 = 0.2588194037928068;
-var _XBIG = 4.5;
-var _AIRY_C = [
-  1,
-  5 / 72,
-  385 / 10368,
-  85085 / 2239488,
-  37182145 / 644972544,
-  576576001025e-2 / 61917364224,
-  1519768071625 / 8918845788160
-];
+var _XBIG = 5;
+var _AIRY_U = (() => {
+  const u = [1];
+  for (let k = 1; k <= 12; k++) {
+    u.push(u[k - 1] * ((6 * k - 5) * (6 * k - 3) * (6 * k - 1)) / ((2 * k - 1) * 216 * k));
+  }
+  return u;
+})();
 function _airyAiSeries(x) {
   const x3 = x * x * x;
   let f = 1;
@@ -5187,7 +5221,7 @@ function _airyAiSeries(x) {
   let factG = 1;
   let prodF = 1;
   let prodG = 1;
-  for (let k = 1; k <= 30; k++) {
+  for (let k = 1; k <= 40; k++) {
     factF *= (3 * k - 2) * (3 * k - 1) * (3 * k);
     factG *= (3 * k - 1) * (3 * k) * (3 * k + 1);
     prodF *= 3 * k - 2;
@@ -5202,41 +5236,6 @@ function _airyAiSeries(x) {
   }
   return _AI0 * f - _AI_PRIME0 * g;
 }
-function _airyAiLargePos(x) {
-  const xp = Math.pow(x, 0.25);
-  const zeta2 = 2 / 3 * x * Math.sqrt(x);
-  let p = 0;
-  let zk = 1;
-  let sign3 = 1;
-  for (const ck of _AIRY_C) {
-    p += sign3 * ck / zk;
-    zk *= zeta2;
-    sign3 = -sign3;
-  }
-  return Math.exp(-zeta2) * p / (2 * Math.sqrt(Math.PI) * xp);
-}
-function _airyAiLargeNeg(x) {
-  const ax = Math.abs(x);
-  const axp = Math.pow(ax, 0.25);
-  const zeta2 = 2 / 3 * ax * Math.sqrt(ax);
-  const theta = zeta2 - Math.PI / 4;
-  let p = 0;
-  let q = 0;
-  let zk = 1;
-  let sign3 = 1;
-  for (let k = 0; k < _AIRY_C.length; k++) {
-    if (k % 2 === 0) p += sign3 * _AIRY_C[k] / zk;
-    else q += sign3 * _AIRY_C[k] / zk;
-    zk *= zeta2;
-    sign3 = -sign3;
-  }
-  return (Math.sin(theta) * p + Math.cos(theta) * q) / (Math.sqrt(Math.PI) * axp);
-}
-function _airyAi(x) {
-  if (x > _XBIG) return _airyAiLargePos(x);
-  if (x < -_XBIG) return _airyAiLargeNeg(x);
-  return _airyAiSeries(x);
-}
 function _airyBiSeries(x) {
   const x3 = x * x * x;
   let f = 1;
@@ -5247,7 +5246,7 @@ function _airyBiSeries(x) {
   let factG = 1;
   let prodF = 1;
   let prodG = 1;
-  for (let k = 1; k <= 30; k++) {
+  for (let k = 1; k <= 40; k++) {
     factF *= (3 * k - 2) * (3 * k - 1) * (3 * k);
     factG *= (3 * k - 1) * (3 * k) * (3 * k + 1);
     prodF *= 3 * k - 2;
@@ -5262,63 +5261,90 @@ function _airyBiSeries(x) {
   }
   return Math.sqrt(3) * (_AI0 * f + _AI_PRIME0 * g);
 }
-function _airyBiLargePos(x) {
+function _airyAsymPos(x, isAi) {
   const xp = Math.pow(x, 0.25);
   const zeta2 = 2 / 3 * x * Math.sqrt(x);
   let p = 0;
   let zk = 1;
-  for (const ck of _AIRY_C) {
-    p += ck / zk;
+  let sign3 = 1;
+  let prevMag = Infinity;
+  for (const uk of _AIRY_U) {
+    const t = uk / zk;
+    if (Math.abs(t) > prevMag) break;
+    prevMag = Math.abs(t);
+    p += isAi ? sign3 * t : t;
     zk *= zeta2;
+    sign3 = -sign3;
   }
-  return Math.exp(zeta2) * p / (Math.sqrt(Math.PI) * xp);
+  const sp = Math.sqrt(Math.PI);
+  return isAi ? Math.exp(-zeta2) * p / (2 * sp * xp) : Math.exp(zeta2) * p / (sp * xp);
 }
-function _airyBiLargeNeg(x) {
+function _airyAsymNeg(x, isAi) {
   const ax = Math.abs(x);
   const axp = Math.pow(ax, 0.25);
   const zeta2 = 2 / 3 * ax * Math.sqrt(ax);
-  const theta = zeta2 + Math.PI / 4;
-  let p = 0;
-  let q = 0;
-  let zk = 1;
-  let sign3 = 1;
-  for (let k = 0; k < _AIRY_C.length; k++) {
-    if (k % 2 === 0) p += sign3 * _AIRY_C[k] / zk;
-    else q += sign3 * _AIRY_C[k] / zk;
-    zk *= zeta2;
-    sign3 = -sign3;
+  let P2 = 0;
+  let Q2 = 0;
+  let pTerm = Infinity;
+  let qTerm = Infinity;
+  const half = Math.floor((_AIRY_U.length - 1) / 2);
+  for (let k = 0; k <= half; k++) {
+    const t = (k % 2 === 0 ? 1 : -1) * _AIRY_U[2 * k] / Math.pow(zeta2, 2 * k);
+    if (Math.abs(t) > Math.abs(pTerm)) break;
+    P2 += t;
+    pTerm = t;
   }
-  return (Math.cos(theta) * p + Math.sin(theta) * q) / (Math.sqrt(Math.PI) * axp);
+  for (let k = 0; k <= half - 1; k++) {
+    const t = (k % 2 === 0 ? 1 : -1) * _AIRY_U[2 * k + 1] / Math.pow(zeta2, 2 * k + 1);
+    if (Math.abs(t) > Math.abs(qTerm)) break;
+    Q2 += t;
+    qTerm = t;
+  }
+  const theta = zeta2 - Math.PI / 4;
+  const sp = Math.sqrt(Math.PI);
+  return isAi ? (Math.cos(theta) * P2 + Math.sin(theta) * Q2) / (sp * axp) : (-Math.sin(theta) * P2 + Math.cos(theta) * Q2) / (sp * axp);
+}
+function _airyAi(x) {
+  if (x > _XBIG) return _airyAsymPos(x, true);
+  if (x < -_XBIG) return _airyAsymNeg(x, true);
+  return _airyAiSeries(x);
 }
 function _airyBi(x) {
-  if (x > _XBIG) return _airyBiLargePos(x);
-  if (x < -_XBIG) return _airyBiLargeNeg(x);
+  if (x > _XBIG) return _airyAsymPos(x, false);
+  if (x < -_XBIG) return _airyAsymNeg(x, false);
   return _airyBiSeries(x);
 }
 
 // src/typed/special.ts
-function _erf(x) {
-  if (x === 0) return 0;
-  if (!isFinite(x)) return x > 0 ? 1 : -1;
-  const sign3 = x < 0 ? -1 : 1;
-  const a = Math.abs(x);
-  if (a <= 0.5) {
-    const c = 2 / Math.sqrt(Math.PI);
-    let sum2 = a;
-    let term = a;
-    for (let n = 1; n < 50; n++) {
-      term *= -a * a / n;
-      const inc = term / (2 * n + 1);
-      sum2 += inc;
-      if (Math.abs(inc) < Math.abs(sum2) * 1e-16) break;
-    }
-    return sign3 * c * sum2;
-  }
-  const t = 2 / (2 + a);
-  const ans = t * Math.exp(
-    -a * a - 1.26551223 + t * (1.00002368 + t * (0.37409196 + t * (0.09678418 + t * (-0.18628806 + t * (0.27886807 + t * (-1.13520398 + t * (1.48851587 + t * (-0.82215223 + t * 0.17087277))))))))
-  );
-  return sign3 * (1 - ans);
+function _erfSeries(a) {
+  const c = 2 / Math.sqrt(Math.PI);
+  let sum2 = a;
+  let term = a;
+  for (let n = 1; n < 80; n++) {
+    term *= -a * a / n;
+    const inc = term / (2 * n + 1);
+    sum2 += inc;
+    if (Math.abs(inc) < Math.abs(sum2) * 1e-17) break;
+  }
+  return c * sum2;
+}
+function _erfcCF(a) {
+  const tiny = 1e-300;
+  let f = a < tiny ? tiny : a;
+  let C = f;
+  let D = 0;
+  for (let i = 1; i <= 300; i++) {
+    const ai = i / 2;
+    D = a + ai * D;
+    if (D === 0) D = tiny;
+    D = 1 / D;
+    C = a + ai / C;
+    if (C === 0) C = tiny;
+    const delta = C * D;
+    f *= delta;
+    if (Math.abs(delta - 1) < 1e-16) break;
+  }
+  return Math.exp(-a * a) / Math.sqrt(Math.PI) / f;
 }
 function _lgamma2(x) {
   if (x <= 0 && x === Math.floor(x)) return Infinity;
@@ -5352,7 +5378,9 @@ function factorial(n) {
   return r;
 }
 function erfcScalar(x) {
-  return 1 - _erf(x);
+  if (!isFinite(x)) return x > 0 ? 0 : 2;
+  if (x < 0) return 2 - erfcScalar(-x);
+  return x < 1.5 ? 1 - _erfSeries(x) : _erfcCF(x);
 }
 function erfiScalar(x) {
   const c = 2 / Math.sqrt(Math.PI);
@@ -5426,72 +5454,101 @@ function digammaScalar(x) {
   }
   return result;
 }
+function besselHankel(nu, x, wantY) {
+  const mu = 4 * nu * nu;
+  let P2 = 1;
+  let Q2 = 0;
+  let a = 1;
+  let xk = 1;
+  let prevMag = Infinity;
+  for (let k = 1; k <= 40; k++) {
+    const twokm1 = 2 * k - 1;
+    a = a * (mu - twokm1 * twokm1) / (8 * k);
+    xk *= x;
+    const t = a / xk;
+    const mag = Math.abs(t);
+    if (mag > prevMag) break;
+    prevMag = mag;
+    const m4 = k & 3;
+    const s = m4 === 1 || m4 === 0 ? 1 : -1;
+    if ((k & 1) === 1) Q2 += s * t;
+    else P2 += s * t;
+  }
+  const chi = x - (nu * 0.5 + 0.25) * Math.PI;
+  const amp = Math.sqrt(2 / (Math.PI * x));
+  return wantY ? amp * (P2 * Math.sin(chi) + Q2 * Math.cos(chi)) : amp * (P2 * Math.cos(chi) - Q2 * Math.sin(chi));
+}
+function besselJ0Series(x) {
+  const z = -0.25 * x * x;
+  let term = 1;
+  let sum2 = 1;
+  for (let k = 1; k <= 80; k++) {
+    term *= z / (k * k);
+    sum2 += term;
+    if (Math.abs(term) <= Math.abs(sum2) * 1e-17) break;
+  }
+  return sum2;
+}
+function besselJ1Series(x) {
+  const z = -0.25 * x * x;
+  let term = 1;
+  let sum2 = 1;
+  for (let k = 1; k <= 80; k++) {
+    term *= z / (k * (k + 1));
+    sum2 += term;
+    if (Math.abs(term) <= Math.abs(sum2) * 1e-17) break;
+  }
+  return 0.5 * x * sum2;
+}
+function besselY0Series(x) {
+  const z = 0.25 * x * x;
+  let u = 1;
+  let h = 0;
+  let s = 0;
+  let sign3 = 1;
+  for (let k = 1; k <= 80; k++) {
+    u *= z / (k * k);
+    h += 1 / k;
+    const d = sign3 * h * u;
+    s += d;
+    sign3 = -sign3;
+    if (k > 2 && Math.abs(d) <= Math.abs(s) * 1e-17) break;
+  }
+  return 0.6366197723675814 * ((Math.log(0.5 * x) + 0.5772156649015329) * besselJ0Series(x) + s);
+}
+function besselY1Series(x) {
+  const z = -0.25 * x * x;
+  let v = 0.5 * x;
+  let hk = 0;
+  let hk1 = 1;
+  let s = (hk + hk1) * v;
+  for (let k = 1; k <= 80; k++) {
+    v *= z / (k * (k + 1));
+    hk += 1 / k;
+    hk1 += 1 / (k + 1);
+    const d = (hk + hk1) * v;
+    s += d;
+    if (k > 2 && Math.abs(d) <= Math.abs(s) * 1e-17) break;
+  }
+  return 0.6366197723675814 * (Math.log(0.5 * x) + 0.5772156649015329) * besselJ1Series(x) - 0.6366197723675814 / x - 0.3183098861837907 * s;
+}
 function besselJ0Scalar(x) {
-  if (x === 0) return 1;
   const ax = Math.abs(x);
-  if (ax < 8) {
-    const y = x * x;
-    const r1 = 57568490574 + y * (-13362590354 + y * (6516196407e-1 + y * (-1121442418e-2 + y * (77392.33017 + y * -184.9052456))));
-    const r2 = 57568490411 + y * (1029532985 + y * (9494680718e-3 + y * (59272.64853 + y * (267.8532712 + y * 1))));
-    return r1 / r2;
-  } else {
-    const z = 8 / ax;
-    const y = z * z;
-    const xx = ax - 0.785398164;
-    const p0 = 1 + y * (-0.001098628627 + y * (2734510407e-14 + y * (-2073370639e-15 + y * 2093887211e-16)));
-    const q0 = -0.01562499995 + y * (1430488765e-13 + y * (-6911147651e-15 + y * (7621095161e-16 - y * 934935152e-16)));
-    return Math.sqrt(0.636619772 / ax) * (p0 * Math.cos(xx) - z * q0 * Math.sin(xx));
-  }
+  return ax <= 13 ? besselJ0Series(ax) : besselHankel(0, ax, false);
 }
 function besselJ1Scalar(x) {
   const ax = Math.abs(x);
-  if (ax < 8) {
-    const y = x * x;
-    const r1 = x * (72362614232 + y * (-7895059235 + y * (2423968531e-1 + y * (-2972611439e-3 + y * (15704.4826 + y * -30.16036606)))));
-    const r2 = 144725228442 + y * (2300535178 + y * (1858330474e-2 + y * (99447.43394 + y * (376.9991397 + y * 1))));
-    return r1 / r2;
-  } else {
-    const z = 8 / ax;
-    const y = z * z;
-    const xx = ax - 2.356194491;
-    const p1 = 1 + y * (183105e-8 + y * (-3516396496e-14 + y * (2457520174e-15 + y * -240337019e-15)));
-    const q1 = 0.04687499995 + y * (-2002690873e-13 + y * (8449199096e-15 + y * (-88228987e-14 + y * 105787412e-15)));
-    let ans = Math.sqrt(0.636619772 / ax) * (p1 * Math.cos(xx) - z * q1 * Math.sin(xx));
-    if (x < 0) ans = -ans;
-    return ans;
-  }
+  const sign3 = x < 0 ? -1 : 1;
+  const val = ax <= 13 ? besselJ1Series(ax) : besselHankel(1, ax, false);
+  return sign3 * val;
 }
 function besselY0Scalar(x) {
   if (x <= 0) return NaN;
-  if (x < 8) {
-    const y = x * x;
-    const r1 = -2957821389 + y * (7062834065 + y * (-5123598036e-1 + y * (1087988129e-2 + y * (-86327.92757 + y * 228.4622733))));
-    const r2 = 40076544269 + y * (7452499648e-1 + y * (7189466438e-3 + y * (47447.2647 + y * (226.1030244 + y * 1))));
-    return r1 / r2 + 0.636619772 * besselJ0Scalar(x) * Math.log(x);
-  } else {
-    const z = 8 / x;
-    const y = z * z;
-    const xx = x - 0.785398164;
-    const p0 = 1 + y * (-0.001098628627 + y * (2734510407e-14 + y * (-2073370639e-15 + y * 2093887211e-16)));
-    const q0 = -0.01562499995 + y * (1430488765e-13 + y * (-6911147651e-15 + y * (7621095161e-16 - y * 934935152e-16)));
-    return Math.sqrt(0.636619772 / x) * (p0 * Math.sin(xx) + z * q0 * Math.cos(xx));
-  }
+  return x <= 13 ? besselY0Series(x) : besselHankel(0, x, true);
 }
 function besselY1Scalar(x) {
   if (x <= 0) return NaN;
-  if (x < 8) {
-    const y = x * x;
-    const r1 = x * (-4900604943e3 + y * (127527439e4 + y * (-51534381390 + y * (7349264551e-1 + y * (-4237922726e-3 + y * 8511.937935)))));
-    const r2 = 249958057e5 + y * (424441966400 + y * (3733650367 + y * (2245904002e-2 + y * (102042.605 + y * (354.9632885 + y)))));
-    return r1 / r2 + 0.636619772 * (besselJ1Scalar(x) * Math.log(x) - 1 / x);
-  } else {
-    const z = 8 / x;
-    const y = z * z;
-    const xx = x - 2.356194491;
-    const p1 = 1 + y * (183105e-8 + y * (-3516396496e-14 + y * (2457520174e-15 + y * -240337019e-15)));
-    const q1 = 0.04687499995 + y * (-2002690873e-13 + y * (8449199096e-15 + y * (-88228987e-14 + y * 105787412e-15)));
-    return Math.sqrt(0.636619772 / x) * (p1 * Math.sin(xx) + z * q1 * Math.cos(xx));
-  }
+  return x <= 13 ? besselY1Series(x) : besselHankel(1, x, true);
 }
 function besselJScalar(n, x) {
   const ni = Math.round(n);
@@ -5499,7 +5556,7 @@ function besselJScalar(n, x) {
   if (ni === 0) return besselJ0Scalar(x);
   if (ni === 1) return besselJ1Scalar(x);
   if (Math.abs(x) < 1e-15) return 0;
-  if (ni <= 20 || Math.abs(x) > ni) {
+  if (Math.abs(x) > ni) {
     let jPrev = besselJ0Scalar(x);
     let jCurr = besselJ1Scalar(x);
     for (let k = 1; k < ni; k++) {
@@ -5518,7 +5575,7 @@ function besselJScalar(n, x) {
       const jPrev = 2 * (k + 1) / x * jCurr - jNext;
       jNext = jCurr;
       jCurr = jPrev;
-      if (k === ni) result = jNext;
+      if (k === ni) result = jCurr;
       if (k % 2 === 0) sum2 += jCurr;
     }
     sum2 = 2 * sum2 - jCurr;
@@ -5551,29 +5608,64 @@ function besselIScalar(n, x) {
   }
   return sum2;
 }
+function besselKAsym(nu, x) {
+  const mu = 4 * nu * nu;
+  let a = 1;
+  let xk = 1;
+  let sum2 = 1;
+  let prevMag = Infinity;
+  for (let k = 1; k <= 40; k++) {
+    const t1 = 2 * k - 1;
+    a = a * (mu - t1 * t1) / (8 * k);
+    xk *= x;
+    const t = a / xk;
+    if (Math.abs(t) > prevMag) break;
+    prevMag = Math.abs(t);
+    sum2 += t;
+  }
+  return Math.sqrt(Math.PI / (2 * x)) * Math.exp(-x) * sum2;
+}
+function besselK0Series(x) {
+  const z = 0.25 * x * x;
+  let t = 1;
+  let I0 = 1;
+  let h = 0;
+  let s = 0;
+  for (let k = 1; k <= 80; k++) {
+    t *= z / (k * k);
+    I0 += t;
+    h += 1 / k;
+    s += h * t;
+    if (k > 2 && t <= I0 * 1e-18) break;
+  }
+  return -(Math.log(0.5 * x) + 0.5772156649015329) * I0 + s;
+}
+function besselK1Series(x) {
+  const z = 0.25 * x * x;
+  let w = 1;
+  let S1 = 1;
+  let hk = 0;
+  let hk1 = 1;
+  let S2 = (hk + hk1) * 1;
+  for (let k = 1; k <= 80; k++) {
+    w *= z / (k * (k + 1));
+    S1 += w;
+    hk += 1 / k;
+    hk1 += 1 / (k + 1);
+    S2 += (hk + hk1) * w;
+    if (k > 2 && w <= S1 * 1e-18) break;
+  }
+  return 1 / x + 0.5 * x * (Math.log(0.5 * x) + 0.5772156649015329) * S1 - 0.25 * x * S2;
+}
 function besselKScalar(n, x) {
   const ni = Math.round(Math.abs(n));
   if (x <= 0) return NaN;
-  function k0(x2) {
-    if (x2 <= 2) {
-      const y2 = x2 * x2 / 4;
-      return -Math.log(x2 / 2) * besselIScalar(0, x2) + (-0.57721566 + y2 * (0.4227842 + y2 * (0.23069756 + y2 * (0.0348859 + y2 * (262698e-8 + y2 * 1075e-7)))));
-    }
-    const y = 2 / x2;
-    return Math.exp(-x2) / Math.sqrt(x2) * (1.25331414 + y * (-0.07832358 + y * (0.02189568 + y * (-0.01062446 + y * (587872e-8 + y * (-25154e-7 + y * 53208e-8))))));
-  }
-  function k1(x2) {
-    if (x2 <= 2) {
-      const y2 = x2 * x2 / 4;
-      return Math.log(x2 / 2) * besselIScalar(1, x2) + 1 / x2 * (1 + y2 * (0.15443144 + y2 * (-0.67278579 + y2 * (-0.18156897 + y2 * (-0.01919402 + y2 * (-110404e-8 + y2 * -4686e-8))))));
-    }
-    const y = 2 / x2;
-    return Math.exp(-x2) / Math.sqrt(x2) * (1.25331414 + y * (0.23498619 + y * (-0.0365562 + y * (0.01504268 + y * (-780353e-8 + y * (325614e-8 + y * -68245e-8))))));
-  }
-  if (ni === 0) return k0(x);
-  if (ni === 1) return k1(x);
-  let kPrev = k0(x);
-  let kCurr = k1(x);
+  const k0 = x <= 9 ? besselK0Series(x) : besselKAsym(0, x);
+  const k1 = x <= 9 ? besselK1Series(x) : besselKAsym(1, x);
+  if (ni === 0) return k0;
+  if (ni === 1) return k1;
+  let kPrev = k0;
+  let kCurr = k1;
   for (let k = 1; k < ni; k++) {
     const kNext = 2 * k / x * kCurr + kPrev;
     kPrev = kCurr;
@@ -5839,27 +5931,28 @@ function fresnelCScalar(x) {
   }
   return sign3 * sum2;
 }
-var AIRY_U = (() => {
+function airyUCoeffs() {
   const u = [1];
-  for (let k = 1; k <= 10; k++) {
-    u.push(u[k - 1] * ((6 * k - 5) * (6 * k - 3) * (6 * k - 1)) / (216 * k));
+  for (let k = 1; k <= 12; k++) {
+    u.push(u[k - 1] * ((6 * k - 5) * (6 * k - 3) * (6 * k - 1)) / ((2 * k - 1) * 216 * k));
   }
   return u;
-})();
+}
 function airyAsymPQ(zeta2) {
   let p = 0, q = 0;
   let pTerm = Infinity, qTerm = Infinity;
-  const half = Math.floor((AIRY_U.length - 1) / 2);
+  const U = airyUCoeffs();
+  const half = Math.floor((U.length - 1) / 2);
   for (let k = 0; k <= half; k++) {
     const sign3 = k % 2 === 0 ? 1 : -1;
-    const pt = sign3 * AIRY_U[2 * k] / Math.pow(zeta2, 2 * k);
+    const pt = sign3 * U[2 * k] / Math.pow(zeta2, 2 * k);
     if (Math.abs(pt) > Math.abs(pTerm)) break;
     p += pt;
     pTerm = pt;
   }
   for (let k = 0; k <= half - 1; k++) {
     const sign3 = k % 2 === 0 ? 1 : -1;
-    const qt = sign3 * AIRY_U[2 * k + 1] / Math.pow(zeta2, 2 * k + 1);
+    const qt = sign3 * U[2 * k + 1] / Math.pow(zeta2, 2 * k + 1);
     if (Math.abs(qt) > Math.abs(qTerm)) break;
     q += qt;
     qTerm = qt;
@@ -5867,24 +5960,18 @@ function airyAsymPQ(zeta2) {
   return { p, q };
 }
 function airyAiScalar(x) {
-  const XBIG = 4.5;
+  const XBIG = 5;
   const AI0 = 0.3550280538878172;
   const AI_PRIME0 = 0.2588194037928068;
-  const C = [
-    1,
-    5 / 72,
-    385 / 10368,
-    85085 / 2239488,
-    37182145 / 644972544,
-    576576001025e-2 / 61917364224,
-    1519768071625 / 8918845788160
-  ];
   if (x > XBIG) {
     const xp = Math.pow(x, 0.25);
     const zeta2 = 2 / 3 * x * Math.sqrt(x);
-    let p = 0, zk = 1, sign3 = 1;
-    for (const ck of C) {
-      p += sign3 * ck / zk;
+    let p = 0, zk = 1, sign3 = 1, prevMag = Infinity;
+    for (const uk of airyUCoeffs()) {
+      const t = uk / zk;
+      if (Math.abs(t) > prevMag) break;
+      prevMag = Math.abs(t);
+      p += sign3 * t;
       zk *= zeta2;
       sign3 = -sign3;
     }
@@ -5916,24 +6003,18 @@ function airyAiScalar(x) {
   return AI0 * f - AI_PRIME0 * g;
 }
 function airyBiScalar(x) {
-  const XBIG = 4.5;
+  const XBIG = 5;
   const AI0 = 0.3550280538878172;
   const AI_PRIME0 = 0.2588194037928068;
-  const C = [
-    1,
-    5 / 72,
-    385 / 10368,
-    85085 / 2239488,
-    37182145 / 644972544,
-    576576001025e-2 / 61917364224,
-    1519768071625 / 8918845788160
-  ];
   if (x > XBIG) {
     const xp = Math.pow(x, 0.25);
     const zeta2 = 2 / 3 * x * Math.sqrt(x);
-    let p = 0, zk = 1;
-    for (const ck of C) {
-      p += ck / zk;
+    let p = 0, zk = 1, prevMag = Infinity;
+    for (const uk of airyUCoeffs()) {
+      const t = uk / zk;
+      if (Math.abs(t) > prevMag) break;
+      prevMag = Math.abs(t);
+      p += t;
       zk *= zeta2;
     }
     return Math.exp(zeta2) * p / (Math.sqrt(Math.PI) * xp);
@@ -5994,7 +6075,7 @@ async function mapArray(x, scalar, buildKernel) {
 }
 var erfc = mathTyped9("erfc", {
   number: erfcScalar,
-  Float64Array: (x) => mapArray(x, erfcScalar, () => kernelSource([_erf, erfcScalar], "(x) => erfcScalar(x)"))
+  Float64Array: (x) => mapArray(x, erfcScalar, () => kernelSource([_erfSeries, _erfcCF, erfcScalar], "(x) => erfcScalar(x)"))
 });
 var erfi = mathTyped9("erfi", {
   number: erfiScalar,
@@ -6054,7 +6135,7 @@ var besselJ0 = mathTyped9("besselJ0", {
     return mapArray(
       x,
       besselJ0Scalar,
-      () => kernelSource([besselJ0Scalar], "(x) => besselJ0Scalar(x)")
+      () => kernelSource([besselHankel, besselJ0Series, besselJ0Scalar], "(x) => besselJ0Scalar(x)")
     );
   }
 });
@@ -6067,7 +6148,7 @@ var besselJ1 = mathTyped9("besselJ1", {
     return mapArray(
       x,
       besselJ1Scalar,
-      () => kernelSource([besselJ1Scalar], "(x) => besselJ1Scalar(x)")
+      () => kernelSource([besselHankel, besselJ1Series, besselJ1Scalar], "(x) => besselJ1Scalar(x)")
     );
   }
 });
@@ -6080,7 +6161,7 @@ var besselY0 = mathTyped9("besselY0", {
     return mapArray(
       x,
       besselY0Scalar,
-      () => kernelSource([besselJ0Scalar, besselY0Scalar], "(x) => besselY0Scalar(x)")
+      () => kernelSource([besselHankel, besselJ0Series, besselY0Series, besselY0Scalar], "(x) => besselY0Scalar(x)")
     );
   }
 });
@@ -6093,7 +6174,7 @@ var besselY1 = mathTyped9("besselY1", {
     return mapArray(
       x,
       besselY1Scalar,
-      () => kernelSource([besselJ1Scalar, besselY1Scalar], "(x) => besselY1Scalar(x)")
+      () => kernelSource([besselHankel, besselJ1Series, besselY1Series, besselY1Scalar], "(x) => besselY1Scalar(x)")
     );
   }
 });
@@ -6107,7 +6188,7 @@ var besselJ = mathTyped9("besselJ", {
       x,
       (v) => besselJScalar(n, v),
       () => kernelSource(
-        [besselJ0Scalar, besselJ1Scalar, besselJScalar],
+        [besselHankel, besselJ0Series, besselJ1Series, besselJ0Scalar, besselJ1Scalar, besselJScalar],
         `(x) => besselJScalar(${n}, x)`
       )
     );
@@ -6123,7 +6204,7 @@ var besselY = mathTyped9("besselY", {
       x,
       (v) => besselYScalar(n, v),
       () => kernelSource(
-        [besselJ0Scalar, besselJ1Scalar, besselY0Scalar, besselY1Scalar, besselYScalar],
+        [besselHankel, besselJ0Series, besselJ1Series, besselY0Series, besselY1Series, besselJ0Scalar, besselJ1Scalar, besselY0Scalar, besselY1Scalar, besselYScalar],
         `(x) => besselYScalar(${n}, x)`
       )
     );
@@ -6143,7 +6224,7 @@ var besselK = mathTyped9("besselK", {
     x,
     (v) => besselKScalar(n, v),
     () => kernelSource(
-      [factorial, _lgamma2, besselIScalar, besselKScalar],
+      [besselKAsym, besselK0Series, besselK1Series, besselKScalar],
       `(x) => besselKScalar(${n}, x)`
     )
   )
@@ -6257,7 +6338,7 @@ var airyAi = mathTyped9("airyAi", {
     if (x.length >= WASM_SPECIAL_THRESHOLD) {
       return Promise.resolve(airyAiDispatch(x));
     }
-    return mapArray(x, airyAiScalar, () => kernelSource([airyAiScalar], "(x) => airyAiScalar(x)"));
+    return mapArray(x, airyAiScalar, () => kernelSource([airyUCoeffs, airyAsymPQ, airyAiScalar], "(x) => airyAiScalar(x)"));
   }
 });
 var airyBi = mathTyped9("airyBi", {
@@ -6266,7 +6347,7 @@ var airyBi = mathTyped9("airyBi", {
     if (x.length >= WASM_SPECIAL_THRESHOLD) {
       return Promise.resolve(airyBiDispatch(x));
     }
-    return mapArray(x, airyBiScalar, () => kernelSource([airyBiScalar], "(x) => airyBiScalar(x)"));
+    return mapArray(x, airyBiScalar, () => kernelSource([airyUCoeffs, airyAsymPQ, airyBiScalar], "(x) => airyBiScalar(x)"));
   }
 });
 var carlsonRC = mathTyped9("carlsonRC", {
@@ -6388,7 +6469,7 @@ function _lgammaD(x) {
   const t = xm1 + g + 0.5;
   return 0.5 * Math.log(2 * Math.PI) + (xm1 + 0.5) * Math.log(t) - t + Math.log(a);
 }
-function _erf2(x) {
+function _erf(x) {
   if (x === 0) return 0;
   const sign3 = x < 0 ? -1 : 1;
   const a = Math.abs(x);
@@ -6419,7 +6500,7 @@ function normalPDFScalar(x, mu, sigma) {
 }
 function normalCDFScalar(x, mu, sigma) {
   if (sigma <= 0) return NaN;
-  return 0.5 * (1 + _erf2((x - mu) / (sigma * Math.SQRT2)));
+  return 0.5 * (1 + _erf((x - mu) / (sigma * Math.SQRT2)));
 }
 function exponentialPDFScalar(x, lambda) {
   if (lambda <= 0) return NaN;
@@ -6488,12 +6569,12 @@ var normalCDF = mathTyped10("normalCDF", {
   Float64Array: (x) => mapArray2(
     x,
     (v) => normalCDFScalar(v, 0, 1),
-    () => kernelSource2([_erf2, normalCDFScalar], "(x) => normalCDFScalar(x, 0, 1)")
+    () => kernelSource2([_erf, normalCDFScalar], "(x) => normalCDFScalar(x, 0, 1)")
   ),
   "Float64Array, number, number": (x, mu, sigma) => mapArray2(
     x,
     (v) => normalCDFScalar(v, mu, sigma),
-    () => kernelSource2([_erf2, normalCDFScalar], `(x) => normalCDFScalar(x, ${mu}, ${sigma})`)
+    () => kernelSource2([_erf, normalCDFScalar], `(x) => normalCDFScalar(x, ${mu}, ${sigma})`)
   )
 });
 var exponentialPDF = mathTyped10("exponentialPDF", {
@@ -11653,7 +11734,7 @@ async function eigenvectorCentrality(adj, opts) {
 import { computePool as computePool10 } from "@danielsimonjr/mathts-parallel";
 var DIST_WORKER_THRESHOLD = 1e5;
 var SQRT_2PI = Math.sqrt(2 * Math.PI);
-function _erf3(x) {
+function _erf2(x) {
   if (x === 0) return 0;
   const sign3 = x < 0 ? -1 : 1;
   const a = Math.abs(x);
@@ -11802,7 +11883,7 @@ function normalDist(mu = 0, sigma = 1) {
   if (sigma <= 0) throw new Error("normalDist: sigma must be positive");
   return {
     pdf: (x) => Math.exp(-0.5 * ((x - mu) / sigma) ** 2) / (sigma * SQRT_2PI),
-    cdf: (x) => 0.5 * (1 + _erf3((x - mu) / (sigma * Math.SQRT2))),
+    cdf: (x) => 0.5 * (1 + _erf2((x - mu) / (sigma * Math.SQRT2))),
     quantile: (p) => mu + sigma * Math.SQRT2 * _erfInv(2 * p - 1),
     mean: mu,
     variance: sigma * sigma,
@@ -12147,7 +12228,7 @@ function logNormalDist(mu = 0, sigma = 1) {
     },
     cdf: (x) => {
       if (x <= 0) return 0;
-      return 0.5 * (1 + _erf3((Math.log(x) - mu) / (sigma * Math.SQRT2)));
+      return 0.5 * (1 + _erf2((Math.log(x) - mu) / (sigma * Math.SQRT2)));
     },
     quantile: (p) => {
       if (p <= 0) return 0;
@@ -12370,7 +12451,7 @@ function _variance(arr, ddof = 1) {
   for (let i = 0; i < arr.length; i++) sum2 += (arr[i] - m) ** 2;
   return sum2 / (arr.length - ddof);
 }
-function _erf4(x) {
+function _erf3(x) {
   if (x === 0) return 0;
   const sign3 = x < 0 ? -1 : 1;
   const a = Math.abs(x);
@@ -12474,7 +12555,7 @@ function _tPValue(t, df) {
   return ib;
 }
 function _normalCDF(x) {
-  return 0.5 * (1 + _erf4(x / Math.SQRT2));
+  return 0.5 * (1 + _erf3(x / Math.SQRT2));
 }
 function _chiSquaredPValue(x, df) {
   return 1 - _gammainc2(df / 2, x / 2);

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

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

package/package.json

@@ -1,71 +1,73 @@
-{
-  "name": "@danielsimonjr/mathts-functions",
-  "version": "0.2.10",
-  "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
-  "author": "Daniel Simon Jr.",
-  "license": "MIT",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --clean && tsc -p tsconfig.dts.json",
-    "dev": "tsup src/index.ts --format esm --dts --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix",
-    "clean": "rm -rf dist",
-    "build:prod": "tsup src/index.ts --format esm --clean --minify --treeshake"
-  },
-  "dependencies": {
-    "@danielsimonjr/mathts-core": "^0.1.5",
-    "@danielsimonjr/mathts-expression": "^0.2.4",
-    "@danielsimonjr/mathts-matrix": "^0.1.6",
-    "@danielsimonjr/mathts-parallel": "^0.2.2",
-    "bignumber.js": "^9.1.2",
-    "complex.js": "^2.2.5",
-    "decimal.js": "^10.4.3",
-    "escape-latex": "^1.2.0",
-    "fraction.js": "^5.2.1",
-    "javascript-natural-sort": "^0.7.1",
-    "seedrandom": "^3.0.5",
-    "tiny-emitter": "^2.1.0",
-    "typed-function": "github:danielsimonjr/typed-function"
-  },
-  "devDependencies": {
-    "@types/node": "^25.5.2",
-    "tsup": "^8.0.0",
-    "typescript": "^5.3.0",
-    "vitest": "^4.1.5"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/danielsimonjr/mathts",
-    "directory": "functions"
-  },
-  "keywords": [
-    "math",
-    "typescript",
-    "functions",
-    "arithmetic",
-    "algebra",
-    "trigonometry",
-    "statistics"
-  ]
-}
+{
+  "name": "@danielsimonjr/mathts-functions",
+  "version": "0.2.11",
+  "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
+  "author": "Daniel Simon Jr.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --clean && tsc -p tsconfig.dts.json",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "vitest run",
+    "test:diff": "node tests/diff-special.test.mjs",
+    "golden:gen": "python -X utf8 tests/golden/gen_special_goldens.py",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "clean": "rm -rf dist",
+    "build:prod": "tsup src/index.ts --format esm --clean --minify --treeshake"
+  },
+  "dependencies": {
+    "@danielsimonjr/mathts-core": "^0.1.5",
+    "@danielsimonjr/mathts-expression": "^0.2.4",
+    "@danielsimonjr/mathts-matrix": "^0.1.6",
+    "@danielsimonjr/mathts-parallel": "^0.2.2",
+    "bignumber.js": "^9.1.2",
+    "complex.js": "^2.2.5",
+    "decimal.js": "^10.4.3",
+    "escape-latex": "^1.2.0",
+    "fraction.js": "^5.2.1",
+    "javascript-natural-sort": "^0.7.1",
+    "seedrandom": "^3.0.5",
+    "tiny-emitter": "^2.1.0",
+    "typed-function": "github:danielsimonjr/typed-function"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.1.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielsimonjr/mathts",
+    "directory": "functions"
+  },
+  "keywords": [
+    "math",
+    "typescript",
+    "functions",
+    "arithmetic",
+    "algebra",
+    "trigonometry",
+    "statistics"
+  ]
+}