diff-grok 1.1.0 → 1.2.0

package/src/solver-tools/cvode/cvode_ls.js

@@ -0,0 +1,210 @@
+/**
+ * TypeScript port of SUNDIALS CVODE v7.5.0 (https://github.com/LLNL/sundials)
+ *
+ * Copyright (c) 2025, Lawrence Livermore National Security, University of
+ *   Maryland Baltimore County, and the SUNDIALS contributors.
+ * Copyright (c) 2013-2025, Lawrence Livermore National Security and
+ *   Southern Methodist University.
+ * Copyright (c) 2002-2013, Lawrence Livermore National Security.
+ * Copyright (c) 2026 Datagrok.
+ *
+ * Licensed under the BSD-3-Clause License. See THIRD_PARTY_LICENSES
+ * for the full license text and provenance chain of the original code.
+ */
+// CVODE TypeScript port - Dense linear solver interface
+// Translated from SUNDIALS cvode_ls.c
+//
+// Instead of SUNDIALS' SUNLinearSolver / SUNMatrix abstraction, we use
+// direct Float64Array[] matrices and dgefa / dgesl from dense_linalg.ts.
+import { CvLsMem, wrmsNorm, CV_SUCCESS, CV_FAIL_BAD_J, CVLS_MSBJ, CVLS_DGMAX } from './common';
+import { dgefa, dgesl } from './dense_linalg';
+/**
+ * cvodeSetLinearSolver - Initialize the dense linear solver.
+ * Sets up CvLsMem, allocates matrix, sets function pointers on CvodeMem.
+ */
+export function cvodeSetLinearSolver(mem) {
+    const N = mem.cv_N;
+    const lmem = new CvLsMem();
+    // Allocate dense matrix A (N x N, row-major)
+    lmem.A = new Array(N);
+    lmem.savedJ = new Array(N);
+    for (let i = 0; i < N; i++) {
+        lmem.A[i] = new Float64Array(N);
+        lmem.savedJ[i] = new Float64Array(N);
+    }
+    lmem.pivots = new Int32Array(N);
+    // Set defaults
+    lmem.jacDQ = true;
+    lmem.jacFn = null;
+    lmem.jbad = true;
+    lmem.nje = 0;
+    lmem.nfeDQ = 0;
+    lmem.nstlj = 0;
+    lmem.tnlj = 0;
+    lmem.msbj = CVLS_MSBJ;
+    lmem.dgmax_jbad = CVLS_DGMAX;
+    // Attach to CvodeMem
+    mem.cv_lmem = lmem;
+    mem.cv_linit = cvLsInitialize;
+    mem.cv_lsetup = cvLsSetup;
+    mem.cv_lsolve = cvLsSolve;
+    mem.cv_lfree = cvLsFree;
+    return CV_SUCCESS;
+}
+/**
+ * cvodeSetJacFn - Set a user-supplied Jacobian function.
+ */
+export function cvodeSetJacFn(mem, jac) {
+    const lmem = mem.cv_lmem;
+    if (!lmem)
+        return -1;
+    if (jac) {
+        lmem.jacDQ = false;
+        lmem.jacFn = jac;
+    }
+    else {
+        lmem.jacDQ = true;
+        lmem.jacFn = null;
+    }
+    return CV_SUCCESS;
+}
+/**
+ * cvLsInitialize - Initialize linear solver counters.
+ */
+function cvLsInitialize(mem) {
+    const lmem = mem.cv_lmem;
+    lmem.nje = 0;
+    lmem.nfeDQ = 0;
+    lmem.nstlj = 0;
+    lmem.jbad = true;
+    return CV_SUCCESS;
+}
+/**
+ * cvLsSetup - Compute Jacobian and form/factor the linear system matrix A = I - gamma*J.
+ *
+ * Heuristic for when to recompute Jacobian:
+ * - On first call (nstlj == 0)
+ * - If convfail is CV_FAIL_BAD_J (NLS flagged Jacobian as bad)
+ * - If enough steps since last eval (nst >= nstlj + msbj)
+ * - If gamma changed significantly (|gamrat - 1| > dgmax_jbad)
+ */
+function cvLsSetup(mem, convfail, ypred, fpred, jcurPtr, tmp1, tmp2, tmp3) {
+    const lmem = mem.cv_lmem;
+    const N = mem.cv_N;
+    let retval;
+    // Determine if Jacobian needs updating
+    const jbad = lmem.jbad;
+    let jok = !jbad;
+    if (!jbad) {
+        // Check gamma ratio
+        if (Math.abs(mem.cv_gamrat - 1.0) > lmem.dgmax_jbad)
+            jok = false;
+        // Check steps since last Jacobian
+        if (mem.cv_nst >= lmem.nstlj + lmem.msbj)
+            jok = false;
+        // Check convfail
+        if (convfail === CV_FAIL_BAD_J)
+            jok = false;
+    }
+    if (jok) {
+        // Reuse saved Jacobian, just form A = I - gamma*J
+        jcurPtr.value = false;
+        // Copy savedJ to A and form I - gamma*J
+        for (let i = 0; i < N; i++) {
+            for (let j = 0; j < N; j++)
+                lmem.A[i][j] = -mem.cv_gamma * lmem.savedJ[i][j];
+            lmem.A[i][i] += 1.0;
+        }
+    }
+    else {
+        // Recompute Jacobian
+        lmem.nje++;
+        lmem.nstlj = mem.cv_nst;
+        lmem.jbad = false;
+        jcurPtr.value = true;
+        // Evaluate Jacobian
+        if (lmem.jacDQ)
+            retval = cvLsDQJac(mem, mem.cv_tn, ypred, fpred, lmem.savedJ, tmp1, tmp2);
+        else
+            retval = lmem.jacFn(mem.cv_tn, ypred, fpred, lmem.savedJ, mem.cv_user_data);
+        if (retval < 0) {
+            lmem.jbad = true;
+            return -1;
+        }
+        if (retval > 0) {
+            lmem.jbad = true;
+            return 1;
+        }
+        // Form A = I - gamma*J
+        for (let i = 0; i < N; i++) {
+            for (let j = 0; j < N; j++)
+                lmem.A[i][j] = -mem.cv_gamma * lmem.savedJ[i][j];
+            lmem.A[i][i] += 1.0;
+        }
+    }
+    // Factor A using LU decomposition
+    const info = dgefa(lmem.A, N, lmem.pivots);
+    if (info !== 0) {
+        lmem.jbad = true;
+        return 1; // recoverable
+    }
+    return CV_SUCCESS;
+}
+/**
+ * cvLsSolve - Solve the linear system A*x = b using LU factors.
+ */
+function cvLsSolve(mem, b, weight, ycur, fcur) {
+    const lmem = mem.cv_lmem;
+    const N = mem.cv_N;
+    dgesl(lmem.A, N, lmem.pivots, b);
+    // Apply gamma/gammap correction if gamma has changed since last setup
+    if (mem.cv_gamrat !== 1.0) {
+        const factor = 2.0 / (1.0 + mem.cv_gamrat);
+        for (let i = 0; i < N; i++)
+            b[i] *= factor;
+    }
+    return CV_SUCCESS;
+}
+/**
+ * cvLsDQJac - Compute difference-quotient Jacobian approximation.
+ *
+ * For each column j:
+ *   sigma_j = max(|y_j|, 1/ewt_j) * sqrt(uround)
+ *   J[:,j] = (f(t, y + sigma_j*e_j) - f(t, y)) / sigma_j
+ */
+function cvLsDQJac(mem, t, y, fy, J, tmp1, tmp2) {
+    const N = mem.cv_N;
+    const lmem = mem.cv_lmem;
+    const uround = 2.2204460492503131e-16;
+    const srur = Math.sqrt(uround);
+    const fnorm_val = wrmsNorm(N, fy, mem.cv_ewt);
+    const minInc = (fnorm_val !== 0.0) ? (1000.0 * Math.abs(mem.cv_h) * uround * N * fnorm_val) : 1.0;
+    // Use tmp1 as perturbed y, tmp2 as perturbed f
+    for (let j = 0; j < N; j++) {
+        const yjsaved = y[j];
+        let inc = Math.max(srur * Math.abs(yjsaved), minInc / mem.cv_ewt[j]);
+        // Ensure inc has same sign (positive since we want to increase)
+        // Perturb y[j]
+        tmp1.set(y);
+        tmp1[j] = yjsaved + inc;
+        inc = tmp1[j] - yjsaved; // exact increment after rounding
+        // Evaluate f(t, y + inc*e_j)
+        const retval = mem.cv_f(t, tmp1, tmp2, mem.cv_user_data);
+        lmem.nfeDQ++;
+        mem.cv_nfe++;
+        if (retval !== 0)
+            return retval;
+        // Compute column j of Jacobian: (f_perturbed - f) / inc
+        const inc_inv = 1.0 / inc;
+        for (let i = 0; i < N; i++)
+            J[i][j] = (tmp2[i] - fy[i]) * inc_inv;
+    }
+    return CV_SUCCESS;
+}
+/**
+ * cvLsFree - Free linear solver memory (no-op in TS, GC handles it).
+ */
+function cvLsFree(mem) {
+    mem.cv_lmem = null;
+}
+//# sourceMappingURL=cvode_ls.js.map

