@johnhenry/math 0.0.0

package/src/differentiation-rules.ts

@@ -0,0 +1,73 @@
+/**
+ * Data-driven derivative rules for single-argument elementary functions --
+ * the `func` `Expr` variant (`sin`, `exp`, `asinh`, etc.). This is the
+ * "declarative rewrite-rule table" from the Woxi-study design note
+ * (github.com/johnhenry/math#15): each `FuncName` maps to a pure function
+ * from (the function's argument `u`, its already-differentiated form `du`)
+ * to d/dx[f(u)]. The chain-rule wrapping itself (computing `du` and
+ * dispatching on `e.name`) stays in Symbolic.ts, since that's structural
+ * recursion over the `Expr` union, not a per-function identity.
+ *
+ * Keeping this as a `Record<FuncName, ...>` rather than a `switch` means:
+ * adding/fixing one function's derivative touches one line here, not the
+ * differentiation engine; TypeScript enforces every `FuncName` has an entry
+ * (no `throw new Error("Unhandled function")` needed); and each rule is
+ * independently unit-testable (see differentiation-rules.test.ts).
+ */
+import type { Expr, FuncName } from "./Symbolic.ts";
+
+const num = (value: number): Expr => ({ type: "const", value });
+const add = (left: Expr, right: Expr): Expr => ({ type: "add", left, right });
+const sub = (left: Expr, right: Expr): Expr => ({ type: "sub", left, right });
+const mul = (left: Expr, right: Expr): Expr => ({ type: "mul", left, right });
+const div = (left: Expr, right: Expr): Expr => ({ type: "div", left, right });
+const pow = (base: Expr, exp: Expr): Expr => ({ type: "pow", base, exp });
+const neg = (arg: Expr): Expr => ({ type: "neg", arg });
+const fn = (name: FuncName, arg: Expr): Expr => ({ type: "func", name, arg });
+
+/** d/dx[f(u)] given `u` and `du` (= du/dx, already computed by the caller). */
+export type FuncDerivativeRule = (u: Expr, du: Expr) => Expr;
+
+export const FUNC_DERIVATIVE_RULES: Record<FuncName, FuncDerivativeRule> = {
+  sin: (u, du) => mul(fn("cos", u), du),
+  cos: (u, du) => neg(mul(fn("sin", u), du)),
+  tan: (u, du) => div(du, pow(fn("cos", u), num(2))),
+  exp: (u, du) => mul(fn("exp", u), du),
+  ln: (u, du) => div(du, u),
+  sqrt: (u, du) => div(du, mul(num(2), fn("sqrt", u))),
+  asin: (u, du) => div(du, fn("sqrt", sub(num(1), pow(u, num(2))))),
+  acos: (u, du) => neg(div(du, fn("sqrt", sub(num(1), pow(u, num(2)))))),
+  atan: (u, du) => div(du, add(num(1), pow(u, num(2)))),
+  sinh: (u, du) => mul(fn("cosh", u), du),
+  cosh: (u, du) => mul(fn("sinh", u), du),
+  tanh: (u, du) => div(du, pow(fn("cosh", u), num(2))),
+  cot: (u, du) => neg(mul(pow(fn("csc", u), num(2)), du)),
+  sec: (u, du) => mul(mul(fn("sec", u), fn("tan", u)), du),
+  csc: (u, du) => neg(mul(mul(fn("csc", u), fn("cot", u)), du)),
+  asinh: (u, du) => div(du, fn("sqrt", add(pow(u, num(2)), num(1)))),
+  acosh: (u, du) => div(du, fn("sqrt", sub(pow(u, num(2)), num(1)))),
+  atanh: (u, du) => div(du, sub(num(1), pow(u, num(2)))),
+  coth: (u, du) => neg(mul(pow(fn("csch", u), num(2)), du)),
+  sech: (u, du) => neg(mul(mul(fn("sech", u), fn("tanh", u)), du)),
+  csch: (u, du) => neg(mul(mul(fn("csch", u), fn("coth", u)), du)),
+  acot: (u, du) => neg(div(du, add(num(1), pow(u, num(2))))),
+  asec: (u, du) => div(du, mul(fn("abs", u), fn("sqrt", sub(pow(u, num(2)), num(1))))),
+  acsc: (u, du) => neg(div(du, mul(fn("abs", u), fn("sqrt", sub(pow(u, num(2)), num(1)))))),
+  acoth: (u, du) => div(du, sub(num(1), pow(u, num(2)))),
+  asech: (u, du) => neg(div(du, mul(u, fn("sqrt", sub(num(1), pow(u, num(2))))))),
+  acsch: (u, du) => neg(div(du, mul(fn("abs", u), fn("sqrt", add(num(1), pow(u, num(2))))))),
+  abs: (u, du) => mul(fn("sign", u), du),
+  log10: (u, du) => div(du, mul(u, fn("ln", num(10)))),
+  log2: (u, du) => div(du, mul(u, fn("ln", num(2)))),
+  cbrt: (u, du) => div(du, mul(num(3), pow(fn("cbrt", u), num(2)))),
+  floor: () => num(0),
+  ceil: () => num(0),
+  round: () => num(0),
+  sign: () => num(0),
+  trunc: () => num(0),
+  expm1: (u, du) => mul(fn("exp", u), du),
+  log1p: (u, du) => div(du, add(num(1), u)),
+  sigmoid: (u, du) => mul(mul(fn("sigmoid", u), sub(num(1), fn("sigmoid", u))), du),
+  erf: (u, du) => mul(mul(div(num(2), fn("sqrt", num(Math.PI))), fn("exp", neg(pow(u, num(2))))), du),
+  relu: (u, du) => mul(div(add(num(1), fn("sign", u)), num(2)), du),
+};

