@sheetxl/formulas 0.7.28-beta.4 → 0.8.0-beta.10

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sheetxl/formulas",
   "description": "Formulas - TypeScript formulas compatible with Excel built-ins.",
-  "version": "0.7.28-beta.4",
+  "version": "0.8.0-beta.10",
   "license": "SEE LICENSE IN <LICENSE>",
   "type": "module",
   "exports": {
@@ -9,13 +9,12 @@
       "types": "./types/index.d.ts",
       "browser": "./browser/esm/index.mjs",
       "node": "./node/esm/index.mjs",
-      "import": "./browser/esm/index.mjs",
-      "require": "./browser/cjs/index.cjs"
+      "default": "./browser/esm/index.mjs"
     }
   },
   "types": "./types/index.d.ts",
   "module": "./browser/esm/index.mjs",
-  "main": "./browser/cjs/index.cjs",
+  "main": "./browser/esm/index.mjs",
   "sideEffects": false,
   "engineStrict": true,
   "homepage": "https://sheetxl.com",
@@ -37,10 +36,9 @@
     "formulas"
   ],
   "dependencies": {
-    "@sheetxl/primitives": "^0.7.28-beta.4",
-    "@sheetxl/scripting": "^0.7.28-beta.4",
+    "@sheetxl/primitives": "^0.8.0-beta.10",
+    "@sheetxl/scripting": "^0.8.0-beta.10",
     "bahttext": "^2.4.0",
-    "bessel": "^1.0.2",
-    "jstat": "^1.9.6"
+    "bessel": "^1.0.2"
   }
 }

package/types/src/.generated/decl/dateTime/Date.decl.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDeclarations } from '@sheetxl/scripting';
+import { MinifiedDeclarations, MinifiedEnums } from '@sheetxl/scripting';
 declare const declarations: MinifiedDeclarations;
+export declare const enums: MinifiedEnums;
 export default declarations;
 //# sourceMappingURL=Date.decl.d.ts.map

package/types/src/.generated/decl/information/Information.decl.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDeclarations } from '@sheetxl/scripting';
+import { MinifiedDeclarations, MinifiedEnums } from '@sheetxl/scripting';
 declare const declarations: MinifiedDeclarations;
+export declare const enums: MinifiedEnums;
 export default declarations;
 //# sourceMappingURL=Information.decl.d.ts.map

package/types/src/.generated/decl/lookupReference/Reference.decl.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDeclarations } from '@sheetxl/scripting';
+import { MinifiedDeclarations, MinifiedEnums } from '@sheetxl/scripting';
 declare const declarations: MinifiedDeclarations;
+export declare const enums: MinifiedEnums;
 export default declarations;
 //# sourceMappingURL=Reference.decl.d.ts.map

package/types/src/.generated/decl/mathTrig/Math.decl.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDeclarations } from '@sheetxl/scripting';
+import { MinifiedDeclarations, MinifiedEnums } from '@sheetxl/scripting';
 declare const declarations: MinifiedDeclarations;
+export declare const enums: MinifiedEnums;
 export default declarations;
 //# sourceMappingURL=Math.decl.d.ts.map

package/types/src/.generated/desc/dateTime/Date.desc.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDescriptors } from '@sheetxl/scripting';
+import { MinifiedDescriptors, MinifiedEnumDescriptors } from '@sheetxl/scripting';
 declare const descriptors: MinifiedDescriptors;
+export declare const enums: MinifiedEnumDescriptors;
 export default descriptors;
 //# sourceMappingURL=Date.desc.d.ts.map

package/types/src/.generated/desc/information/Information.desc.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDescriptors } from '@sheetxl/scripting';
+import { MinifiedDescriptors, MinifiedEnumDescriptors } from '@sheetxl/scripting';
 declare const descriptors: MinifiedDescriptors;
+export declare const enums: MinifiedEnumDescriptors;
 export default descriptors;
 //# sourceMappingURL=Information.desc.d.ts.map

package/types/src/.generated/desc/lookupReference/Reference.desc.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDescriptors } from '@sheetxl/scripting';
+import { MinifiedDescriptors, MinifiedEnumDescriptors } from '@sheetxl/scripting';
 declare const descriptors: MinifiedDescriptors;
+export declare const enums: MinifiedEnumDescriptors;
 export default descriptors;
 //# sourceMappingURL=Reference.desc.d.ts.map