package/src/solver-tools/cvode/cvode_ls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cvode_ls.js","sourceRoot":"","sources":["cvode_ls.ts"],"names":[],"mappings":"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"}

package/src/solver-tools/cvode/cvode_ls.ts

@@ -0,0 +1,249 @@
+/**
+ * TypeScript port of SUNDIALS CVODE v7.5.0 (https://github.com/LLNL/sundials)
+ *
+ * Copyright (c) 2025, Lawrence Livermore National Security, University of
+ *   Maryland Baltimore County, and the SUNDIALS contributors.
+ * Copyright (c) 2013-2025, Lawrence Livermore National Security and
+ *   Southern Methodist University.
+ * Copyright (c) 2002-2013, Lawrence Livermore National Security.
+ * Copyright (c) 2026 Datagrok.
+ *
+ * Licensed under the BSD-3-Clause License. See THIRD_PARTY_LICENSES
+ * for the full license text and provenance chain of the original code.
+ */
+
+// CVODE TypeScript port - Dense linear solver interface
+// Translated from SUNDIALS cvode_ls.c
+//
+// Instead of SUNDIALS' SUNLinearSolver / SUNMatrix abstraction, we use
+// direct Float64Array[] matrices and dgefa / dgesl from dense_linalg.ts.
+
+import {CvodeMem, CvLsMem, CvodeJacFn, wrmsNorm,
+  CV_SUCCESS, CV_RHSFUNC_FAIL, RHSFUNC_RECVR,
+  CV_NO_FAILURES, CV_FAIL_BAD_J, CV_FAIL_OTHER,
+  CVLS_MSBJ, CVLS_DGMAX, ONEPSM} from './common';
+import {dgefa, dgesl} from './dense_linalg';
+
+/**
+ * cvodeSetLinearSolver - Initialize the dense linear solver.
+ * Sets up CvLsMem, allocates matrix, sets function pointers on CvodeMem.
+ */
+export function cvodeSetLinearSolver(mem: CvodeMem): number {
+  const N = mem.cv_N;
+  const lmem = new CvLsMem();
+
+  // Allocate dense matrix A (N x N, row-major)
+  lmem.A = new Array(N);
+  lmem.savedJ = new Array(N);
+  for (let i = 0; i < N; i++) {
+    lmem.A[i] = new Float64Array(N);
+    lmem.savedJ[i] = new Float64Array(N);
+  }
+  lmem.pivots = new Int32Array(N);
+
+  // Set defaults
+  lmem.jacDQ = true;
+  lmem.jacFn = null;
+  lmem.jbad = true;
+  lmem.nje = 0;
+  lmem.nfeDQ = 0;
+  lmem.nstlj = 0;
+  lmem.tnlj = 0;
+  lmem.msbj = CVLS_MSBJ;
+  lmem.dgmax_jbad = CVLS_DGMAX;
+
+  // Attach to CvodeMem
+  mem.cv_lmem = lmem;
+  mem.cv_linit = cvLsInitialize;
+  mem.cv_lsetup = cvLsSetup;
+  mem.cv_lsolve = cvLsSolve;
+  mem.cv_lfree = cvLsFree;
+
+  return CV_SUCCESS;
+}
+
+/**
+ * cvodeSetJacFn - Set a user-supplied Jacobian function.
+ */
+export function cvodeSetJacFn(mem: CvodeMem, jac: CvodeJacFn | null): number {
+  const lmem = mem.cv_lmem;
+  if (!lmem) return -1;
+
+  if (jac) {
+    lmem.jacDQ = false;
+    lmem.jacFn = jac;
+  } else {
+    lmem.jacDQ = true;
+    lmem.jacFn = null;
+  }
+  return CV_SUCCESS;
+}
+
+/**
+ * cvLsInitialize - Initialize linear solver counters.
+ */
+function cvLsInitialize(mem: CvodeMem): number {
+  const lmem = mem.cv_lmem!;
+  lmem.nje = 0;
+  lmem.nfeDQ = 0;
+  lmem.nstlj = 0;
+  lmem.jbad = true;
+  return CV_SUCCESS;
+}
+
+/**
+ * cvLsSetup - Compute Jacobian and form/factor the linear system matrix A = I - gamma*J.
+ *
+ * Heuristic for when to recompute Jacobian:
+ * - On first call (nstlj == 0)
+ * - If convfail is CV_FAIL_BAD_J (NLS flagged Jacobian as bad)
+ * - If enough steps since last eval (nst >= nstlj + msbj)
+ * - If gamma changed significantly (|gamrat - 1| > dgmax_jbad)
+ */
+function cvLsSetup(mem: CvodeMem, convfail: number, ypred: Float64Array,
+  fpred: Float64Array, jcurPtr: { value: boolean },
+  tmp1: Float64Array, tmp2: Float64Array,
+  tmp3: Float64Array): number {
+  const lmem = mem.cv_lmem!;
+  const N = mem.cv_N;
+  let retval: number;
+
+  // Determine if Jacobian needs updating
+  const jbad = lmem.jbad;
+  let jok = !jbad;
+
+  if (!jbad) {
+    // Check gamma ratio
+    if (Math.abs(mem.cv_gamrat - 1.0) > lmem.dgmax_jbad)
+      jok = false;
+
+    // Check steps since last Jacobian
+    if (mem.cv_nst >= lmem.nstlj + lmem.msbj)
+      jok = false;
+
+    // Check convfail
+    if (convfail === CV_FAIL_BAD_J)
+      jok = false;
+  }
+
+  if (jok) {
+    // Reuse saved Jacobian, just form A = I - gamma*J
+    jcurPtr.value = false;
+
+    // Copy savedJ to A and form I - gamma*J
+    for (let i = 0; i < N; i++) {
+      for (let j = 0; j < N; j++)
+        lmem.A[i][j] = -mem.cv_gamma * lmem.savedJ[i][j];
+
+      lmem.A[i][i] += 1.0;
+    }
+  } else {
+    // Recompute Jacobian
+    lmem.nje++;
+    lmem.nstlj = mem.cv_nst;
+    lmem.jbad = false;
+    jcurPtr.value = true;
+
+    // Evaluate Jacobian
+    if (lmem.jacDQ)
+      retval = cvLsDQJac(mem, mem.cv_tn, ypred, fpred, lmem.savedJ, tmp1, tmp2);
+    else
+      retval = lmem.jacFn!(mem.cv_tn, ypred, fpred, lmem.savedJ, mem.cv_user_data);
+
+
+    if (retval < 0) {
+      lmem.jbad = true;
+      return -1;
+    }
+    if (retval > 0) {
+      lmem.jbad = true;
+      return 1;
+    }
+
+    // Form A = I - gamma*J
+    for (let i = 0; i < N; i++) {
+      for (let j = 0; j < N; j++)
+        lmem.A[i][j] = -mem.cv_gamma * lmem.savedJ[i][j];
+
+      lmem.A[i][i] += 1.0;
+    }
+  }
+
+  // Factor A using LU decomposition
+  const info = dgefa(lmem.A, N, lmem.pivots);
+  if (info !== 0) {
+    lmem.jbad = true;
+    return 1; // recoverable
+  }
+
+  return CV_SUCCESS;
+}
+
+/**
+ * cvLsSolve - Solve the linear system A*x = b using LU factors.
+ */
+function cvLsSolve(mem: CvodeMem, b: Float64Array, weight: Float64Array,
+  ycur: Float64Array, fcur: Float64Array): number {
+  const lmem = mem.cv_lmem!;
+  const N = mem.cv_N;
+
+  dgesl(lmem.A, N, lmem.pivots, b);
+
+  // Apply gamma/gammap correction if gamma has changed since last setup
+  if (mem.cv_gamrat !== 1.0) {
+    const factor = 2.0 / (1.0 + mem.cv_gamrat);
+    for (let i = 0; i < N; i++)
+      b[i] *= factor;
+  }
+
+  return CV_SUCCESS;
+}
+
+/**
+ * cvLsDQJac - Compute difference-quotient Jacobian approximation.
+ *
+ * For each column j:
+ *   sigma_j = max(|y_j|, 1/ewt_j) * sqrt(uround)
+ *   J[:,j] = (f(t, y + sigma_j*e_j) - f(t, y)) / sigma_j
+ */
+function cvLsDQJac(mem: CvodeMem, t: number, y: Float64Array, fy: Float64Array,
+  J: Float64Array[], tmp1: Float64Array, tmp2: Float64Array): number {
+  const N = mem.cv_N;
+  const lmem = mem.cv_lmem!;
+  const uround = 2.2204460492503131e-16;
+  const srur = Math.sqrt(uround);
+  const fnorm_val = wrmsNorm(N, fy, mem.cv_ewt);
+  const minInc = (fnorm_val !== 0.0) ? (1000.0 * Math.abs(mem.cv_h) * uround * N * fnorm_val) : 1.0;
+
+  // Use tmp1 as perturbed y, tmp2 as perturbed f
+  for (let j = 0; j < N; j++) {
+    const yjsaved = y[j];
+    let inc = Math.max(srur * Math.abs(yjsaved), minInc / mem.cv_ewt[j]);
+    // Ensure inc has same sign (positive since we want to increase)
+
+    // Perturb y[j]
+    tmp1.set(y);
+    tmp1[j] = yjsaved + inc;
+    inc = tmp1[j] - yjsaved; // exact increment after rounding
+
+    // Evaluate f(t, y + inc*e_j)
+    const retval = mem.cv_f!(t, tmp1, tmp2, mem.cv_user_data);
+    lmem.nfeDQ++;
+    mem.cv_nfe++;
+    if (retval !== 0) return retval;
+
+    // Compute column j of Jacobian: (f_perturbed - f) / inc
+    const inc_inv = 1.0 / inc;
+    for (let i = 0; i < N; i++)
+      J[i][j] = (tmp2[i] - fy[i]) * inc_inv;
+  }
+
+  return CV_SUCCESS;
+}
+
+/**
+ * cvLsFree - Free linear solver memory (no-op in TS, GC handles it).
+ */
+function cvLsFree(mem: CvodeMem): void {
+  mem.cv_lmem = null;
+}

