@tangent.to/lina 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Essi Parent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# tangent/lina
+
+Linear algebra for JavaScript (ESM). Browser-first, zero dependencies,
+runs in Node.js and Deno. The **lin**ear **a**lgebra leaf of the
+[tangent suite](https://github.com/tangent-to) — MIT-licensed
+infrastructure consumed by tangent/ds and tangent/sem.
+
+Matrices are plain nested row-major arrays (`number[][]`) at the API
+boundary; computation runs on flat `Float64Array` storage internally.
+
+## What's in it
+
+- **Factorizations**: `lu` (partial pivoting), `qr` (Householder,
+  reduced/full), `cholesky`, `svd` (one-sided Jacobi — high relative
+  accuracy), `eigSym` (cyclic Jacobi, symmetric matrices)
+- **Solvers**: `solve` (vector or multi-RHS), `choleskySolve`, `lstsq`
+  (QR-based), `pinvSolve` (minimum-norm, any rank)
+- **SVD-derived**: `pinv`, `rank`, `cond`
+- **Utilities**: `matmul`, `transpose`, `identity`, `diag`, `norm`
+  (fro/1/inf), `trace`, `det`, `inv`, `isPositiveDefinite`
+
+## Install
+
+```bash
+npm install @tangent.to/lina     # npm
+deno add jsr:@tangent/lina       # Deno / JSR
+```
+
+## Usage
+
+```javascript
+import { cholesky, eigSym, lstsq, solve, svd } from '@tangent.to/lina';
+
+solve([[2, 1], [1, 3]], [3, 5]);            // [0.8, 1.4]
+
+const { values, vectors } = eigSym(covarianceMatrix);  // PCA in two lines
+const { U, s, V } = svd(dataMatrix);
+
+const { x } = lstsq(designMatrix, y);        // OLS coefficients
+const L = cholesky(spdMatrix);               // throws if not positive definite
+```
+
+## Validation against numpy/scipy
+
+`tests_compare-to-scipy/` checks every operation against
+`numpy.linalg`/`scipy.linalg` on seeded random matrices — solve/det/inv,
+Cholesky (entrywise vs numpy), QR and SVD invariants, singular values and
+symmetric eigenvalues vs numpy, lstsq, pinv (including rank-deficient),
+rank and cond. Agreement is at machine precision (~1e-15). Requires
+[uv](https://docs.astral.sh/uv/) and Node:
+
+```bash
+npm run test:scipy
+```
+
+## Scope
+
+Dense, double-precision, textbook-modern algorithms sized for the suite's
+workloads (covariance algebra, regression, ordination — n up to a few
+hundred). Deliberately out of scope: sparse matrices, complex numbers,
+general nonsymmetric eigenproblems (until a consumer needs them), and
+BLAS-style micro-optimization — wasm kernels belong in tangent/nd when it
+lands.
+
+## Performance
+
+lina favors simple, unconditionally-stable algorithms (one-sided Jacobi
+SVD, cyclic Jacobi eigensolver) that hit machine precision on the suite's
+target sizes. On `solve`/`inv` it is competitive with the mature
+`ml-matrix`; on `matmul` and `svd` it is roughly 1.5–2× slower, and on
+symmetric eigendecomposition about 5× slower, because those Jacobi methods
+trade speed for simplicity. If a consumer ever profiles past this, the fix
+is targeted, not a rewrite: swap the symmetric eigensolver for tridiagonal
+QL and the SVD for Golub–Reinsch (the JAMA algorithms), and improve
+`matmul` cache locality. Until then, correctness and a zero-dependency
+footprint win. lina is not a general-purpose matrix library — for the rich
+`Matrix` API (elementwise arithmetic, broadcasting, views, nonsymmetric
+eigen), use `ml-matrix`; lina is the focused linear-algebra leaf the
+tangent suite's own packages build on.
+
+## License
+
+MIT.

package/dist/index.js

@@ -0,0 +1,2 @@
+var ft=Object.defineProperty;var w=(i,a)=>ft(i,"name",{value:a,configurable:!0});function M(i,a="A"){if(!Array.isArray(i)||i.length===0||!Array.isArray(i[0]))throw new Error(`${a} must be a non-empty array of rows`);let e=i.length,t=i[0].length;if(t===0)throw new Error(`${a} must have at least one column`);let n=new Float64Array(e*t);for(let r=0;r<e;r++){let o=i[r];if(!Array.isArray(o)||o.length!==t)throw new Error(`${a} is not rectangular (row ${r} has length ${o?.length}, expected ${t})`);for(let f=0;f<t;f++)n[r*t+f]=o[f]}return{data:n,m:e,n:t}}w(M,"fromNested");function $(i,a,e){let t=new Array(a);for(let n=0;n<a;n++){let r=new Array(e);for(let o=0;o<e;o++)r[o]=i[n*e+o];t[n]=r}return t}w($,"toNested");function j(i,a,e="b"){if(!Array.isArray(i)||i.length!==a)throw new Error(`${e} must be an array of length ${a} (got ${i?.length})`);return Float64Array.from(i)}w(j,"vecFrom");function Q(i,a,e=1e-10){let{data:t,m:n,n:r}=i;if(n!==r)throw new Error(`${a}: matrix must be square (got ${n}x${r})`);let o=0;for(let l=0;l<t.length;l++)o=Math.max(o,Math.abs(t[l]));let f=e*Math.max(1,o);for(let l=0;l<r;l++)for(let c=l+1;c<r;c++)if(Math.abs(t[l*r+c]-t[c*r+l])>f)throw new Error(`${a}: matrix is not symmetric (A[${l}][${c}] != A[${c}][${l}])`)}w(Q,"assertSymmetric");function W(i,a){let e=Float64Array.from(i),t=new Int32Array(a),n=new Float64Array(a),r=0;for(let c=0;c<e.length;c++)r=Math.max(r,Math.abs(e[c]));let o=1e-13*r,f=1,l=r===0;for(let c=0;c<a;c++){t[c]=c;let u=0;for(let p=0;p<a;p++)u=Math.max(u,Math.abs(e[c*a+p]));n[c]=u}for(let c=0;c<a;c++){let u=c,p=-1;for(let s=c;s<a;s++){let y=n[s]>0?Math.abs(e[s*a+c])/n[s]:0;y>p&&(p=y,u=s)}if(u!==c){for(let m=0;m<a;m++){let g=e[c*a+m];e[c*a+m]=e[u*a+m],e[u*a+m]=g}let s=n[c];n[c]=n[u],n[u]=s;let y=t[c];t[c]=t[u],t[u]=y,f=-f}let d=e[c*a+c];if(Math.abs(d)<=o){l=!0;continue}for(let s=c+1;s<a;s++){let y=e[s*a+c]/d;e[s*a+c]=y;for(let m=c+1;m<a;m++)e[s*a+m]-=y*e[c*a+m]}}return{a:e,perm:t,sign:f,singular:l}}w(W,"luFactor");function B(i,a){let e=M(i,"A");if(e.m!==e.n)throw new Error(`${a}: matrix must be square (got ${e.m}x${e.n})`);return e}w(B,"squareFromNested");function X(i){let{data:a,n:e}=B(i,"lu"),{a:t,perm:n}=W(a,e),r=new Float64Array(e*e),o=new Float64Array(e*e),f=new Float64Array(e*e);for(let l=0;l<e;l++){r[l*e+l]=1,f[l*e+n[l]]=1;for(let c=0;c<l;c++)r[l*e+c]=t[l*e+c];for(let c=l;c<e;c++)o[l*e+c]=t[l*e+c]}return{L:$(r,e,e),U:$(o,e,e),P:$(f,e,e)}}w(X,"lu");function it(i,a,e,t){for(let n=1;n<e;n++){let r=t[n];for(let o=0;o<n;o++)r-=i[n*e+o]*t[o];t[n]=r}for(let n=e-1;n>=0;n--){let r=t[n];for(let o=n+1;o<e;o++)r-=i[n*e+o]*t[o];t[n]=r/i[n*e+n]}}w(it,"luSolveInPlace");function O(i,a){let{data:e,n:t}=B(i,"solve"),{a:n,perm:r,singular:o}=W(e,t);if(o)throw new Error("solve: matrix is singular (pivot below tolerance)");if(!(Array.isArray(a)&&Array.isArray(a[0]))){let d=j(a,t,"b"),s=new Float64Array(t);for(let y=0;y<t;y++)s[y]=d[r[y]];return it(n,r,t,s),Array.from(s)}let l=M(a,"b");if(l.m!==t)throw new Error(`solve: b must have ${t} rows (got ${l.m})`);let c=l.n,u=new Float64Array(t*c),p=new Float64Array(t);for(let d=0;d<c;d++){for(let s=0;s<t;s++)p[s]=l.data[r[s]*c+d];it(n,r,t,p);for(let s=0;s<t;s++)u[s*c+d]=p[s]}return $(u,t,c)}w(O,"solve");function G(i){let{data:a,n:e}=B(i,"det"),{a:t,sign:n,singular:r}=W(a,e);if(r)return 0;let o=n;for(let f=0;f<e;f++)o*=t[f*e+f];return o}w(G,"det");function H(i){let e=B(i,"inv").n,t=new Array(e);for(let n=0;n<e;n++){let r=new Array(e).fill(0);r[n]=1,t[n]=r}return O(i,t)}w(H,"inv");function _(i){let a=M(i,"A");Q(a,"cholesky");let{data:e,n:t}=a,n=new Float64Array(t*t);for(let r=0;r<t;r++){let o=e[r*t+r];for(let l=0;l<r;l++)o-=n[r*t+l]*n[r*t+l];if(o<=0)throw new Error(`cholesky: matrix is not positive definite (pivot ${r} is ${o})`);let f=Math.sqrt(o);n[r*t+r]=f;for(let l=r+1;l<t;l++){let c=e[l*t+r];for(let u=0;u<r;u++)c-=n[l*t+u]*n[r*t+u];n[l*t+r]=c/f}}return $(n,t,t)}w(_,"cholesky");function J(i,a){let e=M(i,"L");if(e.m!==e.n)throw new Error(`choleskySolve: L must be square (got ${e.m}x${e.n})`);let{data:t,n}=e,r=j(a,n,"b");for(let o=0;o<n;o++){let f=r[o];for(let l=0;l<o;l++)f-=t[o*n+l]*r[l];r[o]=f/t[o*n+o]}for(let o=n-1;o>=0;o--){let f=r[o];for(let l=o+1;l<n;l++)f-=t[l*n+o]*r[l];r[o]=f/t[o*n+o]}return Array.from(r)}w(J,"choleskySolve");function K(i){try{return _(i),!0}catch{return!1}}w(K,"isPositiveDefinite");function ct(i,a,e){let t=Math.min(a,e),n=new Array(t),r=new Float64Array(t);for(let o=0;o<t;o++){let f=0;for(let s=o;s<a;s++){let y=i[s*e+o];f+=y*y}f=Math.sqrt(f);let l=new Float64Array(a-o);if(n[o]=l,f===0){r[o]=0;continue}let c=i[o*e+o],u=c>=0?1:-1;l[0]=c+u*f;for(let s=o+1;s<a;s++)l[s-o]=i[s*e+o];let p=0;for(let s=0;s<l.length;s++)p+=l[s]*l[s];let d=2/p;r[o]=d;for(let s=o+1;s<e;s++){let y=0;for(let m=o;m<a;m++)y+=l[m-o]*i[m*e+s];y*=d;for(let m=o;m<a;m++)i[m*e+s]-=y*l[m-o]}i[o*e+o]=-u*f;for(let s=o+1;s<a;s++)i[s*e+o]=0}return{vs:n,betas:r,k:t}}w(ct,"householderFactor");function mt(i,a,e,t){let n=new Float64Array(e*t);for(let r=0;r<t;r++)n[r*t+r]=1;for(let r=i.length-1;r>=0;r--){let o=i[r],f=a[r];if(f!==0)for(let l=0;l<t;l++){let c=0;for(let u=r;u<e;u++)c+=o[u-r]*n[u*t+l];c*=f;for(let u=r;u<e;u++)n[u*t+l]-=c*o[u-r]}}return n}w(mt,"accumulateQ");function T(i,a={}){let{data:e,m:t,n}=M(i,"A"),r=a.mode!==void 0?a.mode:"reduced";if(r!=="reduced"&&r!=="full")throw new Error(`qr: options.mode must be 'reduced' or 'full' (got '${r}')`);let{vs:o,betas:f,k:l}=ct(e,t,n),c=r==="full"?t:l,u=mt(o,f,t,c),p=r==="full"?t:l;return{Q:$(u,t,c),R:$(e.subarray(0,p*n),p,n)}}w(T,"qr");function Y(i,a){let{data:e,m:t,n}=M(i,"A");if(t<n)throw new Error(`lstsq: A must have at least as many rows as columns (got ${t}x${n})`);let r=j(a,t,"b"),o=e.slice(),{vs:f,betas:l,k:c}=ct(e,t,n),u=0;for(let s=0;s<c;s++)for(let y=s;y<n;y++)u=Math.max(u,Math.abs(e[s*n+y]));for(let s=0;s<n;s++)if(Math.abs(e[s*n+s])<1e-12*u||u===0)throw new Error(`lstsq: A is rank deficient (R[${s}][${s}] is negligible); use pinv for a minimum-norm solution`);for(let s=0;s<c;s++){let y=f[s],m=l[s];if(m===0)continue;let g=0;for(let h=s;h<t;h++)g+=y[h-s]*r[h];g*=m;for(let h=s;h<t;h++)r[h]-=g*y[h-s]}let p=new Array(n).fill(0);for(let s=n-1;s>=0;s--){let y=r[s];for(let m=s+1;m<n;m++)y-=e[s*n+m]*p[m];p[s]=y/e[s*n+s]}let d=0;for(let s=0;s<t;s++){let y=-a[s];for(let m=0;m<n;m++)y+=o[s*n+m]*p[m];d+=y*y}return{x:p,residualNorm:Math.sqrt(d)}}w(Y,"lstsq");function R(i,a={}){let e=M(i),t=e.m<e.n,n=t?e.n:e.m,r=t?e.m:e.n,o=new Float64Array(n*r);if(t)for(let h=0;h<r;h++)for(let v=0;v<n;v++)o[h*n+v]=e.data[h*e.n+v];else for(let h=0;h<r;h++)for(let v=0;v<n;v++)o[h*n+v]=e.data[v*e.n+h];let f=new Float64Array(r*r);for(let h=0;h<r;h++)f[h*r+h]=1;let l=a.maxSweeps||60,c=a.tol||1e-15;for(let h=0;h<l;h++){let v=!1;for(let q=0;q<r-1;q++)for(let A=q+1;A<r;A++){let F=0,L=0,S=0,I=q*n,x=A*n;for(let b=0;b<n;b++){let N=o[I+b],k=o[x+b];F+=N*N,L+=k*k,S+=N*k}if(Math.abs(S)<=c*Math.sqrt(F*L)||F===0||L===0)continue;v=!0;let P=(L-F)/(2*S),U=(P>=0?1:-1)/(Math.abs(P)+Math.sqrt(1+P*P)),E=1/Math.sqrt(1+U*U),D=E*U;for(let b=0;b<n;b++){let N=o[I+b],k=o[x+b];o[I+b]=E*N-D*k,o[x+b]=D*N+E*k}for(let b=0;b<r;b++){let N=f[q*r+b],k=f[A*r+b];f[q*r+b]=E*N-D*k,f[A*r+b]=D*N+E*k}}if(!v)break}let u=new Array(r);for(let h=0;h<r;h++){let v=0;for(let q=0;q<n;q++)v+=o[h*n+q]*o[h*n+q];u[h]=Math.sqrt(v)}let p=Array.from({length:r},(h,v)=>v).sort((h,v)=>u[v]-u[h]),d=p.map(h=>u[h]),s=new Float64Array(n*r),y=new Float64Array(r*r);for(let h=0;h<r;h++){let v=p[h],q=u[v];if(q>0)for(let A=0;A<n;A++)s[A*r+h]=o[v*n+A]/q;for(let A=0;A<r;A++)y[A*r+h]=f[v*r+A]}let m=$(s,n,r),g=$(y,r,r);return t?{U:g,s:d,V:m}:{U:m,s:d,V:g}}w(R,"svd");function Z(i,a){let{s:e}=R(i),t=i.length,n=i[0].length,r=a!==void 0?a:Math.max(t,n)*Number.EPSILON*(e[0]||0);return e.filter(o=>o>r).length}w(Z,"rank");function C(i){let{s:a}=R(i),e=a[a.length-1];return e>0?a[0]/e:1/0}w(C,"cond");function z(i,a){let{U:e,s:t,V:n}=R(i),r=e.length,o=n.length,f=t.length,l=(a!==void 0?a:Math.max(r,o)*Number.EPSILON)*(t[0]||0),c=new Array(o);for(let u=0;u<o;u++)c[u]=new Array(r).fill(0);for(let u=0;u<f;u++){if(t[u]<=l)continue;let p=1/t[u];for(let d=0;d<o;d++){let s=n[d][u]*p;if(s===0)continue;let y=c[d];for(let m=0;m<r;m++)y[m]+=s*e[m][u]}}return c}w(z,"pinv");function tt(i,a){let e=i.length;j(a,e,"b");let t=z(i),n=t.length,r=new Array(n).fill(0);for(let o=0;o<n;o++){let f=0;for(let l=0;l<e;l++)f+=t[o][l]*a[l];r[o]=f}return r}w(tt,"pinvSolve");function rt(i,a={}){let e=M(i);Q(e,"eigSym");let t=e.n,n=a.maxSweeps||60,r=a.tol||1e-14,o=Float64Array.from(e.data),f=new Float64Array(t*t);for(let s=0;s<t;s++)f[s*t+s]=1;let l=0;for(let s=0;s<t;s++)l=Math.max(l,Math.abs(o[s*t+s]));for(let s=0;s<o.length;s++)l=Math.max(l,Math.abs(o[s]));let c=r*Math.max(1,l);for(let s=0;s<n;s++){let y=0;for(let m=0;m<t;m++)for(let g=m+1;g<t;g++)y+=Math.abs(o[m*t+g]);if(y<=c*t)break;for(let m=0;m<t;m++)for(let g=m+1;g<t;g++){let h=o[m*t+g];if(Math.abs(h)<=c*.01)continue;let v=o[m*t+m],q=o[g*t+g],A=(q-v)/(2*h),F=Math.sign(A)/(Math.abs(A)+Math.sqrt(A*A+1))||1/(A+Math.sign(A||1)*Math.sqrt(A*A+1)),L=1/Math.sqrt(F*F+1),S=F*L,I=S/(1+L);o[m*t+m]=v-F*h,o[g*t+g]=q+F*h,o[m*t+g]=0,o[g*t+m]=0;for(let x=0;x<t;x++){if(x!==m&&x!==g){let U=o[x*t+m],E=o[x*t+g];o[x*t+m]=U-S*(E+I*U),o[x*t+g]=E+S*(U-I*E),o[m*t+x]=o[x*t+m],o[g*t+x]=o[x*t+g]}let P=f[x*t+m],V=f[x*t+g];f[x*t+m]=P-S*(V+I*P),f[x*t+g]=V+S*(P-I*V)}}}let u=Array.from({length:t},(s,y)=>y).sort((s,y)=>o[y*t+y]-o[s*t+s]),p=u.map(s=>o[s*t+s]),d=new Float64Array(t*t);for(let s=0;s<t;s++){let y=u[s],m=0,g=1;for(let h=0;h<t;h++){let v=f[h*t+y];Math.abs(v)>m&&(m=Math.abs(v),g=v>=0?1:-1)}for(let h=0;h<t;h++)d[h*t+s]=g*f[h*t+y]}return{values:p,vectors:$(d,t,t)}}w(rt,"eigSym");function ot(i,a){let e=M(i,"A"),{data:t,m:n,n:r}=e;if(Array.isArray(a)&&!Array.isArray(a[0])){let u=j(a,r,"B"),p=new Float64Array(n);for(let d=0;d<n;d++){let s=0;for(let y=0;y<r;y++)s+=t[d*r+y]*u[y];p[d]=s}return Array.from(p)}let o=M(a,"B");if(o.m!==r)throw new Error(`matmul: dimension mismatch (A is ${n}x${r}, B is ${o.m}x${o.n})`);let f=o.data,l=o.n,c=new Float64Array(n*l);for(let u=0;u<n;u++)for(let p=0;p<r;p++){let d=t[u*r+p];if(d!==0)for(let s=0;s<l;s++)c[u*l+s]+=d*f[p*l+s]}return $(c,n,l)}w(ot,"matmul");function et(i){let{data:a,m:e,n:t}=M(i,"A"),n=new Float64Array(t*e);for(let r=0;r<e;r++)for(let o=0;o<t;o++)n[o*e+r]=a[r*t+o];return $(n,t,e)}w(et,"transpose");function nt(i){if(!Number.isInteger(i)||i<=0)throw new Error(`identity: n must be a positive integer (got ${i})`);let a=new Array(i);for(let e=0;e<i;e++){let t=new Array(i).fill(0);t[e]=1,a[e]=t}return a}w(nt,"identity");function st(i){if(!Array.isArray(i)||i.length===0)throw new Error("diag: argument must be a non-empty vector or nested matrix");if(Array.isArray(i[0])){let{data:t,m:n,n:r}=M(i,"A"),o=Math.min(n,r),f=new Array(o);for(let l=0;l<o;l++)f[l]=t[l*r+l];return f}let a=i.length,e=new Array(a);for(let t=0;t<a;t++){let n=new Array(a).fill(0);n[t]=i[t],e[t]=n}return e}w(st,"diag");function at(i,a="fro"){if(!Array.isArray(i)||i.length===0)throw new Error("norm: argument must be a non-empty vector or nested matrix");if(!Array.isArray(i[0])){if(a==="fro"||a===2){let r=0;for(let o=0;o<i.length;o++)r+=i[o]*i[o];return Math.sqrt(r)}if(a===1){let r=0;for(let o=0;o<i.length;o++)r+=Math.abs(i[o]);return r}if(a===1/0){let r=0;for(let o=0;o<i.length;o++)r=Math.max(r,Math.abs(i[o]));return r}throw new Error(`norm: unsupported vector norm kind ${String(a)}`)}let{data:e,m:t,n}=M(i,"A");if(a==="fro"){let r=0;for(let o=0;o<e.length;o++)r+=e[o]*e[o];return Math.sqrt(r)}if(a===1){let r=0;for(let o=0;o<n;o++){let f=0;for(let l=0;l<t;l++)f+=Math.abs(e[l*n+o]);r=Math.max(r,f)}return r}if(a===1/0){let r=0;for(let o=0;o<t;o++){let f=0;for(let l=0;l<n;l++)f+=Math.abs(e[o*n+l]);r=Math.max(r,f)}return r}throw new Error(`norm: unsupported matrix norm kind ${String(a)} (use 'fro', 1, or Infinity)`)}w(at,"norm");function lt(i){let{data:a,m:e,n:t}=M(i,"A");if(e!==t)throw new Error(`trace: matrix must be square (got ${e}x${t})`);let n=0;for(let r=0;r<t;r++)n+=a[r*t+r];return n}w(lt,"trace");var Qt={lu:X,solve:O,det:G,inv:H,cholesky:_,choleskySolve:J,isPositiveDefinite:K,qr:T,lstsq:Y,svd:R,pinv:z,pinvSolve:tt,rank:Z,cond:C,eigSym:rt,matmul:ot,transpose:et,identity:nt,diag:st,norm:at,trace:lt};export{_ as cholesky,J as choleskySolve,C as cond,Qt as default,G as det,st as diag,rt as eigSym,nt as identity,H as inv,K as isPositiveDefinite,Y as lstsq,X as lu,ot as matmul,at as norm,z as pinv,tt as pinvSolve,T as qr,Z as rank,O as solve,R as svd,lt as trace,et as transpose};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/_mat.js", "../src/lu.js", "../src/cholesky.js", "../src/qr.js", "../src/svd.js", "../src/eigsym.js", "../src/ops.js", "../src/index.js"],
+  "sourcesContent": ["/**\n * Internal matrix representation.\n *\n * Public lina APIs accept and return row-major nested arrays\n * (Array<Array<number>>) \u2014 the tangent suite's boundary currency.\n * Internally, algorithms run on flat Float64Array storage for speed.\n * This module is the only place that converts between the two.\n */\n\n/**\n * Convert a nested row-major matrix to flat storage.\n * Validates rectangularity and finite dimensions.\n *\n * @param {Array<Array<number>>} A - Nested matrix\n * @param {string} [name='A'] - Argument name for error messages\n * @returns {{data: Float64Array, m: number, n: number}}\n */\nexport function fromNested(A, name = 'A') {\n  if (!Array.isArray(A) || A.length === 0 || !Array.isArray(A[0])) {\n    throw new Error(`${name} must be a non-empty array of rows`);\n  }\n  const m = A.length;\n  const n = A[0].length;\n  if (n === 0) {\n    throw new Error(`${name} must have at least one column`);\n  }\n  const data = new Float64Array(m * n);\n  for (let i = 0; i < m; i++) {\n    const row = A[i];\n    if (!Array.isArray(row) || row.length !== n) {\n      throw new Error(`${name} is not rectangular (row ${i} has length ${row?.length}, expected ${n})`);\n    }\n    for (let j = 0; j < n; j++) {\n      data[i * n + j] = row[j];\n    }\n  }\n  return { data, m, n };\n}\n\n/**\n * Convert flat storage back to a nested row-major matrix.\n *\n * @param {Float64Array|Array<number>} data - Flat row-major values\n * @param {number} m - Rows\n * @param {number} n - Columns\n * @returns {Array<Array<number>>}\n */\nexport function toNested(data, m, n) {\n  const A = new Array(m);\n  for (let i = 0; i < m; i++) {\n    const row = new Array(n);\n    for (let j = 0; j < n; j++) {\n      row[j] = data[i * n + j];\n    }\n    A[i] = row;\n  }\n  return A;\n}\n\n/**\n * Validate a vector argument and copy it to a Float64Array.\n *\n * @param {Array<number>} b - Vector\n * @param {number} expected - Required length\n * @param {string} [name='b'] - Argument name for error messages\n * @returns {Float64Array}\n */\nexport function vecFrom(b, expected, name = 'b') {\n  if (!Array.isArray(b) || b.length !== expected) {\n    throw new Error(`${name} must be an array of length ${expected} (got ${b?.length})`);\n  }\n  return Float64Array.from(b);\n}\n\n/**\n * Check symmetry to a tolerance; throws when violated.\n *\n * @param {{data: Float64Array, m: number, n: number}} M - Flat matrix\n * @param {string} caller - Function name for the error message\n * @param {number} [tol=1e-10] - Relative tolerance\n */\nexport function assertSymmetric(M, caller, tol = 1e-10) {\n  const { data, m, n } = M;\n  if (m !== n) {\n    throw new Error(`${caller}: matrix must be square (got ${m}x${n})`);\n  }\n  let scale = 0;\n  for (let i = 0; i < data.length; i++) scale = Math.max(scale, Math.abs(data[i]));\n  const bound = tol * Math.max(1, scale);\n  for (let i = 0; i < n; i++) {\n    for (let j = i + 1; j < n; j++) {\n      if (Math.abs(data[i * n + j] - data[j * n + i]) > bound) {\n        throw new Error(`${caller}: matrix is not symmetric (A[${i}][${j}] != A[${j}][${i}])`);\n      }\n    }\n  }\n}\n", "/**\n * LU factorization with scaled partial pivoting, and LU-based solve/det/inv.\n *\n * Public APIs accept and return nested row-major matrices; computation runs\n * on flat Float64Array storage (see _mat.js).\n */\n\nimport { fromNested, toNested, vecFrom } from './_mat.js';\n\n/**\n * Factor a flat square matrix in place-of-copy with scaled partial pivoting.\n *\n * Returns the combined LU storage (unit-diagonal L strictly below the\n * diagonal, U on and above), the row permutation `perm` (row k of the\n * factored matrix is row perm[k] of the input), the permutation sign, and a\n * singularity flag (any pivot with |pivot| <= 1e-13 * maxAbs of the input).\n *\n * @param {Float64Array} src - Flat row-major n*n values (not modified)\n * @param {number} n - Dimension\n * @returns {{a: Float64Array, perm: Int32Array, sign: number, singular: boolean}}\n */\nfunction luFactor(src, n) {\n  const a = Float64Array.from(src);\n  const perm = new Int32Array(n);\n  const scale = new Float64Array(n);\n  let maxAbs = 0;\n  for (let i = 0; i < a.length; i++) maxAbs = Math.max(maxAbs, Math.abs(a[i]));\n  const tol = 1e-13 * maxAbs;\n  let sign = 1;\n  let singular = maxAbs === 0;\n\n  for (let i = 0; i < n; i++) {\n    perm[i] = i;\n    let s = 0;\n    for (let j = 0; j < n; j++) s = Math.max(s, Math.abs(a[i * n + j]));\n    scale[i] = s;\n  }\n\n  for (let k = 0; k < n; k++) {\n    // Pick the row maximizing |a[i][k]| / scale[i] among rows k..n-1.\n    let p = k;\n    let best = -1;\n    for (let i = k; i < n; i++) {\n      const v = scale[i] > 0 ? Math.abs(a[i * n + k]) / scale[i] : 0;\n      if (v > best) {\n        best = v;\n        p = i;\n      }\n    }\n    if (p !== k) {\n      for (let j = 0; j < n; j++) {\n        const t = a[k * n + j];\n        a[k * n + j] = a[p * n + j];\n        a[p * n + j] = t;\n      }\n      const ts = scale[k];\n      scale[k] = scale[p];\n      scale[p] = ts;\n      const tp = perm[k];\n      perm[k] = perm[p];\n      perm[p] = tp;\n      sign = -sign;\n    }\n    const pivot = a[k * n + k];\n    if (Math.abs(pivot) <= tol) {\n      singular = true;\n      continue;\n    }\n    for (let i = k + 1; i < n; i++) {\n      const f = a[i * n + k] / pivot;\n      a[i * n + k] = f;\n      for (let j = k + 1; j < n; j++) {\n        a[i * n + j] -= f * a[k * n + j];\n      }\n    }\n  }\n\n  return { a, perm, sign, singular };\n}\n\n/**\n * Validate a square nested matrix and return its flat form.\n *\n * @param {Array<Array<number>>} A - Nested matrix\n * @param {string} caller - Function name for error messages\n * @returns {{data: Float64Array, m: number, n: number}}\n */\nfunction squareFromNested(A, caller) {\n  const M = fromNested(A, 'A');\n  if (M.m !== M.n) {\n    throw new Error(`${caller}: matrix must be square (got ${M.m}x${M.n})`);\n  }\n  return M;\n}\n\n/**\n * LU factorization with partial pivoting: P A = L U.\n *\n * @param {Array<Array<number>>} A - Square nested matrix\n * @returns {{L: Array<Array<number>>, U: Array<Array<number>>, P: Array<Array<number>>}}\n *   L unit lower triangular, U upper triangular, P a permutation matrix.\n */\nexport function lu(A) {\n  const { data, n } = squareFromNested(A, 'lu');\n  const { a, perm } = luFactor(data, n);\n  const L = new Float64Array(n * n);\n  const U = new Float64Array(n * n);\n  const P = new Float64Array(n * n);\n  for (let i = 0; i < n; i++) {\n    L[i * n + i] = 1;\n    P[i * n + perm[i]] = 1;\n    for (let j = 0; j < i; j++) L[i * n + j] = a[i * n + j];\n    for (let j = i; j < n; j++) U[i * n + j] = a[i * n + j];\n  }\n  return { L: toNested(L, n, n), U: toNested(U, n, n), P: toNested(P, n, n) };\n}\n\n/**\n * Solve L U x = P b for one right-hand side, in place in `x`.\n *\n * @param {Float64Array} a - Combined LU storage\n * @param {Int32Array} perm - Row permutation\n * @param {number} n - Dimension\n * @param {Float64Array} x - Permuted right-hand side; overwritten with the solution\n */\nfunction luSolveInPlace(a, perm, n, x) {\n  // Forward substitution with unit lower triangular L.\n  for (let i = 1; i < n; i++) {\n    let s = x[i];\n    for (let j = 0; j < i; j++) s -= a[i * n + j] * x[j];\n    x[i] = s;\n  }\n  // Back substitution with U.\n  for (let i = n - 1; i >= 0; i--) {\n    let s = x[i];\n    for (let j = i + 1; j < n; j++) s -= a[i * n + j] * x[j];\n    x[i] = s / a[i * n + i];\n  }\n}\n\n/**\n * Solve A x = b via LU factorization with partial pivoting.\n *\n * @param {Array<Array<number>>} A - Square nested matrix\n * @param {Array<number>|Array<Array<number>>} b - Right-hand side vector (length n)\n *   or nested matrix of right-hand sides (n x k, solved column by column)\n * @returns {Array<number>|Array<Array<number>>} Solution vector, or nested n x k matrix\n */\nexport function solve(A, b) {\n  const { data, n } = squareFromNested(A, 'solve');\n  const { a, perm, singular } = luFactor(data, n);\n  if (singular) {\n    throw new Error('solve: matrix is singular (pivot below tolerance)');\n  }\n\n  const matrixRhs = Array.isArray(b) && Array.isArray(b[0]);\n  if (!matrixRhs) {\n    const bv = vecFrom(b, n, 'b');\n    const x = new Float64Array(n);\n    for (let i = 0; i < n; i++) x[i] = bv[perm[i]];\n    luSolveInPlace(a, perm, n, x);\n    return Array.from(x);\n  }\n\n  const B = fromNested(b, 'b');\n  if (B.m !== n) {\n    throw new Error(`solve: b must have ${n} rows (got ${B.m})`);\n  }\n  const k = B.n;\n  const X = new Float64Array(n * k);\n  const x = new Float64Array(n);\n  for (let c = 0; c < k; c++) {\n    for (let i = 0; i < n; i++) x[i] = B.data[perm[i] * k + c];\n    luSolveInPlace(a, perm, n, x);\n    for (let i = 0; i < n; i++) X[i * k + c] = x[i];\n  }\n  return toNested(X, n, k);\n}\n\n/**\n * Determinant via LU factorization (permutation sign times product of pivots).\n * Returns 0 for singular matrices instead of throwing.\n *\n * @param {Array<Array<number>>} A - Square nested matrix\n * @returns {number}\n */\nexport function det(A) {\n  const { data, n } = squareFromNested(A, 'det');\n  const { a, sign, singular } = luFactor(data, n);\n  if (singular) return 0;\n  let d = sign;\n  for (let i = 0; i < n; i++) d *= a[i * n + i];\n  return d;\n}\n\n/**\n * Matrix inverse via solve(A, I).\n *\n * @param {Array<Array<number>>} A - Square nested matrix\n * @returns {Array<Array<number>>}\n */\nexport function inv(A) {\n  const M = squareFromNested(A, 'inv');\n  const n = M.n;\n  const I = new Array(n);\n  for (let i = 0; i < n; i++) {\n    const row = new Array(n).fill(0);\n    row[i] = 1;\n    I[i] = row;\n  }\n  return solve(A, I);\n}\n", "/**\n * Cholesky factorization A = L L^T for symmetric positive definite matrices.\n *\n * Public APIs accept and return nested row-major matrices; computation runs\n * on flat Float64Array storage (see _mat.js).\n */\n\nimport { assertSymmetric, fromNested, toNested, vecFrom } from './_mat.js';\n\n/**\n * Cholesky factorization of a symmetric positive definite matrix.\n *\n * @param {Array<Array<number>>} A - Symmetric positive definite nested matrix\n * @returns {Array<Array<number>>} Lower triangular L with A = L L^T\n * @throws {Error} When A is not symmetric, or a diagonal pivot is <= 0\n *   (not positive definite)\n */\nexport function cholesky(A) {\n  const M = fromNested(A, 'A');\n  assertSymmetric(M, 'cholesky');\n  const { data, n } = M;\n  const L = new Float64Array(n * n);\n  for (let j = 0; j < n; j++) {\n    let d = data[j * n + j];\n    for (let k = 0; k < j; k++) d -= L[j * n + k] * L[j * n + k];\n    if (d <= 0) {\n      throw new Error(`cholesky: matrix is not positive definite (pivot ${j} is ${d})`);\n    }\n    const ljj = Math.sqrt(d);\n    L[j * n + j] = ljj;\n    for (let i = j + 1; i < n; i++) {\n      let s = data[i * n + j];\n      for (let k = 0; k < j; k++) s -= L[i * n + k] * L[j * n + k];\n      L[i * n + j] = s / ljj;\n    }\n  }\n  return toNested(L, n, n);\n}\n\n/**\n * Solve A x = b given the Cholesky factor L of A (A = L L^T), by forward\n * substitution (L y = b) then back substitution (L^T x = y).\n *\n * @param {Array<Array<number>>} L - Lower triangular factor from cholesky()\n * @param {Array<number>} b - Right-hand side vector\n * @returns {Array<number>}\n */\nexport function choleskySolve(L, b) {\n  const M = fromNested(L, 'L');\n  if (M.m !== M.n) {\n    throw new Error(`choleskySolve: L must be square (got ${M.m}x${M.n})`);\n  }\n  const { data, n } = M;\n  const x = vecFrom(b, n, 'b');\n  // Forward substitution: L y = b.\n  for (let i = 0; i < n; i++) {\n    let s = x[i];\n    for (let j = 0; j < i; j++) s -= data[i * n + j] * x[j];\n    x[i] = s / data[i * n + i];\n  }\n  // Back substitution: L^T x = y.\n  for (let i = n - 1; i >= 0; i--) {\n    let s = x[i];\n    for (let j = i + 1; j < n; j++) s -= data[j * n + i] * x[j];\n    x[i] = s / data[i * n + i];\n  }\n  return Array.from(x);\n}\n\n/**\n * Test positive definiteness by attempting a Cholesky factorization.\n * Never throws; non-symmetric or malformed input returns false.\n *\n * @param {Array<Array<number>>} A - Nested matrix\n * @returns {boolean}\n */\nexport function isPositiveDefinite(A) {\n  try {\n    cholesky(A);\n    return true;\n  } catch {\n    return false;\n  }\n}\n", "/**\n * QR decomposition via Householder reflections, and least squares on top of it.\n *\n * Public APIs take and return nested row-major matrices (Array<Array<number>>)\n * and plain vectors (Array<number>); computation runs on flat Float64Array\n * storage via the helpers in _mat.js.\n */\n\nimport { fromNested, toNested, vecFrom } from './_mat.js';\n\n/**\n * Factor a flat matrix in place with Householder reflectors.\n *\n * After the call, `data` holds R in its upper triangle (subdiagonal entries of\n * the processed columns are set to exact zeros). The reflectors H_j =\n * I - beta_j v_j v_j^T (with v_j supported on rows j..m-1) satisfy\n * H_{k-1} ... H_0 A = R, i.e. A = H_0 ... H_{k-1} R.\n *\n * Uses the standard stable sign choice v = x + sign(x0) ||x|| e1.\n *\n * @param {Float64Array} data - Row-major m*n storage, overwritten with R\n * @param {number} m - Rows\n * @param {number} n - Columns\n * @returns {{vs: Array<Float64Array>, betas: Float64Array, k: number}}\n */\nfunction householderFactor(data, m, n) {\n  const k = Math.min(m, n);\n  const vs = new Array(k);\n  const betas = new Float64Array(k);\n  for (let j = 0; j < k; j++) {\n    let norm = 0;\n    for (let i = j; i < m; i++) {\n      const t = data[i * n + j];\n      norm += t * t;\n    }\n    norm = Math.sqrt(norm);\n    const v = new Float64Array(m - j);\n    vs[j] = v;\n    if (norm === 0) {\n      betas[j] = 0;\n      continue;\n    }\n    const x0 = data[j * n + j];\n    const sign = x0 >= 0 ? 1 : -1;\n    v[0] = x0 + sign * norm;\n    for (let i = j + 1; i < m; i++) v[i - j] = data[i * n + j];\n    let vv = 0;\n    for (let t = 0; t < v.length; t++) vv += v[t] * v[t];\n    const beta = 2 / vv;\n    betas[j] = beta;\n    // Apply H_j to the trailing columns.\n    for (let c = j + 1; c < n; c++) {\n      let s = 0;\n      for (let i = j; i < m; i++) s += v[i - j] * data[i * n + c];\n      s *= beta;\n      for (let i = j; i < m; i++) data[i * n + c] -= s * v[i - j];\n    }\n    // Column j maps exactly to -sign * norm * e1.\n    data[j * n + j] = -sign * norm;\n    for (let i = j + 1; i < m; i++) data[i * n + j] = 0;\n  }\n  return { vs, betas, k };\n}\n\n/**\n * Accumulate Q = H_0 H_1 ... H_{k-1} applied to the first qCols columns of I.\n *\n * @param {Array<Float64Array>} vs - Reflector vectors\n * @param {Float64Array} betas - Reflector scalings\n * @param {number} m - Rows of Q\n * @param {number} qCols - Columns of Q (min(m, n) for reduced, m for full)\n * @returns {Float64Array} Row-major m*qCols storage of Q\n */\nfunction accumulateQ(vs, betas, m, qCols) {\n  const Q = new Float64Array(m * qCols);\n  for (let i = 0; i < qCols; i++) Q[i * qCols + i] = 1;\n  for (let j = vs.length - 1; j >= 0; j--) {\n    const v = vs[j];\n    const beta = betas[j];\n    if (beta === 0) continue;\n    for (let c = 0; c < qCols; c++) {\n      let s = 0;\n      for (let i = j; i < m; i++) s += v[i - j] * Q[i * qCols + c];\n      s *= beta;\n      for (let i = j; i < m; i++) Q[i * qCols + c] -= s * v[i - j];\n    }\n  }\n  return Q;\n}\n\n/**\n * QR decomposition A = Q R via Householder reflections.\n *\n * Works for any shape: m >= n and m < n alike.\n *\n * @param {Array<Array<number>>} A - m x n matrix\n * @param {Object} [options]\n * @param {string} [options.mode='reduced'] - 'reduced' (Q is m x min(m,n),\n *   R is min(m,n) x n) or 'full' (Q is m x m, R is m x n)\n * @returns {{Q: Array<Array<number>>, R: Array<Array<number>>}}\n */\nexport function qr(A, options = {}) {\n  const { data, m, n } = fromNested(A, 'A');\n  const mode = options.mode !== undefined ? options.mode : 'reduced';\n  if (mode !== 'reduced' && mode !== 'full') {\n    throw new Error(`qr: options.mode must be 'reduced' or 'full' (got '${mode}')`);\n  }\n  const { vs, betas, k } = householderFactor(data, m, n);\n  const qCols = mode === 'full' ? m : k;\n  const Qflat = accumulateQ(vs, betas, m, qCols);\n  const rRows = mode === 'full' ? m : k;\n  return {\n    Q: toNested(Qflat, m, qCols),\n    R: toNested(data.subarray(0, rRows * n), rRows, n),\n  };\n}\n\n/**\n * Least-squares solution of A x \u2248 b via reduced QR.\n *\n * Requires m >= n and full column rank: solves R x = Q^T b by back\n * substitution. Throws for rank-deficient R.\n *\n * @param {Array<Array<number>>} A - m x n matrix with m >= n\n * @param {Array<number>} b - Right-hand side of length m\n * @returns {{x: Array<number>, residualNorm: number}} residualNorm = ||A x - b||_2\n */\nexport function lstsq(A, b) {\n  const { data, m, n } = fromNested(A, 'A');\n  if (m < n) {\n    throw new Error(`lstsq: A must have at least as many rows as columns (got ${m}x${n})`);\n  }\n  const bv = vecFrom(b, m, 'b');\n  const original = data.slice();\n  const { vs, betas, k } = householderFactor(data, m, n);\n\n  // Rank check on the diagonal of R against its largest entry.\n  let maxR = 0;\n  for (let i = 0; i < k; i++) {\n    for (let j = i; j < n; j++) maxR = Math.max(maxR, Math.abs(data[i * n + j]));\n  }\n  for (let i = 0; i < n; i++) {\n    if (Math.abs(data[i * n + i]) < 1e-12 * maxR || maxR === 0) {\n      throw new Error(\n        `lstsq: A is rank deficient (R[${i}][${i}] is negligible); ` +\n        'use pinv for a minimum-norm solution'\n      );\n    }\n  }\n\n  // Compute Q^T b = H_{k-1} ... H_0 b in place.\n  for (let j = 0; j < k; j++) {\n    const v = vs[j];\n    const beta = betas[j];\n    if (beta === 0) continue;\n    let s = 0;\n    for (let i = j; i < m; i++) s += v[i - j] * bv[i];\n    s *= beta;\n    for (let i = j; i < m; i++) bv[i] -= s * v[i - j];\n  }\n\n  // Back substitution: R x = (Q^T b)[0..n-1].\n  const x = new Array(n).fill(0);\n  for (let i = n - 1; i >= 0; i--) {\n    let s = bv[i];\n    for (let j = i + 1; j < n; j++) s -= data[i * n + j] * x[j];\n    x[i] = s / data[i * n + i];\n  }\n\n  // Residual norm from the original A.\n  let rr = 0;\n  for (let i = 0; i < m; i++) {\n    let s = -b[i];\n    for (let j = 0; j < n; j++) s += original[i * n + j] * x[j];\n    rr += s * s;\n  }\n  return { x, residualNorm: Math.sqrt(rr) };\n}\n", "/**\n * Singular value decomposition by one-sided Jacobi (Hestenes), plus the\n * SVD-derived utilities pinv, rank and cond.\n *\n * One-sided Jacobi orthogonalizes pairs of columns of A directly; it is\n * simple, unconditionally convergent, and computes even tiny singular\n * values to high relative accuracy \u2014 a good fit for the suite's target\n * sizes. For m < n the problem is transposed internally.\n */\n\nimport { fromNested, toNested, vecFrom } from './_mat.js';\n\n/**\n * Thin SVD: A = U diag(s) V^T with U m\u00D7k, s length k, V n\u00D7k, k = min(m, n).\n * Singular values are non-negative and descending.\n *\n * @param {Array<Array<number>>} A - Matrix (any shape)\n * @param {Object} [options]\n * @param {number} [options.maxSweeps=60] - Maximum Jacobi sweeps\n * @param {number} [options.tol=1e-15] - Column-pair orthogonality tolerance\n * @returns {{U: Array<Array<number>>, s: Array<number>, V: Array<Array<number>>}}\n */\nexport function svd(A, options = {}) {\n  const M = fromNested(A);\n  const transposed = M.m < M.n;\n  const m = transposed ? M.n : M.m;\n  const n = transposed ? M.m : M.n;\n\n  // Column-major working copy W (m\u00D7n, m >= n) for cache-friendly column ops\n  const W = new Float64Array(m * n);\n  if (transposed) {\n    // W[:, j] = A^T[:, j] = A[j, :]\n    for (let j = 0; j < n; j++) {\n      for (let i = 0; i < m; i++) {\n        W[j * m + i] = M.data[j * M.n + i];\n      }\n    }\n  } else {\n    for (let j = 0; j < n; j++) {\n      for (let i = 0; i < m; i++) {\n        W[j * m + i] = M.data[i * M.n + j];\n      }\n    }\n  }\n\n  // V accumulates the right rotations (n\u00D7n, column-major)\n  const V = new Float64Array(n * n);\n  for (let i = 0; i < n; i++) V[i * n + i] = 1;\n\n  const maxSweeps = options.maxSweeps || 60;\n  const tol = options.tol || 1e-15;\n\n  for (let sweep = 0; sweep < maxSweeps; sweep++) {\n    let rotated = false;\n\n    for (let p = 0; p < n - 1; p++) {\n      for (let q = p + 1; q < n; q++) {\n        let alpha = 0;\n        let beta = 0;\n        let gam = 0;\n        const cp = p * m;\n        const cq = q * m;\n        for (let i = 0; i < m; i++) {\n          const wp = W[cp + i];\n          const wq = W[cq + i];\n          alpha += wp * wp;\n          beta += wq * wq;\n          gam += wp * wq;\n        }\n\n        if (Math.abs(gam) <= tol * Math.sqrt(alpha * beta) || alpha === 0 || beta === 0) {\n          continue;\n        }\n        rotated = true;\n\n        // Jacobi rotation that zeroes the (p, q) inner product.\n        // sign(0) must be +1: zeta = 0 (equal column norms) needs a 45\u00B0\n        // rotation, not a no-op.\n        const zeta = (beta - alpha) / (2 * gam);\n        const sgn = zeta >= 0 ? 1 : -1;\n        const t = sgn / (Math.abs(zeta) + Math.sqrt(1 + zeta * zeta));\n        const c = 1 / Math.sqrt(1 + t * t);\n        const s = c * t;\n\n        for (let i = 0; i < m; i++) {\n          const wp = W[cp + i];\n          const wq = W[cq + i];\n          W[cp + i] = c * wp - s * wq;\n          W[cq + i] = s * wp + c * wq;\n        }\n        for (let i = 0; i < n; i++) {\n          const vp = V[p * n + i];\n          const vq = V[q * n + i];\n          V[p * n + i] = c * vp - s * vq;\n          V[q * n + i] = s * vp + c * vq;\n        }\n      }\n    }\n\n    if (!rotated) break;\n  }\n\n  // Singular values = column norms; U columns = normalized W columns\n  const sv = new Array(n);\n  for (let j = 0; j < n; j++) {\n    let norm = 0;\n    for (let i = 0; i < m; i++) norm += W[j * m + i] * W[j * m + i];\n    sv[j] = Math.sqrt(norm);\n  }\n\n  // Sort descending\n  const order = Array.from({ length: n }, (_, i) => i).sort((i, j) => sv[j] - sv[i]);\n  const s = order.map((j) => sv[j]);\n\n  const Umat = new Float64Array(m * n); // row-major m\u00D7n\n  const Vmat = new Float64Array(n * n); // row-major n\u00D7n\n  for (let col = 0; col < n; col++) {\n    const src = order[col];\n    const norm = sv[src];\n    if (norm > 0) {\n      for (let i = 0; i < m; i++) Umat[i * n + col] = W[src * m + i] / norm;\n    } // zero singular value: leave U column zero (rank-deficient case)\n    for (let i = 0; i < n; i++) Vmat[i * n + col] = V[src * n + i];\n  }\n\n  const Uout = toNested(Umat, m, n);\n  const Vout = toNested(Vmat, n, n);\n\n  // Undo the internal transpose: A^T = U s V^T  =>  A = V s U^T\n  return transposed ? { U: Vout, s, V: Uout } : { U: Uout, s, V: Vout };\n}\n\n/**\n * Numerical rank via SVD.\n *\n * @param {Array<Array<number>>} A - Matrix\n * @param {number} [tol] - Threshold; default max(m,n) * eps * s[0] (numpy convention)\n * @returns {number}\n */\nexport function rank(A, tol) {\n  const { s } = svd(A);\n  const m = A.length;\n  const n = A[0].length;\n  const threshold = tol !== undefined ? tol : Math.max(m, n) * Number.EPSILON * (s[0] || 0);\n  return s.filter((x) => x > threshold).length;\n}\n\n/**\n * Condition number (2-norm): s_max / s_min. Infinity when singular.\n *\n * @param {Array<Array<number>>} A - Matrix\n * @returns {number}\n */\nexport function cond(A) {\n  const { s } = svd(A);\n  const smin = s[s.length - 1];\n  return smin > 0 ? s[0] / smin : Infinity;\n}\n\n/**\n * Moore-Penrose pseudoinverse via SVD, with numpy's default cutoff.\n * Solves rank-deficient least squares: x = pinv(A) b is the minimum-norm\n * solution.\n *\n * @param {Array<Array<number>>} A - Matrix (any shape)\n * @param {number} [rcond] - Relative cutoff; default max(m,n) * eps\n * @returns {Array<Array<number>>} n\u00D7m pseudoinverse\n */\nexport function pinv(A, rcond) {\n  const { U, s, V } = svd(A);\n  const m = U.length;\n  const n = V.length;\n  const k = s.length;\n  const cutoff = (rcond !== undefined ? rcond : Math.max(m, n) * Number.EPSILON) * (s[0] || 0);\n\n  // pinv = V diag(1/s) U^T, dropping singular values below the cutoff\n  const out = new Array(n);\n  for (let i = 0; i < n; i++) {\n    out[i] = new Array(m).fill(0);\n  }\n  for (let j = 0; j < k; j++) {\n    if (s[j] <= cutoff) continue;\n    const invS = 1 / s[j];\n    for (let i = 0; i < n; i++) {\n      const vij = V[i][j] * invS;\n      if (vij === 0) continue;\n      const row = out[i];\n      for (let l = 0; l < m; l++) {\n        row[l] += vij * U[l][j];\n      }\n    }\n  }\n  return out;\n}\n\n/**\n * Minimum-norm least squares via the pseudoinverse (works for any rank).\n *\n * @param {Array<Array<number>>} A - m\u00D7n matrix\n * @param {Array<number>} b - Vector of length m\n * @returns {Array<number>} x of length n\n */\nexport function pinvSolve(A, b) {\n  const m = A.length;\n  vecFrom(b, m, 'b');\n  const P = pinv(A);\n  const n = P.length;\n  const x = new Array(n).fill(0);\n  for (let i = 0; i < n; i++) {\n    let sum = 0;\n    for (let j = 0; j < m; j++) sum += P[i][j] * b[j];\n    x[i] = sum;\n  }\n  return x;\n}\n", "/**\n * Symmetric eigendecomposition by the cyclic Jacobi rotation method.\n *\n * Slower than tridiagonal QL for large n but simple, unconditionally\n * stable, and accurate to machine precision \u2014 the right trade-off for\n * the suite's target sizes (covariance/correlation matrices, n up to a\n * few hundred). Eigenvalues are returned in descending order with\n * orthonormal eigenvectors as matrix columns.\n */\n\nimport { assertSymmetric, fromNested, toNested } from './_mat.js';\n\n/**\n * Eigendecomposition of a symmetric matrix: A = V diag(values) V^T.\n *\n * @param {Array<Array<number>>} A - Symmetric matrix (validated to 1e-10)\n * @param {Object} [options]\n * @param {number} [options.maxSweeps=60] - Maximum Jacobi sweeps\n * @param {number} [options.tol=1e-14] - Off-diagonal convergence tolerance,\n *   relative to the Frobenius norm of the diagonal\n * @returns {{values: Array<number>, vectors: Array<Array<number>>}}\n *   values[i] descending; vectors' column i is the eigenvector for values[i]\n */\nexport function eigSym(A, options = {}) {\n  const M = fromNested(A);\n  assertSymmetric(M, 'eigSym');\n  const n = M.n;\n  const maxSweeps = options.maxSweeps || 60;\n  const tol = options.tol || 1e-14;\n\n  const a = Float64Array.from(M.data);\n  const v = new Float64Array(n * n);\n  for (let i = 0; i < n; i++) v[i * n + i] = 1;\n\n  let scale = 0;\n  for (let i = 0; i < n; i++) scale = Math.max(scale, Math.abs(a[i * n + i]));\n  for (let i = 0; i < a.length; i++) scale = Math.max(scale, Math.abs(a[i]));\n  const thresholdBase = tol * Math.max(1, scale);\n\n  for (let sweep = 0; sweep < maxSweeps; sweep++) {\n    // Sum of off-diagonal magnitudes \u2014 the convergence measure\n    let off = 0;\n    for (let p = 0; p < n; p++) {\n      for (let q = p + 1; q < n; q++) off += Math.abs(a[p * n + q]);\n    }\n    if (off <= thresholdBase * n) break;\n\n    for (let p = 0; p < n; p++) {\n      for (let q = p + 1; q < n; q++) {\n        const apq = a[p * n + q];\n        if (Math.abs(apq) <= thresholdBase * 1e-2) continue;\n\n        const app = a[p * n + p];\n        const aqq = a[q * n + q];\n        const theta = (aqq - app) / (2 * apq);\n        // Stable tangent of the rotation angle\n        const t = Math.sign(theta) / (Math.abs(theta) + Math.sqrt(theta * theta + 1)) ||\n          1 / (theta + Math.sign(theta || 1) * Math.sqrt(theta * theta + 1));\n        const c = 1 / Math.sqrt(t * t + 1);\n        const s = t * c;\n        const tau = s / (1 + c);\n\n        // Update the p and q rows/columns of A (symmetric Jacobi update)\n        a[p * n + p] = app - t * apq;\n        a[q * n + q] = aqq + t * apq;\n        a[p * n + q] = 0;\n        a[q * n + p] = 0;\n\n        for (let i = 0; i < n; i++) {\n          if (i !== p && i !== q) {\n            const aip = a[i * n + p];\n            const aiq = a[i * n + q];\n            a[i * n + p] = aip - s * (aiq + tau * aip);\n            a[i * n + q] = aiq + s * (aip - tau * aiq);\n            a[p * n + i] = a[i * n + p];\n            a[q * n + i] = a[i * n + q];\n          }\n          // Accumulate the rotation into the eigenvector matrix\n          const vip = v[i * n + p];\n          const viq = v[i * n + q];\n          v[i * n + p] = vip - s * (viq + tau * vip);\n          v[i * n + q] = viq + s * (vip - tau * viq);\n        }\n      }\n    }\n  }\n\n  // Extract eigenvalues, sort descending, reorder eigenvector columns\n  const order = Array.from({ length: n }, (_, i) => i)\n    .sort((i, j) => a[j * n + j] - a[i * n + i]);\n  const values = order.map((i) => a[i * n + i]);\n  const vectors = new Float64Array(n * n);\n  for (let col = 0; col < n; col++) {\n    const src = order[col];\n    // Sign convention: largest-magnitude component positive (deterministic)\n    let maxAbs = 0;\n    let sign = 1;\n    for (let i = 0; i < n; i++) {\n      const val = v[i * n + src];\n      if (Math.abs(val) > maxAbs) {\n        maxAbs = Math.abs(val);\n        sign = val >= 0 ? 1 : -1;\n      }\n    }\n    for (let i = 0; i < n; i++) {\n      vectors[i * n + col] = sign * v[i * n + src];\n    }\n  }\n\n  return { values, vectors: toNested(vectors, n, n) };\n}\n", "/**\n * Basic dense matrix operations: multiply, transpose, identity, diagonal,\n * norms, and trace.\n *\n * Public APIs accept and return nested row-major matrices; computation runs\n * on flat Float64Array storage (see _mat.js).\n */\n\nimport { fromNested, toNested, vecFrom } from './_mat.js';\n\n/**\n * Matrix product A B, or matrix-vector product A b.\n *\n * @param {Array<Array<number>>} A - m x n nested matrix\n * @param {Array<Array<number>>|Array<number>} B - n x p nested matrix, or\n *   vector of length n\n * @returns {Array<Array<number>>|Array<number>} m x p nested matrix, or\n *   vector of length m\n */\nexport function matmul(A, B) {\n  const Ma = fromNested(A, 'A');\n  const { data: a, m, n } = Ma;\n\n  if (Array.isArray(B) && !Array.isArray(B[0])) {\n    const x = vecFrom(B, n, 'B');\n    const y = new Float64Array(m);\n    for (let i = 0; i < m; i++) {\n      let s = 0;\n      for (let j = 0; j < n; j++) s += a[i * n + j] * x[j];\n      y[i] = s;\n    }\n    return Array.from(y);\n  }\n\n  const Mb = fromNested(B, 'B');\n  if (Mb.m !== n) {\n    throw new Error(`matmul: dimension mismatch (A is ${m}x${n}, B is ${Mb.m}x${Mb.n})`);\n  }\n  const b = Mb.data;\n  const p = Mb.n;\n  const c = new Float64Array(m * p);\n  for (let i = 0; i < m; i++) {\n    for (let k = 0; k < n; k++) {\n      const aik = a[i * n + k];\n      if (aik === 0) continue;\n      for (let j = 0; j < p; j++) {\n        c[i * p + j] += aik * b[k * p + j];\n      }\n    }\n  }\n  return toNested(c, m, p);\n}\n\n/**\n * Matrix transpose.\n *\n * @param {Array<Array<number>>} A - m x n nested matrix\n * @returns {Array<Array<number>>} n x m nested matrix\n */\nexport function transpose(A) {\n  const { data, m, n } = fromNested(A, 'A');\n  const t = new Float64Array(n * m);\n  for (let i = 0; i < m; i++) {\n    for (let j = 0; j < n; j++) {\n      t[j * m + i] = data[i * n + j];\n    }\n  }\n  return toNested(t, n, m);\n}\n\n/**\n * Identity matrix of size n.\n *\n * @param {number} n - Dimension (positive integer)\n * @returns {Array<Array<number>>}\n */\nexport function identity(n) {\n  if (!Number.isInteger(n) || n <= 0) {\n    throw new Error(`identity: n must be a positive integer (got ${n})`);\n  }\n  const I = new Array(n);\n  for (let i = 0; i < n; i++) {\n    const row = new Array(n).fill(0);\n    row[i] = 1;\n    I[i] = row;\n  }\n  return I;\n}\n\n/**\n * Build a diagonal matrix from a vector, or extract the diagonal of a matrix.\n *\n * @param {Array<number>|Array<Array<number>>} x - Vector (returns an n x n\n *   nested matrix) or nested matrix (returns its diagonal, length min(m, n))\n * @returns {Array<Array<number>>|Array<number>}\n */\nexport function diag(x) {\n  if (!Array.isArray(x) || x.length === 0) {\n    throw new Error('diag: argument must be a non-empty vector or nested matrix');\n  }\n  if (Array.isArray(x[0])) {\n    const { data, m, n } = fromNested(x, 'A');\n    const len = Math.min(m, n);\n    const d = new Array(len);\n    for (let i = 0; i < len; i++) d[i] = data[i * n + i];\n    return d;\n  }\n  const n = x.length;\n  const D = new Array(n);\n  for (let i = 0; i < n; i++) {\n    const row = new Array(n).fill(0);\n    row[i] = x[i];\n    D[i] = row;\n  }\n  return D;\n}\n\n/**\n * Matrix or vector norm.\n *\n * For a nested matrix: 'fro' (Frobenius), 1 (max column abs sum), or\n * Infinity (max row abs sum). For a vector: 'fro' or 2 (euclidean),\n * 1 (abs sum), or Infinity (max abs).\n *\n * @param {Array<Array<number>>|Array<number>} A - Nested matrix or vector\n * @param {'fro'|1|2|Infinity} [kind='fro'] - Norm kind\n * @returns {number}\n */\nexport function norm(A, kind = 'fro') {\n  if (!Array.isArray(A) || A.length === 0) {\n    throw new Error('norm: argument must be a non-empty vector or nested matrix');\n  }\n\n  if (!Array.isArray(A[0])) {\n    if (kind === 'fro' || kind === 2) {\n      let s = 0;\n      for (let i = 0; i < A.length; i++) s += A[i] * A[i];\n      return Math.sqrt(s);\n    }\n    if (kind === 1) {\n      let s = 0;\n      for (let i = 0; i < A.length; i++) s += Math.abs(A[i]);\n      return s;\n    }\n    if (kind === Infinity) {\n      let s = 0;\n      for (let i = 0; i < A.length; i++) s = Math.max(s, Math.abs(A[i]));\n      return s;\n    }\n    throw new Error(`norm: unsupported vector norm kind ${String(kind)}`);\n  }\n\n  const { data, m, n } = fromNested(A, 'A');\n  if (kind === 'fro') {\n    let s = 0;\n    for (let i = 0; i < data.length; i++) s += data[i] * data[i];\n    return Math.sqrt(s);\n  }\n  if (kind === 1) {\n    let best = 0;\n    for (let j = 0; j < n; j++) {\n      let s = 0;\n      for (let i = 0; i < m; i++) s += Math.abs(data[i * n + j]);\n      best = Math.max(best, s);\n    }\n    return best;\n  }\n  if (kind === Infinity) {\n    let best = 0;\n    for (let i = 0; i < m; i++) {\n      let s = 0;\n      for (let j = 0; j < n; j++) s += Math.abs(data[i * n + j]);\n      best = Math.max(best, s);\n    }\n    return best;\n  }\n  throw new Error(`norm: unsupported matrix norm kind ${String(kind)} (use 'fro', 1, or Infinity)`);\n}\n\n/**\n * Sum of the diagonal of a square matrix.\n *\n * @param {Array<Array<number>>} A - Square nested matrix\n * @returns {number}\n */\nexport function trace(A) {\n  const { data, m, n } = fromNested(A, 'A');\n  if (m !== n) {\n    throw new Error(`trace: matrix must be square (got ${m}x${n})`);\n  }\n  let s = 0;\n  for (let i = 0; i < n; i++) s += data[i * n + i];\n  return s;\n}\n", "/**\n * @tangent.to/lina - Linear algebra for JavaScript (ESM)\n *\n * LU, QR, Cholesky, SVD, symmetric eigendecomposition and least squares\n * on plain nested arrays, computed on flat Float64Array storage\n * internally. numpy/scipy.linalg-validated. MIT infrastructure of the\n * tangent suite.\n */\n\nexport { det, inv, lu, solve } from './lu.js';\nexport { cholesky, choleskySolve, isPositiveDefinite } from './cholesky.js';\nexport { lstsq, qr } from './qr.js';\nexport { cond, pinv, pinvSolve, rank, svd } from './svd.js';\nexport { eigSym } from './eigsym.js';\nexport { diag, identity, matmul, norm, trace, transpose } from './ops.js';\n\nimport { det, inv, lu, solve } from './lu.js';\nimport { cholesky, choleskySolve, isPositiveDefinite } from './cholesky.js';\nimport { lstsq, qr } from './qr.js';\nimport { cond, pinv, pinvSolve, rank, svd } from './svd.js';\nimport { eigSym } from './eigsym.js';\nimport { diag, identity, matmul, norm, trace, transpose } from './ops.js';\n\nexport default {\n  lu,\n  solve,\n  det,\n  inv,\n  cholesky,\n  choleskySolve,\n  isPositiveDefinite,\n  qr,\n  lstsq,\n  svd,\n  pinv,\n  pinvSolve,\n  rank,\n  cond,\n  eigSym,\n  matmul,\n  transpose,\n  identity,\n  diag,\n  norm,\n  trace,\n};\n"],
+  "mappings": "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",
+  "names": ["fromNested", "A", "name", "m", "n", "data", "i", "row", "j", "__name", "toNested", "vecFrom", "b", "expected", "assertSymmetric", "M", "caller", "tol", "scale", "bound", "luFactor", "src", "n", "a", "perm", "scale", "maxAbs", "i", "tol", "sign", "singular", "s", "j", "k", "p", "best", "v", "t", "ts", "tp", "pivot", "f", "__name", "squareFromNested", "A", "caller", "M", "fromNested", "lu", "data", "L", "U", "P", "toNested", "luSolveInPlace", "x", "solve", "b", "bv", "vecFrom", "B", "X", "c", "det", "d", "inv", "I", "row", "cholesky", "A", "M", "fromNested", "assertSymmetric", "data", "n", "L", "j", "d", "k", "ljj", "i", "s", "toNested", "__name", "choleskySolve", "b", "x", "vecFrom", "isPositiveDefinite", "householderFactor", "data", "m", "n", "k", "vs", "betas", "j", "norm", "i", "t", "v", "x0", "sign", "vv", "beta", "c", "s", "__name", "accumulateQ", "qCols", "Q", "qr", "A", "options", "fromNested", "mode", "Qflat", "rRows", "toNested", "lstsq", "b", "bv", "vecFrom", "original", "maxR", "x", "rr", "svd", "A", "options", "M", "fromNested", "transposed", "m", "n", "W", "j", "i", "V", "maxSweeps", "tol", "sweep", "rotated", "p", "q", "alpha", "beta", "gam", "cp", "cq", "wp", "wq", "zeta", "t", "c", "s", "vp", "vq", "sv", "norm", "order", "_", "Umat", "Vmat", "col", "src", "Uout", "toNested", "Vout", "__name", "rank", "threshold", "x", "cond", "smin", "pinv", "rcond", "U", "k", "cutoff", "out", "invS", "vij", "row", "l", "pinvSolve", "b", "vecFrom", "P", "sum", "eigSym", "A", "options", "M", "fromNested", "assertSymmetric", "n", "maxSweeps", "tol", "a", "v", "i", "scale", "thresholdBase", "sweep", "off", "p", "q", "apq", "app", "aqq", "theta", "t", "c", "s", "tau", "aip", "aiq", "vip", "viq", "order", "_", "j", "values", "vectors", "col", "src", "maxAbs", "sign", "val", "toNested", "__name", "matmul", "A", "B", "Ma", "fromNested", "a", "m", "n", "x", "vecFrom", "y", "i", "j", "Mb", "b", "p", "k", "aik", "toNested", "__name", "transpose", "data", "t", "identity", "I", "row", "diag", "len", "d", "D", "norm", "kind", "s", "best", "trace", "index_default", "lu", "solve", "det", "inv", "cholesky", "choleskySolve", "isPositiveDefinite", "qr", "lstsq", "svd", "pinv", "pinvSolve", "rank", "cond", "eigSym", "matmul", "transpose", "identity", "diag", "norm", "trace"]
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@tangent.to/lina",
+  "version": "0.1.0",
+  "description": "Linear algebra for JavaScript (ESM): LU, QR, Cholesky, SVD, symmetric eigen, least squares. scipy.linalg-validated.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "browser": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prepare": "npm run build:browser",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:scipy": "uv run --with scipy python3 tests_compare-to-scipy/compare_with_scipy.py",
+    "build:browser": "esbuild src/index.js --bundle --platform=browser --format=esm --target=es2020 --outfile=dist/index.js --sourcemap --minify --keep-names",
+    "jsr:publish": "deno publish --allow-dirty",
+    "jsr:publish:dry-run": "deno publish --dry-run --allow-dirty",
+    "deno:check": "deno check src/index.js"
+  },
+  "keywords": [
+    "linalg",
+    "matrix",
+    "svd",
+    "qr",
+    "cholesky",
+    "eigenvalues",
+    "esm",
+    "browser"
+  ],
+  "author": "Essi Parent",
+  "license": "MIT",
+  "homepage": "https://github.com/tangent-to/lina",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tangent-to/lina"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.11",
+    "vitest": "^1.6.0"
+  }
+}