package/types/src/.generated/desc/mathTrig/Math.desc.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDescriptors } from '@sheetxl/scripting';
+import { MinifiedDescriptors, MinifiedEnumDescriptors } from '@sheetxl/scripting';
 declare const descriptors: MinifiedDescriptors;
+export declare const enums: MinifiedEnumDescriptors;
 export default descriptors;
 //# sourceMappingURL=Math.desc.d.ts.map

package/types/src/_utils/AValues.d.ts

@@ -0,0 +1,30 @@
+import { IRange, Scalar } from '@sheetxl/primitives';
+/**
+ * The reading the A functions apply to a member their plain twin skips — AVERAGEA, MAXA, MINA,
+ * STDEVA, STDEVPA, VARA and VARPA.
+ *
+ * Text and FALSE are 0, TRUE is 1, and a NUMERIC text is 0 rather than its number. All of it
+ * applies to a member of a REFERENCE; inside an ARRAY the A functions are their plain twins —
+ * `MAXA({-1,-2,"x"})` is -1 where MAXA over the same three CELLS is 0 — with one exception:
+ * AVERAGEA carries the text rule into an array as well, so `AVERAGEA({-1,-2,"x"})` is -1. A
+ * BOOLEAN in an array is skipped by every one of them, AVERAGEA included, typed or computed
+ * alike: `AVERAGEA({TRUE})` and `AVERAGEA(TRANSPOSE({TRUE}))` are both #DIV/0! while a TRUE CELL
+ * averages 1. The split is the reference-vs-array KIND, not literalness.
+ *
+ * A DIRECT argument never reaches any of this — those slots are typed `number`, so a boolean
+ * coerced to 1 and a text failed to #VALUE! before it was boxed.
+ *
+ * It lives here rather than beside the functions because an exported helper in a category
+ * directory registers a formula function, and both category files need it.
+ */
+export declare const isReferenceRange: (range: IRange) => boolean;
+/** MAXA, MINA, STDEVA, STDEVPA, VARA and VARPA. */
+export declare const ValueOptionsAFunctions: IRange.ValueOptions;
+/** AVERAGEA's, which differs in one place: a text member of an ARRAY is 0 rather than skipped. */
+export declare const ValueOptionsAverageA: IRange.ValueOptions;
+/**
+ * The same reading applied to a RAW member, for the bodies that need each deviation rather than
+ * an aggregate. `reference` is `isReferenceRange` of the range the value came out of.
+ */
+export declare const coerceAValue: (v: Scalar, reference: boolean) => number | null;
+//# sourceMappingURL=AValues.d.ts.map

package/types/src/_utils/AggregateIFS.d.ts

@@ -6,7 +6,9 @@ import { IRange, IFormulaContext, IReferenceRange, Scalar } from '@sheetxl/primi
  * @param context - The formula context.
  * @param pairs - The `[criteriaRange, criteria]` groups to evaluate. Each criteria is a single
  *   VALUE: the slot is declared `AcceptError<Scalar>`, so a range in that position is lifted by
- *   the engine and this helper is called once per element.
+ *   the engine and this helper is called once per element. `AcceptError` because an error is a
+ *   MATCHABLE criterion, not a fault — `COUNTIF(J1:J3,1/0)` over a `#DIV/0!` cell is 1 and
+ *   `SUMIF(J1:J3,NA(),J1:J3)` sums the matched `#N/A` cell.
  * @param aggregateFn - Called for each matching cell position with
  *   `(accumulator, value)`. `accumulator` is `null` on the first matching call.
  *   Return `accumulator` unchanged to skip a value (e.g. non-numeric).
@@ -31,9 +33,9 @@ import { IRange, IFormulaContext, IReferenceRange, Scalar } from '@sheetxl/primi
  *
  * Blanks keep their meaning through `emptyFold`: whether a blank matches is a constant per
  * criteria (`evaluator(null)`), so the blank positions contribute one term stated once rather
- * than a million evaluations. Measured, `COUNTIFS(A:A,"<>10")` is 1,048,576 and
+ * than a million evaluations. `COUNTIFS(A:A,"<>10")` is 1,048,576 and
  * `COUNTIFS(A:A,"<>10",B:B,">0")` is the handful B has members at — the second pair rejects
