diff-grok 1.1.0 → 1.2.0

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

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

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

@@ -0,0 +1,259 @@
+/**
+ * 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 {CvodeMem, wrmsNorm, vLinearSum, vScale, vConst,
+  CV_SUCCESS, CV_BDF, CV_ADAMS, CV_RHSFUNC_FAIL, CV_LSETUP_FAIL, CV_LSOLVE_FAIL,
+  RHSFUNC_RECVR, SUN_NLS_CONV_RECVR, SUN_NLS_CONTINUE,
+  CV_NO_FAILURES, CV_FAIL_BAD_J, CV_FAIL_OTHER,
+  FIRST_CALL, PREV_CONV_FAIL, PREV_ERR_FAIL, DO_ERROR_TEST,
+  NLS_MAXCOR, CRDOWN, RDIV, ONEPSM} 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: CvodeMem, nflag: number): number {
+  const N = mem.cv_N;
+  let callSetup: boolean;
+
+  // 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: number;
+  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: CvodeMem, callSetup: boolean): number {
+  const N = mem.cv_N;
+  let retval: number;
+
+  // 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: CvodeMem): number {
+  const N = mem.cv_N;
+  let retval: number;
+
+  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: CvodeMem, del: number, m: number, tol: number): number {
+  // 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;
+}

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

@@ -0,0 +1,415 @@
+/**
+ * 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 rootfinding routines
+// Ported from SUNDIALS cvode.c v7.5.0 (rootfinding section, lines ~821-4737)
+import { cvodeGetDky, vLinearSum, vScale, CV_SUCCESS, CV_RTFUNC_FAIL, RTFOUND, CLOSERT, UROUND, CV_NORMAL, CV_ONE_STEP, } from './common';
+// ============================================================================
+// Local constants (matching SUNDIALS cvode.c)
+// ============================================================================
+const ZERO = 0.0;
+const HALF = 0.5;
+const ONE = 1.0;
+const TWO = 2.0;
+const FIVE = 5.0;
+const HUNDRED = 100.0;
+const PT1 = 0.1;
+// ============================================================================
+// Exported functions
+// ============================================================================
+/**
+ * CVodeRootInit - Initialize rootfinding for CVODE.
+ *
+ * C reference: CVodeRootInit (cvode.c, lines ~821-1012)
+ *
+ * If nrtfn <= 0, disables rootfinding and returns CV_SUCCESS.
+ * Otherwise, allocates arrays for root functions and sets defaults.
+ *
+ * @param mem   - CVODE memory block
+ * @param nrtfn - number of root functions
+ * @param g     - root function callback
+ * @returns CV_SUCCESS on success
+ */
+export function cvodeRootInit(mem, nrtfn, g) {
+    // If nrtfn <= 0, disable rootfinding
+    if (nrtfn <= 0) {
+        mem.cv_nrtfn = 0;
+        mem.cv_gfun = null;
+        return CV_SUCCESS;
+    }
+    mem.cv_nrtfn = nrtfn;
+    mem.cv_gfun = g;
+    // Allocate Float64Arrays for g values
+    mem.cv_glo = new Float64Array(nrtfn);
+    mem.cv_ghi = new Float64Array(nrtfn);
+    mem.cv_grout = new Float64Array(nrtfn);
+    // Allocate Int32Arrays for root info and direction
+    mem.cv_iroots = new Int32Array(nrtfn);
+    mem.cv_rootdir = new Int32Array(nrtfn);
+    // Allocate Uint8Array for active flags
+    mem.cv_gactive = new Uint8Array(nrtfn);
+    // Set default values: rootdir = 0 (both directions), gactive = 1 (all active)
+    mem.cv_rootdir.fill(0);
+    mem.cv_gactive.fill(1);
+    return CV_SUCCESS;
+}
+/**
+ * cvRcheck1 - First-step root check.
+ *
+ * C reference: cvRcheck1 (cvode.c, lines ~4251-4300)
+ *
+ * Completes initialization of rootfinding memory and checks whether g
+ * has a zero both at and very near the initial point of the IVP.
+ *
+ * @param mem - CVODE memory block
+ * @returns CV_SUCCESS or CV_RTFUNC_FAIL
+ */
+export function cvRcheck1(mem) {
+    const nrtfn = mem.cv_nrtfn;
+    const N = mem.cv_N;
+    for (let i = 0; i < nrtfn; i++)
+        mem.cv_iroots[i] = 0;
+    mem.cv_tlo = mem.cv_tn;
+    mem.cv_ttol = (Math.abs(mem.cv_tn) + Math.abs(mem.cv_h)) * UROUND * HUNDRED;
+    // Evaluate g at initial t and check for zero values
+    const retval = mem.cv_gfun(mem.cv_tlo, mem.cv_zn[0], mem.cv_glo, mem.cv_user_data);
+    mem.cv_nge = 1;
+    if (retval !== 0)
+        return CV_RTFUNC_FAIL;
+    let zroot = false;
+    for (let i = 0; i < nrtfn; i++) {
+        if (Math.abs(mem.cv_glo[i]) === ZERO) {
+            zroot = true;
+            mem.cv_gactive[i] = 0; // SUNFALSE
+        }
+    }
+    if (!zroot)
+        return CV_SUCCESS;
+    // Some g_i is zero at t0; look at g at t0+(small increment)
+    const hratio = Math.max(mem.cv_ttol / Math.abs(mem.cv_h), PT1);
+    const smallh = hratio * mem.cv_h;
+    const tplus = mem.cv_tlo + smallh;
+    // y = zn[0] + hratio * zn[1]
+    vLinearSum(ONE, mem.cv_zn[0], hratio, mem.cv_zn[1], mem.cv_y, N);
+    const retval2 = mem.cv_gfun(tplus, mem.cv_y, mem.cv_ghi, mem.cv_user_data);
+    mem.cv_nge++;
+    if (retval2 !== 0)
+        return CV_RTFUNC_FAIL;
+    // Re-activate components where g moved away from zero
+    for (let i = 0; i < nrtfn; i++) {
+        if (mem.cv_gactive[i] === 0 && Math.abs(mem.cv_ghi[i]) !== ZERO) {
+            mem.cv_gactive[i] = 1; // SUNTRUE
+            mem.cv_glo[i] = mem.cv_ghi[i];
+        }
+    }
+    return CV_SUCCESS;
+}
+/**
+ * cvRcheck2 - Subsequent-step root check for exact zeros at last root.
+ *
+ * C reference: cvRcheck2 (cvode.c, lines ~4323-4385)
+ *
+ * Checks for exact zeros of g at the last root found, for close pairs
+ * of zeros (error condition), and for a new root at a nearby point.
+ *
+ * @param mem - CVODE memory block
+ * @returns CV_SUCCESS, CLOSERT, RTFOUND, or CV_RTFUNC_FAIL
+ */
+export function cvRcheck2(mem) {
+    const nrtfn = mem.cv_nrtfn;
+    const N = mem.cv_N;
+    if (mem.cv_irfnd === 0)
+        return CV_SUCCESS;
+    // Get y at tlo via interpolation
+    cvodeGetDky(mem, mem.cv_tlo, 0, mem.cv_y);
+    // Evaluate g(tlo, y)
+    let retval = mem.cv_gfun(mem.cv_tlo, mem.cv_y, mem.cv_glo, mem.cv_user_data);
+    mem.cv_nge++;
+    if (retval !== 0)
+        return CV_RTFUNC_FAIL;
+    let zroot = false;
+    for (let i = 0; i < nrtfn; i++)
+        mem.cv_iroots[i] = 0;
+    for (let i = 0; i < nrtfn; i++) {
+        if (mem.cv_gactive[i] === 0)
+            continue;
+        if (Math.abs(mem.cv_glo[i]) === ZERO) {
+            zroot = true;
+            mem.cv_iroots[i] = 1;
+        }
+    }
+    if (!zroot)
+        return CV_SUCCESS;
+    // One or more g_i has a zero at tlo. Check g at tlo+smallh.
+    mem.cv_ttol = (Math.abs(mem.cv_tn) + Math.abs(mem.cv_h)) * UROUND * HUNDRED;
+    const smallh = (mem.cv_h > ZERO) ? mem.cv_ttol : -mem.cv_ttol;
+    const tplus = mem.cv_tlo + smallh;
+    if ((tplus - mem.cv_tn) * mem.cv_h >= ZERO) {
+        const hratio = smallh / mem.cv_h;
+        // y = y + hratio * zn[1]
+        vLinearSum(ONE, mem.cv_y, hratio, mem.cv_zn[1], mem.cv_y, N);
+    }
+    else
+        cvodeGetDky(mem, tplus, 0, mem.cv_y);
+    retval = mem.cv_gfun(tplus, mem.cv_y, mem.cv_ghi, mem.cv_user_data);
+    mem.cv_nge++;
+    if (retval !== 0)
+        return CV_RTFUNC_FAIL;
+    // Check for close roots (error return), new zero at tlo+smallh,
+    // and g_i that changed from zero to nonzero.
+    zroot = false;
+    for (let i = 0; i < nrtfn; i++) {
+        if (mem.cv_gactive[i] === 0)
+            continue;
+        if (Math.abs(mem.cv_ghi[i]) === ZERO) {
+            if (mem.cv_iroots[i] === 1)
+                return CLOSERT;
+            zroot = true;
+            mem.cv_iroots[i] = 1;
+        }
+        else {
+            if (mem.cv_iroots[i] === 1)
+                mem.cv_glo[i] = mem.cv_ghi[i];
+        }
+    }
+    if (zroot)
+        return RTFOUND;
+    return CV_SUCCESS;
+}
+/**
+ * cvRcheck3 - Root search between tlo and tn (or tout).
+ *
+ * C reference: cvRcheck3 (cvode.c, lines ~4400-4453)
+ *
+ * Interfaces to cvRootfind to look for a root of g between tlo and
+ * either tn or tout, whichever comes first.
+ *
+ * @param mem - CVODE memory block
+ * @returns CV_SUCCESS, RTFOUND, or CV_RTFUNC_FAIL
+ */
+export function cvRcheck3(mem) {
+    const nrtfn = mem.cv_nrtfn;
+    const N = mem.cv_N;
+    // Set thi = tn or tout, whichever comes first; set y = y(thi)
+    if (mem.cv_taskc === CV_ONE_STEP) {
+        mem.cv_thi = mem.cv_tn;
+        vScale(ONE, mem.cv_zn[0], mem.cv_y, N);
+    }
+    if (mem.cv_taskc === CV_NORMAL) {
+        if ((mem.cv_toutc - mem.cv_tn) * mem.cv_h >= ZERO) {
+            mem.cv_thi = mem.cv_tn;
+            vScale(ONE, mem.cv_zn[0], mem.cv_y, N);
+        }
+        else {
+            mem.cv_thi = mem.cv_toutc;
+            cvodeGetDky(mem, mem.cv_thi, 0, mem.cv_y);
+        }
+    }
+    // Evaluate g(thi, y) and call cvRootfind
+    const retval = mem.cv_gfun(mem.cv_thi, mem.cv_y, mem.cv_ghi, mem.cv_user_data);
+    mem.cv_nge++;
+    if (retval !== 0)
+        return CV_RTFUNC_FAIL;
+    mem.cv_ttol = (Math.abs(mem.cv_tn) + Math.abs(mem.cv_h)) * UROUND * HUNDRED;
+    const ier = cvRootfind(mem);
+    if (ier === CV_RTFUNC_FAIL)
+        return CV_RTFUNC_FAIL;
+    // Re-activate g components that moved away from zero
+    for (let i = 0; i < nrtfn; i++) {
+        if (mem.cv_gactive[i] === 0 && mem.cv_grout[i] !== ZERO)
+            mem.cv_gactive[i] = 1; // SUNTRUE
+    }
+    mem.cv_tlo = mem.cv_trout;
+    for (let i = 0; i < nrtfn; i++)
+        mem.cv_glo[i] = mem.cv_grout[i];
+    // If no root found, return CV_SUCCESS
+    if (ier === CV_SUCCESS)
+        return CV_SUCCESS;
+    // If a root was found, interpolate to get y(trout) and return
+    cvodeGetDky(mem, mem.cv_trout, 0, mem.cv_y);
+    return RTFOUND;
+}
+// ============================================================================
+// Internal (non-exported) functions
+// ============================================================================
+/**
+ * cvRootfind - Illinois algorithm for root finding.
+ *
+ * C reference: cvRootfind (cvode.c, lines ~4532-4737)
+ *
+ * Solves for a root of g(t) between tlo and thi using a modified secant
+ * method (Illinois algorithm). Only roots of odd multiplicity (sign changes)
+ * or exact zeros are found. When multiple roots exist, the one closest to
+ * tlo is returned.
+ *
+ * @param mem - CVODE memory block
+ * @returns CV_SUCCESS, RTFOUND, or CV_RTFUNC_FAIL
+ */
+function cvRootfind(mem) {
+    const nrtfn = mem.cv_nrtfn;
+    let imax = 0;
+    let alph;
+    let tmid;
+    let gfrac;
+    let maxfrac;
+    let fracint;
+    let fracsub;
+    // First check for change in sign in ghi or for a zero in ghi.
+    maxfrac = ZERO;
+    let zroot = false;
+    let sgnchg = false;
+    for (let i = 0; i < nrtfn; i++) {
+        if (mem.cv_gactive[i] === 0)
+            continue;
+        if (Math.abs(mem.cv_ghi[i]) === ZERO) {
+            if (mem.cv_rootdir[i] * mem.cv_glo[i] <= ZERO)
+                zroot = true;
+        }
+        else {
+            if ((mem.cv_glo[i] * mem.cv_ghi[i] < 0) &&
+                (mem.cv_rootdir[i] * mem.cv_glo[i] <= ZERO)) {
+                gfrac = Math.abs(mem.cv_ghi[i] / (mem.cv_ghi[i] - mem.cv_glo[i]));
+                if (gfrac > maxfrac) {
+                    sgnchg = true;
+                    maxfrac = gfrac;
+                    imax = i;
+                }
+            }
+        }
+    }
+    // If no sign change was found, reset trout and grout.
+    // Return CV_SUCCESS if no zero was found, or set iroots and return RTFOUND.
+    if (!sgnchg) {
+        mem.cv_trout = mem.cv_thi;
+        for (let i = 0; i < nrtfn; i++)
+            mem.cv_grout[i] = mem.cv_ghi[i];
+        if (!zroot)
+            return CV_SUCCESS;
+        for (let i = 0; i < nrtfn; i++) {
+            mem.cv_iroots[i] = 0;
+            if (mem.cv_gactive[i] === 0)
+                continue;
+            if ((Math.abs(mem.cv_ghi[i]) === ZERO) &&
+                (mem.cv_rootdir[i] * mem.cv_glo[i] <= ZERO))
+                mem.cv_iroots[i] = mem.cv_glo[i] > 0 ? -1 : 1;
+        }
+        return RTFOUND;
+    }
+    // Initialize alph
+    alph = ONE;
+    // A sign change was found. Loop to locate nearest root.
+    let side = 0;
+    let sideprev = -1;
+    for (;;) {
+        // If interval size is already less than tolerance ttol, break.
+        if (Math.abs(mem.cv_thi - mem.cv_tlo) <= mem.cv_ttol)
+            break;
+        // Set weight alph.
+        // On the first two passes, set alph = 1. Thereafter, reset alph
+        // according to the side of the subinterval where the sign change was found.
+        if (sideprev === side)
+            alph = (side === 2) ? alph * TWO : alph * HALF;
+        else
+            alph = ONE;
+        // Set next root approximation tmid and get g(tmid).
+        // If tmid is too close to tlo or thi, adjust it inward.
+        tmid = mem.cv_thi -
+            (mem.cv_thi - mem.cv_tlo) * mem.cv_ghi[imax] /
+                (mem.cv_ghi[imax] - alph * mem.cv_glo[imax]);
+        if (Math.abs(tmid - mem.cv_tlo) < HALF * mem.cv_ttol) {
+            fracint = Math.abs(mem.cv_thi - mem.cv_tlo) / mem.cv_ttol;
+            fracsub = (fracint > FIVE) ? PT1 : HALF / fracint;
+            tmid = mem.cv_tlo + fracsub * (mem.cv_thi - mem.cv_tlo);
+        }
+        if (Math.abs(mem.cv_thi - tmid) < HALF * mem.cv_ttol) {
+            fracint = Math.abs(mem.cv_thi - mem.cv_tlo) / mem.cv_ttol;
+            fracsub = (fracint > FIVE) ? PT1 : HALF / fracint;
+            tmid = mem.cv_thi - fracsub * (mem.cv_thi - mem.cv_tlo);
+        }
+        // Interpolate to get y(tmid) and evaluate g(tmid)
+        cvodeGetDky(mem, tmid, 0, mem.cv_y);
+        const retval = mem.cv_gfun(tmid, mem.cv_y, mem.cv_grout, mem.cv_user_data);
+        mem.cv_nge++;
+        if (retval !== 0)
+            return CV_RTFUNC_FAIL;
+        // Check in which subinterval g changes sign, and reset imax.
+        // Set side = 1 if sign change is on low side, or 2 if on high side.
+        maxfrac = ZERO;
+        zroot = false;
+        sgnchg = false;
+        sideprev = side;
+        for (let i = 0; i < nrtfn; i++) {
+            if (mem.cv_gactive[i] === 0)
+                continue;
+            if (Math.abs(mem.cv_grout[i]) === ZERO) {
+                if (mem.cv_rootdir[i] * mem.cv_glo[i] <= ZERO)
+                    zroot = true;
+            }
+            else {
+                if ((mem.cv_glo[i] * mem.cv_grout[i] < 0) &&
+                    (mem.cv_rootdir[i] * mem.cv_glo[i] <= ZERO)) {
+                    gfrac = Math.abs(mem.cv_grout[i] /
+                        (mem.cv_grout[i] - mem.cv_glo[i]));
+                    if (gfrac > maxfrac) {
+                        sgnchg = true;
+                        maxfrac = gfrac;
+                        imax = i;
+                    }
+                }
+            }
+        }
+        if (sgnchg) {
+            // Sign change found in (tlo, tmid); replace thi with tmid.
+            mem.cv_thi = tmid;
+            for (let i = 0; i < nrtfn; i++)
+                mem.cv_ghi[i] = mem.cv_grout[i];
+            side = 1;
+            // Stop at root thi if converged; otherwise loop.
+            if (Math.abs(mem.cv_thi - mem.cv_tlo) <= mem.cv_ttol)
+                break;
+            continue;
+        }
+        if (zroot) {
+            // No sign change in (tlo, tmid), but g = 0 at tmid; return root tmid.
+            mem.cv_thi = tmid;
+            for (let i = 0; i < nrtfn; i++)
+                mem.cv_ghi[i] = mem.cv_grout[i];
+            break;
+        }
+        // No sign change in (tlo, tmid), and no zero at tmid.
+        // Sign change must be in (tmid, thi). Replace tlo with tmid.
+        mem.cv_tlo = tmid;
+        for (let i = 0; i < nrtfn; i++)
+            mem.cv_glo[i] = mem.cv_grout[i];
+        side = 2;
+        // Stop at root thi if converged; otherwise loop back.
+        if (Math.abs(mem.cv_thi - mem.cv_tlo) <= mem.cv_ttol)
+            break;
+    } // End of root-search loop
+    // Reset trout and grout, set iroots, and return RTFOUND.
+    mem.cv_trout = mem.cv_thi;
+    for (let i = 0; i < nrtfn; i++) {
+        mem.cv_grout[i] = mem.cv_ghi[i];
+        mem.cv_iroots[i] = 0;
+        if (mem.cv_gactive[i] === 0)
+            continue;
+        if ((Math.abs(mem.cv_ghi[i]) === ZERO) &&
+            (mem.cv_rootdir[i] * mem.cv_glo[i] <= ZERO))
+            mem.cv_iroots[i] = mem.cv_glo[i] > 0 ? -1 : 1;
+        if ((mem.cv_glo[i] * mem.cv_ghi[i] < 0) &&
+            (mem.cv_rootdir[i] * mem.cv_glo[i] <= ZERO))
+            mem.cv_iroots[i] = mem.cv_glo[i] > 0 ? -1 : 1;
+    }
+    return RTFOUND;
+}
+//# sourceMappingURL=cvode_root.js.map