diff-grok 1.2.0 → 1.3.1

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

@@ -1,1226 +0,0 @@
-/**
- * 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 - Main integration loop
-// Ported from SUNDIALS CVODE v7.5.0 cvode.c
-
-import {
-  CvodeMem, CvodeRhsFn,
-  CV_ADAMS, CV_BDF,
-  CV_NORMAL, CV_ONE_STEP,
-  CV_SUCCESS, CV_TSTOP_RETURN, CV_ROOT_RETURN,
-  CV_TOO_MUCH_WORK, CV_TOO_MUCH_ACC, CV_ERR_FAILURE, CV_CONV_FAILURE,
-  CV_RHSFUNC_FAIL, CV_FIRST_RHSFUNC_ERR, CV_RTFUNC_FAIL, CV_TOO_CLOSE,
-  CV_LSETUP_FAIL, CV_LSOLVE_FAIL, CV_UNREC_RHSFUNC_ERR, CV_REPTD_RHSFUNC_ERR,
-  CV_LINIT_FAIL, CV_NLS_FAIL,
-  CV_NN, CV_SS, CV_SV,
-  ADAMS_Q_MAX, BDF_Q_MAX,
-  HMIN_DEFAULT, HMAX_INV_DEFAULT, MXSTEP_DEFAULT, MXHNIL_DEFAULT,
-  MSBP_DEFAULT, DGMAX_LSETUP_DEFAULT,
-  ETA_MIN_FX_DEFAULT, ETA_MAX_FX_DEFAULT, ETA_MAX_FS_DEFAULT,
-  ETA_MAX_ES_DEFAULT, ETA_MAX_GS_DEFAULT,
-  ETA_MIN_DEFAULT, ETA_MIN_EF_DEFAULT, ETA_MAX_EF_DEFAULT, ETA_CF_DEFAULT,
-  SMALL_NST_DEFAULT, SMALL_NEF_DEFAULT,
-  MXNEF, MXNCF, MXNEF1,
-  DO_ERROR_TEST, PREDICT_AGAIN, TRY_AGAIN, FIRST_CALL,
-  PREV_CONV_FAIL, PREV_ERR_FAIL,
-  RHSFUNC_RECVR, SUN_NLS_CONV_RECVR,
-  CV_NO_FAILURES,
-  FUZZ_FACTOR, UROUND, CORTES, ONEPSM, TINY,
-  ADDON, BIAS1, BIAS2, BIAS3, LONG_WAIT,
-  NUM_TESTS, L_MAX,
-  RTFOUND, CLOSERT,
-  wrmsNorm, vLinearSum, vScale, cvodeGetDky,
-} from './common';
-
-import {cvSetBDF, cvIncreaseBDF, cvDecreaseBDF} from './cvode_bdf';
-import {cvSetAdams, cvAdjustAdams} from './cvode_adams';
-import {cvHin} from './cvode_hin';
-import {cvNls} from './cvode_nls';
-import {cvRcheck1, cvRcheck2, cvRcheck3} from './cvode_root';
-
-// ============================================================================
-// PUBLIC EXPORTED FUNCTIONS
-// ============================================================================
-
-/** cvodeCreate - Create and initialize CvodeMem */
-export function cvodeCreate(lmm: number): CvodeMem {
-  if (lmm !== CV_ADAMS && lmm !== CV_BDF)
-    throw new Error('cvodeCreate: bad lmm, must be CV_ADAMS or CV_BDF');
-
-
-  const maxord = (lmm === CV_ADAMS) ? ADAMS_Q_MAX : BDF_Q_MAX;
-  const mem = new CvodeMem();
-
-  mem.cv_lmm = lmm;
-  mem.cv_qmax = maxord;
-  mem.cv_qmax_alloc = maxord;
-
-  // Initialize ssdat as 6x4 array of zeros (1-based indexing: i=1..5, k=1..3)
-  mem.cv_ssdat = [];
-  for (let i = 0; i < 6; i++)
-    mem.cv_ssdat[i] = [0, 0, 0, 0];
-
-
-  mem.cv_nlscoef = CORTES;
-
-  return mem;
-}
-
-/** cvodeInit - Initialize problem */
-export function cvodeInit(mem: CvodeMem, f: CvodeRhsFn, t0: number, y0: Float64Array): number {
-  mem.cv_f = f;
-  mem.cv_tn = t0;
-  mem.cv_N = y0.length;
-  const N = mem.cv_N;
-
-  // Allocate Nordsieck history array: zn[0..qmax_alloc+1]
-  const allocQ = mem.cv_qmax_alloc;
-  mem.cv_zn = [];
-  for (let i = 0; i <= allocQ + 1; i++)
-    mem.cv_zn[i] = new Float64Array(N);
-
-
-  // Allocate work vectors
-  mem.cv_ewt = new Float64Array(N);
-  mem.cv_acor = new Float64Array(N);
-  mem.cv_tempv = new Float64Array(N);
-  mem.cv_ftemp = new Float64Array(N);
-  mem.cv_vtemp1 = new Float64Array(N);
-  mem.cv_vtemp2 = new Float64Array(N);
-  mem.cv_vtemp3 = new Float64Array(N);
-  mem.cv_y = new Float64Array(N);
-
-  // Copy y0 into zn[0]
-  mem.cv_zn[0].set(y0);
-
-  // Set step parameters
-  mem.cv_q = 1;
-  mem.cv_L = 2;
-  mem.cv_qwait = mem.cv_L;
-  mem.cv_etamax = mem.cv_eta_max_fs;
-
-  mem.cv_qu = 0;
-  mem.cv_hu = 0.0;
-  mem.cv_tolsf = 1.0;
-
-  // Reset all counters
-  mem.cv_nst = 0;
-  mem.cv_nfe = 0;
-  mem.cv_ncfn = 0;
-  mem.cv_netf = 0;
-  mem.cv_nni = 0;
-  mem.cv_nnf = 0;
-  mem.cv_nsetups = 0;
-  mem.cv_nhnil = 0;
-  mem.cv_nstlp = 0;
-  mem.cv_nscon = 0;
-  mem.cv_nge = 0;
-  mem.cv_irfnd = 0;
-
-  mem.cv_h0u = 0.0;
-  mem.cv_next_h = 0.0;
-  mem.cv_next_q = 0;
-
-  // Initialize stability limit detection data
-  mem.cv_nor = 0;
-  mem.cv_ssdat = [];
-  for (let i = 0; i < 6; i++)
-    mem.cv_ssdat[i] = [0, 0, 0, 0];
-
-
-  // Set indx_acor to qmax_alloc (the zn slot used to save acor)
-  mem.cv_indx_acor = mem.cv_qmax_alloc;
-
-  mem.cv_MallocDone = true;
-
-  return CV_SUCCESS;
-}
-
-/** cvode - Main integration loop */
-export function cvode(
-  mem: CvodeMem, tout: number, yout: Float64Array, itask: number,
-): { flag: number; t: number } {
-  let istate: number;
-  let troundoff: number;
-  let retval: number;
-  let ier: number;
-  let tret = mem.cv_tn;
-
-  // Check itask
-  if (itask !== CV_NORMAL && itask !== CV_ONE_STEP)
-    return {flag: -99, t: mem.cv_tn};
-
-
-  if (itask === CV_NORMAL) mem.cv_toutc = tout;
-  mem.cv_taskc = itask;
-
-  // --- nst == 0: first step initialization ---
-  if (mem.cv_nst === 0) {
-    mem.cv_tretlast = tret = mem.cv_tn;
-
-    // Check inputs
-    ier = cvInitialSetup(mem);
-    if (ier !== CV_SUCCESS) return {flag: ier, t: tret};
-
-    // Call f at (t0, y0), set zn[1] = y'(t0)
-    retval = mem.cv_f!(mem.cv_tn, mem.cv_zn[0], mem.cv_zn[1], mem.cv_user_data);
-    mem.cv_nfe++;
-    if (retval < 0) return {flag: CV_RHSFUNC_FAIL, t: tret};
-    if (retval > 0) return {flag: CV_FIRST_RHSFUNC_ERR, t: tret};
-
-    // Test tstop legality
-    if (mem.cv_tstopset) {
-      if ((mem.cv_tstop - mem.cv_tn) * (tout - mem.cv_tn) <= 0.0)
-        return {flag: -99, t: tret}; // CV_ILL_INPUT
-    }
-
-    // Set initial h
-    mem.cv_h = mem.cv_hin;
-    if (mem.cv_h !== 0.0 && (tout - mem.cv_tn) * mem.cv_h < 0.0)
-      return {flag: -99, t: tret};
-
-    if (mem.cv_h === 0.0) {
-      let tout_hin = tout;
-      if (mem.cv_tstopset && (tout - mem.cv_tn) * (tout - mem.cv_tstop) > 0.0)
-        tout_hin = mem.cv_tstop;
-
-      const hflag = cvHin(mem, tout_hin);
-      if (hflag !== CV_SUCCESS) {
-        istate = cvHandleFailure(mem, hflag);
-        return {flag: istate, t: tret};
-      }
-    }
-
-    // Enforce hmax and hmin
-    const rh = Math.abs(mem.cv_h) * mem.cv_hmax_inv;
-    if (rh > 1.0) mem.cv_h /= rh;
-    if (Math.abs(mem.cv_h) < mem.cv_hmin)
-      mem.cv_h *= mem.cv_hmin / Math.abs(mem.cv_h);
-
-
-    // Check for approach to tstop
-    if (mem.cv_tstopset) {
-      if ((mem.cv_tn + mem.cv_h - mem.cv_tstop) * mem.cv_h > 0.0)
-        mem.cv_h = (mem.cv_tstop - mem.cv_tn) * (1.0 - 4.0 * UROUND);
-    }
-
-    // Scale zn[1] by h
-    mem.cv_hscale = mem.cv_h;
-    mem.cv_h0u = mem.cv_h;
-    mem.cv_hprime = mem.cv_h;
-    vScale(mem.cv_h, mem.cv_zn[1], mem.cv_zn[1], mem.cv_N);
-
-    // Check for roots at/near t0
-    if (mem.cv_nrtfn > 0) {
-      retval = cvRcheck1(mem);
-      if (retval === CV_RTFUNC_FAIL)
-        return {flag: CV_RTFUNC_FAIL, t: tret};
-    }
-  }
-
-  // --- nst > 0: stop tests ---
-  if (mem.cv_nst > 0) {
-    troundoff = FUZZ_FACTOR * UROUND *
-      (Math.abs(mem.cv_tn) + Math.abs(mem.cv_h));
-
-    // Root check from last step
-    if (mem.cv_nrtfn > 0) {
-      const irfndp = mem.cv_irfnd;
-
-      retval = cvRcheck2(mem);
-
-      if (retval === CLOSERT)
-        return {flag: -99, t: mem.cv_tlo};
-      else if (retval === CV_RTFUNC_FAIL)
-        return {flag: CV_RTFUNC_FAIL, t: mem.cv_tlo};
-      else if (retval === RTFOUND) {
-        mem.cv_tretlast = tret = mem.cv_tlo;
-        return {flag: CV_ROOT_RETURN, t: tret};
-      }
-
-      // If tn is distinct from tretlast, check remaining interval
-      if (Math.abs(mem.cv_tn - mem.cv_tretlast) > troundoff) {
-        retval = cvRcheck3(mem);
-
-        if (retval === CV_SUCCESS) {
-          mem.cv_irfnd = 0;
-          if (irfndp === 1 && itask === CV_ONE_STEP) {
-            mem.cv_tretlast = tret = mem.cv_tn;
-            yout.set(mem.cv_zn[0]);
-            return {flag: CV_SUCCESS, t: tret};
-          }
-        } else if (retval === RTFOUND) {
-          mem.cv_irfnd = 1;
-          mem.cv_tretlast = tret = mem.cv_tlo;
-          return {flag: CV_ROOT_RETURN, t: tret};
-        } else if (retval === CV_RTFUNC_FAIL)
-          return {flag: CV_RTFUNC_FAIL, t: mem.cv_tlo};
-      }
-    }
-
-    // Test for tn at tstop
-    if (mem.cv_tstopset) {
-      if (Math.abs(mem.cv_tn - mem.cv_tstop) <= troundoff) {
-        if ((tout - mem.cv_tstop) * mem.cv_h >= 0.0 ||
-            Math.abs(tout - mem.cv_tstop) <= troundoff) {
-          if (mem.cv_tstopinterp)
-            cvodeGetDky(mem, mem.cv_tstop, 0, yout);
-          else
-            yout.set(mem.cv_zn[0]);
-
-          mem.cv_tretlast = tret = mem.cv_tstop;
-          mem.cv_tstopset = false;
-          return {flag: CV_TSTOP_RETURN, t: tret};
-        }
-      } else if ((mem.cv_tn + mem.cv_hprime - mem.cv_tstop) * mem.cv_h > 0.0) {
-        mem.cv_hprime = (mem.cv_tstop - mem.cv_tn) * (1.0 - 4.0 * UROUND);
-        mem.cv_eta = mem.cv_hprime / mem.cv_h;
-      }
-    }
-
-    // In NORMAL mode, test if tout was reached
-    if (itask === CV_NORMAL && (mem.cv_tn - tout) * mem.cv_h >= 0.0) {
-      mem.cv_tretlast = tret = tout;
-      cvodeGetDky(mem, tout, 0, yout);
-      return {flag: CV_SUCCESS, t: tret};
-    }
-
-    // In ONE_STEP mode, test if tn was returned
-    if (itask === CV_ONE_STEP &&
-        Math.abs(mem.cv_tn - mem.cv_tretlast) > troundoff) {
-      mem.cv_tretlast = tret = mem.cv_tn;
-      yout.set(mem.cv_zn[0]);
-      return {flag: CV_SUCCESS, t: tret};
-    }
-  }
-
-  // --- Main integration loop ---
-  let nstloc = 0;
-  istate = CV_SUCCESS; // will be overwritten
-
-  for (;;) {
-    mem.cv_next_h = mem.cv_h;
-    mem.cv_next_q = mem.cv_q;
-
-    // Reset and check ewt
-    if (mem.cv_nst > 0) {
-      const ewtsetOK = cvEwtSet(mem);
-      if (ewtsetOK !== 0) {
-        istate = -99; // CV_ILL_INPUT
-        mem.cv_tretlast = tret = mem.cv_tn;
-        yout.set(mem.cv_zn[0]);
-        break;
-      }
-    }
-
-    // Check for too many steps
-    if (mem.cv_mxstep > 0 && nstloc >= mem.cv_mxstep) {
-      istate = CV_TOO_MUCH_WORK;
-      mem.cv_tretlast = tret = mem.cv_tn;
-      yout.set(mem.cv_zn[0]);
-      break;
-    }
-
-    // Check for too much accuracy requested
-    const nrm = wrmsNorm(mem.cv_N, mem.cv_zn[0], mem.cv_ewt);
-    mem.cv_tolsf = UROUND * nrm;
-    if (mem.cv_tolsf > 1.0) {
-      istate = CV_TOO_MUCH_ACC;
-      mem.cv_tretlast = tret = mem.cv_tn;
-      yout.set(mem.cv_zn[0]);
-      mem.cv_tolsf *= 2.0;
-      break;
-    } else
-      mem.cv_tolsf = 1.0;
-
-
-    // Check for h below roundoff
-    if (mem.cv_tn + mem.cv_h === mem.cv_tn)
-      mem.cv_nhnil++;
-
-
-    // Take a step
-    const kflag = cvStep(mem);
-
-    // Process failed step
-    if (kflag !== CV_SUCCESS) {
-      istate = cvHandleFailure(mem, kflag);
-      mem.cv_tretlast = tret = mem.cv_tn;
-      yout.set(mem.cv_zn[0]);
-      break;
-    }
-
-    nstloc++;
-
-    // If tstop was reached, reset tn
-    if (mem.cv_tstopset) {
-      troundoff = FUZZ_FACTOR * UROUND *
-        (Math.abs(mem.cv_tn) + Math.abs(mem.cv_h));
-      if (Math.abs(mem.cv_tn - mem.cv_tstop) <= troundoff)
-        mem.cv_tn = mem.cv_tstop;
-    }
-
-    // Check for root in last step
-    if (mem.cv_nrtfn > 0) {
-      retval = cvRcheck3(mem);
-
-      if (retval === RTFOUND) {
-        mem.cv_irfnd = 1;
-        istate = CV_ROOT_RETURN;
-        mem.cv_tretlast = tret = mem.cv_tlo;
-        break;
-      } else if (retval === CV_RTFUNC_FAIL) {
-        istate = CV_RTFUNC_FAIL;
-        break;
-      }
-    }
-
-    // Check tstop in loop
-    if (mem.cv_tstopset) {
-      troundoff = FUZZ_FACTOR * UROUND *
-        (Math.abs(mem.cv_tn) + Math.abs(mem.cv_h));
-
-      if (Math.abs(mem.cv_tn - mem.cv_tstop) <= troundoff) {
-        if ((tout - mem.cv_tstop) * mem.cv_h >= 0.0 ||
-            Math.abs(tout - mem.cv_tstop) <= troundoff) {
-          if (mem.cv_tstopinterp)
-            cvodeGetDky(mem, mem.cv_tstop, 0, yout);
-          else
-            yout.set(mem.cv_zn[0]);
-
-          mem.cv_tretlast = tret = mem.cv_tstop;
-          mem.cv_tstopset = false;
-          istate = CV_TSTOP_RETURN;
-          break;
-        }
-      } else if ((mem.cv_tn + mem.cv_hprime - mem.cv_tstop) * mem.cv_h > 0.0) {
-        mem.cv_hprime = (mem.cv_tstop - mem.cv_tn) * (1.0 - 4.0 * UROUND);
-        mem.cv_eta = mem.cv_hprime / mem.cv_h;
-      }
-    }
-
-    // In NORMAL mode, check if tout reached
-    if (itask === CV_NORMAL && (mem.cv_tn - tout) * mem.cv_h >= 0.0) {
-      istate = CV_SUCCESS;
-      mem.cv_tretlast = tret = tout;
-      cvodeGetDky(mem, tout, 0, yout);
-      mem.cv_next_q = mem.cv_qprime;
-      mem.cv_next_h = mem.cv_hprime;
-      break;
-    }
-
-    // In ONE_STEP mode, copy y and exit
-    if (itask === CV_ONE_STEP) {
-      istate = CV_SUCCESS;
-      mem.cv_tretlast = tret = mem.cv_tn;
-      yout.set(mem.cv_zn[0]);
-      mem.cv_next_q = mem.cv_qprime;
-      mem.cv_next_h = mem.cv_hprime;
-      break;
-    }
-  }
-
-  return {flag: istate, t: tret};
-}
-
-// ============================================================================
-// INTERNAL FUNCTIONS
-// ============================================================================
-
-/** cvInitialSetup - First-step checks */
-function cvInitialSetup(mem: CvodeMem): number {
-  // Did the user specify tolerances?
-  if (mem.cv_itol === CV_NN) {
-    mem.cv_error = 'cvInitialSetup: no tolerances set';
-    return -99; // CV_ILL_INPUT
-  }
-
-  // Load initial error weights
-  const ier = cvEwtSet(mem);
-  if (ier !== 0) {
-    mem.cv_error = 'cvInitialSetup: bad ewt';
-    return -99; // CV_ILL_INPUT
-  }
-
-  // Call linit function if it exists
-  if (mem.cv_linit !== null) {
-    const linit_ret = mem.cv_linit(mem);
-    if (linit_ret !== 0) {
-      mem.cv_error = 'cvInitialSetup: linear solver init failed';
-      return CV_LINIT_FAIL;
-    }
-  }
-
-  return CV_SUCCESS;
-}
-
-/** cvEwtSet - Set error weights based on tolerance type */
-function cvEwtSet(mem: CvodeMem): number {
-  switch (mem.cv_itol) {
-  case CV_SS: return cvEwtSetSS(mem);
-  case CV_SV: return cvEwtSetSV(mem);
-  default: return -1;
-  }
-}
-
-/** cvEwtSetSS - ewt[i] = 1/(reltol*|y[i]| + Sabstol) */
-function cvEwtSetSS(mem: CvodeMem): number {
-  const N = mem.cv_N;
-  const rtol = mem.cv_reltol;
-  const atol = mem.cv_Sabstol;
-  const y = mem.cv_zn[0];
-  const ewt = mem.cv_ewt;
-
-  for (let i = 0; i < N; i++) {
-    const tol = rtol * Math.abs(y[i]) + atol;
-    if (mem.cv_atolmin0 && tol <= 0.0) return -1;
-    ewt[i] = 1.0 / tol;
-  }
-  return 0;
-}
-
-/** cvEwtSetSV - ewt[i] = 1/(reltol*|y[i]| + Vabstol[i]) */
-function cvEwtSetSV(mem: CvodeMem): number {
-  const N = mem.cv_N;
-  const rtol = mem.cv_reltol;
-  const vatol = mem.cv_Vabstol;
-  const y = mem.cv_zn[0];
-  const ewt = mem.cv_ewt;
-
-  for (let i = 0; i < N; i++) {
-    const tol = rtol * Math.abs(y[i]) + vatol[i];
-    if (mem.cv_atolmin0 && tol <= 0.0) return -1;
-    ewt[i] = 1.0 / tol;
-  }
-  return 0;
-}
-
-/** cvStep - One internal step */
-function cvStep(mem: CvodeMem): number {
-  let dsm = 0.0;
-  let ncf = 0;
-  let nef = 0;
-  let nflag: number;
-  let kflag: number;
-  let eflag: number;
-
-  // If step size changed, update history array
-  if (mem.cv_nst > 0 && mem.cv_hprime !== mem.cv_h)
-    cvAdjustParams(mem);
-
-
-  const saved_t = mem.cv_tn;
-  nflag = FIRST_CALL;
-
-  // Looping point for step attempts
-  for (;;) {
-    cvPredict(mem);
-    cvSet(mem);
-
-    nflag = cvNls(mem, nflag);
-
-    const nflagRef = {value: nflag};
-    const ncfRef = {value: ncf};
-    kflag = cvHandleNFlag(mem, nflagRef, saved_t, ncfRef);
-    nflag = nflagRef.value;
-    ncf = ncfRef.value;
-
-    // Go back if we need to predict again
-    if (kflag === PREDICT_AGAIN) continue;
-
-    // Return if nonlinear solve failed and recovery is not possible
-    if (kflag !== DO_ERROR_TEST) return kflag;
-
-    // Perform error test
-    const nflagRef2 = {value: nflag};
-    const nefRef = {value: nef};
-    const dsmRef = {value: dsm};
-    eflag = cvDoErrorTest(mem, nflagRef2, saved_t, nefRef, dsmRef);
-    nflag = nflagRef2.value;
-    nef = nefRef.value;
-    dsm = dsmRef.value;
-
-    // Go back if we need to try again
-    if (eflag === TRY_AGAIN) continue;
-
-    // Return if error test failed and recovery is not possible
-    if (eflag !== CV_SUCCESS) return eflag;
-
-    // Error test passed, break from loop
-    break;
-  }
-
-  // Step successful: update data and consider order/step changes
-  cvCompleteStep(mem);
-  cvPrepareNextStep(mem, dsm);
-
-  // BDF stability limit detection
-  if (mem.cv_sldeton) cvBDFStab(mem);
-
-  mem.cv_etamax = (mem.cv_nst <= mem.cv_small_nst) ?
-    mem.cv_eta_max_es :
-    mem.cv_eta_max_gs;
-
-  // Rescale acor to be the estimated local error vector
-  vScale(mem.cv_tq[2], mem.cv_acor, mem.cv_acor, mem.cv_N);
-
-  return CV_SUCCESS;
-}
-
-/** cvAdjustParams - adjust order and rescale when step size changes */
-function cvAdjustParams(mem: CvodeMem): void {
-  if (mem.cv_qprime !== mem.cv_q) {
-    if (!mem.first_step_after_resize)
-      cvAdjustOrder(mem, mem.cv_qprime - mem.cv_q);
-
-    mem.cv_q = mem.cv_qprime;
-    mem.cv_L = mem.cv_q + 1;
-    mem.cv_qwait = mem.cv_L;
-  }
-  cvRescale(mem);
-}
-
-/** cvAdjustOrder - handle order change by deltaq */
-function cvAdjustOrder(mem: CvodeMem, deltaq: number): void {
-  if (mem.cv_q === 2 && deltaq !== 1) return;
-
-  if (mem.cv_lmm === CV_ADAMS)
-    cvAdjustAdams(mem, deltaq);
-  else if (mem.cv_lmm === CV_BDF) {
-    if (deltaq === 1) cvIncreaseBDF(mem);
-    else if (deltaq === -1) cvDecreaseBDF(mem);
-  }
-}
-
-/** cvRescale - multiply zn[j] by eta^j for j=1..q */
-function cvRescale(mem: CvodeMem): void {
-  const N = mem.cv_N;
-  let factor = mem.cv_eta;
-  for (let j = 1; j <= mem.cv_q; j++) {
-    const znj = mem.cv_zn[j];
-    for (let i = 0; i < N; i++)
-      znj[i] *= factor;
-
-    factor *= mem.cv_eta;
-  }
-  mem.cv_h = mem.cv_hscale * mem.cv_eta;
-  mem.cv_next_h = mem.cv_h;
-  mem.cv_hscale = mem.cv_h;
-  mem.cv_nscon = 0;
-}
-
-/** cvPredict - advance tn and compute predicted Nordsieck array */
-function cvPredict(mem: CvodeMem): void {
-  const N = mem.cv_N;
-
-  mem.cv_tn += mem.cv_h;
-  if (mem.cv_tstopset) {
-    if ((mem.cv_tn - mem.cv_tstop) * mem.cv_h > 0.0)
-      mem.cv_tn = mem.cv_tstop;
-  }
-
-  for (let k = 1; k <= mem.cv_q; k++) {
-    for (let j = mem.cv_q; j >= k; j--) {
-      const znjm1 = mem.cv_zn[j - 1];
-      const znj = mem.cv_zn[j];
-      for (let i = 0; i < N; i++)
-        znjm1[i] += znj[i];
-    }
-  }
-}
-
-/** cvSet - compute method coefficients l, tq, rl1, gamma, gamrat */
-function cvSet(mem: CvodeMem): void {
-  if (mem.cv_lmm === CV_ADAMS) cvSetAdams(mem);
-  else cvSetBDF(mem);
-
-  mem.cv_rl1 = 1.0 / mem.cv_l[1];
-  mem.cv_gamma = mem.cv_h * mem.cv_rl1;
-  if (mem.cv_nst === 0) mem.cv_gammap = mem.cv_gamma;
-  mem.cv_gamrat = (mem.cv_nst > 0) ?
-    mem.cv_gamma / mem.cv_gammap :
-    1.0;
-}
-
-/** cvHandleNFlag - take action on nonlinear solver return */
-function cvHandleNFlag(
-  mem: CvodeMem, nflagRef: { value: number }, saved_t: number, ncfRef: { value: number },
-): number {
-  const nflag = nflagRef.value;
-
-  if (nflag === CV_SUCCESS) return DO_ERROR_TEST;
-
-  // Nonlinear solve failed; increment ncfn and restore zn
-  mem.cv_ncfn++;
-  cvRestore(mem, saved_t);
-
-  // Return if failed unrecoverably
-  if (nflag < 0) {
-    if (nflag === CV_LSETUP_FAIL) return CV_LSETUP_FAIL;
-    else if (nflag === CV_LSOLVE_FAIL) return CV_LSOLVE_FAIL;
-    else if (nflag === CV_RHSFUNC_FAIL) return CV_RHSFUNC_FAIL;
-    else return CV_NLS_FAIL;
-  }
-
-  // Recoverable error
-  ncfRef.value++;
-  mem.cv_etamax = 1.0;
-
-  // If maxncf failures or |h| = hmin, return failure
-  if (Math.abs(mem.cv_h) <= mem.cv_hmin * ONEPSM ||
-      ncfRef.value === mem.cv_maxncf) {
-    if (nflag === SUN_NLS_CONV_RECVR) return CV_CONV_FAILURE;
-    if (nflag === RHSFUNC_RECVR) return CV_REPTD_RHSFUNC_ERR;
-  }
-
-  // Reduce step size; return to reattempt
-  mem.cv_eta = Math.max(mem.cv_eta_cf, mem.cv_hmin / Math.abs(mem.cv_h));
-  nflagRef.value = PREV_CONV_FAIL;
-  cvRescale(mem);
-
-  return PREDICT_AGAIN;
-}
-
-/** cvRestore - undo prediction, restore tn and zn */
-function cvRestore(mem: CvodeMem, saved_t: number): void {
-  const N = mem.cv_N;
-
-  mem.cv_tn = saved_t;
-  for (let k = 1; k <= mem.cv_q; k++) {
-    for (let j = mem.cv_q; j >= k; j--) {
-      const znjm1 = mem.cv_zn[j - 1];
-      const znj = mem.cv_zn[j];
-      for (let i = 0; i < N; i++)
-        znjm1[i] -= znj[i];
-    }
-  }
-}
-
-/** cvDoErrorTest - local error test */
-function cvDoErrorTest(
-  mem: CvodeMem, nflagRef: { value: number }, saved_t: number,
-  nefRef: { value: number }, dsmRef: { value: number },
-): number {
-  const dsm = mem.cv_acnrm * mem.cv_tq[2];
-  dsmRef.value = dsm;
-
-  // If dsm <= 1, test passed
-  if (dsm <= 1.0) return CV_SUCCESS;
-
-  // Test failed
-  nefRef.value++;
-  mem.cv_netf++;
-  nflagRef.value = PREV_ERR_FAIL;
-  cvRestore(mem, saved_t);
-
-  // At maxnef failures or |h| = hmin, return failure
-  if (Math.abs(mem.cv_h) <= mem.cv_hmin * ONEPSM ||
-      nefRef.value === mem.cv_maxnef)
-    return CV_ERR_FAILURE;
-
-
-  // Set etamax = 1 to prevent step size increase
-  mem.cv_etamax = 1.0;
-
-  // Compute eta from dsm and rescale
-  if (nefRef.value <= MXNEF1) {
-    mem.cv_eta = 1.0 / (Math.pow(BIAS2 * dsm, 1.0 / mem.cv_L) + ADDON);
-    mem.cv_eta = Math.max(mem.cv_eta_min_ef,
-      Math.max(mem.cv_eta, mem.cv_hmin / Math.abs(mem.cv_h)));
-    if (nefRef.value >= mem.cv_small_nef)
-      mem.cv_eta = Math.min(mem.cv_eta, mem.cv_eta_max_ef);
-
-    cvRescale(mem);
-    return TRY_AGAIN;
-  }
-
-  // After MXNEF1 failures, force order reduction
-  if (mem.cv_q > 1) {
-    mem.cv_eta = Math.max(mem.cv_eta_min_ef,
-      mem.cv_hmin / Math.abs(mem.cv_h));
-    cvAdjustOrder(mem, -1);
-    mem.cv_L = mem.cv_q;
-    mem.cv_q--;
-    mem.cv_qwait = mem.cv_L;
-    cvRescale(mem);
-    return TRY_AGAIN;
-  }
-
-  // Already at order 1: restart by reloading zn
-  mem.cv_eta = Math.max(mem.cv_eta_min_ef,
-    mem.cv_hmin / Math.abs(mem.cv_h));
-  mem.cv_h *= mem.cv_eta;
-  mem.cv_next_h = mem.cv_h;
-  mem.cv_hscale = mem.cv_h;
-  mem.cv_qwait = LONG_WAIT;
-  mem.cv_nscon = 0;
-
-  const retval = mem.cv_f!(mem.cv_tn, mem.cv_zn[0], mem.cv_tempv, mem.cv_user_data);
-  mem.cv_nfe++;
-  if (retval < 0) return CV_RHSFUNC_FAIL;
-  if (retval > 0) return CV_UNREC_RHSFUNC_ERR;
-
-  vScale(mem.cv_h, mem.cv_tempv, mem.cv_zn[1], mem.cv_N);
-
-  return TRY_AGAIN;
-}
-
-/** cvCompleteStep - update state after successful step */
-function cvCompleteStep(mem: CvodeMem): void {
-  const N = mem.cv_N;
-
-  mem.cv_nst++;
-  mem.cv_nscon++;
-  mem.cv_hu = mem.cv_h;
-  mem.cv_qu = mem.cv_q;
-
-  mem.first_step_after_resize = false;
-
-  // Shift tau array
-  for (let i = mem.cv_q; i >= 2; i--)
-    mem.cv_tau[i] = mem.cv_tau[i - 1];
-
-  if (mem.cv_q === 1 && mem.cv_nst > 1)
-    mem.cv_tau[2] = mem.cv_tau[1];
-
-  mem.cv_tau[1] = mem.cv_h;
-
-  // Apply corrections to zn: zn[j] += l[j] * acor
-  for (let j = 0; j <= mem.cv_q; j++) {
-    const lj = mem.cv_l[j];
-    const znj = mem.cv_zn[j];
-    const acor = mem.cv_acor;
-    for (let i = 0; i < N; i++)
-      znj[i] += lj * acor[i];
-  }
-
-  // Decrement qwait, save acor if qwait==1 and q < qmax
-  mem.cv_qwait--;
-  if (mem.cv_qwait === 1 && mem.cv_q !== mem.cv_qmax) {
-    mem.cv_zn[mem.cv_qmax].set(mem.cv_acor);
-    mem.cv_saved_tq5 = mem.cv_tq[5];
-    mem.cv_indx_acor = mem.cv_qmax;
-  }
-}
-
-/** cvPrepareNextStep - set stepsize and order for next step */
-function cvPrepareNextStep(mem: CvodeMem, dsm: number): void {
-  if (mem.cv_etamax === 1.0) {
-    // Defer step size or order changes
-    mem.cv_qwait = Math.max(mem.cv_qwait, 2);
-    mem.cv_qprime = mem.cv_q;
-    mem.cv_hprime = mem.cv_h;
-    mem.cv_eta = 1.0;
-  } else {
-    // Compute etaq
-    mem.cv_etaq = 1.0 / (Math.pow(BIAS2 * dsm, 1.0 / mem.cv_L) + ADDON);
-
-    if (mem.cv_qwait !== 0) {
-      // No order change, just adjust eta
-      mem.cv_eta = mem.cv_etaq;
-      mem.cv_qprime = mem.cv_q;
-      cvSetEta(mem);
-    } else {
-      // Consider order change
-      mem.cv_qwait = 2;
-      mem.cv_etaqm1 = cvComputeEtaqm1(mem);
-      mem.cv_etaqp1 = cvComputeEtaqp1(mem);
-      cvChooseEta(mem);
-      cvSetEta(mem);
-    }
-  }
-}
-
-/** cvSetEta - adjust eta by heuristic limits and hmax */
-function cvSetEta(mem: CvodeMem): void {
-  if (mem.cv_eta > mem.cv_eta_min_fx && mem.cv_eta < mem.cv_eta_max_fx) {
-    // Eta within fixed-step bounds, retain step size
-    mem.cv_eta = 1.0;
-    mem.cv_hprime = mem.cv_h;
-  } else {
-    if (mem.cv_eta >= mem.cv_eta_max_fx) {
-      // Increase step size
-      mem.cv_eta = Math.min(mem.cv_eta, mem.cv_etamax);
-      mem.cv_eta /= Math.max(1.0,
-        Math.abs(mem.cv_h) * mem.cv_hmax_inv * mem.cv_eta);
-    } else {
-      // Reduce step size
-      mem.cv_eta = Math.max(mem.cv_eta, mem.cv_eta_min);
-      mem.cv_eta = Math.max(mem.cv_eta,
-        mem.cv_hmin / Math.abs(mem.cv_h));
-    }
-    mem.cv_hprime = mem.cv_h * mem.cv_eta;
-    if (mem.cv_qprime < mem.cv_q) mem.cv_nscon = 0;
-  }
-}
-
-/** cvComputeEtaqm1 - eta for possible order decrease */
-function cvComputeEtaqm1(mem: CvodeMem): number {
-  mem.cv_etaqm1 = 0.0;
-  if (mem.cv_q > 1) {
-    const ddn = wrmsNorm(mem.cv_N, mem.cv_zn[mem.cv_q], mem.cv_ewt) * mem.cv_tq[1];
-    mem.cv_etaqm1 = 1.0 / (Math.pow(BIAS1 * ddn, 1.0 / mem.cv_q) + ADDON);
-  }
-  return mem.cv_etaqm1;
-}
-
-/** cvComputeEtaqp1 - eta for possible order increase */
-function cvComputeEtaqp1(mem: CvodeMem): number {
-  mem.cv_etaqp1 = 0.0;
-  if (mem.cv_q !== mem.cv_qmax) {
-    if (mem.cv_saved_tq5 === 0.0) return mem.cv_etaqp1;
-    const cquot = (mem.cv_tq[5] / mem.cv_saved_tq5) *
-      Math.pow(mem.cv_h / mem.cv_tau[2], mem.cv_L);
-
-    // tempv = acor - cquot * zn[qmax]
-    const N = mem.cv_N;
-    const tempv = mem.cv_tempv;
-    const znqmax = mem.cv_zn[mem.cv_qmax];
-    const acor = mem.cv_acor;
-    for (let i = 0; i < N; i++)
-      tempv[i] = acor[i] - cquot * znqmax[i];
-
-
-    const dup = wrmsNorm(N, tempv, mem.cv_ewt) * mem.cv_tq[3];
-    mem.cv_etaqp1 = 1.0 / (Math.pow(BIAS3 * dup, 1.0 / (mem.cv_L + 1)) + ADDON);
-  }
-  return mem.cv_etaqp1;
-}
-
-/** cvChooseEta - choose max of etaqm1, etaq, etaqp1 */
-function cvChooseEta(mem: CvodeMem): void {
-  const etam = Math.max(mem.cv_etaqm1, Math.max(mem.cv_etaq, mem.cv_etaqp1));
-
-  if (etam > mem.cv_eta_min_fx && etam < mem.cv_eta_max_fx) {
-    mem.cv_eta = 1.0;
-    mem.cv_qprime = mem.cv_q;
-  } else {
-    // Preference: keep > decrease > increase
-    if (etam === mem.cv_etaq) {
-      mem.cv_eta = mem.cv_etaq;
-      mem.cv_qprime = mem.cv_q;
-    } else if (etam === mem.cv_etaqm1) {
-      mem.cv_eta = mem.cv_etaqm1;
-      mem.cv_qprime = mem.cv_q - 1;
-    } else {
-      mem.cv_eta = mem.cv_etaqp1;
-      mem.cv_qprime = mem.cv_q + 1;
-
-      if (mem.cv_lmm === CV_BDF) {
-        // Store Delta_n in zn[qmax] for order increase
-        mem.cv_zn[mem.cv_qmax].set(mem.cv_acor);
-      }
-    }
-  }
-}
-
-/** cvHandleFailure - set error and return flag */
-function cvHandleFailure(mem: CvodeMem, flag: number): number {
-  switch (flag) {
-  case CV_ERR_FAILURE:
-    mem.cv_error = `Error test failures at t=${mem.cv_tn}, h=${mem.cv_h}`;
-    break;
-  case CV_CONV_FAILURE:
-    mem.cv_error = `Convergence failures at t=${mem.cv_tn}, h=${mem.cv_h}`;
-    break;
-  case CV_LSETUP_FAIL:
-    mem.cv_error = `Linear solver setup failed at t=${mem.cv_tn}`;
-    break;
-  case CV_LSOLVE_FAIL:
-    mem.cv_error = `Linear solver solve failed at t=${mem.cv_tn}`;
-    break;
-  case CV_RHSFUNC_FAIL:
-    mem.cv_error = `RHS function failed at t=${mem.cv_tn}`;
-    break;
-  case CV_UNREC_RHSFUNC_ERR:
-    mem.cv_error = `Unrecoverable RHS function error at t=${mem.cv_tn}`;
-    break;
-  case CV_REPTD_RHSFUNC_ERR:
-    mem.cv_error = `Repeated RHS function errors at t=${mem.cv_tn}`;
-    break;
-  case CV_RTFUNC_FAIL:
-    mem.cv_error = `Root function failed at t=${mem.cv_tn}`;
-    break;
-  case CV_TOO_CLOSE:
-    mem.cv_error = 'tout too close to t0';
-    break;
-  default:
-    mem.cv_error = `Unrecognized failure flag: ${flag}`;
-    break;
-  }
-  return flag;
-}
-
-/** cvBDFStab - BDF stability limit detection (STALD) */
-function cvBDFStab(mem: CvodeMem): void {
-  // If order >= 3, save scaled derivative data
-  if (mem.cv_q >= 3) {
-    for (let k = 1; k <= 3; k++) {
-      for (let i = 5; i >= 2; i--)
-        mem.cv_ssdat[i][k] = mem.cv_ssdat[i - 1][k];
-    }
-
-    let factorial = 1;
-    for (let i = 1; i <= mem.cv_q - 1; i++) factorial *= i;
-
-    const sq = factorial * mem.cv_q * (mem.cv_q + 1) * mem.cv_acnrm /
-      Math.max(mem.cv_tq[5], TINY);
-    const sqm1 = factorial * mem.cv_q *
-      wrmsNorm(mem.cv_N, mem.cv_zn[mem.cv_q], mem.cv_ewt);
-    const sqm2 = factorial *
-      wrmsNorm(mem.cv_N, mem.cv_zn[mem.cv_q - 1], mem.cv_ewt);
-
-    mem.cv_ssdat[1][1] = sqm2 * sqm2;
-    mem.cv_ssdat[1][2] = sqm1 * sqm1;
-    mem.cv_ssdat[1][3] = sq * sq;
-  }
-
-  if (mem.cv_qprime >= mem.cv_q) {
-    // If enough data, call stability limit detection
-    if (mem.cv_q >= 3 && mem.cv_nscon >= mem.cv_q + 5) {
-      const ldflag = cvSLdet(mem);
-      if (ldflag > 3) {
-        // Stability limit violation: reduce order
-        mem.cv_qprime = mem.cv_q - 1;
-        mem.cv_eta = mem.cv_etaqm1;
-        mem.cv_eta = Math.min(mem.cv_eta, mem.cv_etamax);
-        mem.cv_eta = mem.cv_eta /
-          Math.max(1.0, Math.abs(mem.cv_h) * mem.cv_hmax_inv * mem.cv_eta);
-        mem.cv_hprime = mem.cv_h * mem.cv_eta;
-        mem.cv_nor = mem.cv_nor + 1;
-      }
-    }
-  } else {
-    // Let order increase happen, reset nscon
-    mem.cv_nscon = 0;
-  }
-}
-
-/** cvSLdet - Stability limit detection algorithm (~300 lines from C) */
-function cvSLdet(mem: CvodeMem): number {
-  let kmin = 0;
-  let kflag = 0;
-
-  // Allocate local arrays with 1-based indexing
-  const rat: number[][] = [];
-  for (let i = 0; i < 5; i++) rat[i] = [0, 0, 0, 0];
-  const rav = [0, 0, 0, 0];
-  const qkr = [0, 0, 0, 0];
-  const sigsq = [0, 0, 0, 0];
-  const smax = [0, 0, 0, 0];
-  const ssmax = [0, 0, 0, 0];
-  const drr = [0, 0, 0, 0];
-  const rrc = [0, 0, 0, 0];
-  const sqmx = [0, 0, 0, 0];
-  const vrat = [0, 0, 0, 0, 0];
-
-  // qjk[j][k], qc[i][k], qco[i][k] - all 1-based
-  const qjk: number[][] = [];
-  for (let j = 0; j < 4; j++) qjk[j] = [0, 0, 0, 0];
-  const qc: number[][] = [];
-  for (let i = 0; i < 6; i++) qc[i] = [0, 0, 0, 0];
-  const qco: number[][] = [];
-  for (let i = 0; i < 6; i++) qco[i] = [0, 0, 0, 0];
-
-  // Cutoffs and tolerances
-  const rrcut = 0.98;
-  const vrrtol = 1.0e-4;
-  const vrrt2 = 5.0e-4;
-  const sqtol = 1.0e-3;
-  const rrtol = 1.0e-2;
-
-  let rr = 0.0;
-
-  // Get maxima, minima, and variances, form quartic coefficients
-  for (let k = 1; k <= 3; k++) {
-    let smink = mem.cv_ssdat[1][k];
-    let smaxk = 0.0;
-
-    for (let i = 1; i <= 5; i++) {
-      smink = Math.min(smink, mem.cv_ssdat[i][k]);
-      smaxk = Math.max(smaxk, mem.cv_ssdat[i][k]);
-    }
-
-    if (smink < TINY * smaxk) return -1;
-
-    smax[k] = smaxk;
-    ssmax[k] = smaxk * smaxk;
-
-    let sumrat = 0.0;
-    let sumrsq = 0.0;
-    for (let i = 1; i <= 4; i++) {
-      rat[i][k] = mem.cv_ssdat[i][k] / mem.cv_ssdat[i + 1][k];
-      sumrat += rat[i][k];
-      sumrsq += rat[i][k] * rat[i][k];
-    }
-    rav[k] = 0.25 * sumrat;
-    vrat[k] = Math.abs(0.25 * sumrsq - rav[k] * rav[k]);
-
-    qc[5][k] = mem.cv_ssdat[1][k] * mem.cv_ssdat[3][k] -
-               mem.cv_ssdat[2][k] * mem.cv_ssdat[2][k];
-    qc[4][k] = mem.cv_ssdat[2][k] * mem.cv_ssdat[3][k] -
-               mem.cv_ssdat[1][k] * mem.cv_ssdat[4][k];
-    qc[3][k] = 0.0;
-    qc[2][k] = mem.cv_ssdat[2][k] * mem.cv_ssdat[5][k] -
-               mem.cv_ssdat[3][k] * mem.cv_ssdat[4][k];
-    qc[1][k] = mem.cv_ssdat[4][k] * mem.cv_ssdat[4][k] -
-               mem.cv_ssdat[3][k] * mem.cv_ssdat[5][k];
-
-    for (let i = 1; i <= 5; i++) qco[i][k] = qc[i][k];
-  }
-
-  // Isolate normal or nearly-normal matrix case
-  const vmin = Math.min(vrat[1], Math.min(vrat[2], vrat[3]));
-  const vmax = Math.max(vrat[1], Math.max(vrat[2], vrat[3]));
-
-  if (vmin < vrrtol * vrrtol) {
-    if (vmax > vrrt2 * vrrt2) return -2;
-    else {
-      rr = (rav[1] + rav[2] + rav[3]) / 3.0;
-      let drrmax = 0.0;
-      for (let k = 1; k <= 3; k++) {
-        const adrr = Math.abs(rav[k] - rr);
-        drrmax = Math.max(drrmax, adrr);
-      }
-      if (drrmax > vrrt2) return -3;
-      kflag = 1;
-    }
-  } else {
-    // Use quartics to get rr
-    if (Math.abs(qco[1][1]) < TINY * ssmax[1]) return -4;
-
-    let tem = qco[1][2] / qco[1][1];
-    for (let i = 2; i <= 5; i++) qco[i][2] = qco[i][2] - tem * qco[i][1];
-    qco[1][2] = 0.0;
-
-    tem = qco[1][3] / qco[1][1];
-    for (let i = 2; i <= 5; i++) qco[i][3] = qco[i][3] - tem * qco[i][1];
-    qco[1][3] = 0.0;
-
-    if (Math.abs(qco[2][2]) < TINY * ssmax[2]) return -4;
-
-    tem = qco[2][3] / qco[2][2];
-    for (let i = 3; i <= 5; i++) qco[i][3] = qco[i][3] - tem * qco[i][2];
-
-    if (Math.abs(qco[4][3]) < TINY * ssmax[3]) return -4;
-
-    rr = -qco[5][3] / qco[4][3];
-
-    if (rr < TINY || rr > 100.0) return -5;
-
-    for (let k = 1; k <= 3; k++)
-      qkr[k] = qc[5][k] + rr * (qc[4][k] + rr * rr * (qc[2][k] + rr * qc[1][k]));
-
-
-    let sqmax = 0.0;
-    for (let k = 1; k <= 3; k++) {
-      const saqk = Math.abs(qkr[k]) / ssmax[k];
-      if (saqk > sqmax) sqmax = saqk;
-    }
-
-    if (sqmax < sqtol)
-      kflag = 2;
-    else {
-      // Newton corrections to improve rr
-      for (let it = 1; it <= 3; it++) {
-        for (let k = 1; k <= 3; k++) {
-          const qp = qc[4][k] + rr * rr * (3.0 * qc[2][k] + rr * 4.0 * qc[1][k]);
-          drr[k] = 0.0;
-          if (Math.abs(qp) > TINY * ssmax[k]) drr[k] = -qkr[k] / qp;
-          rrc[k] = rr + drr[k];
-        }
-
-        for (let k = 1; k <= 3; k++) {
-          const s = rrc[k];
-          let sqmaxk = 0.0;
-          for (let j = 1; j <= 3; j++) {
-            qjk[j][k] = qc[5][j] + s * (qc[4][j] + s * s * (qc[2][j] + s * qc[1][j]));
-            const saqj = Math.abs(qjk[j][k]) / ssmax[j];
-            if (saqj > sqmaxk) sqmaxk = saqj;
-          }
-          sqmx[k] = sqmaxk;
-        }
-
-        let sqmin = sqmx[1] + 1.0;
-        for (let k = 1; k <= 3; k++) {
-          if (sqmx[k] < sqmin) {
-            kmin = k;
-            sqmin = sqmx[k];
-          }
-        }
-        rr = rrc[kmin];
-
-        if (sqmin < sqtol) {
-          kflag = 3;
-          break;
-        } else
-          for (let j = 1; j <= 3; j++) qkr[j] = qjk[j][kmin];
-      }
-
-      if (kflag !== 3) {
-        // sqmin > sqtol after all Newton iterations
-        return -6;
-      }
-    }
-  }
-
-  // Given rr, find sigsq[k] and verify rr
-  for (let k = 1; k <= 3; k++) {
-    const rsa = mem.cv_ssdat[1][k];
-    const rsb = mem.cv_ssdat[2][k] * rr;
-    const rsc = mem.cv_ssdat[3][k] * rr * rr;
-    const rsd = mem.cv_ssdat[4][k] * rr * rr * rr;
-    const rd1a = rsa - rsb;
-    const rd1b = rsb - rsc;
-    const rd1c = rsc - rsd;
-    const rd2a = rd1a - rd1b;
-    const rd2b = rd1b - rd1c;
-    const rd3a = rd2a - rd2b;
-
-    if (Math.abs(rd1b) < TINY * smax[k]) return -7;
-
-    const cest1 = -rd3a / rd1b;
-    if (cest1 < TINY || cest1 > 4.0) return -7;
-
-    const corr1 = (rd2b / cest1) / (rr * rr);
-    sigsq[k] = mem.cv_ssdat[3][k] + corr1;
-  }
-
-  if (sigsq[2] < TINY) return -8;
-
-  const ratp = sigsq[3] / sigsq[2];
-  const ratm = sigsq[1] / sigsq[2];
-  const qfac1 = 0.25 * (mem.cv_q * mem.cv_q - 1);
-  const qfac2 = 2.0 / (mem.cv_q - 1);
-  const bb = ratp * ratm - 1.0 - qfac1 * ratp;
-  const tem2 = 1.0 - qfac2 * bb;
-
-  if (Math.abs(tem2) < TINY) return -8;
-
-  const rrb = 1.0 / tem2;
-
-  if (Math.abs(rrb - rr) > rrtol) return -9;
-
-  // Check if rr is above cutoff
-  if (rr > rrcut) {
-    if (kflag === 1) kflag = 4;
-    if (kflag === 2) kflag = 5;
-    if (kflag === 3) kflag = 6;
-  }
-
-  return kflag;
-}
-
-// Rootfinding functions imported from cvode_root.ts (cvRcheck1, cvRcheck2, cvRcheck3)