- * blanks, so the blank term drops out on its own (probe-criteria-blank.ps1).
+ * blanks, so the blank term drops out on its own.
  */
 export declare function aggregateIFS(context: IFormulaContext, pairs: readonly [criteriaRange: IReferenceRange | IRange, criteria: Scalar][], aggregateFn: (accumulator: Scalar, value: Scalar) => Scalar, aggRange: IRange | undefined, noMatchDefault: Scalar, emptyFold: ((accumulator: Scalar, count: number) => Scalar) | null): Scalar;
 //# sourceMappingURL=AggregateIFS.d.ts.map

package/types/src/_utils/Arithmetic.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Excel's arithmetic rules, for the bodies that have to reproduce them INSIDE a computation
+ * rather than at the boundary.
+ */
+/**
+ * Zeroes a subnormal, and folds -0 to 0 with it.
+ *
+ * Excel flushes a subnormal at its MULTIPLYING operators and nowhere else — a function's result
+ * keeps one (`EXP(-745)` is 5E-324) and so do `+` and `-`. A body whose answer comes out of a
+ * DIVISION inherits the rule and has to say so here, because JavaScript's `/` does not:
+ * `ACOTH(1E307*17)` is 0 in Excel, where `1/1.7E308` is a subnormal that would otherwise survive
+ * the arctangent.
+ */
+export declare const flushSubnormal: (value: number) => number;
+/**
+ * The inverse hyperbolic tangent, decomposed the way a C library does it — the log form above
+ * half and `log1p` below — rather than through the platform's `Math.atanh`.
+ *
+ * It is the spelling Excel agrees with: `ATANH(0.5)` is 0.5493061443340549,
+ * which is `ln(3)/2`, where `Math.atanh(0.5)` is one ulp below; and ACOTH reaches it with
+ * `y = 1/x`, where the log form keeps precision the rounded reciprocal has already lost
+ * (`ACOTH(1.0000001)` is 8.405621440467199, and `Math.atanh(1/1.0000001)` is 8.40562144042724 —
+ * a difference of eleven digits, not of a bit).
+ */
+export declare const atanhExcel: (y: number) => number;
+/**
+ * A double read at 15 SIGNIFICANT DECIMAL DIGITS — the precision at which Excel reads one before
+ * deciding which side of a boundary it falls on.
+ *
+ * `INT(4.35*100)` is 435 where the double is 434.99999999999994, and `ROUND(50*0.57,0)` is 29
+ * because 28.4999999999999964 reads as 28.5. It is a PER-SLOT rule and not a global one — MOD,
+ * QUOTIENT, EVEN and ODD read the raw double at the same position their siblings read this — so a
+ * body applies it at the slots that read this way and nowhere else.
+ */
+export declare const round15: (value: number) => number;
+//# sourceMappingURL=Arithmetic.d.ts.map

package/types/src/_utils/Combinatorics.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `n!` the way Excel accumulates it: a DESCENDING double product, `n · (n-1) · … · 2`.
+ *
+ * The order is the whole of the rule. Ascending gives a different double on twenty-two of the
+ * integers in range, and the correctly rounded value is a third answer again.
+ */
+export declare const factorialKernel: (n: number) => number;
+/** The largest `number` COMBIN accepts: `2^31 - 2`, one short of INT_MAX. */
+export declare const CombinMax = 2147483646;
+/**
+ * `C(n,k)` as a multiplicative product rather than a ratio of factorials.
+ *
+ * That is why `COMBIN(171,85)` answers where `FACT(171)` is `#NUM!`, and why the refusal is on
+ * the ANSWER rather than the arguments: `COMBIN(1029,514)` is 1.43E308 and `COMBIN(1030,514)` is
+ * `#NUM!`. Dividing before multiplying keeps the running value in range, and the smaller of
+ * `k` and `n-k` decides the step count — `COMBIN(170,84)` and `COMBIN(170,86)` are the same
+ * double, not merely the same number.
+ */
+export declare const binomialKernel: (n: number, k: number) => number;
+//# sourceMappingURL=Combinatorics.d.ts.map

package/types/src/_utils/Distributions.d.ts

