@compstats/core 0.3.0 → 0.4.0

package/dist/core/arith.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arith.d.ts","sourceRoot":"","sources":["../../src/core/arith.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,mDAAmD;AACnD,wBAAgB,GAAG,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAErD;AAED,iEAAiE;AACjE,wBAAgB,IAAI,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAEtD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAQlE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,yDAAyD;AACzD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAI9D;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,EAAE,EAAE,SAAS,CAAC,EAAE,EAChB,EAAE,EAAE,SAAS,CAAC,EAAE,EAChB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,GACzB,CAAC,EAAE,CAIL;AAED;;;;;;GAMG;AACH,wBAAgB,EAAE,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAQpD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAGvE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKxE;AA0BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,MAAM,EAAE,CAaV;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAExD"}
+{"version":3,"file":"arith.d.ts","sourceRoot":"","sources":["../../src/core/arith.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,mDAAmD;AACnD,wBAAgB,GAAG,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAErD;AAED,iEAAiE;AACjE,wBAAgB,IAAI,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAEtD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAQlE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,yDAAyD;AACzD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAI9D;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,EAAE,EAAE,SAAS,CAAC,EAAE,EAChB,EAAE,EAAE,SAAS,CAAC,EAAE,EAChB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,GACzB,CAAC,EAAE,CAIL;AAED;;;;;;GAMG;AACH,wBAAgB,EAAE,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAQpD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAGvE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAUxE;AA0BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,MAAM,EAAE,CAaV;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAExD"}

package/dist/core/linalg/cov.d.ts

@@ -0,0 +1,50 @@
+/**
+ * R's `var()`, `cov()` and `cor()`.
+ *
+ * R computes a covariance in two passes: the mean of each column, refined
+ * once by adding the mean of the residuals (its `cov.c` does this to shave
+ * the rounding off a long sum), then the sum of products of deviations over
+ * `n − 1`. A correlation is the covariance matrix scaled by the square roots
+ * of its diagonal, clamped to `[-1, 1]`, with an exact 1 on the diagonal.
+ * The port follows those steps. R accumulates in `long double` where the
+ * platform has one; the conformance fixtures come from arm64, where it does
+ * not, and the values are verified at a relative tolerance (plan Q1).
+ *
+ * A missing value gives NaN, as R's default `use = "everything"` gives NA.
+ * A constant column gives NaN for its correlations, where R warns "the
+ * standard deviation is zero" and gives NA.
+ */
+import { type Matrix } from "./matrix";
+import type { Vector } from "./vector";
+/**
+ * R's `var(x)` of a vector: the sample variance with the `n − 1` divisor.
+ *
+ * @returns The variance, or NaN below two values or with a missing value.
+ */
+export declare function variance(a: Vector): number;
+/**
+ * R's `cov()`: the covariance of two vectors, or the covariance matrix of
+ * the columns of a matrix.
+ *
+ * @param x A vector, or a matrix whose columns are the variables.
+ * @param y The second vector when `x` is a vector.
+ * @returns The covariance, or the symmetric covariance matrix with the
+ *   column names of `x` on both sides.
+ * @throws RangeError If two vectors differ in length.
+ */
+export declare function cov(x: Vector, y: Vector): number;
+export declare function cov(x: Matrix): Matrix;
+/**
+ * R's `cor()`: the Pearson correlation of two vectors, or the correlation
+ * matrix of the columns of a matrix.
+ *
+ * @param x A vector, or a matrix whose columns are the variables.
+ * @param y The second vector when `x` is a vector.
+ * @returns The correlation, clamped to `[-1, 1]`, or the symmetric
+ *   correlation matrix with an exact 1 on its diagonal. NaN where a
+ *   variable has no spread.
+ * @throws RangeError If two vectors differ in length.
+ */
+export declare function cor(x: Vector, y: Vector): number;
+export declare function cor(x: Matrix): Matrix;
+//# sourceMappingURL=cov.d.ts.map

package/dist/core/linalg/cov.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cov.d.ts","sourceRoot":"","sources":["../../../src/core/linalg/cov.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,EAAuB,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAwCvC;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG1C;AAED;;;;;;;;;GASG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;AAClD,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;AAYvC;;;;;;;;;;GAUG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;AAClD,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC"}

package/dist/core/linalg/eigen.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The eigendecomposition of a symmetric matrix, R's
+ * `eigen(x, symmetric = TRUE)`.
+ *
+ * R goes through LAPACK's `dsyevr`. The port uses cyclic Jacobi rotations,
+ * which for the matrices a teaching library sees — a covariance of a handful
+ * of variables — converge to machine precision in a few sweeps and are
+ * short enough to read. Eigenvalues come back descending, as R's do, and
+ * the eigenvectors are orthonormal columns. Verified against R in
+ * `eigen.test.ts`: the eigenvalues to a relative `1e-12`, the vectors up to
+ * sign (plan Q1).
+ *
+ * **Signs are this port's own.** LAPACK leaves the sign of each eigenvector
+ * to the arithmetic; the port makes the entry of largest magnitude positive
+ * (a tie goes to the first), which is the rule `pca.ts` already uses, so
+ * that the same input gives the same picture every time.
+ *
+ * Two departures from R, both stated: a matrix that is not symmetric is
+ * refused, where R silently reads its lower triangle; and the eigenvector
+ * matrix carries the row names of the input as its row names, where R's
+ * carries none — a loading without its variable is unreadable. The refusals
+ * R does make are followed in its order and its words: a non-square matrix,
+ * then a 0 x 0 one, then a missing or infinite entry (fixture 5e).
+ *
+ * Index loops throughout: a rotation addresses entries by position.
+ */
+import { type Matrix } from "./matrix";
+import type { Vector } from "./vector";
+/** R's `eigen()` result for a symmetric matrix. */
+export interface SymmetricEigen {
+    /** The eigenvalues, largest first. */
+    readonly values: Vector;
+    /**
+     * The eigenvectors as columns, in the order of the values, each of unit
+     * length with its largest entry positive. Row names are the input's.
+     */
+    readonly vectors: Matrix;
+}
+/**
+ * R's `isSymmetric()`: whether a square matrix equals its transpose to a
+ * relative tolerance, R's `all.equal()` default of `100 * eps`.
+ */
+export declare function isSymmetric(m: Matrix, tolerance?: number): boolean;
+/**
+ * Decompose a symmetric matrix, as R's `eigen(x, symmetric = TRUE)` does.
+ *
+ * @param m The symmetric matrix. The function does not modify it.
+ * @returns The eigenvalues, descending, and the eigenvectors as columns.
+ * @throws RangeError If the matrix is not square, is 0 x 0, holds a missing
+ *   or infinite entry, or is not symmetric.
+ */
+export declare function eigenSymmetric(m: Matrix): SymmetricEigen;
+//# sourceMappingURL=eigen.d.ts.map

package/dist/core/linalg/eigen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eigen.d.ts","sourceRoot":"","sources":["../../../src/core/linalg/eigen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAQ,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,mDAAmD;AACnD,MAAM,WAAW,cAAc;IAC7B,sCAAsC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,SAAuB,GAAG,OAAO,CAehF;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,cAAc,CA0CxD"}

package/dist/core/linalg/lm.d.ts

@@ -0,0 +1,78 @@
+/**
+ * R's `lm()` over a data frame, with what `summary.lm()` reads off the fit.
+ *
+ * `lm()` is `model.matrix()` followed by `lm.fit()`, and `lm.fit()` is
+ * `dqrls`: the `qr()` of `qr.ts` — LINPACK's `dqrdc2` with its limited
+ * column pivoting — followed by `dqrsl`'s coefficients and residuals, with
+ * the fitted values as `y` minus the residuals. The port runs that same
+ * arithmetic, so the coefficients, fitted values and residuals pin bit for
+ * bit against R. The summary statistics — R², adjusted R², σ, the standard
+ * errors and the t and p values — follow `summary.lm()`'s formulas but not
+ * its rounding step for step (`chol2inv` and `pt`), and are verified at a
+ * stated tolerance. See `lm.test.ts`.
+ *
+ * Coefficients come back as a `NamedVector` in R's order, `null` where R
+ * reports `NA` for an aliased column. Fitted values and residuals are padded
+ * with NaN to the input length where a row was dropped for a missing value,
+ * R's `na.exclude`, which is the convention every fit in this package uses.
+ */
+import type { DataFrame } from "../frame";
+import { type ModelSpec } from "./modelMatrix";
+import { type NamedVector } from "./namedVector";
+import type { Vector } from "./vector";
+/** The model, with the outcome required, and the rank tolerance. */
+export interface LmOptions extends ModelSpec {
+    /** The column to fit. */
+    readonly outcome: string;
+    /** How far a column's norm may collapse before it is aliased. R's `lm.fit()` default. */
+    readonly tolerance?: number;
+}
+/** R's `summary(fit)$fstatistic`. */
+export interface FStatistic {
+    readonly value: number;
+    readonly numdf: number;
+    readonly dendf: number;
+}
+/** A fitted linear model and its summary. */
+export interface LmFit {
+    /** `coef(fit)`: one entry per design column, null where R reports `NA`. */
+    readonly coefficients: NamedVector;
+    /** `coef(summary(fit))[, "Std. Error"]`, null for an aliased term. */
+    readonly standardErrors: NamedVector;
+    /** `coef(summary(fit))[, "t value"]`, null for an aliased term. */
+    readonly tValues: NamedVector;
+    /** `coef(summary(fit))[, "Pr(>|t|)"]`, null for an aliased term. */
+    readonly pValues: NamedVector;
+    /** The fitted outcome of each data row, in input order; NaN for a row dropped. */
+    readonly fitted: Vector;
+    /** The outcome minus the fit, in input order; NaN for a row dropped. */
+    readonly residuals: Vector;
+    /** The number of columns the fit could identify. */
+    readonly rank: number;
+    /** `fit$df.residual`: rows fitted minus rank. */
+    readonly dfResidual: number;
+    /** `summary(fit)$r.squared`. */
+    readonly rSquared: number;
+    /** `summary(fit)$adj.r.squared`. */
+    readonly adjRSquared: number;
+    /** `summary(fit)$sigma`: the residual standard error. */
+    readonly sigma: number;
+    /** `summary(fit)$fstatistic`, or null when the model has no term beyond the intercept. */
+    readonly fStatistic: FStatistic | null;
+    /** The data rows the fit used, in input order. */
+    readonly rows: readonly number[];
+    /** R's `term.labels`. */
+    readonly termLabels: readonly string[];
+}
+/**
+ * Fit a linear model, as R's `lm()` does.
+ *
+ * @param data The frame holding every column the model names.
+ * @param options The outcome, the terms, the intercept flag, and the rank
+ *   tolerance.
+ * @returns The fit and its summary.
+ * @throws RangeError If a named column is absent or not numeric, if the
+ *   frame is ragged, or if no row is complete — R's "0 (non-NA) cases".
+ */
+export declare function lm(data: DataFrame, options: LmOptions): LmFit;
+//# sourceMappingURL=lm.d.ts.map

package/dist/core/linalg/lm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lm.d.ts","sourceRoot":"","sources":["../../../src/core/linalg/lm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,oEAAoE;AACpE,MAAM,WAAW,SAAU,SAAQ,SAAS;IAC1C,yBAAyB;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,yFAAyF;IACzF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,qCAAqC;AACrC,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,6CAA6C;AAC7C,MAAM,WAAW,KAAK;IACpB,2EAA2E;IAC3E,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC;IACnC,sEAAsE;IACtE,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC;IACrC,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,oDAAoD;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iDAAiD;IACjD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,gCAAgC;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oCAAoC;IACpC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0FAA0F;IAC1F,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IACvC,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,yBAAyB;IACzB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED;;;;;;;;;GASG;AACH,wBAAgB,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,CAyD7D"}

package/dist/core/linalg/lu.d.ts

@@ -0,0 +1,154 @@
+/**
+ * The LU factorization with partial pivoting, and what R reads off it:
+ * `solve()`, `det()`, `determinant()`, `rcond()` and `norm()`.
+ *
+ * R's `solve(a, b)` is LAPACK `dgesv` — `dgetrf` to factor, `dgetrs` to
+ * substitute — followed by `dgecon`'s condition estimate and an error when
+ * that estimate falls below `tol`. `det()` factors the same way and then
+ * exponentiates a sum of logarithms of the diagonal, which is why the
+ * determinant of an integer matrix comes back as `30.000000000000004`. This
+ * module follows those routines step for step, with the arithmetic of the
+ * reference BLAS build the fixtures come from (each product rounded once
+ * into its sum — see `fusedMultiplyAdd`), so that the factorization, the
+ * solves and the determinant pin bit for bit. Verified in `lu.test.ts`.
+ * The 2 × 2 special case in `../matrix.ts` is the same algorithm and the
+ * two agree exactly on every fixture of the interactive demo.
+ *
+ * Three departures from R, each stated where it applies: `rcond` is the
+ * exact one-norm ratio rather than `dgecon`'s estimate; a vector right-hand
+ * side comes back as a plain array rather than R's named vector; and a
+ * negative or NaN tolerance is refused where R would skip the check.
+ *
+ * Index loops throughout: a factorization addresses single entries by
+ * position, and this one follows `dgetf2` and `dtrsm` as written.
+ */
+import { type Matrix } from "./matrix";
+import type { Vector } from "./vector";
+/** R's `solve()` result on a square matrix, factored. */
+export interface LuDecomposition {
+    /**
+     * The compact factorization, LAPACK's: `U` on and above the diagonal, the
+     * multipliers of the unit lower triangle `L` below it, rows already
+     * interchanged.
+     */
+    readonly lu: Matrix;
+    /**
+     * The row interchanges, LAPACK's `ipiv` **zero-based**: at step `i` row
+     * `i` was swapped with row `pivots[i]`. Apply them in order to recover
+     * `P` such that `P A = L U`. Plural, and not `pivot` as in
+     * `QrDecomposition`, because this is a list of interchanges rather than
+     * a column order.
+     */
+    readonly pivots: readonly number[];
+    /**
+     * The zero-based index of the first exactly zero pivot — LAPACK's `info`,
+     * less one — or null if the factorization completed. R reports it as
+     * `U[i,i] = 0`, one-based.
+     */
+    readonly zeroPivot: number | null;
+}
+/**
+ * Factor a square matrix, as LAPACK's `dgetrf` does.
+ *
+ * @param a The matrix. The function does not modify it.
+ * @returns The compact factorization, the row interchanges, and the first
+ *   zero pivot if any. A zero pivot does not stop the factorization, as it
+ *   does not in LAPACK.
+ * @throws RangeError If the matrix is not square.
+ * @throws TypeError If `a` is not a matrix.
+ */
+export declare function lu(a: Matrix): LuDecomposition;
+export interface SolveOptions {
+    /**
+     * The reciprocal condition number below which the system is refused as
+     * computationally singular. R's default is `.Machine$double.eps`; zero
+     * skips the check, as it does in R. R also skips it for a negative or
+     * NA `tol`; the port refuses those with a `RangeError` — a deliberate
+     * narrowing, as `matrix()` narrows R's recycling.
+     */
+    readonly tolerance?: number;
+}
+/** The singularity tolerance of R's `solve()`: one machine epsilon. */
+export declare const DEFAULT_SOLVE_TOLERANCE: number;
+/**
+ * R's `solve(a)`, `solve(a, b)` and `solve(a, B)`: the inverse, the solution
+ * of `a x = b` for a vector, or the solution of `a X = B` for a matrix.
+ *
+ * @param a The square coefficient matrix.
+ * @param b The right-hand side, or the options when only the inverse is
+ *   wanted. A vector gives a plain array (R names it by the column names of
+ *   `a`; the port carries no names on a bare array — plan Q11). A matrix
+ *   gives a matrix whose row names are the column names of `a` and whose
+ *   column names are those of `b`; the inverse has the column names of `a`
+ *   as rows and the row names of `a` as columns, as R's does.
+ * @param options The singularity tolerance.
+ * @returns The solution.
+ * @throws RangeError If `a` is not square or has no rows, `b` does not
+ *   conform or has no columns, the factorization meets an exactly zero
+ *   pivot, or the reciprocal condition number is below the tolerance —
+ *   each in R's own words. As in R, a non-finite entry in `a` leaves the
+ *   condition unchecked: R's `dgecon` reports a bad norm and `solve()`
+ *   goes on.
+ * @throws TypeError If `a` or `b` is neither a matrix nor an array.
+ */
+export declare function solve(a: Matrix, options?: SolveOptions): Matrix;
+export declare function solve(a: Matrix, b: Vector, options?: SolveOptions): number[];
+export declare function solve(a: Matrix, b: Matrix, options?: SolveOptions): Matrix;
+/**
+ * R's `det()`: the determinant, through the factorization and a sum of
+ * logarithms, as R computes it. A 0 × 0 matrix has determinant 1, as in R.
+ *
+ * @throws RangeError If the matrix is not square.
+ * @throws TypeError If `a` is not a matrix.
+ */
+export declare function det(a: Matrix): number;
+/**
+ * R's `determinant()`: the logarithm of the absolute determinant and its
+ * sign. An exactly singular matrix reports `-Infinity` and sign 1, so that
+ * `det()` is a positive zero, as R's is.
+ *
+ * @throws RangeError If the matrix is not square.
+ * @throws TypeError If `a` is not a matrix.
+ */
+export declare function determinant(a: Matrix): {
+    readonly modulus: number;
+    readonly sign: 1 | -1;
+};
+/**
+ * The reciprocal condition number in the one-norm, R's `rcond(x)`:
+ * `1 / (norm(x) * norm(solve(x)))` for a square matrix, 0 when it is
+ * exactly singular, and Infinity for a 0 × 0 matrix. A matrix that is not
+ * square goes through the triangular factor of its QR, as R's does
+ * (`rcond(qr.R(qr(x)))`, transposed first when wide).
+ *
+ * R's `rcond()` and `solve()` read an estimate of this number from LAPACK's
+ * `dgecon` rather than computing it, and the port computes it exactly. On
+ * the fixtures the two agree to the last bit for most matrices (3a, 3c, 3d,
+ * 3e, 3i) and differ by one unit in the last place on two (3b, 3h);
+ * `solve()`'s error message matches R's to the six digits it prints on
+ * every singular case pinned. The estimate bounds the norm of the inverse
+ * from below, so R's number is never smaller than the port's.
+ *
+ * @throws RangeError If an entry is not finite — R's "error code -5 from
+ *   Lapack routine 'dgecon()'", because `dgecon` refuses a norm it cannot
+ *   read.
+ * @throws TypeError If `a` is not a matrix.
+ */
+export declare function rcond(a: Matrix): number;
+/**
+ * R's `norm()` types. `"O"` is R's default; the letters are accepted in
+ * either case, as R's `lsame` accepts them. R's `"2"`, the spectral norm,
+ * needs a singular value decomposition, which this plan leaves out.
+ */
+export type MatrixNormType = "O" | "1" | "I" | "F" | "E" | "M" | "o" | "i" | "f" | "e" | "m";
+/**
+ * R's `norm(x, type)`: the one-norm (`"O"` or `"1"`, the largest absolute
+ * column sum), the infinity norm (`"I"`, the largest absolute row sum), the
+ * Frobenius norm (`"F"` or `"E"`), or the largest absolute entry (`"M"`).
+ * Named `matrixNorm` because `norm` in this entry is the vector length.
+ *
+ * @throws RangeError If the type is none of those, in R's words.
+ * @throws TypeError If `a` is not a matrix.
+ */
+export declare function matrixNorm(a: Matrix, type?: MatrixNormType): number;
+//# sourceMappingURL=lu.d.ts.map

package/dist/core/linalg/lu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lu.d.ts","sourceRoot":"","sources":["../../../src/core/linalg/lu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,EAAuB,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAG5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAUvC,yDAAyD;AACzD,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,eAAe,CAoD7C;AAWD,MAAM,WAAW,YAAY;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,QAAiB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC;AACjE,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM,EAAE,CAAC;AAC9E,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC;AA2I5E;;;;;;GAMG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAGrC;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;CAAE,CAoB1F;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAoBvC;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAE7F;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,GAAE,cAAoB,GAAG,MAAM,CAmCxE"}

package/dist/core/linalg/matrix.d.ts

@@ -0,0 +1,131 @@
+/**
+ * A matrix, held the way R holds one.
+ *
+ * R stores a matrix as one vector in column-major order with a `dim`
+ * attribute and optional `dimnames`. This module keeps that shape as a plain
+ * object: a `Float64Array` of the entries column by column, the two extents,
+ * and the names. Plain data, not a class — a matrix serializes, clones and
+ * crosses a worker boundary as it is, and every operation on it is a function
+ * in R's vocabulary (`t`, `matmul`, `crossprod`, `cbind`, …) in `ops.ts`.
+ *
+ * Column-major is load-bearing. It is what R, LAPACK and every conformance
+ * fixture assume, so `matrix(c(x1, y1, x2, y2), nrow = 2)` translates with
+ * no reordering, and a factorization ported from LINPACK reads the same
+ * memory in the same order.
+ *
+ * Indices are zero-based throughout, as the language's are. R's `A[1, 1]` is
+ * `at(a, 0, 0)` here.
+ *
+ * R recycles the data to fill the matrix: a scalar silently, a sub-multiple
+ * of the extent silently too (`matrix(1:3, 3, 2)` repeats the column), and
+ * any other length with a warning. This module recycles a scalar only —
+ * `matrix([0], {nrow: 3, ncol: 3})` is R's `matrix(0, 3, 3)` — and refuses
+ * every other mismatch, warned or not. A silently recycled column lets a
+ * typo fit the wrong model; a caller who wants the repeat writes
+ * `cbind(v, v)`.
+ */
+import { type DataFrame } from "../frame";
+import type { Vector } from "./vector";
+/** Row names and column names, either of which R may leave `NULL`. */
+export type Dimnames = readonly [
+    readonly string[] | null,
+    readonly string[] | null
+];
+/** A matrix in R's layout: column-major data with its two extents. */
+export interface Matrix {
+    readonly nrow: number;
+    readonly ncol: number;
+    /**
+     * The entries, column by column: entry `(i, j)` is `data[j * nrow + i]`.
+     * Treat it as read-only. A `Float64Array` has no read-only type, so the
+     * rule is stated rather than enforced.
+     */
+    readonly data: Float64Array;
+    /** R's `dimnames`, or null when the matrix has none. */
+    readonly dimnames: Dimnames | null;
+}
+/** The named arguments of R's `matrix()`. */
+export interface MatrixOptions {
+    /** The number of rows. At least one of `nrow` and `ncol` is required. */
+    readonly nrow?: number;
+    /** The number of columns. */
+    readonly ncol?: number;
+    /** Fill row by row instead of column by column. False by default. */
+    readonly byrow?: boolean;
+    /** Row names and column names. */
+    readonly dimnames?: Dimnames;
+}
+/**
+ * Build a matrix from its entries, as R's `matrix()` does.
+ *
+ * @param values The entries, in column-major order unless `byrow` is set,
+ *   or a single value to fill the whole matrix with. The function copies
+ *   them; a hole in a sparse array reads as NaN.
+ * @param options `nrow` or `ncol` (or both, in which case they must agree
+ *   with the length), `byrow`, and `dimnames`. An extent may be zero, as
+ *   R's may.
+ * @returns The matrix.
+ * @throws RangeError If neither extent is given, an extent is not a
+ *   non-negative integer, the length is not a multiple of the extent given
+ *   (R warns and recycles; the port refuses), both extents are given and do
+ *   not multiply to the length (R recycles a sub-multiple silently; the port
+ *   refuses), or a dimnames entry has the wrong length.
+ */
+export declare function matrix(values: Vector, options: MatrixOptions): Matrix;
+/**
+ * Assemble a matrix from data already in column-major order, checking the
+ * dimnames against the extents and copying the name arrays so that no two
+ * matrices share one. The data is taken as is, not copied.
+ *
+ * @internal Not part of the entry point. The other linalg modules build
+ *   their results through it.
+ */
+export declare function make(nrow: number, ncol: number, data: Float64Array, dimnames: Dimnames | null): Matrix;
+/**
+ * Build a matrix from its rows.
+ *
+ * @param rows One array per row, each one value per column. Copied.
+ * @returns The matrix.
+ * @throws RangeError If there are no rows, a row is empty, or the rows have
+ *   different lengths.
+ */
+export declare function fromRows(rows: readonly Vector[]): Matrix;
+/**
+ * Build a matrix from its columns. This is R's `cbind()` over vectors and
+ * the natural constructor from a column-keyed data frame.
+ *
+ * @param columns One array per column, each one value per row. Copied.
+ * @returns The matrix.
+ * @throws RangeError If there are no columns, a column is empty, or the
+ *   columns have different lengths.
+ */
+export declare function fromColumns(columns: readonly Vector[]): Matrix;
+/**
+ * Read one entry. R's `m[i + 1, j + 1]`.
+ *
+ * @throws RangeError If the index is outside the matrix.
+ */
+export declare function at(m: Matrix, i: number, j: number): number;
+/** Read one row as a plain array. R's `m[i + 1, ]`. */
+export declare function row(m: Matrix, i: number): number[];
+/** Read one column as a plain array. R's `m[, j + 1]`. */
+export declare function column(m: Matrix, j: number): number[];
+/** The matrix as an array of rows. */
+export declare function toRows(m: Matrix): number[][];
+/** The matrix as an array of columns. */
+export declare function toColumns(m: Matrix): number[][];
+/**
+ * R's `as.matrix()` of a data frame: the numeric columns side by side, with
+ * the column names carried. The natural way into `cov`, `prcomp` and
+ * `matmul` from a column-keyed frame.
+ *
+ * @param data The frame.
+ * @param columns The columns to take, in order. By default every numeric
+ *   column, in frame order — R's `Filter(is.numeric, data)`.
+ * @returns The matrix, `frameRows(data)` by `columns.length`, with the
+ *   column names as its column names.
+ * @throws RangeError If a named column is absent or not numeric (through
+ *   `requireNumericColumn`), or if the frame is ragged.
+ */
+export declare function fromFrame(data: DataFrame, columns?: readonly string[]): Matrix;
+//# sourceMappingURL=matrix.d.ts.map

package/dist/core/linalg/matrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../../../src/core/linalg/matrix.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,sEAAsE;AACtE,MAAM,MAAM,QAAQ,GAAG,SAAS;IAC9B,SAAS,MAAM,EAAE,GAAG,IAAI;IACxB,SAAS,MAAM,EAAE,GAAG,IAAI;CACzB,CAAC;AAEF,sEAAsE;AACtE,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;CACpC;AAED,6CAA6C;AAC7C,MAAM,WAAW,aAAa;IAC5B,yEAAyE;IACzE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,6BAA6B;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CACpB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,aAAa,GACrB,MAAM,CAqBR;AAwDD;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAClB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,QAAQ,GAAG,IAAI,GACxB,MAAM,CAwBR;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAsBxD;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,MAAM,CAqBR;AAED;;;;GAIG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAQ1D;AAED,uDAAuD;AACvD,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAKlD;AAED,0DAA0D;AAC1D,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAKrD;AAED,sCAAsC;AACtC,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAE5C;AAED,yCAAyC;AACzC,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAE/C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAQ9E"}

package/dist/core/linalg/modelMatrix.d.ts

@@ -0,0 +1,69 @@
+/**
+ * R's `model.matrix()`: a data frame and a list of terms → the design
+ * matrix, with the column names `lm()` gives its coefficients.
+ *
+ * R builds this from a formula. The port has no formulas (CLAUDE.md: the
+ * canonical form is explicit column names in an options object), so a
+ * model is a list of terms — a column name for a main effect, an array of
+ * column names for an interaction — and the intercept is a flag. R's
+ * `y ~ x * z + w` is `{ outcome: "y", terms: ["x", "z", "w", ["x", "z"]] }`.
+ *
+ * The columns come out in R's order, whatever order the terms were written
+ * in: the intercept, then the terms by degree — every main effect before
+ * every two-way interaction before every three-way — and within a degree in
+ * the order given. A term written twice enters once. The `assign` vector is
+ * R's: the index of the term each column came from, 0 for the intercept.
+ *
+ * Rows with a missing (non-finite) value in the outcome or in any column a
+ * term names are dropped, R's `model.frame()` under `na.omit`; the indices
+ * of the rows kept are returned, so a fit can pad its results back to the
+ * input order (the `na.exclude` convention every fit in this package uses).
+ * Only numeric columns can enter; R's factors and contrasts are out of
+ * scope.
+ */
+import { type DataFrame } from "../frame";
+import { type Matrix } from "./matrix";
+/**
+ * One term of a model: a column name for a main effect, or the column names
+ * of an interaction, R's `a:b`.
+ */
+export type Term = string | readonly string[];
+/** Which columns make the model. */
+export interface ModelSpec {
+    /**
+     * The outcome column. It enters no design column, but a row missing it is
+     * dropped, as `model.frame()` drops it. Optional here; `lm()` requires it.
+     */
+    readonly outcome?: string;
+    /** The terms, in any order. R's order is restored. */
+    readonly terms: readonly Term[];
+    /** Whether to lead with a column of ones. True by default, R's `+ 1`. */
+    readonly intercept?: boolean;
+}
+/** A design matrix and where its rows came from. */
+export interface ModelMatrix {
+    /**
+     * The design, one row per complete data row, with the coefficient names
+     * as column names: `(Intercept)`, the main effects, the interactions as
+     * `a:b`.
+     */
+    readonly matrix: Matrix;
+    /** The data rows the design holds, in input order. */
+    readonly rows: readonly number[];
+    /** R's `assign`: the term each column came from, 0 for the intercept. */
+    readonly assign: readonly number[];
+    /** R's `term.labels`: the terms in the order the columns follow. */
+    readonly termLabels: readonly string[];
+}
+/**
+ * Build the design matrix of a model, as R's `model.matrix()` does.
+ *
+ * @param data The frame holding every column the model names.
+ * @param spec The outcome, the terms, and the intercept flag.
+ * @returns The design, the rows it kept, and R's `assign` and term labels.
+ * @throws RangeError If a named column is absent or not numeric (through
+ *   `requireNumericColumn`, naming the option it arrived through), if the
+ *   frame is ragged, or if an interaction term names no column.
+ */
+export declare function modelMatrix(data: DataFrame, spec: ModelSpec): ModelMatrix;
+//# sourceMappingURL=modelMatrix.d.ts.map

package/dist/core/linalg/modelMatrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelMatrix.d.ts","sourceRoot":"","sources":["../../../src/core/linalg/modelMatrix.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAmC,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AAC3E,OAAO,EAAQ,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAE7C;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;AAE9C,oCAAoC;AACpC,MAAM,WAAW,SAAS;IACxB;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,sDAAsD;IACtD,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;IAChC,yEAAyE;IACzE,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,oDAAoD;AACpD,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,oEAAoE;IACpE,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG,WAAW,CA0DzE"}

package/dist/core/linalg/namedVector.d.ts

@@ -0,0 +1,37 @@
+/**
+ * R's named vector: values with a name each, in order.
+ *
+ * A coefficient vector is the case that matters here — `coef(fit)` in R
+ * prints `(Intercept)`, `x`, `z`, `x:z` above its values, and `summary()`
+ * lines the standard errors up under the same names. The port holds the
+ * names alongside the values rather than in an object keyed by name,
+ * because a JavaScript object moves an integer-like key to the front: a
+ * column called `"1"` would jump ahead of `(Intercept)`. The pair of arrays
+ * keeps R's order, and pairs with `dimnames` on a `Matrix`, so the column
+ * names of a model matrix become the names of a fit with no reshaping
+ * (plan Q11).
+ *
+ * `null` is R's `NA`: a coefficient the fit could not identify.
+ */
+/** Values with a name each, in order. */
+export interface NamedVector {
+    readonly names: readonly string[];
+    /** One value per name; null where R reports `NA`. */
+    readonly values: readonly (number | null)[];
+}
+/**
+ * Pair names with values.
+ *
+ * @param names One name per value. Copied.
+ * @param values One value per name; null for R's `NA`. Copied.
+ * @throws RangeError If the two lengths differ.
+ */
+export declare function namedVector(names: readonly string[], values: readonly (number | null)[]): NamedVector;
+/**
+ * Read one value by name. R's `v[["name"]]`.
+ *
+ * @returns The value, null where the entry is R's `NA`, or undefined when
+ *   no entry carries the name. With a repeated name, the first.
+ */
+export declare function lookup(v: NamedVector, name: string): number | null | undefined;
+//# sourceMappingURL=namedVector.d.ts.map

package/dist/core/linalg/namedVector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namedVector.d.ts","sourceRoot":"","sources":["../../../src/core/linalg/namedVector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,yCAAyC;AACzC,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,qDAAqD;IACrD,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;CAC7C;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GACjC,WAAW,CAOb;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAG9E"}