package/src/_mat.js

@@ -0,0 +1,97 @@
+/**
+ * Internal matrix representation.
+ *
+ * Public lina APIs accept and return row-major nested arrays
+ * (Array<Array<number>>) — the tangent suite's boundary currency.
+ * Internally, algorithms run on flat Float64Array storage for speed.
+ * This module is the only place that converts between the two.
+ */
+
+/**
+ * Convert a nested row-major matrix to flat storage.
+ * Validates rectangularity and finite dimensions.
+ *
+ * @param {Array<Array<number>>} A - Nested matrix
+ * @param {string} [name='A'] - Argument name for error messages
+ * @returns {{data: Float64Array, m: number, n: number}}
+ */
+export function fromNested(A, name = 'A') {
+  if (!Array.isArray(A) || A.length === 0 || !Array.isArray(A[0])) {
+    throw new Error(`${name} must be a non-empty array of rows`);
+  }
+  const m = A.length;
+  const n = A[0].length;
+  if (n === 0) {
+    throw new Error(`${name} must have at least one column`);
+  }
+  const data = new Float64Array(m * n);
+  for (let i = 0; i < m; i++) {
+    const row = A[i];
+    if (!Array.isArray(row) || row.length !== n) {
+      throw new Error(`${name} is not rectangular (row ${i} has length ${row?.length}, expected ${n})`);
+    }
+    for (let j = 0; j < n; j++) {
+      data[i * n + j] = row[j];
+    }
+  }
+  return { data, m, n };
+}
+
+/**
+ * Convert flat storage back to a nested row-major matrix.
+ *
+ * @param {Float64Array|Array<number>} data - Flat row-major values
+ * @param {number} m - Rows
+ * @param {number} n - Columns
+ * @returns {Array<Array<number>>}
+ */
+export function toNested(data, m, n) {
+  const A = new Array(m);
+  for (let i = 0; i < m; i++) {
+    const row = new Array(n);
+    for (let j = 0; j < n; j++) {
+      row[j] = data[i * n + j];
+    }
+    A[i] = row;
+  }
+  return A;
+}
+
+/**
+ * Validate a vector argument and copy it to a Float64Array.
+ *
+ * @param {Array<number>} b - Vector
+ * @param {number} expected - Required length
+ * @param {string} [name='b'] - Argument name for error messages
+ * @returns {Float64Array}
+ */
+export function vecFrom(b, expected, name = 'b') {
+  if (!Array.isArray(b) || b.length !== expected) {
+    throw new Error(`${name} must be an array of length ${expected} (got ${b?.length})`);
+  }
+  return Float64Array.from(b);
+}
+
+/**
+ * Check symmetry to a tolerance; throws when violated.
+ *
+ * @param {{data: Float64Array, m: number, n: number}} M - Flat matrix
+ * @param {string} caller - Function name for the error message
+ * @param {number} [tol=1e-10] - Relative tolerance
+ */
+export function assertSymmetric(M, caller, tol = 1e-10) {
+  const { data, m, n } = M;
+  if (m !== n) {
+    throw new Error(`${caller}: matrix must be square (got ${m}x${n})`);
+  }
+  let scale = 0;
+  for (let i = 0; i < data.length; i++) scale = Math.max(scale, Math.abs(data[i]));
+  const bound = tol * Math.max(1, scale);
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      if (Math.abs(data[i * n + j] - data[j * n + i]) > bound) {
+        throw new Error(`${caller}: matrix is not symmetric (A[${i}][${j}] != A[${j}][${i}])`);
+      }
+    }
+  }
+}