@@ -0,0 +1,94 @@
+export declare const normalPdf: (x: number, mean: number, std: number) => number;
+/**
+ * Taken through `erfc` rather than `1 + erf`: below about `-6` standard deviations the latter is
+ * one plus a value one ulp short of minus one, so the whole lower tail cancels away to zero
+ * where Excel carries it out to 1E-300.
+ */
+export declare const normalCdf: (x: number, mean: number, std: number) => number;
+export declare const normalInv: (p: number, mean: number, std: number) => number;
+export declare function lognormalPdf(x: number, mu: number, sigma: number): number;
+export declare function lognormalCdf(x: number, mu: number, sigma: number): number;
+export declare const lognormalInv: (p: number, mu: number, sigma: number) => number;
+export declare function gammaPdf(x: number, shape: number, scale: number): number;
+export declare function gammaCdf(x: number, shape: number, scale: number): number;
+export declare const gammaInv: (p: number, shape: number, scale: number) => number;
+export declare function chisquarePdf(x: number, dof: number): number;
+export declare function chisquareCdf(x: number, dof: number): number;
+/** `1 - chisquareCdf`, taken from the tail itself rather than by subtracting it from one. */
+export declare function chisquareCdfUpper(x: number, dof: number): number;
+export declare const chisquareInv: (p: number, dof: number) => number;
+export declare function centralFPdf(x: number, df1: number, df2: number): number;
+export declare function centralFCdf(x: number, df1: number, df2: number): number;
+/**
+ * `1 - centralFCdf`, as the incomplete beta's OTHER tail — argument and parameters both swapped,
+ * so the small quantity is the one computed. Subtracting the lower tail from one instead loses
+ * the whole answer once the tail is under an ulp of one.
+ */
+export declare function centralFCdfUpper(x: number, df1: number, df2: number): number;
+export declare const centralFInv: (p: number, df1: number, df2: number) => number;
+export declare function studenttPdf(x: number, dof: number): number;
+/**
+ * The argument is `dof/(dof + x^2)` rather than `(x + sqrt(x^2+dof))/(2 sqrt(x^2+dof))`: the
+ * latter is one minus a value the size of the ANSWER, so at `x = 1E7` it arrives as `1 - 2.5E-15`
+ * and the tail is gone before the kernel is called. Both spell the same function.
+ */
+export declare function studenttCdf(x: number, dof: number): number;
+/**
+ * `1 - studenttCdf`, from the tail itself — see {@link studenttCdf} for the argument.
+ *
+ * An `x` whose square overflows is refused rather than read as the limit. Excel refuses it too
+ * (`T.DIST(1E307,5,TRUE)` is `#NUM!` while `T.DIST(2^31,5,TRUE)` is 1), and the boundary is the
+ * same one: `x^2` past a double.
+ */
+export declare function studenttCdfUpper(x: number, dof: number): number;
+export declare function studenttInv(p: number, dof: number): number;
+export declare function poissonPdf(k: number, l: number): number;
+/**
+ * The CDF sums the mass function term by term, and adds the terms BACK TO FRONT.
+ *
+ * `x` is the caller's argument and the mass function divides by `k!`, so the walk answers only
+ * while every term is finite: past 170 the factorial overflows and a term is `Infinity`, `NaN`
+ * or a silently truncated tail. Where the walk cannot answer, the complementary regularized
+ * gamma is the same function in closed form.
+ *
+ * The ORDER is the one place this differs from the rest of the category, where Excel accumulates
+ * forward. It is kept because nothing separates the two orders: only nine of the family's rows
+ * move at all and they split between them, and a summation order should not be changed on a
+ * coin toss.
+ */
+export declare function poissonCdf(x: number, l: number): number;
+export declare const binomialPdf: (k: number, n: number, p: number) => number;
+/**
+ * The CDF is the complement of a `1e-10` incomplete beta, ROUNDED to that same tolerance.
+ *
+ * The rounding is EXCEL'S, not a leftover: it is why a cumulative binomial in the bulk carries
+ * ten decimal places and no more. Taking it out moves answers AWAY from Excel — it costs sixty
+ * of BINOM.DIST's rows on its own — so it is not a cleanup to make.
+ */
+export declare function binomialCdf(x: number, n: number, p: number): number;
+export declare function negbinPdf(k: number, r: number, p: number): number;
+/**
+ * `x` is the caller's argument, so the walk needs both an exit and a fallback: it stops once the
+ * tail has underflowed — the mass is unimodal, so a zero term is followed only by zero terms and
+ * the sum can no longer move — and hands over to the regularized incomplete beta, the same
+ * function in closed form, when a term overflows or the tail has not arrived by `NegbinMaxSteps`.
+ * A walk that never saw a NONZERO term hands over too: `p^r` underflows well before the answer
+ * does, so an all-zero walk measures the mass function's range and not the distribution.
+ */
+export declare function negbinCdf(x: number, r: number, p: number): number;
+export declare const exponentialPdf: (x: number, rate: number) => number;
+export declare const exponentialCdf: (x: number, rate: number) => number;
+export declare function betaPdf(x: number, alpha: number, beta: number): number;
+export declare const betaCdf: (x: number, alpha: number, beta: number) => number;
+export declare const betaInv: (p: number, alpha: number, beta: number) => number;
+/**
+ * Half-width of the confidence interval around a mean, from the normal quantile.
+ *
+ * The `(1 + h) - 1` round trip is not redundant: it rounds the half-width against a unit
+ * magnitude, which moves the answer on most shapes. Whether Excel rounds there too is not
+ * established, so the round trip stays.
+ */
+export declare function normalConfidence(alpha: number, standardDev: number, size: number): number;
+/** The same half-width from Student's t on `size - 1` degrees of freedom. */
+export declare function studenttConfidence(alpha: number, standardDev: number, size: number): number;
+//# sourceMappingURL=Distributions.d.ts.map

