@johnhenry/math 0.1.0 → 0.3.0

package/src/SpecialFunctions.ts

@@ -38,22 +38,18 @@ export class SpecialFunctions {
     return Math.exp(SpecialFunctions.lnGamma(a) + SpecialFunctions.lnGamma(b) - SpecialFunctions.lnGamma(a + b));
   }
 
-  /** The error function erf(x). */
+  /** The error function erf(x) (to ~1e-15, via the regularised incomplete gamma P(1/2, x²)). */
   static erf(x: number): number {
-    const sign = x < 0 ? -1 : 1;
-    const ax = Math.abs(x);
-    const t = 1 / (1 + 0.3275911 * ax);
-    const y =
-      1 -
-      ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) *
-        t *
-        Math.exp(-ax * ax);
-    return sign * y;
+    if (x === 0 || Number.isNaN(x)) return x;
+    const v = SpecialFunctions.regularizedGammaP(0.5, x * x);
+    return x < 0 ? -v : v;
   }
 
-  /** The complementary error function erfc(x) = 1 − erf(x). */
+  /** The complementary error function erfc(x) = 1 − erf(x), accurate in the upper tail (no cancellation). */
   static erfc(x: number): number {
-    return 1 - SpecialFunctions.erf(x);
+    if (Number.isNaN(x)) return x;
+    if (x < 0) return 2 - SpecialFunctions.regularizedGammaQ(0.5, x * x);
+    return SpecialFunctions.regularizedGammaQ(0.5, x * x);
   }
 
   /**
@@ -63,44 +59,16 @@ export class SpecialFunctions {
   static regularizedGammaP(a: number, x: number): number {
     if (x < 0 || a <= 0) return Number.NaN;
     if (x === 0) return 0;
-    if (x < a + 1) {
-      // series expansion
-      let ap = a;
-      let sum = 1 / a;
-      let del = sum;
-      for (let n = 0; n < 200; n++) {
-        ap++;
-        del *= x / ap;
-        sum += del;
-        if (Math.abs(del) < Math.abs(sum) * 1e-15) break;
-      }
-      return sum * Math.exp(-x + a * Math.log(x) - SpecialFunctions.lnGamma(a));
-    }
-    // continued fraction for the upper part Q, then P = 1 - Q
-    const tiny = 1e-300;
-    let b = x + 1 - a;
-    let c = 1 / tiny;
-    let d = 1 / b;
-    let h = d;
-    for (let i = 1; i < 200; i++) {
-      const an = -i * (i - a);
-      b += 2;
-      d = an * d + b;
-      if (Math.abs(d) < tiny) d = tiny;
-      c = b + an / c;
-      if (Math.abs(c) < tiny) c = tiny;
-      d = 1 / d;
-      const del = d * c;
-      h *= del;
-      if (Math.abs(del - 1) < 1e-15) break;
-    }
-    const q = Math.exp(-x + a * Math.log(x) - SpecialFunctions.lnGamma(a)) * h;
-    return 1 - q;
+    if (x === Number.POSITIVE_INFINITY) return 1;
+    return x < a + 1 ? gammaSeries(a, x) : 1 - gammaContinuedFraction(a, x);
   }
 
-  /** The regularised upper incomplete gamma function Q(a, x) = 1 − P(a, x). */
+  /** The regularised upper incomplete gamma function Q(a, x) = 1 − P(a, x), computed directly in the upper tail. */
   static regularizedGammaQ(a: number, x: number): number {
-    return 1 - SpecialFunctions.regularizedGammaP(a, x);
+    if (x < 0 || a <= 0) return Number.NaN;
+    if (x === 0) return 1;
+    if (x === Number.POSITIVE_INFINITY) return 0;
+    return x < a + 1 ? 1 - gammaSeries(a, x) : gammaContinuedFraction(a, x);
   }
 
   /**
@@ -129,7 +97,7 @@ function betaContinuedFraction(a: number, b: number, x: number): number {
   if (Math.abs(d) < tiny) d = tiny;
   d = 1 / d;
   let h = d;
-  for (let m = 1; m < 200; m++) {
+  for (let m = 1; m < 1000; m++) {
     const m2 = 2 * m;
     let aa = (m * (b - m) * x) / ((qam + m2) * (a + m2));
     d = 1 + aa * d;
@@ -150,3 +118,39 @@ function betaContinuedFraction(a: number, b: number, x: number): number {
   }
   return h;
 }
+
+/** Series for P(a, x), valid and fast for x < a + 1. */
+function gammaSeries(a: number, x: number): number {
+  let ap = a;
+  let sum = 1 / a;
+  let del = sum;
+  for (let n = 0; n < 1000; n++) {
+    ap++;
+    del *= x / ap;
+    sum += del;
+    if (Math.abs(del) < Math.abs(sum) * 1e-16) break;
+  }
+  return sum * Math.exp(-x + a * Math.log(x) - SpecialFunctions.lnGamma(a));
+}
+
+/** Lentz continued fraction for Q(a, x), valid and fast for x >= a + 1. */
+function gammaContinuedFraction(a: number, x: number): number {
+  const tiny = 1e-300;
+  let b = x + 1 - a;
+  let c = 1 / tiny;
+  let d = 1 / b;
+  let h = d;
+  for (let i = 1; i < 1000; i++) {
+    const an = -i * (i - a);
+    b += 2;
+    d = an * d + b;
+    if (Math.abs(d) < tiny) d = tiny;
+    c = b + an / c;
+    if (Math.abs(c) < tiny) c = tiny;
+    d = 1 / d;
+    const del = d * c;
+    h *= del;
+    if (Math.abs(del - 1) < 1e-16) break;
+  }
+  return Math.exp(-x + a * Math.log(x) - SpecialFunctions.lnGamma(a)) * h;
+}