package/src/solver-tools/cvode/cvode_nls.js

@@ -0,0 +1,220 @@
+/**
+ * TypeScript port of SUNDIALS CVODE v7.5.0 (https://github.com/LLNL/sundials)
+ *
+ * Copyright (c) 2025, Lawrence Livermore National Security, University of
+ *   Maryland Baltimore County, and the SUNDIALS contributors.
+ * Copyright (c) 2013-2025, Lawrence Livermore National Security and
+ *   Southern Methodist University.
+ * Copyright (c) 2002-2013, Lawrence Livermore National Security.
+ * Copyright (c) 2026 Datagrok.
+ *
+ * Licensed under the BSD-3-Clause License. See THIRD_PARTY_LICENSES
+ * for the full license text and provenance chain of the original code.
+ */
+import { wrmsNorm, vLinearSum, vScale, vConst, CV_SUCCESS, CV_BDF, CV_RHSFUNC_FAIL, CV_LSETUP_FAIL, CV_LSOLVE_FAIL, RHSFUNC_RECVR, SUN_NLS_CONV_RECVR, SUN_NLS_CONTINUE, CV_NO_FAILURES, CV_FAIL_OTHER, FIRST_CALL, PREV_CONV_FAIL, PREV_ERR_FAIL, NLS_MAXCOR, CRDOWN, RDIV } from './common';
+/**
+ * cvNls - Solve the nonlinear system for one step.
+ *
+ * For BDF: Newton iteration solving G(ycor) = 0 where
+ *   G(ycor) = rl1*zn[1] + ycor - gamma*f(tn, zn[0]+ycor)
+ * The Newton update is: (I - gamma*J) * delta = -G(ycor)
+ *
+ * For Adams: Fixed-point iteration
+ *   ycor_new = h * rl1 * f(tn, zn[0]+ycor) - rl1*zn[1]
+ */
+export function cvNls(mem, nflag) {
+    const N = mem.cv_N;
+    let callSetup;
+    // Decide whether to call linear solver setup
+    if (mem.cv_lsetup) {
+        mem.convfail = (nflag === FIRST_CALL || nflag === PREV_ERR_FAIL) ?
+            CV_NO_FAILURES :
+            CV_FAIL_OTHER;
+        callSetup = (nflag === PREV_CONV_FAIL) || (nflag === PREV_ERR_FAIL) ||
+            (mem.cv_nst === 0) || (mem.first_step_after_resize) ||
+            (mem.cv_nst >= mem.cv_nstlp + mem.cv_msbp) ||
+            (Math.abs(mem.cv_gamrat - 1.0) > mem.cv_dgmax_lsetup);
+    }
+    else {
+        mem.cv_crate = 1.0;
+        callSetup = false;
+    }
+    // Initial guess for correction: acor = 0
+    vConst(0.0, mem.cv_acor, N);
+    // Set acnrmcur to false
+    mem.cv_acnrmcur = false;
+    // Dispatch to Newton or fixed-point
+    let flag;
+    if (mem.cv_lmm === CV_BDF)
+        flag = cvNewtonIteration(mem, callSetup);
+    else
+        flag = cvFixedPointIteration(mem);
+    if (flag !== CV_SUCCESS)
+        return flag;
+    // Solve successful - update y = zn[0] + acor
+    vLinearSum(1.0, mem.cv_zn[0], 1.0, mem.cv_acor, mem.cv_y, N);
+    // Compute acnrm if not already done
+    if (!mem.cv_acnrmcur)
+        mem.cv_acnrm = wrmsNorm(N, mem.cv_acor, mem.cv_ewt);
+    // Update Jacobian status
+    mem.cv_jcur = false;
+    return CV_SUCCESS;
+}
+/**
+ * Newton iteration for BDF method.
+ * Solves: (I - gamma*J) * delta = -G(ycor)
+ * where G(ycor) = rl1*zn[1] + ycor - gamma*f(tn, zn[0]+ycor)
+ */
+function cvNewtonIteration(mem, callSetup) {
+    const N = mem.cv_N;
+    let retval;
+    // Call linear solver setup if needed
+    if (callSetup && mem.cv_lsetup) {
+        // y = zn[0] + acor (current approximation)
+        vLinearSum(1.0, mem.cv_zn[0], 1.0, mem.cv_acor, mem.cv_y, N);
+        // Evaluate f at current approximation
+        retval = mem.cv_f(mem.cv_tn, mem.cv_y, mem.cv_ftemp, mem.cv_user_data);
+        mem.cv_nfe++;
+        if (retval < 0)
+            return CV_RHSFUNC_FAIL;
+        if (retval > 0)
+            return RHSFUNC_RECVR;
+        // Call lsetup
+        const jcurPtr = { value: false };
+        retval = mem.cv_lsetup(mem, mem.convfail, mem.cv_y, mem.cv_ftemp, jcurPtr, mem.cv_vtemp1, mem.cv_vtemp2, mem.cv_vtemp3);
+        mem.cv_nsetups++;
+        mem.cv_jcur = jcurPtr.value;
+        mem.cv_gamrat = 1.0;
+        mem.cv_gammap = mem.cv_gamma;
+        mem.cv_crate = 1.0;
+        mem.cv_nstlp = mem.cv_nst;
+        if (retval < 0)
+            return CV_LSETUP_FAIL;
+        if (retval > 0)
+            return SUN_NLS_CONV_RECVR;
+    }
+    // Newton iteration loop
+    for (let m = 0; m < NLS_MAXCOR; m++) {
+        mem.cv_nni++;
+        // y = zn[0] + acor
+        vLinearSum(1.0, mem.cv_zn[0], 1.0, mem.cv_acor, mem.cv_y, N);
+        // Evaluate f(tn, y)
+        retval = mem.cv_f(mem.cv_tn, mem.cv_y, mem.cv_ftemp, mem.cv_user_data);
+        mem.cv_nfe++;
+        if (retval < 0)
+            return CV_RHSFUNC_FAIL;
+        if (retval > 0)
+            return RHSFUNC_RECVR;
+        // Compute residual: b = rl1*zn[1] + acor - gamma*ftemp
+        // Store in tempv as the RHS for the linear solve
+        const b = mem.cv_tempv;
+        for (let i = 0; i < N; i++)
+            b[i] = mem.cv_rl1 * mem.cv_zn[1][i] + mem.cv_acor[i] - mem.cv_gamma * mem.cv_ftemp[i];
+        // Solve: (I - gamma*J) * delta = -b, so pass b (which is G, so we negate)
+        // Actually the convention is lsolve solves (I-gamma*J)*x = b
+        // and b here is -G so we negate
+        for (let i = 0; i < N; i++)
+            b[i] = -b[i];
+        retval = mem.cv_lsolve(mem, b, mem.cv_ewt, mem.cv_y, mem.cv_ftemp);
+        if (retval < 0)
+            return CV_LSOLVE_FAIL;
+        if (retval > 0)
+            return SUN_NLS_CONV_RECVR;
+        // Update acor += delta (delta is in b after solve)
+        for (let i = 0; i < N; i++)
+            mem.cv_acor[i] += b[i];
+        // Convergence test
+        const del = wrmsNorm(N, b, mem.cv_ewt);
+        const convTestResult = cvNlsConvTest(mem, del, m, mem.cv_tq[4]);
+        if (convTestResult === CV_SUCCESS)
+            return CV_SUCCESS;
+        if (convTestResult === SUN_NLS_CONV_RECVR) {
+            mem.cv_nnf++;
+            return SUN_NLS_CONV_RECVR;
+        }
+        // SUN_NLS_CONTINUE: continue iterating
+    }
+    // Max iterations reached without convergence
+    mem.cv_nnf++;
+    return SUN_NLS_CONV_RECVR;
+}
+/**
+ * Fixed-point iteration for Adams method.
+ * ycor = rl1 * (h * f(tn, zn[0]+ycor) - zn[1])
+ */
+function cvFixedPointIteration(mem) {
+    const N = mem.cv_N;
+    let retval;
+    for (let m = 0; m < NLS_MAXCOR; m++) {
+        mem.cv_nni++;
+        // y = zn[0] + acor
+        vLinearSum(1.0, mem.cv_zn[0], 1.0, mem.cv_acor, mem.cv_y, N);
+        // Evaluate f(tn, y) -> store in tempv
+        retval = mem.cv_f(mem.cv_tn, mem.cv_y, mem.cv_tempv, mem.cv_user_data);
+        mem.cv_nfe++;
+        if (retval < 0)
+            return CV_RHSFUNC_FAIL;
+        if (retval > 0)
+            return RHSFUNC_RECVR;
+        // Compute new ycor: rl1 * (h * f - zn[1])
+        // First: tempv = h * tempv - zn[1]
+        for (let i = 0; i < N; i++)
+            mem.cv_tempv[i] = mem.cv_h * mem.cv_tempv[i] - mem.cv_zn[1][i];
+        // Then scale by rl1
+        const newAcor = mem.cv_vtemp1;
+        vScale(mem.cv_rl1, mem.cv_tempv, newAcor, N);
+        // Compute delta = newAcor - acor
+        const delta = mem.cv_tempv;
+        for (let i = 0; i < N; i++)
+            delta[i] = newAcor[i] - mem.cv_acor[i];
+        // Update acor
+        for (let i = 0; i < N; i++)
+            mem.cv_acor[i] = newAcor[i];
+        // Convergence test
+        const del = wrmsNorm(N, delta, mem.cv_ewt);
+        const convTestResult = cvNlsConvTest(mem, del, m, mem.cv_tq[4]);
+        if (convTestResult === CV_SUCCESS)
+            return CV_SUCCESS;
+        if (convTestResult === SUN_NLS_CONV_RECVR) {
+            mem.cv_nnf++;
+            return SUN_NLS_CONV_RECVR;
+        }
+        // SUN_NLS_CONTINUE: continue iterating
+    }
+    // Max iterations reached
+    mem.cv_nnf++;
+    return SUN_NLS_CONV_RECVR;
+}
+/**
+ * cvNlsConvTest - Test for convergence of the nonlinear iteration.
+ *
+ * del: WRMS norm of the current update
+ * m: iteration count (0-based)
+ * tol: tolerance (tq[4])
+ *
+ * Returns: CV_SUCCESS if converged, SUN_NLS_CONV_RECVR if diverging,
+ *          SUN_NLS_CONTINUE if not yet converged
+ */
+function cvNlsConvTest(mem, del, m, tol) {
+    // Update convergence rate estimate
+    if (m > 0)
+        mem.cv_crate = Math.max(CRDOWN * mem.cv_crate, del / mem.cv_delp);
+    // Test for convergence
+    const dcon = del * Math.min(1.0, mem.cv_crate) / tol;
+    if (dcon <= 1.0) {
+        // Converged
+        if (m === 0)
+            mem.cv_acnrm = del;
+        else
+            mem.cv_acnrm = wrmsNorm(mem.cv_N, mem.cv_acor, mem.cv_ewt);
+        mem.cv_acnrmcur = true;
+        return CV_SUCCESS;
+    }
+    // Check for divergence
+    if (m >= 1 && del > RDIV * mem.cv_delp)
+        return SUN_NLS_CONV_RECVR;
+    // Save del and continue
+    mem.cv_delp = del;
+    return SUN_NLS_CONTINUE;
+}
+//# sourceMappingURL=cvode_nls.js.map