package/types/src/_utils/Errors.d.ts

@@ -1,23 +1,4 @@
-import { IRange, Scalar } from '@sheetxl/primitives';
-/**
- * Throws the first error member (row-major) — the in-body form of the engine's reject scan,
- * for functions that cannot use the engine's reject default. Call it once per range, in
- * ARGUMENT order, where a function takes several.
- *
- * Three reasons a function ends up here, all measured:
- * * its policy depends on a runtime argument (SUBTOTAL/AGGREGATE options),
- * * or on which rows matched (the database family),
- * * or one of its own verdicts OUTRANKS a member error, so the scan has to run after that check
- *   rather than before the body. The count mismatch is the one that does this
- *   (`CHISQ.TEST(<3 cells with an error>, <2 cells>)` is `#N/A`, not the error — the same rule
- *   the SUMX2MY2 family and `PROB` follow); every other validation loses to the error and needs
- *   no in-body scan at all.
- *
- * Those parameters declare `AcceptError` to keep the engine's reject default off; everything
- * with a static reject policy needs no marker at all. Callers hand UNTYPED ranges, so the read
- * is already raw.
- */
-export declare function throwFirstErrorMember(range: IRange): void;
+import { Scalar } from '@sheetxl/primitives';
 /**
  * Wraps a value-aggregating reduce callback (SUMIF / AVERAGEIF / MAXIFS / …) so an error in a
  * MATCHED member becomes the whole result, while a non-matched one stays invisible.

package/types/src/_utils/FirstCell.d.ts

@@ -0,0 +1,32 @@
+import { IRange, Scalar } from '@sheetxl/primitives';
+/**
+ * The answer for a CONTAINER at a slot that reads a multi-cell REFERENCE by its FIRST CELL while
+ * an array constant still answers per member — `N` and `T`.
+ *
+ * @remarks
+ * `T(AF1:AF3)` is `"alpha"` and stays a scalar —
+ * `ROWS` of it is 1 and `INDEX(…,2,1)` is `#REF!` — while `T({"alpha";"bravo"})` spills 2x1. Both
+ * names declare `IRange | Scalar`, so a value and a ONE-CELL reference never reach here (the
+ * marshaller dereferences them at the scalar arm, errors included); what arrives is a container,
+ * and only its KIND separates the two readings.
+ *
+ * `paramIndex` is the slot the kind is asked about — 0 for both of today's callers.
+ *
+ * An error at the first cell of a multi-cell reference propagates here, which is what a one-cell
+ * reference does (`T(<#N/A cell>)` is `#N/A`).
+ */
+export declare const readFirstOrMembers: <T extends Scalar>(container: IRange, read: (value: Scalar) => T, paramIndex?: number) => T;
+/**
+ * The one cell a multi-cell REFERENCE reads as at a slot Excel declares a plain VALUE.
+ *
+ * @remarks
+ * The choice is the call's implicit-intersection MODE: in VALUE
+ * mode the cell the formula's own row and column select — the `@` rule on both axes, `#VALUE!`
+ * when the formula cell lies outside the range — and in ARRAY mode the first cell. A one-cell
+ * reference is its own cell in either mode.
+ *
+ * `LeastSquares.readOneCell` in `@sheetxl/formulas-extended` is the same rule; the two packages
+ * share only `@sheetxl/primitives`, which is why there are two copies rather than one import.
+ */
+export declare const readIntersectedCell: (range: IRange) => Scalar;
+//# sourceMappingURL=FirstCell.d.ts.map