package/src/Symbolic.ts

@@ -8,6 +8,7 @@ import { FUNC_DERIVATIVE_RULES } from "./differentiation-rules.ts";
 import { MatrixMath } from "./MatrixMath.ts";
 import { Numerical } from "./Numerical.ts";
 import { Rational } from "./Rational.ts";
+import { compileShader, type ShaderOptions, type ShaderResult } from "./Shader.ts";
 import { SpecialFunctions } from "./SpecialFunctions.ts";
 import type { Structure } from "./Structure.ts";
 
@@ -864,6 +865,23 @@ export class Symbolic {
     return render(typeof expr === "string" ? Symbolic.parse(expr) : expr, 0);
   }
 
+  /**
+   * Compile `expr` to a GLSL ES 3.0 expression over `float` (default) or, with
+   * `{ complex: true }`, over `vec2` complex numbers (the helpers it needs, such as
+   * `mx_cmul`, are returned in `helpers` and emitted once). Output is deterministic.
+   * Refuses nodes with no shader form (`sum`, `product`, `erf`, `gcd`, `lcm`, and anything
+   * not closed under the complex numbers in complex mode) with a `ShaderUnsupportedError`.
+   * Shader `pow` of a negative base with a non-integer exponent is undefined, unlike JS `NaN`.
+   */
+  static toGLSL(expr: Expr | string, options: ShaderOptions = {}): ShaderResult {
+    return compileShader(typeof expr === "string" ? Symbolic.parse(expr) : expr, "glsl", options);
+  }
+
+  /** As {@link toGLSL}, for WGSL (`f32` / `vec2<f32>`; `select` replaces the ternary). */
+  static toWGSL(expr: Expr | string, options: ShaderOptions = {}): ShaderResult {
+    return compileShader(typeof expr === "string" ? Symbolic.parse(expr) : expr, "wgsl", options);
+  }
+
   /** Render `expr` as a LaTeX string, e.g. `"x/2"` -> `"\\frac{x}{2}"`. */
   static toLatex(expr: Expr | string): string {
     return toLatexRec(typeof expr === "string" ? Symbolic.parse(expr) : expr, 0);

package/src/index.ts

@@ -24,18 +24,31 @@ export { ComplexNumber } from "./ComplexNumber.ts";
 export { Cycle } from "./Cycle.ts";
 export { Decimal } from "./Decimal.ts";
 export {
+  type Alternative,
+  type ChiSquareIndependenceResult,
   type ContinuousDistribution,
   type DiscreteDistribution,
   Distributions,
   HypothesisTests,
   type TestResult,
+  type TTestIndependentOptions,
+  type TTestOptions,
 } from "./Distributions.ts";
 export { DualNumber } from "./DualNumber.ts";
 export { FUNC_DERIVATIVE_RULES, type FuncDerivativeRule } from "./differentiation-rules.ts";
+export type { GeneralEigenResult } from "./EigenGeneral.ts";
 // Expression evaluation
 export { Environment } from "./Environment.ts";
 export { Expression } from "./Expression.ts";
 export { FFT } from "./FFT.ts";
+export {
+  type FrobeniusBlock,
+  type FrobeniusResult,
+  frobeniusNormalForm,
+  type NumericMatrix,
+  type RationalCanonicalResult,
+  rationalCanonicalForm,
+} from "./Frobenius.ts";
 export {
   type BivectorGeometricProduct,
   commutatorProduct,
@@ -90,16 +103,37 @@ export {
   type QRResult,
   type SVDResult,
 } from "./MatrixMath.ts";
+export {
+  type BootstrapResult,
+  type ConvergencePoint,
+  type DartPiResult,
+  type DartPoint,
+  type HistogramBin,
+  type IntegrationConvergencePoint,
+  type IntegrationResult,
+  MonteCarlo,
+} from "./MonteCarlo.ts";
 export { NumberTheory } from "./NumberTheory.ts";
 export { type LevenbergMarquardtResult, Numerical, type ODEStep } from "./Numerical.ts";
 export { Permutation } from "./Permutation.ts";
 export { Polygon } from "./Polygon.ts";
 export { PolynomialRing, parsePolynomial, polynomialToString } from "./PolynomialRing.ts";
 export { Quaternion } from "./Quaternion.ts";
+export { Rng, seed } from "./Random.ts";
 export { Rational } from "./Rational.ts";
 // Numeric cores
 export * as RealMath from "./RealMath.ts";
+export {
+  type CurveFitOptions,
+  type CurveFitResult,
+  type HuberLinearResult,
+  type LeastSquaresOptions,
+  type LeastSquaresResult,
+  Regression,
+  type RobustLoss,
+} from "./Regression.ts";
 export { Rotor4 } from "./Rotor4.ts";
+export { type ShaderDialect, type ShaderOptions, type ShaderResult, ShaderUnsupportedError } from "./Shader.ts";
 export { SpecialFunctions } from "./SpecialFunctions.ts";
 export { SpecialOperator } from "./SpecialOperator.ts";
 export * as Statistics from "./Statistics.ts";