package/src/cholesky.js

@@ -0,0 +1,84 @@
+/**
+ * Cholesky factorization A = L L^T for symmetric positive definite matrices.
+ *
+ * Public APIs accept and return nested row-major matrices; computation runs
+ * on flat Float64Array storage (see _mat.js).
+ */
+
+import { assertSymmetric, fromNested, toNested, vecFrom } from './_mat.js';
+
+/**
+ * Cholesky factorization of a symmetric positive definite matrix.
+ *
+ * @param {Array<Array<number>>} A - Symmetric positive definite nested matrix
+ * @returns {Array<Array<number>>} Lower triangular L with A = L L^T
+ * @throws {Error} When A is not symmetric, or a diagonal pivot is <= 0
+ *   (not positive definite)
+ */
+export function cholesky(A) {
+  const M = fromNested(A, 'A');
+  assertSymmetric(M, 'cholesky');
+  const { data, n } = M;
+  const L = new Float64Array(n * n);
+  for (let j = 0; j < n; j++) {
+    let d = data[j * n + j];
+    for (let k = 0; k < j; k++) d -= L[j * n + k] * L[j * n + k];
+    if (d <= 0) {
+      throw new Error(`cholesky: matrix is not positive definite (pivot ${j} is ${d})`);
+    }
+    const ljj = Math.sqrt(d);
+    L[j * n + j] = ljj;
+    for (let i = j + 1; i < n; i++) {
+      let s = data[i * n + j];
+      for (let k = 0; k < j; k++) s -= L[i * n + k] * L[j * n + k];
+      L[i * n + j] = s / ljj;
+    }
+  }
+  return toNested(L, n, n);
+}
+
+/**
+ * Solve A x = b given the Cholesky factor L of A (A = L L^T), by forward
+ * substitution (L y = b) then back substitution (L^T x = y).
+ *
+ * @param {Array<Array<number>>} L - Lower triangular factor from cholesky()
+ * @param {Array<number>} b - Right-hand side vector
+ * @returns {Array<number>}
+ */
+export function choleskySolve(L, b) {
+  const M = fromNested(L, 'L');
+  if (M.m !== M.n) {
+    throw new Error(`choleskySolve: L must be square (got ${M.m}x${M.n})`);
+  }
+  const { data, n } = M;
+  const x = vecFrom(b, n, 'b');
+  // Forward substitution: L y = b.
+  for (let i = 0; i < n; i++) {
+    let s = x[i];
+    for (let j = 0; j < i; j++) s -= data[i * n + j] * x[j];
+    x[i] = s / data[i * n + i];
+  }
+  // Back substitution: L^T x = y.
+  for (let i = n - 1; i >= 0; i--) {
+    let s = x[i];
+    for (let j = i + 1; j < n; j++) s -= data[j * n + i] * x[j];
+    x[i] = s / data[i * n + i];
+  }
+  return Array.from(x);
+}
+
+/**
+ * Test positive definiteness by attempting a Cholesky factorization.
+ * Never throws; non-symmetric or malformed input returns false.
+ *
+ * @param {Array<Array<number>>} A - Nested matrix
+ * @returns {boolean}
+ */
+export function isPositiveDefinite(A) {
+  try {
+    cholesky(A);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/eigsym.js

@@ -0,0 +1,111 @@
+/**
+ * Symmetric eigendecomposition by the cyclic Jacobi rotation method.
+ *
+ * Slower than tridiagonal QL for large n but simple, unconditionally
+ * stable, and accurate to machine precision — the right trade-off for
+ * the suite's target sizes (covariance/correlation matrices, n up to a
+ * few hundred). Eigenvalues are returned in descending order with
+ * orthonormal eigenvectors as matrix columns.
+ */
+
+import { assertSymmetric, fromNested, toNested } from './_mat.js';
+
+/**
+ * Eigendecomposition of a symmetric matrix: A = V diag(values) V^T.
+ *
+ * @param {Array<Array<number>>} A - Symmetric matrix (validated to 1e-10)
+ * @param {Object} [options]
+ * @param {number} [options.maxSweeps=60] - Maximum Jacobi sweeps
+ * @param {number} [options.tol=1e-14] - Off-diagonal convergence tolerance,
+ *   relative to the Frobenius norm of the diagonal
+ * @returns {{values: Array<number>, vectors: Array<Array<number>>}}
+ *   values[i] descending; vectors' column i is the eigenvector for values[i]
+ */
+export function eigSym(A, options = {}) {
+  const M = fromNested(A);
+  assertSymmetric(M, 'eigSym');
+  const n = M.n;
+  const maxSweeps = options.maxSweeps || 60;
+  const tol = options.tol || 1e-14;
+
+  const a = Float64Array.from(M.data);
+  const v = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) v[i * n + i] = 1;
+
+  let scale = 0;
+  for (let i = 0; i < n; i++) scale = Math.max(scale, Math.abs(a[i * n + i]));
+  for (let i = 0; i < a.length; i++) scale = Math.max(scale, Math.abs(a[i]));
+  const thresholdBase = tol * Math.max(1, scale);
+
+  for (let sweep = 0; sweep < maxSweeps; sweep++) {
+    // Sum of off-diagonal magnitudes — the convergence measure
+    let off = 0;
+    for (let p = 0; p < n; p++) {
+      for (let q = p + 1; q < n; q++) off += Math.abs(a[p * n + q]);
+    }
+    if (off <= thresholdBase * n) break;
+
+    for (let p = 0; p < n; p++) {
+      for (let q = p + 1; q < n; q++) {
+        const apq = a[p * n + q];
+        if (Math.abs(apq) <= thresholdBase * 1e-2) continue;
+
+        const app = a[p * n + p];
+        const aqq = a[q * n + q];
+        const theta = (aqq - app) / (2 * apq);
+        // Stable tangent of the rotation angle
+        const t = Math.sign(theta) / (Math.abs(theta) + Math.sqrt(theta * theta + 1)) ||
+          1 / (theta + Math.sign(theta || 1) * Math.sqrt(theta * theta + 1));
+        const c = 1 / Math.sqrt(t * t + 1);
+        const s = t * c;
+        const tau = s / (1 + c);
+
+        // Update the p and q rows/columns of A (symmetric Jacobi update)
+        a[p * n + p] = app - t * apq;
+        a[q * n + q] = aqq + t * apq;
+        a[p * n + q] = 0;
+        a[q * n + p] = 0;
+
+        for (let i = 0; i < n; i++) {
+          if (i !== p && i !== q) {
+            const aip = a[i * n + p];
+            const aiq = a[i * n + q];
+            a[i * n + p] = aip - s * (aiq + tau * aip);
+            a[i * n + q] = aiq + s * (aip - tau * aiq);
+            a[p * n + i] = a[i * n + p];
+            a[q * n + i] = a[i * n + q];
+          }
+          // Accumulate the rotation into the eigenvector matrix
+          const vip = v[i * n + p];
+          const viq = v[i * n + q];
+          v[i * n + p] = vip - s * (viq + tau * vip);
+          v[i * n + q] = viq + s * (vip - tau * viq);
+        }
+      }
+    }
+  }
+
+  // Extract eigenvalues, sort descending, reorder eigenvector columns
+  const order = Array.from({ length: n }, (_, i) => i)
+    .sort((i, j) => a[j * n + j] - a[i * n + i]);
+  const values = order.map((i) => a[i * n + i]);
+  const vectors = new Float64Array(n * n);
+  for (let col = 0; col < n; col++) {
+    const src = order[col];
+    // Sign convention: largest-magnitude component positive (deterministic)
+    let maxAbs = 0;
+    let sign = 1;
+    for (let i = 0; i < n; i++) {
+      const val = v[i * n + src];
+      if (Math.abs(val) > maxAbs) {
+        maxAbs = Math.abs(val);
+        sign = val >= 0 ? 1 : -1;
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      vectors[i * n + col] = sign * v[i * n + src];
+    }
+  }
+
+  return { values, vectors: toNested(vectors, n, n) };
+}