package/types/src/_utils/Matrix.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The elimination behind MDETERM and MINVERSE — LU with partial pivoting, and no tolerance
+ * anywhere in it.
+ *
+ * The determinant of a SINGULAR matrix is what makes the algorithm visible rather than a matter
+ * of taste: Excel answers 6.661338147750939E-16 for `MDETERM({1,2,3;4,5,6;7,8,9})`, exactly 0 for
+ * its transpose, and the same residue negated when its first two rows are swapped. Those are the
+ * numbers the elimination leaves; a body that cuts a small pivot to zero can produce none of
+ * them, and one without pivoting produces a different residue again.
+ *
+ * The inverse is this same decomposition followed by a forward and back SUBSTITUTION per unit
+ * column. Gauss-Jordan over `[A | I]` — the textbook alternative, and in five spellings — lands
+ * further from Excel on the same matrices.
+ */
+/**
+ * The determinant, as the signed product of the pivots.
+ *
+ * The product is a multiplication, so it carries the two rules Excel's multiplying operators do:
+ * a subnormal flushes to zero (`MDETERM({1E-160,2E-160;3E-160,4E-160})` is 0, not 2E-320) and an
+ * overflow is `#NUM!` rather than an infinity, which is what `NaN` means to the caller.
+ */
+export declare const determinant: (m: readonly (readonly number[])[]) => number;
+/**
+ * The inverse, one unit column at a time. `null` when a pivot was zero — the caller's `#NUM!`.
+ *
+ * The substitution subtracts term by term rather than accumulating a sum and subtracting once;
+ * the two differ in the last bit wherever the terms cancel, and only the first reproduces
+ * Excel's `MINVERSE({1,2;3,4})`, which is not the exact `[[-2,1],[1.5,-0.5]]`.
+ */
+export declare const invert: (m: readonly (readonly number[])[]) => number[][] | null;
+//# sourceMappingURL=Matrix.d.ts.map

