@danielsimonjr/mathts-functions 0.29.0 → 0.30.0

package/dist/index.d.ts

@@ -45,7 +45,11 @@ export type { LinregressResult } from './regression-extra.js';
 export { nelderMead, gradientDescent, levenbergMarquardt } from './optimization-extra.js';
 export type { OptimizeResult, LMResult } from './optimization-extra.js';
 export { kmeans, spectralClustering } from './clustering-extra.js';
+export { bfgs } from './numeric/bfgs.js';
+export type { BfgsOptions, BfgsResult } from './numeric/bfgs.js';
 export type { KMeansResult } from './clustering-extra.js';
+export { nnls, lsqBounded } from './numeric/nnls.js';
+export type { NnlsOptions, NnlsResult, LsqBoundedOptions, LsqBoundedResult, } from './numeric/nnls.js';
 export { symbolicIntegral } from './cas-integration.js';
 export { firwin, butter, lfilter, lfilterZi, filtfilt } from './signal-filter-extra.js';
 export { haversine, EARTH_RADIUS_KM, slerp, quaternionMultiply, quaternionConjugate, quaternionNormalize, quaternionFromAxisAngle, quaternionRotate, quaternionToRotationMatrix, } from './geometry-extra.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,cAAc,kBAAkB,CAAC;AAKjC,cAAc,gBAAgB,CAAC;AAG/B,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAOzC,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAG7C,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGlG,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACnF,YAAY,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAGhD,OAAO,EACL,KAAK,EACL,KAAK,EACL,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,EACH,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,UAAU,EACV,QAAQ,EACR,SAAS,EACT,UAAU,EACV,GAAG,EACH,SAAS,EACT,WAAW,EACX,QAAQ,EACR,SAAS,GACV,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,gBAAgB,EAChB,qBAAqB,EACrB,cAAc,EACd,eAAe,GAChB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,KAAK,EACL,OAAO,EACP,SAAS,EACT,OAAO,EACP,OAAO,EACP,MAAM,EACN,MAAM,EACN,QAAQ,GACT,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,cAAc,EACd,WAAW,EACX,gBAAgB,EAChB,aAAa,EACb,kBAAkB,EAClB,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,aAAa,EACb,OAAO,EACP,YAAY,EACZ,SAAS,EACT,SAAS,EACT,cAAc,EACd,UAAU,EACV,UAAU,EACV,eAAe,EACf,WAAW,EACX,WAAW,EACX,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,KAAK,EACL,UAAU,EACV,aAAa,EACb,QAAQ,EACR,WAAW,EACX,mBAAmB,EACnB,wBAAwB,EACxB,QAAQ,GACT,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,WAAW,EACX,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,eAAe,GAChB,MAAM,uBAAuB,CAAC;AAI/B,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,QAAQ,EACR,SAAS,EACT,SAAS,EACT,MAAM,EACN,eAAe,EACf,cAAc,EACd,EAAE,GACH,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAKxD,OAAO,EAAE,GAAG,EAAE,MAAM,8BAA8B,CAAC;AACnD,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAC7C,YAAY,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIzD,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,YAAY,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAIzF,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AACxE,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAIlG,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAKzD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,YAAY,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAKhG,OAAO,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAClD,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAG1E,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAG1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,YAAY,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAG9D,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC1F,YAAY,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGxE,OAAO,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACnE,YAAY,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAGxD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGxF,OAAO,EACL,SAAS,EACT,eAAe,EACf,KAAK,EACL,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,0BAA0B,GAC3B,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -8381,18 +8381,18 @@ import { computePool as computePool7 } from "@danielsimonjr/mathts-parallel";
 var GEOMETRY_WASM_THRESHOLD = 32;
 var HULL3D_WASM_THRESHOLD = 1024;
 function angle2D(v1, v2) {
-  const dot3 = v1[0] * v2[0] + v1[1] * v2[1];
+  const dot4 = v1[0] * v2[0] + v1[1] * v2[1];
   const mag1 = Math.sqrt(v1[0] ** 2 + v1[1] ** 2);
   const mag2 = Math.sqrt(v2[0] ** 2 + v2[1] ** 2);
   if (mag1 === 0 || mag2 === 0) return NaN;
-  return Math.acos(Math.max(-1, Math.min(1, dot3 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot4 / (mag1 * mag2))));
 }
 function angle3D(v1, v2) {
-  const dot3 = v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
+  const dot4 = v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
   const mag1 = Math.sqrt(v1[0] ** 2 + v1[1] ** 2 + v1[2] ** 2);
   const mag2 = Math.sqrt(v2[0] ** 2 + v2[1] ** 2 + v2[2] ** 2);
   if (mag1 === 0 || mag2 === 0) return NaN;
-  return Math.acos(Math.max(-1, Math.min(1, dot3 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot4 / (mag1 * mag2))));
 }
 function cross3D(a, b) {
   return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
@@ -8497,14 +8497,14 @@ function reflectVector(v, normal) {
   const mag = Math.sqrt(normal.reduce((s, c) => s + c * c, 0));
   if (mag === 0) return v.slice();
   const n = normal.map((c) => c / mag);
-  const dot3 = v.reduce((s, c, i) => s + c * n[i], 0);
-  return v.map((c, i) => c - 2 * dot3 * n[i]);
+  const dot4 = v.reduce((s, c, i) => s + c * n[i], 0);
+  return v.map((c, i) => c - 2 * dot4 * n[i]);
 }
 function projectVector(v, onto) {
-  const dot3 = v.reduce((s, c, i) => s + c * onto[i], 0);
+  const dot4 = v.reduce((s, c, i) => s + c * onto[i], 0);
   const magSq = onto.reduce((s, c) => s + c * c, 0);
   if (magSq === 0) return onto.map(() => 0);
-  const scale = dot3 / magSq;
+  const scale = dot4 / magSq;
   return onto.map((c) => c * scale);
 }
 function distance2D(a, b) {
@@ -13108,7 +13108,7 @@ function quadprog(H, f, A, b) {
   }
   return x;
 }
-function linprog(c, A, b) {
+function linprogOnePhaseLegacy(c, A, b) {
   const m = A.length;
   const n = c.length;
   const tableau = [];
@@ -13179,6 +13179,285 @@ function linprog(c, A, b) {
   }
   return x;
 }
+var LINPROG_TOL = 1e-9;
+function linprogSolveTwoPhase(costWork, Aeq, beq, hasSlack, slackCol) {
+  const m = Aeq.length;
+  const nw = costWork.length;
+  if (m === 0) {
+    for (let j = 0; j < nw; j++) {
+      if (costWork[j] < -LINPROG_TOL) return { xWork: [], status: "unbounded" };
+    }
+    return { xWork: new Array(nw).fill(0), status: "optimal" };
+  }
+  const rows = [];
+  const rhs = [];
+  const flipped = [];
+  for (let i2 = 0; i2 < m; i2++) {
+    let row2 = [...Aeq[i2]];
+    let b = beq[i2];
+    let f = false;
+    if (b < 0) {
+      row2 = row2.map((v) => -v);
+      b = -b;
+      f = true;
+    }
+    rows.push(row2);
+    rhs.push(b);
+    flipped.push(f);
+  }
+  const basis = new Array(m).fill(-1);
+  const artificialCols = [];
+  let nextCol = nw;
+  for (let i2 = 0; i2 < m; i2++) {
+    if (hasSlack[i2] && !flipped[i2]) {
+      basis[i2] = slackCol[i2];
+    } else {
+      const col = nextCol++;
+      artificialCols.push(col);
+      basis[i2] = col;
+    }
+  }
+  const totalCols = nextCol;
+  const isArtificial = new Array(totalCols).fill(false);
+  for (const col of artificialCols) isArtificial[col] = true;
+  const width = totalCols + 1;
+  const tableau = [];
+  for (let i2 = 0; i2 < m; i2++) {
+    const row2 = new Array(width).fill(0);
+    for (let j = 0; j < nw; j++) row2[j] = rows[i2][j];
+    if (isArtificial[basis[i2]]) row2[basis[i2]] = 1;
+    row2[totalCols] = rhs[i2];
+    tableau.push(row2);
+  }
+  const pivot = (pr, pc, objRow) => {
+    const pivotVal = tableau[pr][pc];
+    for (let j = 0; j < width; j++) tableau[pr][j] /= pivotVal;
+    for (let i2 = 0; i2 < tableau.length; i2++) {
+      if (i2 === pr) continue;
+      const factor3 = tableau[i2][pc];
+      if (factor3 === 0) continue;
+      for (let j = 0; j < width; j++) tableau[i2][j] -= factor3 * tableau[pr][j];
+    }
+    const factor2 = objRow[pc];
+    if (factor2 !== 0) {
+      for (let j = 0; j < width; j++) objRow[j] -= factor2 * tableau[pr][j];
+    }
+  };
+  const buildObjRow = (costFull) => {
+    const row2 = new Array(width).fill(0);
+    for (let j = 0; j < totalCols; j++) row2[j] = costFull[j];
+    for (let i2 = 0; i2 < tableau.length; i2++) {
+      const cb = costFull[basis[i2]];
+      if (cb === 0) continue;
+      for (let j = 0; j < width; j++) row2[j] -= cb * tableau[i2][j];
+    }
+    return row2;
+  };
+  const runSimplex = (objRow, excluded, maxIter = 2e3) => {
+    for (let iter = 0; iter < maxIter; iter++) {
+      let pivotCol = -1;
+      let minVal = -LINPROG_TOL;
+      for (let j = 0; j < totalCols; j++) {
+        if (excluded[j]) continue;
+        if (objRow[j] < minVal) {
+          minVal = objRow[j];
+          pivotCol = j;
+        }
+      }
+      if (pivotCol === -1) return "optimal";
+      let pivotRow = -1;
+      let minRatio = Infinity;
+      for (let i2 = 0; i2 < tableau.length; i2++) {
+        if (tableau[i2][pivotCol] > LINPROG_TOL) {
+          const ratio = tableau[i2][totalCols] / tableau[i2][pivotCol];
+          if (ratio < minRatio - 1e-12) {
+            minRatio = ratio;
+            pivotRow = i2;
+          }
+        }
+      }
+      if (pivotRow === -1) return "unbounded";
+      basis[pivotRow] = pivotCol;
+      pivot(pivotRow, pivotCol, objRow);
+    }
+    return "optimal";
+  };
+  const noExclusions = new Array(totalCols).fill(false);
+  const cost1 = new Array(totalCols).fill(0);
+  for (const col of artificialCols) cost1[col] = 1;
+  const objRow1 = buildObjRow(cost1);
+  const phase1Status = runSimplex(objRow1, noExclusions);
+  if (phase1Status === "unbounded") return { xWork: [], status: "infeasible" };
+  let phase1Obj = 0;
+  for (let i2 = 0; i2 < tableau.length; i2++) phase1Obj += cost1[basis[i2]] * tableau[i2][totalCols];
+  if (phase1Obj > 1e-7) return { xWork: [], status: "infeasible" };
+  let i = 0;
+  while (i < tableau.length) {
+    if (!isArtificial[basis[i]]) {
+      i++;
+      continue;
+    }
+    let pc = -1;
+    for (let j = 0; j < nw; j++) {
+      if (Math.abs(tableau[i][j]) > 1e-8) {
+        pc = j;
+        break;
+      }
+    }
+    if (pc === -1) {
+      tableau.splice(i, 1);
+      basis.splice(i, 1);
+      continue;
+    }
+    basis[i] = pc;
+    pivot(i, pc, new Array(width).fill(0));
+    i++;
+  }
+  const costFull2 = new Array(totalCols).fill(0);
+  for (let j = 0; j < nw; j++) costFull2[j] = costWork[j];
+  const objRow2 = buildObjRow(costFull2);
+  const excludeArtificial = isArtificial.slice();
+  const phase2Status = runSimplex(objRow2, excludeArtificial);
+  if (phase2Status === "unbounded") return { xWork: [], status: "unbounded" };
+  const xWork = new Array(nw).fill(0);
+  for (let r = 0; r < tableau.length; r++) {
+    if (basis[r] < nw) xWork[basis[r]] = Math.max(0, tableau[r][totalCols]);
+  }
+  return { xWork, status: "optimal" };
+}
+function linprogTwoPhase(c, opts) {
+  const n = c.length;
+  const boundsResolved = [];
+  for (let j = 0; j < n; j++) {
+    const b = opts.bounds?.[j];
+    boundsResolved.push(b ? [b[0], b[1]] : [0, null]);
+  }
+  let col = 0;
+  const expansions = [];
+  for (let j = 0; j < n; j++) {
+    const low = boundsResolved[j][0];
+    if (low === null) {
+      const colPos = col++;
+      const colNeg = col++;
+      expansions.push({ kind: "split", colPos, colNeg });
+    } else {
+      const c0 = col++;
+      expansions.push({ kind: "shift", col: c0, shift: low });
+    }
+  }
+  const nx = col;
+  const expandRow = (row2) => {
+    const out = new Array(nx).fill(0);
+    for (let j = 0; j < n; j++) {
+      const coeff = row2[j] ?? 0;
+      if (coeff === 0) continue;
+      const e = expansions[j];
+      if (e.kind === "shift") out[e.col] += coeff;
+      else {
+        out[e.colPos] += coeff;
+        out[e.colNeg] -= coeff;
+      }
+    }
+    return out;
+  };
+  const shiftedRhs = (row2, rhsVal) => {
+    let r = rhsVal;
+    for (let j = 0; j < n; j++) {
+      const e = expansions[j];
+      if (e.kind === "shift" && e.shift !== 0) r -= (row2[j] ?? 0) * e.shift;
+    }
+    return r;
+  };
+  let constant = 0;
+  const cWork = new Array(nx).fill(0);
+  for (let j = 0; j < n; j++) {
+    const e = expansions[j];
+    if (e.kind === "shift") {
+      cWork[e.col] = c[j];
+      constant += c[j] * e.shift;
+    } else {
+      cWork[e.colPos] = c[j];
+      cWork[e.colNeg] = -c[j];
+    }
+  }
+  const ubRows = [];
+  const ubRhs = [];
+  const A_ub = opts.A_ub ?? [];
+  const b_ub = opts.b_ub ?? [];
+  for (let i = 0; i < A_ub.length; i++) {
+    ubRows.push(expandRow(A_ub[i]));
+    ubRhs.push(shiftedRhs(A_ub[i], b_ub[i]));
+  }
+  for (let j = 0; j < n; j++) {
+    const high = boundsResolved[j][1];
+    if (high === null) continue;
+    const e = expansions[j];
+    const row2 = new Array(nx).fill(0);
+    let rhsVal;
+    if (e.kind === "shift") {
+      row2[e.col] = 1;
+      rhsVal = high - e.shift;
+    } else {
+      row2[e.colPos] = 1;
+      row2[e.colNeg] = -1;
+      rhsVal = high;
+    }
+    ubRows.push(row2);
+    ubRhs.push(rhsVal);
+  }
+  const A_eq = opts.A_eq ?? [];
+  const b_eq = opts.b_eq ?? [];
+  const eqRows = [];
+  const eqRhs = [];
+  for (let i = 0; i < A_eq.length; i++) {
+    eqRows.push(expandRow(A_eq[i]));
+    eqRhs.push(shiftedRhs(A_eq[i], b_eq[i]));
+  }
+  const mUb = ubRows.length;
+  const mEq = eqRows.length;
+  const nw = nx + mUb;
+  const Aeq = [];
+  const beq = [];
+  const hasSlack = [];
+  const slackCol = [];
+  for (let i = 0; i < mUb; i++) {
+    const row2 = new Array(nw).fill(0);
+    for (let j = 0; j < nx; j++) row2[j] = ubRows[i][j];
+    row2[nx + i] = 1;
+    Aeq.push(row2);
+    beq.push(ubRhs[i]);
+    hasSlack.push(true);
+    slackCol.push(nx + i);
+  }
+  for (let i = 0; i < mEq; i++) {
+    const row2 = new Array(nw).fill(0);
+    for (let j = 0; j < nx; j++) row2[j] = eqRows[i][j];
+    Aeq.push(row2);
+    beq.push(eqRhs[i]);
+    hasSlack.push(false);
+    slackCol.push(-1);
+  }
+  const costWorkFull = new Array(nw).fill(0);
+  for (let j = 0; j < nx; j++) costWorkFull[j] = cWork[j];
+  const raw = linprogSolveTwoPhase(costWorkFull, Aeq, beq, hasSlack, slackCol);
+  if (raw.status !== "optimal") {
+    return { x: new Array(n).fill(NaN), fun: NaN, success: false, status: raw.status };
+  }
+  const x = new Array(n).fill(0);
+  for (let j = 0; j < n; j++) {
+    const e = expansions[j];
+    x[j] = e.kind === "shift" ? raw.xWork[e.col] + e.shift : raw.xWork[e.colPos] - raw.xWork[e.colNeg];
+  }
+  let fun = constant;
+  for (let j = 0; j < nx; j++) fun += cWork[j] * raw.xWork[j];
+  return { x, fun, success: true, status: "optimal" };
+}
+function linprog(c, arg22, arg3) {
+  if (Array.isArray(arg22)) {
+    return linprogOnePhaseLegacy(c, arg22, arg3);
+  }
+  return linprogTwoPhase(c, arg22);
+}
 function solvePDE(pde, domain, bc) {
   const { alpha } = pde;
   const { L, nx, nt, T } = domain;
@@ -14118,9 +14397,9 @@ function _aggregateEigenvector(vectors, aggregation) {
   const count2 = vectors.length;
   const ref = vectors[0];
   const aligned = vectors.map((v) => {
-    let dot3 = 0;
-    for (let i = 0; i < n; i++) dot3 += v[i] * ref[i];
-    if (dot3 < 0) {
+    let dot4 = 0;
+    for (let i = 0; i < n; i++) dot4 += v[i] * ref[i];
+    if (dot4 < 0) {
       const flipped = new Float64Array(n);
       for (let i = 0; i < n; i++) flipped[i] = -v[i];
       return flipped;
@@ -15971,9 +16250,9 @@ function principalComponentAnalysis(data, k) {
   const explained = eigenvalues.map((ev) => totalVar > 0 ? Math.abs(ev) / totalVar : 0);
   const scores = centered.map((row2) => {
     return eigenvectors.map((ev) => {
-      let dot3 = 0;
-      for (let j = 0; j < p; j++) dot3 += row2[j] * ev[j];
-      return dot3;
+      let dot4 = 0;
+      for (let j = 0; j < p; j++) dot4 += row2[j] * ev[j];
+      return dot4;
     });
   });
   return { components: eigenvectors, explained, scores };
@@ -16584,30 +16863,30 @@ function hessenbergForm(A) {
     if (normV < 1e-30) continue;
     const beta2 = 2 / normV;
     for (let j = k; j < n; j++) {
-      let dot3 = 0;
+      let dot4 = 0;
       for (let i = 0; i < len; i++) {
-        dot3 += v[i] * H[k + 1 + i][j];
+        dot4 += v[i] * H[k + 1 + i][j];
       }
       for (let i = 0; i < len; i++) {
-        H[k + 1 + i][j] -= beta2 * v[i] * dot3;
+        H[k + 1 + i][j] -= beta2 * v[i] * dot4;
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot3 = 0;
+      let dot4 = 0;
       for (let j = 0; j < len; j++) {
-        dot3 += H[i][k + 1 + j] * v[j];
+        dot4 += H[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        H[i][k + 1 + j] -= beta2 * dot3 * v[j];
+        H[i][k + 1 + j] -= beta2 * dot4 * v[j];
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot3 = 0;
+      let dot4 = 0;
       for (let j = 0; j < len; j++) {
-        dot3 += Q2[i][k + 1 + j] * v[j];
+        dot4 += Q2[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        Q2[i][k + 1 + j] -= beta2 * dot3 * v[j];
+        Q2[i][k + 1 + j] -= beta2 * dot4 * v[j];
       }
     }
   }
@@ -29919,7 +30198,7 @@ var createPinv = /* @__PURE__ */ factory(
     deepEqual: deepEqual3,
     equal: equal2,
     dotDivide: dotDivide2,
-    dot: dot3,
+    dot: dot4,
     ctranspose: ctranspose2,
     divideScalar: divideScalar2,
     multiply: multiply2,
@@ -29935,7 +30214,7 @@ var createPinv = /* @__PURE__ */ factory(
             if (size2[0] === 1) {
               return inv2(x);
             } else {
-              return dotDivide2(ctranspose2(x), dot3(x, x));
+              return dotDivide2(ctranspose2(x), dot4(x, x));
             }
           case 2: {
             if (_isZeros(x)) return ctranspose2(x);
@@ -30014,8 +30293,8 @@ var createPinv = /* @__PURE__ */ factory(
     }
     function _rankFact(mat, rows, cols) {
       const rref = _rref(mat, rows, cols);
-      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot3(rref[j], rref[j]))));
-      const F = rref.filter((_, i) => !_isZero(dot3(rref[i], rref[i])));
+      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot4(rref[j], rref[j]))));
+      const F = rref.filter((_, i) => !_isZero(dot4(rref[i], rref[i])));
       return { C, F };
     }
     function _isZero(x) {
@@ -36978,7 +37257,7 @@ function createComplexEigs({
   larger: larger2,
   smaller: smaller2,
   matrixFromColumns: _matrixFromColumns,
-  dot: dot3
+  dot: dot4
 }) {
   function complexEigs(arr7, N, prec, type, findVectors = true) {
     if (!findVectors && type === "number" && N * N >= WASM_EIGS_THRESHOLD) {
@@ -37419,7 +37698,7 @@ function createComplexEigs({
       v = subtract2(
         v,
         multiply2(
-          divideScalar2(dot3(w, v), dot3(w, w)),
+          divideScalar2(dot4(w, v), dot4(w, w)),
           w
         )
       );
@@ -37427,7 +37706,7 @@ function createComplexEigs({
     return v;
   }
   function norm4(v) {
-    return abs2(sqrt2(dot3(v, v)));
+    return abs2(sqrt2(dot4(v, v)));
   }
   function normalize2(v, type) {
     const big = type === "BigNumber";
@@ -37847,7 +38126,7 @@ var createEigs = /* @__PURE__ */ factory(
     re: re3,
     smaller: smaller2,
     matrixFromColumns: matrixFromColumns2,
-    dot: dot3
+    dot: dot4
   }) => {
     const doRealSymmetric = createRealSymmetric({
       config: config2,
@@ -37886,7 +38165,7 @@ var createEigs = /* @__PURE__ */ factory(
       larger: larger2,
       smaller: smaller2,
       matrixFromColumns: matrixFromColumns2,
-      dot: dot3
+      dot: dot4
     });
     return typed3("eigs", {
       // The conversion to matrix in the first two implementations,
@@ -44978,16 +45257,16 @@ function fsolve(F, x0, opts = {}) {
       const msg = err instanceof Error ? err.message : String(err);
       throw new Error(`fsolve: singular Jacobian at iteration ${iter} (${msg})`);
     }
-    const residualNorm = norm24(Fx);
+    const residualNorm2 = norm24(Fx);
     let xNext = x.map((xi, i) => xi + delta[i]);
     let FxNext = F(xNext);
-    if (norm24(FxNext) >= residualNorm) {
+    if (norm24(FxNext) >= residualNorm2) {
       let trialLambda = 1;
       for (let halving = 0; halving < 20; halving++) {
         trialLambda /= 2;
         const xTrial = x.map((xi, i) => xi + trialLambda * delta[i]);
         const FxTrial = F(xTrial);
-        if (norm24(FxTrial) < residualNorm) {
+        if (norm24(FxTrial) < residualNorm2) {
           xNext = xTrial;
           FxNext = FxTrial;
           break;
@@ -45413,6 +45692,253 @@ function spectralClustering(adjacency, k, opts = {}) {
   return kmeans(embed, k, opts).labels;
 }
 
+// src/numeric/bfgs.ts
+var CBRT_EPS = Math.cbrt(2220446049250313e-31);
+function numericGradient(f, x) {
+  const n = x.length;
+  const g = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const h = Math.max(1, Math.abs(x[i])) * CBRT_EPS;
+    const xp = x.slice();
+    const xm = x.slice();
+    xp[i] += h;
+    xm[i] -= h;
+    g[i] = (f(xp) - f(xm)) / (2 * h);
+  }
+  return g;
+}
+function clipToBounds(x, bounds) {
+  if (!bounds) return x;
+  return x.map((v, i) => {
+    const b = bounds[i];
+    if (!b) return v;
+    const [lo, hi] = b;
+    return Math.min(hi, Math.max(lo, v));
+  });
+}
+function dot2(a, b) {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+function matVec(H, v) {
+  const n = v.length;
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) {
+    let s = 0;
+    for (let j = 0; j < n; j++) s += H[i][j] * v[j];
+    out[i] = s;
+  }
+  return out;
+}
+function bfgs(f, x0, opts = {}) {
+  const { grad, bounds, tol = 1e-8, maxIter = 500 } = opts;
+  const gradOf = grad ?? ((x2) => numericGradient(f, x2));
+  const n = x0.length;
+  const c1 = 1e-4;
+  let x = clipToBounds(x0.slice(), bounds);
+  let fx = f(x);
+  let g = gradOf(x);
+  let H = Array.from(
+    { length: n },
+    (_, i) => Array.from({ length: n }, (_2, j) => i === j ? 1 : 0)
+  );
+  const infNorm = (v) => v.reduce((m, c) => Math.max(m, Math.abs(c)), 0);
+  let iter = 0;
+  let converged = infNorm(g) < tol;
+  while (!converged && iter < maxIter) {
+    const d = matVec(H, g).map((v) => -v);
+    const gd = dot2(g, d);
+    const dir = gd < 0 ? d : g.map((v) => -v);
+    const dirSlope = gd < 0 ? gd : -dot2(g, g);
+    let alpha = 1;
+    let xNew = clipToBounds(
+      x.map((v, i) => v + alpha * dir[i]),
+      bounds
+    );
+    let fNew = f(xNew);
+    let halvings = 0;
+    while (fNew > fx + c1 * alpha * dirSlope && halvings < 50) {
+      alpha *= 0.5;
+      xNew = clipToBounds(
+        x.map((v, i) => v + alpha * dir[i]),
+        bounds
+      );
+      fNew = f(xNew);
+      halvings++;
+    }
+    const gNew = gradOf(xNew);
+    const s = xNew.map((v, i) => v - x[i]);
+    const y = gNew.map((v, i) => v - g[i]);
+    const sy = dot2(s, y);
+    if (sy > 1e-12) {
+      const rho = 1 / sy;
+      const Hy = matVec(H, y);
+      const yHy = dot2(y, Hy);
+      const HNew = Array.from({ length: n }, () => new Array(n).fill(0));
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+          HNew[i][j] = H[i][j] - rho * (s[i] * Hy[j] + Hy[i] * s[j]) + rho * rho * yHy * s[i] * s[j] + rho * s[i] * s[j];
+        }
+      }
+      H = HNew;
+    }
+    x = xNew;
+    fx = fNew;
+    g = gNew;
+    iter++;
+    converged = infNorm(g) < tol;
+  }
+  return { x, fval: fx, iterations: iter, converged };
+}
+
+// src/numeric/nnls.ts
+function matVec2(A, x) {
+  const m = A.length;
+  const result = new Array(m);
+  for (let i = 0; i < m; i++) {
+    const row2 = A[i];
+    let s = 0;
+    for (let j = 0; j < row2.length; j++) s += row2[j] * x[j];
+    result[i] = s;
+  }
+  return result;
+}
+function residualNorm(A, x, b) {
+  const Ax = matVec2(A, x);
+  let s = 0;
+  for (let i = 0; i < b.length; i++) {
+    const d = Ax[i] - b[i];
+    s += d * d;
+  }
+  return Math.sqrt(s);
+}
+function nnls(A, b, opts = {}) {
+  const m = A.length;
+  const n = A[0]?.length ?? 0;
+  const tol = opts.tol ?? 1e-10;
+  const maxIter = opts.maxIter ?? 3 * n;
+  let x = new Array(n).fill(0);
+  const passive = /* @__PURE__ */ new Set();
+  const gradient2 = (xv) => {
+    const Ax = matVec2(A, xv);
+    const w = new Array(n).fill(0);
+    for (let j = 0; j < n; j++) {
+      let s = 0;
+      for (let i = 0; i < m; i++) s += A[i][j] * (b[i] - Ax[i]);
+      w[j] = s;
+    }
+    return w;
+  };
+  const solvePassive = (P2) => {
+    const z = new Array(n).fill(0);
+    if (P2.length === 0) return z;
+    const Asub = A.map((row2) => P2.map((j) => row2[j]));
+    let zp;
+    try {
+      zp = leastSquares(Asub, b);
+    } catch {
+      return x.slice();
+    }
+    for (let k = 0; k < P2.length; k++) z[P2[k]] = zp[k];
+    return z;
+  };
+  let outerIter = 0;
+  while (outerIter < maxIter) {
+    const w = gradient2(x);
+    let maxW = -Infinity;
+    let maxJ = -1;
+    for (let j = 0; j < n; j++) {
+      if (!passive.has(j) && w[j] > maxW) {
+        maxW = w[j];
+        maxJ = j;
+      }
+    }
+    if (maxJ === -1 || maxW <= tol) break;
+    passive.add(maxJ);
+    let z = solvePassive(Array.from(passive));
+    let innerIter = 0;
+    while (Array.from(passive).some((j) => z[j] <= tol) && innerIter < maxIter) {
+      innerIter++;
+      let alpha = Infinity;
+      for (const j of passive) {
+        if (z[j] <= tol) {
+          const denom = x[j] - z[j];
+          if (denom > 0) alpha = Math.min(alpha, x[j] / denom);
+        }
+      }
+      if (!isFinite(alpha)) alpha = 0;
+      for (let j = 0; j < n; j++) x[j] = x[j] + alpha * (z[j] - x[j]);
+      for (const j of Array.from(passive)) {
+        if (Math.abs(x[j]) < tol) passive.delete(j);
+      }
+      z = solvePassive(Array.from(passive));
+    }
+    x = z;
+    outerIter++;
+  }
+  return { x, residual: residualNorm(A, x, b) };
+}
+function clip(v, lower, upper) {
+  return v.map((vi, i) => Math.min(Math.max(vi, lower[i]), upper[i]));
+}
+function lsqBounded(A, b, lower, upper, opts = {}) {
+  const m = A.length;
+  const n = A[0]?.length ?? 0;
+  const tol = opts.tol ?? 1e-10;
+  const maxIter = opts.maxIter ?? Math.max(200, 20 * n);
+  let x = clip(new Array(n).fill(0), lower, upper);
+  const gradient2 = (xv) => {
+    const Ax = matVec2(A, xv);
+    const r = new Array(m);
+    for (let i = 0; i < m; i++) r[i] = Ax[i] - b[i];
+    const g = new Array(n).fill(0);
+    for (let j = 0; j < n; j++) {
+      let s = 0;
+      for (let i = 0; i < m; i++) s += A[i][j] * r[i];
+      g[j] = s;
+    }
+    return g;
+  };
+  const objective = (xv) => {
+    const r = residualNorm(A, xv, b);
+    return 0.5 * r * r;
+  };
+  for (let iter = 0; iter < maxIter; iter++) {
+    const g = gradient2(x);
+    const projFull = clip(
+      x.map((xi, i) => xi - g[i]),
+      lower,
+      upper
+    );
+    let pgNorm = 0;
+    for (let i = 0; i < n; i++) pgNorm += (x[i] - projFull[i]) ** 2;
+    pgNorm = Math.sqrt(pgNorm);
+    if (pgNorm < tol) break;
+    const fx = objective(x);
+    let alpha = 1;
+    let xNext = clip(
+      x.map((xi, i) => xi - alpha * g[i]),
+      lower,
+      upper
+    );
+    let fNext = objective(xNext);
+    let backtrack = 0;
+    while (fNext > fx && backtrack < 50) {
+      alpha /= 2;
+      xNext = clip(
+        x.map((xi, i) => xi - alpha * g[i]),
+        lower,
+        upper
+      );
+      fNext = objective(xNext);
+      backtrack++;
+    }
+    x = xNext;
+  }
+  return { x, residual: residualNorm(A, x, b) };
+}
+
 // src/cas-integration.ts
 var parse2 = parse;
 var evaluate2 = evaluate;
@@ -45671,15 +46197,15 @@ function haversine(lat1, lon1, lat2, lon2, radius = EARTH_RADIUS_KM) {
   const a = Math.sin(dPhi / 2) ** 2 + Math.cos(phi1) * Math.cos(phi2) * Math.sin(dLambda / 2) ** 2;
   return radius * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
 }
-var dot2 = (a, b) => a.reduce((s, v, i) => s + v * b[i], 0);
-var norm3 = (a) => Math.sqrt(dot2(a, a));
+var dot3 = (a, b) => a.reduce((s, v, i) => s + v * b[i], 0);
+var norm3 = (a) => Math.sqrt(dot3(a, a));
 function slerp(v0, v1, t) {
   const n0 = norm3(v0);
   const n16 = norm3(v1);
   if (n0 === 0 || n16 === 0) throw new Error("slerp: input vectors must be non-zero");
   const u0 = v0.map((v) => v / n0);
   const u1 = v1.map((v) => v / n16);
-  let cos2 = dot2(u0, u1);
+  let cos2 = dot3(u0, u1);
   cos2 = cos2 > 1 ? 1 : cos2 < -1 ? -1 : cos2;
   const omega = Math.acos(cos2);
   const mag = n0 + (n16 - n0) * t;
@@ -45795,6 +46321,7 @@ export {
   betainc,
   betweennessCentrality,
   bezierCurve,
+  bfgs,
   bigint,
   bignumber,
   bin,
@@ -46239,6 +46766,7 @@ export {
   lowpassFilter,
   lsolve,
   lsolveAll,
+  lsqBounded,
   lucas,
   lucasL,
   lup,
@@ -46303,6 +46831,7 @@ export {
   newtonInterp,
   nextPrime,
   nintegrate,
+  nnls,
   nodeOperations,
   noncentralChi2PDF,
   norm,

package/dist/numeric/bfgs.d.ts

@@ -0,0 +1,70 @@
+/**
+ * BFGS quasi-Newton minimization of `f: ℝⁿ → ℝ`.
+ *
+ * Maintains an approximate inverse Hessian `H` (started at the identity) and
+ * updates it after every accepted step via the classic BFGS formula:
+ *
+ *   s = x_{k+1} − x_k,  y = g_{k+1} − g_k,  ρ = 1 / (yᵀs)
+ *   H ← (I − ρ s yᵀ) H (I − ρ y sᵀ) + ρ s sᵀ
+ *
+ * The update is skipped (H left unchanged) when `yᵀs ≤ 1e-12` — a near-zero
+ * or negative curvature pairing would make H indefinite. The search direction
+ * is `d = −H g`, accepted via a backtracking Armijo line search (`c1 = 1e-4`,
+ * starting step `α = 1`, halved up to 50 times).
+ *
+ * `opts.bounds`, if supplied, turns this into a lightweight **projected**
+ * BFGS: after every accepted step each coordinate is clipped into its
+ * `[lo, hi]` range. This is NOT the full active-set L-BFGS-B method (no
+ * distinction between free/active variables in the Hessian update) — it is a
+ * simple, effective projection that keeps the iterate feasible.
+ *
+ * Complements the derivative-free `minimize` (Nelder–Mead): BFGS converges
+ * superlinearly on smooth functions using gradient information (analytic or
+ * numeric), at the cost of assuming enough smoothness for the gradient/line
+ * search to behave.
+ *
+ * @packageDocumentation
+ */
+type f64 = number;
+/** Options for {@link bfgs}. */
+export interface BfgsOptions {
+    /**
+     * Analytic gradient `∇f(x)`. If omitted, a central-difference gradient is
+     * used with per-coordinate step `h_i = max(1, |x_i|) · cbrt(machine eps)`.
+     */
+    grad?: (x: number[]) => number[];
+    /**
+     * Box constraints `[lo_i, hi_i]` per coordinate. After each accepted step,
+     * `x` is clipped into these bounds (projected BFGS — a lightweight
+     * approximation of L-BFGS-B, not the full active-set method).
+     */
+    bounds?: [f64, f64][];
+    /** Convergence tolerance on `‖g‖∞` (default 1e-8). */
+    tol?: f64;
+    /** Maximum iterations (default 500). */
+    maxIter?: number;
+}
+/** Result of {@link bfgs}. */
+export interface BfgsResult {
+    /** The minimizer. */
+    x: number[];
+    /** `f(x)` at the minimizer. */
+    fval: f64;
+    /** Number of iterations performed. */
+    iterations: number;
+    /** Whether `‖g‖∞ < tol` was reached within `maxIter`. */
+    converged: boolean;
+}
+/**
+ * Minimize `f: ℝⁿ → ℝ` from `x0` via BFGS quasi-Newton with an Armijo
+ * backtracking line search. Uses `opts.grad` if supplied, else a local
+ * central-difference gradient. `opts.bounds` clips each accepted step
+ * (projected BFGS, not full L-BFGS-B).
+ *
+ * @example
+ * bfgs((v) => (1 - v[0]) ** 2 + 100 * (v[1] - v[0] ** 2) ** 2, [-1.2, 1])
+ * // => { x: ~[1, 1], fval: ~0, ... }
+ */
+export declare function bfgs(f: (x: number[]) => number, x0: number[], opts?: BfgsOptions): BfgsResult;
+export {};
+//# sourceMappingURL=bfgs.d.ts.map

package/dist/numeric/bfgs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bfgs.d.ts","sourceRoot":"","sources":["../../src/numeric/bfgs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,KAAK,GAAG,GAAG,MAAM,CAAC;AAElB,gCAAgC;AAChC,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;IACjC;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;IACtB,sDAAsD;IACtD,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,wCAAwC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,8BAA8B;AAC9B,MAAM,WAAW,UAAU;IACzB,qBAAqB;IACrB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,+BAA+B;IAC/B,IAAI,EAAE,GAAG,CAAC;IACV,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,SAAS,EAAE,OAAO,CAAC;CACpB;AA+CD;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,WAAgB,GAAG,UAAU,CA8EjG"}

package/dist/numeric/nnls.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Constrained least squares: `nnls` (Lawson–Hanson active-set non-negative
+ * least squares) and `lsqBounded` (projected-gradient box-constrained least
+ * squares). Both minimize `||Ax - b||_2` subject to simple bound constraints
+ * on `x`, complementing the unconstrained `leastSquares` (`../typed/numeric.ts`).
+ *
+ * @packageDocumentation
+ */
+/** Options shared by `nnls` and `lsqBounded`. */
+export interface NnlsOptions {
+    /** Convergence tolerance (default 1e-10). */
+    tol?: number;
+    /** Maximum iterations (default `3 * n`). */
+    maxIter?: number;
+}
+/** Options for `lsqBounded` (same shape as `NnlsOptions`, kept as a distinct alias for clarity). */
+export type LsqBoundedOptions = NnlsOptions;
+/** Result of `nnls` / `lsqBounded`: the solution and its residual norm. */
+export interface NnlsResult {
+    /** Solution vector x. */
+    x: number[];
+    /** `||Ax - b||_2` at the returned solution. */
+    residual: number;
+}
+/** Alias for `NnlsResult` (used by `lsqBounded`). */
+export type LsqBoundedResult = NnlsResult;
+/**
+ * Non-negative least squares: `min ||Ax - b||_2 s.t. x >= 0`, via the
+ * Lawson–Hanson active-set algorithm.
+ *
+ * Maintains a "passive" set `P` of coordinates allowed to be nonzero (all
+ * others held at 0). Each outer iteration adds to `P` the inactive index
+ * with the most positive gradient component `w_j = (A^T(b - Ax))_j`, solves
+ * the unconstrained least-squares problem restricted to the columns in `P`
+ * (via `leastSquares`), and — if that restricted solution has any
+ * non-positive component — walks back along the line from the current `x`
+ * toward it until the first such component would hit zero, dropping that
+ * index from `P` and re-solving. Terminates when no inactive index has a
+ * positive gradient (KKT optimality) or `maxIter` is exhausted.
+ *
+ * @param A - Matrix (m x n)
+ * @param b - Right-hand side (length m)
+ * @param opts - Options (tol, maxIter; default maxIter = 3n)
+ * @returns `{ x, residual }` with `x >= 0` (up to `tol`) and `residual = ||Ax - b||_2`
+ *
+ * @example
+ * nnls([[1, 0], [0, 1]], [3, -2]) // => { x: [3, 0], residual: 2 }
+ */
+export declare function nnls(A: number[][], b: number[], opts?: NnlsOptions): NnlsResult;
+/**
+ * Box-constrained least squares: `min ||Ax - b||_2 s.t. lower <= x <= upper`,
+ * via projected-gradient descent.
+ *
+ * Each iteration computes the gradient `g = A^T(Ax - b)` of the smooth
+ * objective `f(x) = (1/2)||Ax - b||^2`, takes a candidate step
+ * `x - alpha*g` projected (clipped) into the box, and backtracks
+ * (`alpha /= 2`) until the projected step does not increase `f`. Converges
+ * when the projected-gradient norm `||x - clip(x - g, lower, upper)||` is
+ * below `tol`.
+ *
+ * @param A - Matrix (m x n)
+ * @param b - Right-hand side (length m)
+ * @param lower - Per-component lower bounds (length n)
+ * @param upper - Per-component upper bounds (length n)
+ * @param opts - Options (tol, maxIter; default maxIter = max(200, 20n))
+ * @returns `{ x, residual }` with `lower <= x <= upper` and `residual = ||Ax - b||_2`
+ *
+ * @example
+ * lsqBounded([[1, 0], [0, 1]], [5, -3], [0, 0], [2, 2]) // => { x: [2, 0], residual: ... }
+ */
+export declare function lsqBounded(A: number[][], b: number[], lower: number[], upper: number[], opts?: LsqBoundedOptions): LsqBoundedResult;
+//# sourceMappingURL=nnls.d.ts.map

package/dist/numeric/nnls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nnls.d.ts","sourceRoot":"","sources":["../../src/numeric/nnls.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,iDAAiD;AACjD,MAAM,WAAW,WAAW;IAC1B,6CAA6C;IAC7C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,oGAAoG;AACpG,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC;AAE5C,2EAA2E;AAC3E,MAAM,WAAW,UAAU;IACzB,yBAAyB;IACzB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qDAAqD;AACrD,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC;AA8B1C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,WAAgB,GAAG,UAAU,CA6EnF;AAOD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,MAAM,EAAE,EAAE,EACb,CAAC,EAAE,MAAM,EAAE,EACX,KAAK,EAAE,MAAM,EAAE,EACf,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,GAAE,iBAAsB,GAC3B,gBAAgB,CAgElB"}

package/dist/typed/numeric.d.ts

@@ -367,15 +367,36 @@ export declare function padeApproximant(coeffs: number[], m: i32, n: i32): {
  */
 export declare function quadprog(H: number[][], f: number[], A: number[][], b: number[]): number[];
 /**
- * Linear programming: minimize c^T x subject to Ax <= b, x >= 0.
- * Simple simplex method implementation.
+ * Options form of {@link linprog}: minimize c^T x subject to A_ub x <= b_ub,
+ * A_eq x = b_eq, and per-variable bounds.
+ */
+export interface LinprogOptions {
+    A_ub?: number[][];
+    b_ub?: number[];
+    A_eq?: number[][];
+    b_eq?: number[];
+    /** Per-variable [lower, upper] bounds; null = unbounded. Default: [0, null] for every variable. */
+    bounds?: readonly (readonly [number | null, number | null])[];
+}
+/** Result of the options form of {@link linprog}. */
+export interface LinprogResult {
+    x: number[];
+    fun: number;
+    success: boolean;
+    status: 'optimal' | 'infeasible' | 'unbounded';
+}
+/**
+ * Linear programming: minimize c^T x.
  *
- * @param c - Objective coefficients (length n)
- * @param A - Constraint matrix (m x n)
- * @param b - Constraint bounds (length m, non-negative)
- * @returns Solution vector x, or null if infeasible
+ * Two overloads:
+ * - Legacy positional form `linprog(c, A_ub, b_ub)` — subject to `A_ub x <= b_ub`,
+ *   `x >= 0`; returns the solution vector `x` (or `null` if unbounded).
+ * - Options form `linprog(c, { A_ub, b_ub, A_eq, b_eq, bounds })` — a two-phase
+ *   simplex supporting equality constraints, variable bounds, and negative-RHS
+ *   rows; returns `{ x, fun, success, status }`.
  */
-export declare function linprog(c: number[], A: number[][], b: number[]): number[] | null;
+export declare function linprog(c: number[], A_ub: number[][], b_ub: number[]): number[] | null;
+export declare function linprog(c: number[], opts: LinprogOptions): LinprogResult;
 /**
  * Simple 1D PDE solver using finite differences (heat equation).
  *

package/dist/typed/numeric.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numeric.d.ts","sourceRoot":"","sources":["../../src/typed/numeric.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"numeric.d.ts","sourceRoot":"","sources":["../../src/typed/numeric.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",