diff-grok 1.2.0 → 1.3.1

package/dist/src/solver-tools/callbacks/iter-checker-callback.d.ts

@@ -0,0 +1,12 @@
+import { Callback } from './callback-base';
+/** This callback terminates computations if the maximum iterations is exceeded */
+export declare class IterCheckerCallback extends Callback {
+    private maxIter;
+    private currentIter;
+    /**
+     * @param maxIter - the maximum number of iterations
+     */
+    constructor(maxIter: number);
+    /** Action performed on iteration start of numerical method */
+    onIterationStart(): void;
+}

package/{src → dist/src}/solver-tools/callbacks/iter-checker-callback.js

@@ -2,6 +2,8 @@ import { Callback } from './callback-base';
 import { CallbackAction } from '../solver-defs';
 /** This callback terminates computations if the maximum iterations is exceeded */
 export class IterCheckerCallback extends Callback {
+    maxIter;
+    currentIter;
     /**
      * @param maxIter - the maximum number of iterations
      */

package/dist/src/solver-tools/callbacks/iter-checker-callback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iter-checker-callback.js","sourceRoot":"","sources":["../../../../src/solver-tools/callbacks/iter-checker-callback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAC,cAAc,EAAC,MAAM,gBAAgB,CAAC;AAE9C,kFAAkF;AAClF,MAAM,OAAO,mBAAoB,SAAQ,QAAQ;IACvC,OAAO,CAAS;IAChB,WAAW,CAAS;IAE5B;;OAEG;IACH,YAAY,OAAe;QACzB,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;IACvB,CAAC;IAED,8DAA8D;IACvD,gBAAgB;QACrB,EAAE,IAAI,CAAC,WAAW,CAAC;QAEnB,IAAI,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO;YACjC,MAAM,IAAI,cAAc,CAAC,kCAAkC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;IAChF,CAAC;CACF"}

package/dist/src/solver-tools/callbacks/time-checker-callback.d.ts

@@ -0,0 +1,12 @@
+import { Callback } from './callback-base';
+/** This callback terminates computations if the maximum calculation time is exceeded */
+export declare class TimeCheckerCallback extends Callback {
+    private maxTime;
+    private startingTime;
+    /**
+     * @param maxTime - the maximum time of computations
+     */
+    constructor(maxTime: number);
+    /** The action performed at the start of numerical method iteration */
+    onIterationStart(): void;
+}

package/{src → dist/src}/solver-tools/callbacks/time-checker-callback.js

@@ -2,13 +2,13 @@ import { Callback } from './callback-base';
 import { CallbackAction } from '../solver-defs';
 /** This callback terminates computations if the maximum calculation time is exceeded */
 export class TimeCheckerCallback extends Callback {
+    maxTime = 0;
+    startingTime = 0;
     /**
      * @param maxTime - the maximum time of computations
      */
     constructor(maxTime) {
         super();
-        this.maxTime = 0;
-        this.startingTime = 0;
         this.maxTime = maxTime;
         this.startingTime = performance.now();
     }

package/dist/src/solver-tools/callbacks/time-checker-callback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-checker-callback.js","sourceRoot":"","sources":["../../../../src/solver-tools/callbacks/time-checker-callback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAC,cAAc,EAAC,MAAM,gBAAgB,CAAC;AAE9C,wFAAwF;AACxF,MAAM,OAAO,mBAAoB,SAAQ,QAAQ;IACvC,OAAO,GAAG,CAAC,CAAC;IACZ,YAAY,GAAG,CAAC,CAAC;IAEzB;;OAEG;IACH,YAAY,OAAe;QACzB,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;IACxC,CAAC;IAED,sEAAsE;IAC/D,gBAAgB;QACrB,IAAI,WAAW,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,OAAO;YACtD,MAAM,IAAI,cAAc,CAAC,sBAAsB,IAAI,CAAC,OAAO,MAAM,CAAC,CAAC;IACvE,CAAC;CACF"}

package/dist/src/solver-tools/cvode/common.d.ts

@@ -0,0 +1,395 @@
+/**
+ * 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.
+ */
+export declare const ADAMS_Q_MAX = 12;
+export declare const BDF_Q_MAX = 5;
+export declare const Q_MAX = 12;
+export declare const L_MAX = 13;
+export declare const NUM_TESTS = 5;
+export declare const CV_ADAMS = 1;
+export declare const CV_BDF = 2;
+export declare const CV_NORMAL = 1;
+export declare const CV_ONE_STEP = 2;
+export declare const CV_SUCCESS = 0;
+export declare const CV_TSTOP_RETURN = 1;
+export declare const CV_ROOT_RETURN = 2;
+export declare const CV_TOO_MUCH_WORK = -1;
+export declare const CV_TOO_MUCH_ACC = -2;
+export declare const CV_ERR_FAILURE = -3;
+export declare const CV_CONV_FAILURE = -4;
+export declare const CV_RHSFUNC_FAIL = -8;
+export declare const CV_FIRST_RHSFUNC_ERR = -9;
+export declare const CV_RTFUNC_FAIL = -12;
+export declare const CV_TOO_CLOSE = -27;
+export declare const HMIN_DEFAULT = 0;
+export declare const HMAX_INV_DEFAULT = 0;
+export declare const MXHNIL_DEFAULT = 10;
+export declare const MXSTEP_DEFAULT = 500;
+export declare const MSBP_DEFAULT = 20;
+export declare const DGMAX_LSETUP_DEFAULT = 0.3;
+export declare const ETA_MIN_FX_DEFAULT = 0;
+export declare const ETA_MAX_FX_DEFAULT = 1.5;
+export declare const ETA_MAX_FS_DEFAULT = 10000;
+export declare const ETA_MAX_ES_DEFAULT = 10;
+export declare const ETA_MAX_GS_DEFAULT = 10;
+export declare const ETA_MIN_DEFAULT = 0.1;
+export declare const ETA_MAX_EF_DEFAULT = 0.2;
+export declare const ETA_MIN_EF_DEFAULT = 0.1;
+export declare const ETA_CF_DEFAULT = 0.25;
+export declare const SMALL_NST_DEFAULT = 10;
+export declare const SMALL_NEF_DEFAULT = 2;
+export declare const ONEPSM = 1.000001;
+export declare const ADDON = 0.000001;
+export declare const BIAS1 = 6;
+export declare const BIAS2 = 6;
+export declare const BIAS3 = 10;
+export declare const LONG_WAIT = 10;
+export declare const MXNCF = 10;
+export declare const MXNEF = 7;
+export declare const MXNEF1 = 3;
+export declare const DO_ERROR_TEST = 2;
+export declare const PREDICT_AGAIN = 3;
+export declare const TRY_AGAIN = 5;
+export declare const FIRST_CALL = 6;
+export declare const PREV_CONV_FAIL = 7;
+export declare const PREV_ERR_FAIL = 9;
+export declare const RHSFUNC_RECVR = 10;
+export declare const CV_NN = 0;
+export declare const CV_SS = 1;
+export declare const CV_SV = 2;
+export declare const CV_NO_FAILURES = 0;
+export declare const CV_FAIL_BAD_J = 1;
+export declare const CV_FAIL_OTHER = 2;
+export declare const FUZZ_FACTOR = 100;
+export declare const HLB_FACTOR = 100;
+export declare const HUB_FACTOR = 0.1;
+export declare const H_BIAS = 0.5;
+export declare const MAX_ITERS = 4;
+export declare const CORTES = 0.1;
+export declare const TINY = 1e-10;
+export declare const NLS_MAXCOR = 3;
+export declare const CRDOWN = 0.3;
+export declare const RDIV = 2;
+export declare const SUN_NLS_CONTINUE = 901;
+export declare const SUN_NLS_CONV_RECVR = 902;
+export declare const CV_LSETUP_FAIL = -13;
+export declare const CV_LSOLVE_FAIL = -14;
+export declare const CV_UNREC_RHSFUNC_ERR = -10;
+export declare const CV_REPTD_RHSFUNC_ERR = -11;
+export declare const CV_LINIT_FAIL = -31;
+export declare const CV_NLS_INIT_FAIL = -32;
+export declare const CV_NLS_FAIL = -33;
+export declare const UROUND = 2.220446049250313e-16;
+export declare const RTFOUND = 1;
+export declare const CLOSERT = 3;
+export declare const CVLS_MSBJ = 51;
+export declare const CVLS_DGMAX = 0.2;
+/** RHS function: y' = f(t, y). Returns 0 on success, non-zero on failure. */
+export type CvodeRhsFn = (t: number, y: Float64Array, ydot: Float64Array, userData: any) => number;
+/** Jacobian function: J = df/dy. Returns 0 on success, non-zero on failure. */
+export type CvodeJacFn = (t: number, y: Float64Array, fy: Float64Array, J: Float64Array[], userData: any) => number;
+/** Root function: g(t, y). Returns 0 on success, non-zero on failure. */
+export type CvodeRootFn = (t: number, y: Float64Array, gout: Float64Array, userData: any) => number;
+export declare class CvLsMem {
+    /** N x N Jacobian matrix (row-major) */
+    A: Float64Array[];
+    /** LU pivot indices */
+    pivots: Int32Array;
+    /** Saved copy of Jacobian */
+    savedJ: Float64Array[];
+    /** User-supplied Jacobian function */
+    jacFn: CvodeJacFn | null;
+    /** Use difference-quotient Jacobian by default */
+    jacDQ: boolean;
+    /** Number of Jacobian evaluations */
+    nje: number;
+    /** Number of f evaluations for DQ Jacobian */
+    nfeDQ: number;
+    /** nst at last Jacobian evaluation */
+    nstlj: number;
+    /** t at last Jacobian evaluation */
+    tnlj: number;
+    /** Max steps between Jacobian evaluations (CVLS_MSBJ) */
+    msbj: number;
+    /** Gamma change threshold (CVLS_DGMAX) */
+    dgmax_jbad: number;
+    /** Is Jacobian stale? */
+    jbad: boolean;
+}
+export declare class CvodeMem {
+    /** RHS function: y' = f(t, y) */
+    cv_f: CvodeRhsFn | null;
+    /** User data passed to f, jac, root functions */
+    cv_user_data: any;
+    /** Linear multistep method: CV_ADAMS or CV_BDF */
+    cv_lmm: number;
+    /** Tolerance type: CV_NN, CV_SS, or CV_SV */
+    cv_itol: number;
+    /** Relative tolerance */
+    cv_reltol: number;
+    /** Scalar absolute tolerance */
+    cv_Sabstol: number;
+    /** Vector absolute tolerance */
+    cv_Vabstol: Float64Array;
+    /** Flag: is min(atol) == 0? */
+    cv_atolmin0: boolean;
+    /** Nordsieck array: cv_zn[j][i], j=0..q, i=0..N-1 */
+    cv_zn: Float64Array[];
+    /** Error weight vector */
+    cv_ewt: Float64Array;
+    /** Solution vector (scratch for user output) */
+    cv_y: Float64Array;
+    /** Accumulated correction */
+    cv_acor: Float64Array;
+    /** Temporary vector */
+    cv_tempv: Float64Array;
+    /** Temporary for f evaluations */
+    cv_ftemp: Float64Array;
+    /** Temporary vector 1 */
+    cv_vtemp1: Float64Array;
+    /** Temporary vector 2 */
+    cv_vtemp2: Float64Array;
+    /** Temporary vector 3 */
+    cv_vtemp3: Float64Array;
+    /** Is tstop set? */
+    cv_tstopset: boolean;
+    /** Interpolate at tstop? */
+    cv_tstopinterp: boolean;
+    /** Stop time */
+    cv_tstop: number;
+    /** Current method order */
+    cv_q: number;
+    /** Order for next step */
+    cv_qprime: number;
+    /** Next order to be used (during step) */
+    cv_next_q: number;
+    /** Steps remaining before order change allowed */
+    cv_qwait: number;
+    /** L = q + 1 */
+    cv_L: number;
+    /** Initial step size (user-supplied) */
+    cv_hin: number;
+    /** Current step size */
+    cv_h: number;
+    /** Step size for next step */
+    cv_hprime: number;
+    /** Next h (during step) */
+    cv_next_h: number;
+    /** Step size ratio: hprime / h */
+    cv_eta: number;
+    /** Step size at last Nordsieck rescale */
+    cv_hscale: number;
+    /** Current internal time */
+    cv_tn: number;
+    /** Last return time */
+    cv_tretlast: number;
+    /** Step size history: tau[i], i=0..L_MAX */
+    cv_tau: Float64Array;
+    /** Error test quantities: tq[i], i=0..NUM_TESTS */
+    cv_tq: Float64Array;
+    /** Polynomial coefficients: l[i], i=0..L_MAX-1 */
+    cv_l: Float64Array;
+    /** 1 / l[1] */
+    cv_rl1: number;
+    /** gamma = h * rl1 */
+    cv_gamma: number;
+    /** gamma at last setup */
+    cv_gammap: number;
+    /** gamma / gammap */
+    cv_gamrat: number;
+    /** NLS convergence rate estimate */
+    cv_crate: number;
+    /** Previous del value (NLS) */
+    cv_delp: number;
+    /** WRMS norm of accumulated correction */
+    cv_acnrm: number;
+    /** Current acnrm (during step) */
+    cv_acnrmcur: boolean;
+    /** NLS convergence coefficient */
+    cv_nlscoef: number;
+    /** Max method order */
+    cv_qmax: number;
+    /** Max internal steps per call */
+    cv_mxstep: number;
+    /** Max t+h==t warnings */
+    cv_mxhnil: number;
+    /** Max error test failures per step */
+    cv_maxnef: number;
+    /** Max convergence failures per step */
+    cv_maxncf: number;
+    /** Min step size */
+    cv_hmin: number;
+    /** 1/hmax (inverse of max step size) */
+    cv_hmax_inv: number;
+    /** Max eta for step size increase */
+    cv_etamax: number;
+    /** Min fixed eta threshold */
+    cv_eta_min_fx: number;
+    /** Max fixed eta threshold */
+    cv_eta_max_fx: number;
+    /** Max eta on first step */
+    cv_eta_max_fs: number;
+    /** Max eta on early steps */
+    cv_eta_max_es: number;
+    /** Max eta on general steps */
+    cv_eta_max_gs: number;
+    /** Min eta */
+    cv_eta_min: number;
+    /** Min eta on error failure */
+    cv_eta_min_ef: number;
+    /** Max eta on error failure */
+    cv_eta_max_ef: number;
+    /** Eta on convergence failure */
+    cv_eta_cf: number;
+    /** Small step count threshold */
+    cv_small_nst: number;
+    /** Small error failure threshold */
+    cv_small_nef: number;
+    /** Total internal steps taken */
+    cv_nst: number;
+    /** Total RHS evaluations */
+    cv_nfe: number;
+    /** Convergence failures */
+    cv_ncfn: number;
+    /** Nonlinear iterations */
+    cv_nni: number;
+    /** Nonlinear iteration failures */
+    cv_nnf: number;
+    /** Error test failures */
+    cv_netf: number;
+    /** Linear solver setups */
+    cv_nsetups: number;
+    /** t+h==t warnings */
+    cv_nhnil: number;
+    /** Eta for order q-1 */
+    cv_etaqm1: number;
+    /** Eta for order q */
+    cv_etaq: number;
+    /** Eta for order q+1 */
+    cv_etaqp1: number;
+    /** Linear solver init function */
+    cv_linit: ((mem: CvodeMem) => number) | null;
+    /** Linear solver setup function */
+    cv_lsetup: ((mem: CvodeMem, convfail: number, ypred: Float64Array, fpred: Float64Array, jcurPtr: {
+        value: boolean;
+    }, tmp1: Float64Array, tmp2: Float64Array, tmp3: Float64Array) => number) | null;
+    /** Linear solver solve function */
+    cv_lsolve: ((mem: CvodeMem, b: Float64Array, weight: Float64Array, ycur: Float64Array, fcur: Float64Array) => number) | null;
+    /** Linear solver free function */
+    cv_lfree: ((mem: CvodeMem) => void) | null;
+    /** Linear solver memory */
+    cv_lmem: CvLsMem | null;
+    /** Max steps between Jacobian setups */
+    cv_msbp: number;
+    /** Gamma change threshold for Jacobian redo */
+    cv_dgmax_lsetup: number;
+    /** Order used on last successful step */
+    cv_qu: number;
+    /** nst at last Jacobian setup */
+    cv_nstlp: number;
+    /** Initial step size actually used */
+    cv_h0u: number;
+    /** Step size used on last successful step */
+    cv_hu: number;
+    /** Saved tq[5] for order selection */
+    cv_saved_tq5: number;
+    /** Is Jacobian current? */
+    cv_jcur: boolean;
+    /** Tolerance scale factor */
+    cv_tolsf: number;
+    /** Max order allocated in Nordsieck array */
+    cv_qmax_alloc: number;
+    /** Index of acor in zn array */
+    cv_indx_acor: number;
+    /** Has CvodeMem been allocated/initialized? */
+    cv_MallocDone: boolean;
+    /** Has vector abstol been allocated? */
+    cv_VabstolMallocDone: boolean;
+    /** Enable stability limit detection? */
+    cv_sldeton: boolean;
+    /** Stability data: ssdat[6][4] (6 rows, 4 cols) */
+    cv_ssdat: number[][];
+    /** Steps since stability check */
+    cv_nscon: number;
+    /** Order flag for stability */
+    cv_nor: number;
+    /** Root function */
+    cv_gfun: CvodeRootFn | null;
+    /** Number of root functions */
+    cv_nrtfn: number;
+    /** Root direction info (which roots were found) */
+    cv_iroots: Int32Array;
+    /** Root direction constraints */
+    cv_rootdir: Int32Array;
+    /** t at low end of bracket */
+    cv_tlo: number;
+    /** t at high end of bracket */
+    cv_thi: number;
+    /** t at root */
+    cv_trout: number;
+    /** g values at low end */
+    cv_glo: Float64Array;
+    /** g values at high end */
+    cv_ghi: Float64Array;
+    /** g values at root */
+    cv_grout: Float64Array;
+    /** Output time saved for root check */
+    cv_toutc: number;
+    /** Root time tolerance */
+    cv_ttol: number;
+    /** Task flag for root check */
+    cv_taskc: number;
+    /** Root found on previous step? */
+    cv_irfnd: number;
+    /** Number of g evaluations */
+    cv_nge: number;
+    /** Active root functions flags */
+    cv_gactive: Uint8Array;
+    /** Max steps with g inactive before declaring permanently inactive */
+    cv_mxgnull: number;
+    /** Convergence failure type (CV_NO_FAILURES, CV_FAIL_BAD_J, CV_FAIL_OTHER) */
+    convfail: number;
+    /** Error message string */
+    cv_error: string;
+    /** Number of equations */
+    cv_N: number;
+    /** First step after problem resize */
+    first_step_after_resize: boolean;
+}
+/**
+ * Weighted root-mean-square norm.
+ * Returns sqrt(sum((v[i]*w[i])^2) / n) for i = 0..n-1.
+ */
+export declare function wrmsNorm(n: number, v: Float64Array, w: Float64Array): number;
+/**
+ * Linear combination of two vectors: z[i] = a*x[i] + b*y[i] for i = 0..n-1.
+ */
+export declare function vLinearSum(a: number, x: Float64Array, b: number, y: Float64Array, z: Float64Array, n: number): void;
+/**
+ * Scale a vector: z[i] = c * x[i] for i = 0..n-1.
+ */
+export declare function vScale(c: number, x: Float64Array, z: Float64Array, n: number): void;
+/**
+ * Set all elements of a vector to a constant: z[i] = c for i = 0..n-1.
+ */
+export declare function vConst(c: number, z: Float64Array, n: number): void;
+/**
+ * Dense output interpolation from the Nordsieck history array.
+ *
+ * Computes the k-th derivative of the interpolating polynomial at time t:
+ *   dky = sum_{j=k}^{q} c(j,k) * s^(j-k) * h^(-k) * zn[j]
+ * where s = (t - tn) / h, c(j,k) = j*(j-1)*...*(j-k+1).
+ *
+ * @returns 0 on success, -1 on invalid input.
+ */
+export declare function cvodeGetDky(mem: CvodeMem, t: number, k: number, dky: Float64Array): number;