package/types/src/_utils/SpecialFunctions.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Log-gamma. Lanczos with `g = 671/128` and fourteen coefficients.
+ *
+ * The six-coefficient form this was seeded with holds about ten digits, and every function here
+ * reads its answer through an `exp`, so those ten were the ceiling under the whole distribution
+ * library — `ibetainv` cannot find a root more accurately than the `ibeta` it is inverting.
+ */
+export declare function gammaln(x: number): number;
+/** Gamma, by the rational approximation — `Infinity` past the double's last representable value. */
+export declare function gammafn(x: number): number;
+/** The beta function. */
+export declare function betafn(x: number, y: number): number | undefined;
+/** The argument above which {@link stirlerr}'s series is good to the last bit. */
+export declare const StirlingFloor = 30;
+/**
+ * `ln B(x, y)`.
+ *
+ * `ln G(x) + ln G(y) - ln G(x + y)` is a difference of large numbers whenever either argument is
+ * large, and the answer is not large — the loss is total enough to be the whole story behind the
+ * F and t families' five-digit plateau at a degrees of freedom of 1E10. Above
+ * {@link StirlingFloor} the larger argument is folded into {@link lgammaDelta} instead, which
+ * never forms it. Below it the expression is the original one, so nothing else changes.
+ */
+export declare const betaln: (x: number, y: number) => number;
+/** The error function, by Chebyshev approximation. */
+export declare const erf: (x: number) => number;
+/** The complementary error function. */
+export declare const erfc: (x: number) => number;
+/** The inverse of {@link erfc}. */
+export declare function erfcinv(p: number): number;
+/**
+ * The lower regularized incomplete gamma, `P(a, x)`.
+ *
+ * The iteration count is a formula rather than a convergence test — both branches simply run
+ * `ITMAX` times. The cap is sized from the shape, so both also stop as soon as the accumulator
+ * has stopped moving; without that a large shape walks the cap one term at a time for no gain
+ * (a shape of 1e9 takes ten seconds).
+ *
+ * Past {@link TemmeShape} neither branch is asked at all — see {@link temmeQ}.
+ */
+export declare const lowRegGamma: (a: number, x: number) => number;
+/**
+ * `Q(a, x) = 1 - P(a, x)`, on the branch that does not cancel.
+ *
+ * The continued fraction computes `Q` and the series computes `P`, so spelling either one as
+ * `1 -` the other throws the smaller of the two away — for a far tail that is the entire answer.
+ */
+export declare const upRegGamma: (a: number, x: number) => number;
+/**
+ * `ln` of the `Gamma(a, 1)` density at `x`, written so that nothing in it cancels.
+ *
+ * The direct spelling `(a-1) ln x - x - ln G(a)` is a sum of terms the size of `a ln a` — 1.6E8
+ * at a shape of 1E7 — that has to come out near zero, so it holds seven digits there whatever
+ * `ln G` is asked. Folding Stirling's form for `ln G(a)` in symbolically leaves
+ *
+ * ```
+ *   -a (u - ln(1+u)) - ln(1+u) - ln(a)/2 - ln(2 pi)/2 - stirlerr(a),   u = x/a - 1
+ * ```
+ *
+ * whose every term is the size of the answer. Excel's own `GAMMA.DIST(1E7,1E7,1,FALSE)` is bit
+ * for bit the value this returns, so it is what Excel computes too.
+ */
+export declare function gammaLogPdf(a: number, x: number): number;
+/** The inverse of {@link lowRegGamma} in its second argument. */
+export declare function gammapinv(p: number, a: number): number;
+/**
+ * The continued fraction of the incomplete beta, by modified Lentz's method.
+ *
+ * The stop is an ulp of the ratio. The single-precision `3e-7` it was seeded with put a floor
+ * under every F and t answer at about seven digits — visible wherever a body asked for eight.
+ */
+export declare function betacf(x: number, a: number, b: number): number;
+/**
+ * The regularized incomplete beta, `I_x(a, b)`.
+ *
+ * The front factor goes through {@link betaln}, which does not cancel at a large argument.
+ */
+export declare const ibeta: (x: number, a: number, b: number) => number;
+/**
+ * `I_x(a, b)` where the caller supplies `1 - x` as well as `x`.
+ *
+ * A caller that has both in closed form has a far better `1 - x` than the subtraction does: an
+ * `x` of `dof/(dof + t^2)` is `1 - 2.25E-10` at a degrees of freedom of 1E10, and recovering
+ * that complement by subtracting leaves six of its digits, which is the whole answer on this
+ * branch. {@link ibeta} passes the subtraction, which is all there is to pass when `x` is what
+ * the caller was given.
+ */
+export declare function ibetaAt(x: number, cx: number, a: number, b: number): number;
+/** The inverse of {@link ibeta} in its first argument. */
+export declare function ibetainv(p: number, a: number, b: number): number;
+//# sourceMappingURL=SpecialFunctions.d.ts.map

package/types/src/_utils/X87.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Excel's circular trigonometry, which is not the platform library's.
+ *
+ * Excel's `SIN` `COS` `TAN` disagree with a correctly-rounded library in the FOURTH significant
+ * digit near a multiple of pi/2 — `SIN(PI())` is 1.22514845490862E-16 where the true sine of the
+ * double `PI()` is 1.2246467991473532E-16 — because Excel reduces the argument against pi
+ * ROUNDED TO A 64-BIT SIGNIFICAND (the x87 80-bit extended constant) rather than against pi. The
+ * difference is a constant, not noise to be tolerated at 15 digits.
+ *
+ * The reduction has to be carried at more than double precision: `k` reaches 2^27/(pi/2), about
+ * 8.5E7, so `k * PI_HI/2` needs the exact product rather than the rounded one. That is what the
+ * double-double helpers below are for. The answer is re-evaluated from the reduced argument
+ * rather than perturbed from the library's: perturbing keeps the ordinary arguments exact and
+ * loses the reduced ones.
+ */
+/** `|x|` at or above which Excel refuses a circular trig argument outright. */
+export declare const MAX_TRIG_ARGUMENT: number;
+/** Excel's sine. The caller owns the {@link MAX_TRIG_ARGUMENT} refusal. */
+export declare function x87Sin(x: number): number;
+/** Excel's cosine. The caller owns the {@link MAX_TRIG_ARGUMENT} refusal. */
+export declare function x87Cos(x: number): number;
+/**
+ * Excel's tangent, which is the quotient of the two above and not a function of its own.
+ * `TAN(x)` is exactly `SIN(x)/COS(x)` everywhere, including at the poles, where the quotient is
+ * what produces the large finite answer (`TAN(PI()/2)` is 1.6324552277619072E16).
+ */
+export declare const x87Tan: (x: number) => number;
+//# sourceMappingURL=X87.d.ts.map