package/src/index.ts

@@ -0,0 +1,140 @@
+/**
+ * @johnhenry/math — advanced college-level mathematics for TypeScript.
+ *
+ * A modern, tested TypeScript port of the Mallory ActionScript 3 library.
+ */
+
+// 4D geometric algebra (vectors, bivectors, rotors) -- see report/MIEGAKURE_REPORT.md
+// in johnhenry/miegakure-archive for the design context this was built for.
+export { Bivector4 } from "./Bivector4.ts";
+// Reactive, pull-based dependency graph -- promoted from johnhenry/mallory
+// (its src/lib/cell-graph.ts), which math-grapher also vendored a frozen
+// copy of; both now import it from here instead. See johnhenry/math#56.
+export { CellGraph, type CellRole, CircularDependencyError, structuralEqual } from "./CellGraph.ts";
+// Counting mathematics
+export { Combinatorics } from "./Combinatorics.ts";
+export {
+  combinations,
+  combinationsWithReplacement,
+  permutations,
+  product,
+} from "./CombinatoricsGenerators.ts";
+export * as ComplexMath from "./ComplexMath.ts";
+export { ComplexNumber } from "./ComplexNumber.ts";
+export { Cycle } from "./Cycle.ts";
+export { Decimal } from "./Decimal.ts";
+export {
+  type ContinuousDistribution,
+  type DiscreteDistribution,
+  Distributions,
+  HypothesisTests,
+  type TestResult,
+} from "./Distributions.ts";
+export { DualNumber } from "./DualNumber.ts";
+export { FUNC_DERIVATIVE_RULES, type FuncDerivativeRule } from "./differentiation-rules.ts";
+// Expression evaluation
+export { Environment } from "./Environment.ts";
+export { Expression } from "./Expression.ts";
+export { FFT } from "./FFT.ts";
+export {
+  type BivectorGeometricProduct,
+  commutatorProduct,
+  dotProduct as dotProduct4,
+  dual as dual4,
+  geometricProductBivectors,
+  geometricProductVectors,
+  leftContraction,
+  type VectorGeometricProduct,
+  wedgeProduct as wedgeProduct4,
+} from "./GeometricAlgebra4.ts";
+export { Geometry, type Point, Transform2D } from "./Geometry.ts";
+export { type Edge, Graph } from "./Graph.ts";
+export {
+  type Face,
+  Graph3DUtils,
+  type Material,
+  type Mesh,
+  type Placement3D,
+  type Vec3,
+} from "./Graph3DUtils.ts";
+// Graphing (renderer-agnostic geometry)
+export {
+  type BarPlacement2D,
+  type FillStyle,
+  GraphUtils,
+  type Path2D,
+  type PathCommand,
+  type Placement2D,
+  type StrokeStyle,
+} from "./GraphUtils.ts";
+export { GroupTheory } from "./GroupTheory.ts";
+// Combinatorics & number theory
+export { Interval } from "./Interval.ts";
+export { IntUtils } from "./IntUtils.ts";
+export {
+  HEX_AXIAL_DIRECTIONS,
+  type HexDirection,
+  hexNeighbor,
+  hexNeighbors,
+  type TriDirection,
+  type TriOrientation,
+  triNeighbor,
+  triNeighbors,
+  triOrientation,
+} from "./Lattice.ts";
+export { Logic } from "./Logic.ts";
+export {
+  type EigenResult,
+  type LUResult,
+  MatrixMath,
+  type QRResult,
+  type SVDResult,
+} from "./MatrixMath.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 { Rational } from "./Rational.ts";
+// Numeric cores
+export * as RealMath from "./RealMath.ts";
+export { Rotor4 } from "./Rotor4.ts";
+export { SpecialFunctions } from "./SpecialFunctions.ts";
+export { SpecialOperator } from "./SpecialOperator.ts";
+export * as Statistics from "./Statistics.ts";
+export { StringEvaluator } from "./StringEvaluator.ts";
+// Algebraic structures & geometry
+export { Structure, type StructureOptions } from "./Structure.ts";
+export {
+  type Assumption,
+  type BinaryFuncName,
+  type CmpOp,
+  DegenerateOdeError,
+  type DifferentiationStep,
+  type Expr,
+  FUNCTION_NAMES,
+  type FuncName,
+  InfiniteSolutionsError,
+  IntegrationSingularityError,
+  NoClosedFormError,
+  NonLinearSystemError,
+  NotIntegrableError,
+  NotSeparableError,
+  type OdeClosedFormResult,
+  ProductNotDifferentiableError,
+  SeriesDivergesError,
+  SingularSystemError,
+  Symbolic,
+  SystemDidNotConvergeError,
+  UndeclaredVariableError,
+} from "./Symbolic.ts";
+export { Type, TypeTag } from "./Type.ts";
+// Utilities & leaves
+export { Utilities } from "./Utilities.ts";
+export { Vec4 } from "./Vec4.ts";
+// Foundations
+export { Vector } from "./Vector.ts";
+export { VectorCalculus } from "./VectorCalculus.ts";
+// Linear algebra
+export { type Matrix, VectorUtils } from "./VectorUtils.ts";