diff-grok 1.1.0 → 1.2.0

package/.claude/skills/license-updater/scripts/generate_license_files.py

@@ -0,0 +1,467 @@
+#!/usr/bin/env python3
+"""Generate license attribution files for ported third-party code.
+
+This script produces three files:
+  1. THIRD_PARTY_LICENSES — for the repo root
+  2. HEADER_TEMPLATE.txt  — comment block to prepend to each ported file
+  3. LICENSE_GUIDE.md      — human-readable instructions
+
+Usage:
+    python3 generate_license_files.py \
+        --license-type "MIT" \
+        --copyright-holders "Copyright (c) 2011 Foo;Copyright (c) 2020 Bar" \
+        --project-name "liblsoda" \
+        --project-url "https://github.com/sdwfrost/liblsoda" \
+        --ported-files-path "src/solver-tools/lsoda" \
+        --target-copyright "Copyright (c) 2025 Datagrok" \
+        --output-dir "./license-output"
+
+Optional:
+    --provenance       Semicolon-separated provenance chain
+    --description      Brief description of what the ported code does
+    --license-text     Full license text (if not a well-known SPDX type)
+    --target-license   Target project license type (default: MIT)
+    --file-ext         File extension for header comment style (default: ts)
+    --append           If set, append to existing THIRD_PARTY_LICENSES
+"""
+
+import argparse
+import os
+import sys
+import textwrap
+
+# Well-known license texts keyed by SPDX identifier
+KNOWN_LICENSES = {
+    "MIT": textwrap.dedent("""\
+        The MIT License
+
+        {COPYRIGHT}
+
+        Permission is hereby granted, free of charge, to any person obtaining
+        a copy of this software and associated documentation files (the
+        "Software"), to deal in the Software without restriction, including
+        without limitation the rights to use, copy, modify, merge, publish,
+        distribute, sublicense, and/or sell copies of the Software, and to
+        permit persons to whom the Software is furnished to do so, subject to
+        the following conditions:
+
+        The above copyright notice and this permission notice shall be
+        included in all copies or substantial portions of the Software.
+
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+        LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+        OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+        WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."""),
+
+    "BSD-2-Clause": textwrap.dedent("""\
+        BSD 2-Clause License
+
+        {COPYRIGHT}
+
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+
+        1. Redistributions of source code must retain the above copyright notice,
+           this list of conditions and the following disclaimer.
+
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."""),
+
+    "BSD-3-Clause": textwrap.dedent("""\
+        BSD 3-Clause License
+
+        {COPYRIGHT}
+
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+
+        1. Redistributions of source code must retain the above copyright notice,
+           this list of conditions and the following disclaimer.
+
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."""),
+
+    "Apache-2.0": textwrap.dedent("""\
+        Apache License, Version 2.0
+
+        {COPYRIGHT}
+
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+            http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License."""),
+
+    "ISC": textwrap.dedent("""\
+        ISC License
+
+        {COPYRIGHT}
+
+        Permission to use, copy, modify, and/or distribute this software for any
+        purpose with or without fee is hereby granted, provided that the above
+        copyright notice and this permission notice appear in all copies.
+
+        THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+        WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+        MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+        ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+        WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+        ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+        OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE."""),
+}
+
+# Compatibility matrix: (upstream, target) -> compatible?
+# True = compatible, False = incompatible, None = conditional
+COMPAT = {
+    ("MIT", "MIT"): True,
+    ("MIT", "BSD-2-Clause"): True,
+    ("MIT", "BSD-3-Clause"): True,
+    ("MIT", "Apache-2.0"): True,
+    ("BSD-2-Clause", "MIT"): True,
+    ("BSD-2-Clause", "BSD-2-Clause"): True,
+    ("BSD-2-Clause", "BSD-3-Clause"): True,
+    ("BSD-2-Clause", "Apache-2.0"): True,
+    ("BSD-3-Clause", "MIT"): True,
+    ("BSD-3-Clause", "BSD-2-Clause"): True,
+    ("BSD-3-Clause", "BSD-3-Clause"): True,
+    ("BSD-3-Clause", "Apache-2.0"): True,
+    ("Apache-2.0", "MIT"): True,
+    ("Apache-2.0", "BSD-2-Clause"): True,
+    ("Apache-2.0", "BSD-3-Clause"): True,
+    ("Apache-2.0", "Apache-2.0"): True,
+    ("ISC", "MIT"): True,
+    ("ISC", "BSD-2-Clause"): True,
+    ("ISC", "BSD-3-Clause"): True,
+    ("ISC", "Apache-2.0"): True,
+}
+
+COMMENT_STYLES = {
+    "ts": ("/**", " *", " */"),
+    "js": ("/**", " *", " */"),
+    "tsx": ("/**", " *", " */"),
+    "jsx": ("/**", " *", " */"),
+    "py": ("#", "#", "#"),
+    "c": ("/*", " *", " */"),
+    "cpp": ("/*", " *", " */"),
+    "h": ("/*", " *", " */"),
+    "rs": ("//!", "//!", "//!"),
+    "go": ("//", "//", "//"),
+}
+
+
+def parse_list(value: str) -> list[str]:
+    """Split a semicolon-separated string into a list of stripped items."""
+    if not value:
+        return []
+    return [item.strip() for item in value.split(";") if item.strip()]
+
+
+def get_license_text(license_type: str, copyright_holders: list[str],
+                     custom_text: str | None = None) -> str:
+    """Return the full license text with copyright holders inserted."""
+    if custom_text:
+        return custom_text
+
+    template = KNOWN_LICENSES.get(license_type)
+    if not template:
+        return (f"[License text for {license_type} not available.\n"
+                f"Please paste the full license text here manually.]")
+
+    copyright_block = "\n".join(copyright_holders)
+    return template.replace("{COPYRIGHT}", copyright_block)
+
+
+def check_compatibility(upstream: str, target: str) -> tuple[bool, str]:
+    """Check license compatibility and return (ok, message)."""
+    key = (upstream, target)
+    if key in COMPAT:
+        if COMPAT[key]:
+            return True, f"{upstream} is compatible with {target}."
+        else:
+            return False, (f"⚠️  {upstream} is NOT compatible with {target}. "
+                           f"The ported code cannot be included under {target}.")
+
+    # Assume copyleft is incompatible with permissive
+    copyleft = {"GPL-2.0-only", "GPL-3.0-only", "AGPL-3.0-only",
+                "GPL-2.0-or-later", "GPL-3.0-or-later", "AGPL-3.0-or-later"}
+    if upstream in copyleft:
+        return False, (f"⚠️  {upstream} is copyleft and cannot be included "
+                       f"in a {target} project without the entire project "
+                       f"adopting {upstream}.")
+
+    return True, (f"Compatibility between {upstream} and {target} is not in "
+                  f"the built-in matrix. Manual review recommended.")
+
+
+def generate_third_party(args, copyright_holders: list[str],
+                         provenance: list[str]) -> str:
+    """Generate the THIRD_PARTY_LICENSES content."""
+    lines = []
+    lines.append("Third-Party Licenses")
+    lines.append("=" * 20)
+    lines.append("")
+    lines.append("This file documents the licenses for third-party code included in or adapted")
+    lines.append("by this project.")
+    lines.append("")
+    lines.append("")
+    lines.append("=" * 80)
+    lines.append(f"{args.project_name}")
+    lines.append("=" * 80)
+    lines.append("")
+    lines.append(f"Source:       {args.project_url}")
+    lines.append(f"License:      {args.license_type}")
+    lines.append(f"Files:        {args.ported_files_path}")
+    lines.append("")
+
+    if args.description:
+        lines.append(args.description)
+        lines.append("")
+
+    if provenance:
+        lines.append("Provenance chain:")
+        lines.append("")
+        for i, step in enumerate(provenance, 1):
+            lines.append(f"  {i}. {step}")
+        lines.append("")
+
+    license_text = get_license_text(
+        args.license_type, copyright_holders, args.license_text
+    )
+    lines.append(license_text)
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def generate_header(args, copyright_holders: list[str]) -> str:
+    """Generate the header template for ported files."""
+    ext = args.file_ext
+    start, mid, end = COMMENT_STYLES.get(ext, ("/**", " *", " */"))
+
+    lines = []
+    lines.append(start)
+
+    if args.description:
+        lines.append(f"{mid} {args.description}")
+        lines.append(f"{mid}")
+
+    lines.append(f"{mid} Port of {args.project_name} ({args.project_url})")
+    lines.append(f"{mid}")
+
+    for holder in copyright_holders:
+        lines.append(f"{mid} {holder}")
+    if args.target_copyright:
+        lines.append(f"{mid} {args.target_copyright}")
+
+    lines.append(f"{mid}")
+    lines.append(f"{mid} Licensed under the {args.license_type} License.")
+    lines.append(f"{mid} See THIRD_PARTY_LICENSES for the full license text and provenance.")
+    lines.append(end)
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def generate_guide(args, copyright_holders: list[str],
+                   compat_ok: bool, compat_msg: str) -> str:
+    """Generate the LICENSE_GUIDE.md content."""
+    status = "✅ Compatible" if compat_ok else "❌ Incompatible"
+    target_lic = args.target_license
+
+    lines = []
+    lines.append(f"# License Attribution Guide for {args.project_name}")
+    lines.append("")
+    lines.append("## File structure")
+    lines.append("")
+    lines.append("```")
+    lines.append("your-repo/")
+    lines.append("├── LICENSE                      ← do not modify")
+    lines.append("├── THIRD_PARTY_LICENSES         ← add/update this file")
+
+    # Show the ported files path
+    parts = args.ported_files_path.split("/")
+    indent = "│   "
+    for i, part in enumerate(parts[:-1]):
+        lines.append(f"{indent}└── {part}/")
+        indent += "    "
+    lines.append(f"{indent}└── {parts[-1]}/")
+    lines.append(f"{indent}    └── *.{args.file_ext}          ← add header to each file")
+
+    lines.append("```")
+    lines.append("")
+    lines.append("## Steps")
+    lines.append("")
+    lines.append("### 1. Add `THIRD_PARTY_LICENSES` to the repository root")
+    lines.append("")
+
+    if args.append:
+        lines.append("Append the provided section to your existing `THIRD_PARTY_LICENSES` file.")
+    else:
+        lines.append("Place the provided `THIRD_PARTY_LICENSES` file next to your existing `LICENSE`.")
+
+    lines.append("")
+    lines.append(f"### 2. Add header to each `.{args.file_ext}` file in `{args.ported_files_path}/`")
+    lines.append("")
+    lines.append("Prepend the content of `HEADER_TEMPLATE.txt` to the top of every")
+    lines.append(f"`.{args.file_ext}` file in the `{args.ported_files_path}/` directory.")
+    lines.append("")
+    lines.append("### 3. `LICENSE` — no changes needed")
+    lines.append("")
+    lines.append(f"Your project license ({target_lic}) stays as-is.")
+    lines.append("`THIRD_PARTY_LICENSES` handles attribution for ported code separately.")
+    lines.append("")
+    lines.append("### 4. README — optional")
+    lines.append("")
+    lines.append("Consider adding a note in your README's License section:")
+    lines.append("")
+    lines.append("```markdown")
+    lines.append("## License")
+    lines.append("")
+    lines.append(f"This project is licensed under the [{target_lic} License](LICENSE).")
+    lines.append("")
+    lines.append(f"Some components are ported from [{args.project_name}]({args.project_url}).")
+    lines.append("See [THIRD_PARTY_LICENSES](THIRD_PARTY_LICENSES) for details.")
+    lines.append("```")
+    lines.append("")
+    lines.append("## Compatibility check")
+    lines.append("")
+    lines.append(f"- Upstream license: **{args.license_type}**")
+    lines.append(f"- Target license:   **{target_lic}**")
+    lines.append(f"- Status:           {status}")
+    lines.append("")
+    lines.append(compat_msg)
+
+    # Special notes
+    if args.license_type == "BSD-3-Clause":
+        lines.append("")
+        lines.append("### BSD-3-Clause special condition")
+        lines.append("")
+        lines.append("You may NOT use the names of the original copyright holders")
+        lines.append("to endorse or promote your product without their written permission.")
+
+    if args.license_type == "Apache-2.0":
+        lines.append("")
+        lines.append("### Apache-2.0 special conditions")
+        lines.append("")
+        lines.append("- The patent grant from Apache-2.0 applies to the ported code")
+        lines.append("- If the upstream repo has a NOTICE file, its contents must be preserved")
+        lines.append("- You must state significant changes made to the ported files")
+
+    lines.append("")
+    return "\n".join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate license attribution files for ported code."
+    )
+    parser.add_argument("--license-type", required=True,
+                        help="SPDX license identifier (e.g., MIT, BSD-3-Clause)")
+    parser.add_argument("--copyright-holders", required=True,
+                        help="Semicolon-separated copyright lines")
+    parser.add_argument("--project-name", required=True,
+                        help="Name of the upstream project")
+    parser.add_argument("--project-url", required=True,
+                        help="URL to the upstream project")
+    parser.add_argument("--ported-files-path", required=True,
+                        help="Relative path in target repo to ported files")
+    parser.add_argument("--target-copyright", default="",
+                        help="Copyright line for the target project")
+    parser.add_argument("--target-license", default="MIT",
+                        help="Target project license (default: MIT)")
+    parser.add_argument("--provenance", default="",
+                        help="Semicolon-separated provenance chain")
+    parser.add_argument("--description", default="",
+                        help="Brief description of the ported code")
+    parser.add_argument("--license-text", default=None,
+                        help="Full custom license text (if not a known SPDX type)")
+    parser.add_argument("--file-ext", default="ts",
+                        help="File extension for comment style (default: ts)")
+    parser.add_argument("--output-dir", default="./license-output",
+                        help="Output directory for generated files")
+    parser.add_argument("--append", action="store_true",
+                        help="Append to existing THIRD_PARTY_LICENSES")
+
+    args = parser.parse_args()
+
+    copyright_holders = parse_list(args.copyright_holders)
+    provenance = parse_list(args.provenance)
+
+    if not copyright_holders:
+        print("Error: at least one copyright holder is required.", file=sys.stderr)
+        sys.exit(1)
+
+    # Check compatibility
+    compat_ok, compat_msg = check_compatibility(args.license_type, args.target_license)
+    if not compat_ok:
+        print(f"\n⚠️  LICENSE COMPATIBILITY WARNING:\n{compat_msg}\n", file=sys.stderr)
+        print("Files will still be generated, but review carefully before using.",
+              file=sys.stderr)
+
+    # Create output directory
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    # Generate files
+    third_party = generate_third_party(args, copyright_holders, provenance)
+    header = generate_header(args, copyright_holders)
+    guide = generate_guide(args, copyright_holders, compat_ok, compat_msg)
+
+    # Write files
+    tp_path = os.path.join(args.output_dir, "THIRD_PARTY_LICENSES")
+    with open(tp_path, "w") as f:
+        f.write(third_party)
+    print(f"✅ Created: {tp_path}")
+
+    header_path = os.path.join(args.output_dir, "HEADER_TEMPLATE.txt")
+    with open(header_path, "w") as f:
+        f.write(header)
+    print(f"✅ Created: {header_path}")
+
+    guide_path = os.path.join(args.output_dir, "LICENSE_GUIDE.md")
+    with open(guide_path, "w") as f:
+        f.write(guide)
+    print(f"✅ Created: {guide_path}")
+
+    print(f"\n{'✅' if compat_ok else '⚠️'}  License compatibility: {compat_msg}")
+    print(f"\nAll files written to: {args.output_dir}/")
+
+
+if __name__ == "__main__":
+    main()

package/CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-**diff-grok** is a zero-dependency TypeScript library for solving initial value problems (IVPs) for ordinary differential equations (ODEs), focused on stiff equations. It implements Rosenbrock-Wanner type numerical methods and includes a declarative model scripting system.
+**diff-grok** is a zero-dependency TypeScript library for solving initial value problems (IVPs) for ordinary differential equations (ODEs), focused on stiff equations. It implements Rosenbrock-Wanner type numerical methods, a port of SUNDIALS CVODE, and includes a declarative model scripting system.
 
 ## Build & Development Commands
 
@@ -31,9 +31,12 @@ npx jest src/tests/correctness.test.ts
   - **Implicit methods** (for stiff ODEs): `mrt` (Modified Rosenbrock Triple), `ros3prw`, `ros34prw`
     - Require Jacobian computation and linear system solves
     - Use LU decomposition for solving W*k = b at each stage
-  - **Automatic methods** (stiffness-detecting): `lsoda` (variable-order Nordsieck Adams/BDF with automatic switching)
+  - **Automatic methods** (stiffness-detecting): `lsoda` (variable-order Nordsieck Adams/BDF with automatic switching), `cvode` (SUNDIALS CVODE variable-order Adams/BDF)
     - Automatically switch between non-stiff (Adams) and stiff (BDF) modes
-    - Use consecutive rejection counting (Adams→BDF) and periodic trial steps (BDF→Adams)
+    - `lsoda`: consecutive rejection counting (Adams→BDF) and periodic trial steps (BDF→Adams)
+    - `cvode`: TypeScript port of SUNDIALS CVODE v7.5.0; variable-order variable-step with Newton iteration + dense LU; supports rootfinding and dense output (`getDky`); wrapper uses BDF mode with warmup for extremely stiff problems
+    - CVODE module in `src/solver-tools/cvode/` (12 files): `cvode.ts` (main loop), `cvode_class.ts` (high-level `Cvode` class), `cvode_adams.ts`/`cvode_bdf.ts` (method coefficients), `cvode_nls.ts` (Newton solver), `cvode_ls.ts` (linear solver), `cvode_hin.ts` (initial step estimation), `cvode_root.ts` (rootfinding), `cvode_io.ts` (config/stats), `dense_linalg.ts` (LU), `common.ts` (types/constants)
+    - CVODE standard interface wrapper in `src/solver-tools/cvode-method.ts`
   - **Explicit methods** (for non-stiff ODEs): `rk3` (Bogacki-Shampine 3(2)), `rk4` (Runge-Kutta-Fehlberg 4(5)), `ab5` (Adams-Bashforth-Moulton 5), `ab4` (Adams-Bashforth-Moulton 4), `rkdp` (Dormand-Prince 5(4))
     - Only require function evaluations (no Jacobian)
     - Include `hMax` constraint to prevent poor interpolation
@@ -61,7 +64,7 @@ npx jest src/tests/correctness.test.ts
 ### Data Flow
 
 1. Define problem as `ODEs` object (programmatic) or parse model string via `getIVP()`
-2. Call solver method (`mrt`/`ros3prw`/`ros34prw`/`rk3`/`rk4`/`ab5`/`ab4`/`rkdp`/`lsoda`) → returns `Float64Array[]` (argument values + solution columns)
+2. Call solver method (`mrt`/`ros3prw`/`ros34prw`/`rk3`/`rk4`/`ab5`/`ab4`/`rkdp`/`lsoda`/`cvode`) → returns `Float64Array[]` (argument values + solution columns)
 3. For complex models: create pipeline via `getPipelineCreator()` → `applyPipeline()`
 
 ### Performance Patterns
@@ -86,6 +89,9 @@ Tests are in `src/tests/` using Jest with ts-jest:
 - `performance.test.ts` — Benchmarks solver speed on stiff problems (timeout: 10,000ms)
   - Tests implicit and automatic methods (MRT, ROS3PRw, ROS34PRw, LSODA)
   - Test problems: Robertson, HIRES, VDPOL, OREGO, E5, Pollution
+- `cvode-lib-correctness.test.ts` — CVODE-specific validation (low-level procedural API + high-level `Cvode` class)
+  - Robertson kinetics, non-stiff (Adams) and stiff (BDF) problems, rootfinding, dense output, error handling, re-initialization
+- `cvode-lib-performance.test.ts` — CVODE benchmarks on stiff problems (Robertson, HIRES, VDPOL, OREGO, E5, Pollution)
 - `pipeline.test.ts` — Pipeline integration tests (3 model types)
 - Method definitions in `test-defs.ts`: `methods` map (all 11 solvers), `implicitMethods` map (stiff-capable only)
 

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Datagrok
+Copyright (c) 2026 Datagrok
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.MD

@@ -6,7 +6,7 @@
 [![Build Status](https://github.com/datagrok-ai/diff-grok/actions/workflows/libraries.yaml/badge.svg)](https://github.com/datagrok-ai/diff-grok/actions/workflows/libraries.yaml)
 [![Run tests](https://github.com/datagrok-ai/diff-grok/actions/workflows/test.yaml/badge.svg)](https://github.com/datagrok-ai/diff-grok/actions/workflows/test.yaml)
 
-A lightweight TypeScript library for solving initial value problem ([IVP](https://en.wikipedia.org/wiki/Initial_value_problem)) for ordinary differential equations ([ODEs](https://en.wikipedia.org/wiki/Ordinary_differential_equation)) using numerical methods. The primary solver is [LSODA](https://doi.org/10.1137/0904010) — a variable-order method that automatically detects stiffness and switches between Adams (non-stiff) and BDF (stiff) formulations.
+A lightweight TypeScript library for solving initial value problem ([IVP](https://en.wikipedia.org/wiki/Initial_value_problem)) for ordinary differential equations ([ODEs](https://en.wikipedia.org/wiki/Ordinary_differential_equation)) using numerical methods. The primary solvers are [LSODA](https://doi.org/10.1137/0904010) — a variable-order method that automatically detects stiffness and switches between Adams (non-stiff) and BDF (stiff) formulations — and [CVODE](https://sundials.readthedocs.io/en/latest/cvode/index.html) — a variable-order, variable-step solver from the SUNDIALS suite supporting both Adams and BDF methods.
 
 ## Features
 
@@ -14,6 +14,8 @@ A lightweight TypeScript library for solving initial value problem ([IVP](https:
 * Fast computations
 * Automatic stiffness-detecting method:
   * [LSODA](https://doi.org/10.1137/0904010) - variable-order Nordsieck-based solver with automatic switching between Adams (non-stiff) and BDF (stiff) methods ([Petzold, 1983](https://doi.org/10.1137/0904010); [Hindmarsh, 1983](https://computing.llnl.gov/sites/default/files/ODEPACK_pub1_u88007.pdf)). Ported to TypeScript from the C library [liblsoda](https://github.com/sdwfrost/liblsoda)
+* Variable-order multistep method:
+  * [CVODE](https://sundials.readthedocs.io/en/latest/cvode/index.html) - variable-order, variable-step solver from the [SUNDIALS](https://github.com/LLNL/sundials) suite with BDF (stiff) and Adams (non-stiff) modes ([Hindmarsh et al., 2005](https://doi.org/10.1145/1089014.1089020); [Cohen & Hindmarsh, 1996](https://doi.org/10.1063/1.4822377)). Ported to TypeScript from SUNDIALS CVODE v7.5.0
 * Implicit methods (for stiff ODEs) - Rosenbrock–Wanner type:
   * The modified Rosenbrock triple ([MRT](https://doi.org/10.1137/S1064827594276424))
   * The [ROS3PRw](https://doi.org/10.1016/j.cam.2015.03.010) method
@@ -45,20 +47,20 @@ Minimal "Hello World" example:
 ```typescript
 // example.ts
 
-import {ODEs, mrt} from 'diff-grok';
+import {ODEs, cvode} from 'diff-grok';
 
 const task: ODEs = {
   name: 'Example',
   arg: {name: 't', start: 0, finish: 1, step: 0.1},
-  initial: [1, -1],
+  initial: [1],
   func: (t: number, y: Float64Array, output: Float64Array) => {
-    out[0] = y[0] - t;
+    output[0] = y[0] - t;
   },
   tolerance: 1e-7,
   solutionColNames: ['y(t)'],
 };
 
-const solution = mrt(task);
+const solution = cvode(task);
 
 console.log('t:', solution[0]);
 console.log('y(t):', solution[1]);
@@ -80,6 +82,9 @@ on the segment $[t_0, t_1]$ with the step $h$:
    Automatic method:
    * `lsoda` - [LSODA](https://doi.org/10.1137/0904010) variable-order solver with automatic switching between Adams (non-stiff) and BDF (stiff)
 
+   Variable-order multistep method:
+   * `cvode` - [CVODE](https://sundials.readthedocs.io/en/latest/cvode/index.html) variable-order BDF solver from the SUNDIALS suite
+
    Implicit methods (for stiff ODEs):
    * `mrt` - the [MRT](https://doi.org/10.1137/S1064827594276424) method
    * `ros3prw`- the [ROS3PRw](https://doi.org/10.1016/j.cam.2015.03.010) method
@@ -196,27 +201,29 @@ The following [classic problems](https://archimede.uniba.it/~testset/testsetivps
   * describes a chemical reaction part of the air pollution model designed at The Dutch National Institute of Public Health and Environmental Protection
   * [pollution.ts](./src/examples/pollution.ts)
 
-The LSODA, MRT, ROS3PRw and ROS34PRw methods demonstrate the following time performance (AMD Ryzen 5 5600H 3.30 GHz CPU):
+The LSODA, CVODE, MRT, ROS3PRw and ROS34PRw methods demonstrate the following time performance (AMD Ryzen 5 5600H 3.30 GHz CPU):
+
+|Problem|Segment|Points|Tolerance|LSODA, ms|CVODE, ms|MRT, ms|ROS3PRw, ms|ROS34PRw, ms|
+|-|-|-|-|-|-|-|-|-|
+|[Rober](https://archimede.uniba.it/~testset/report/rober.pdf)|[0, 10E+11]|40K|1E-7|67|85|175|446|285|
+|[HIRES](https://archimede.uniba.it/~testset/report/hires.pdf)|[0, 321.8122]|32K|1E-10|125|142|122|362|215|
+|[VDPOL](https://archimede.uniba.it/~testset/report/vdpol.pdf)|[0, 2000]|20K|1E-12|268|352|492|1576|760|
+|[OREGO](https://archimede.uniba.it/~testset/report/orego.pdf)|[0, 360]|36K|1E-8|76|98|205|483|199|
+|[E5](https://archimede.uniba.it/~testset/report/e5.pdf)|[0, 10E+13]|40K|1E-6|7|*|6|17|8|
+|[Pollution](https://archimede.uniba.it/~testset/report/pollu.pdf)|[0, 60]|30K|1E-6|12|15|18|50|23|
 
-|Problem|Segment|Points|Tolerance|LSODA, ms|MRT, ms|ROS3PRw, ms|ROS34PRw, ms|
-|-|-|-|-|-|-|-|-|
-|[Rober](https://archimede.uniba.it/~testset/report/rober.pdf)|[0, 10E+11]|40K|1E-7|67|175|446|285|
-|[HIRES](https://archimede.uniba.it/~testset/report/hires.pdf)|[0, 321.8122]|32K|1E-10|125|122|362|215|
-|[VDPOL](https://archimede.uniba.it/~testset/report/vdpol.pdf)|[0, 2000]|20K|1E-12|268|492|1576|760|
-|[OREGO](https://archimede.uniba.it/~testset/report/orego.pdf)|[0, 360]|36K|1E-8|76|205|483|199|
-|[E5](https://archimede.uniba.it/~testset/report/e5.pdf)|[0, 10E+13]|40K|1E-6|7|6|17|8|
-|[Pollution](https://archimede.uniba.it/~testset/report/pollu.pdf)|[0, 60]|30K|1E-6|12|18|50|23|
+\* E5 is skipped for CVODE: the extremely stiff rate constants (spanning 20 orders of magnitude) cause convergence failures with the dense direct linear solver.
 
 Maximum absolute deviations (MADs) from the reference solutions obtained using SciPy (Radau) are summarized in the table below:
 
-|Problem|LSODA|MRT|ROS3PRw|ROS34PRw|
-|-|-|-|-|-|
-|[Rober](https://archimede.uniba.it/~testset/report/rober.pdf)|1.87e-8|1.87e-8|1.88e-8|1.88e-8|
-|[HIRES](https://archimede.uniba.it/~testset/report/hires.pdf)|1.51e-11|4.80e-11|1.05e-14|2.87e-14|
-|[VDPOL](https://archimede.uniba.it/~testset/report/vdpol.pdf)|5.12e-4|5.12e-4|5.12e-4|5.12e-4|
-|[OREGO](https://archimede.uniba.it/~testset/report/orego.pdf)|3.84e-6|3.05e-5|3.45e-7|2.31e-6|
-|[E5](https://archimede.uniba.it/~testset/report/e5.pdf)|3.02e-19|1.12e-19| 1.33e-19|3.40e-17|
-|[Pollution](https://archimede.uniba.it/~testset/report/pollu.pdf)|1.23e-10|4.06e-10|9.16e-12|1.58e-10|
+|Problem|LSODA|CVODE|MRT|ROS3PRw|ROS34PRw|
+|-|-|-|-|-|-|
+|[Rober](https://archimede.uniba.it/~testset/report/rober.pdf)|1.87e-8|1.87e-8|1.87e-8|1.88e-8|1.88e-8|
+|[HIRES](https://archimede.uniba.it/~testset/report/hires.pdf)|1.51e-11|2.10e-11|4.80e-11|1.05e-14|2.87e-14|
+|[VDPOL](https://archimede.uniba.it/~testset/report/vdpol.pdf)|5.12e-4|5.12e-4|5.12e-4|5.12e-4|5.12e-4|
+|[OREGO](https://archimede.uniba.it/~testset/report/orego.pdf)|3.84e-6|5.20e-6|3.05e-5|3.45e-7|2.31e-6|
+|[E5](https://archimede.uniba.it/~testset/report/e5.pdf)|3.02e-19|*|1.12e-19| 1.33e-19|3.40e-17|
+|[Pollution](https://archimede.uniba.it/~testset/report/pollu.pdf)|1.23e-10|2.15e-10|4.06e-10|9.16e-12|1.58e-10|
 
 Run [check-methods.ts](./src/examples/check-methods.ts) to reproduce these results (see [here](#examples) how to run scripts standalone).
 
@@ -585,7 +592,7 @@ Diff Grok contains a set of examples located in the folder [src/examples](./src/
 
 |File|Features|
 |-|-|
-|[basic-use.ts](./src/examples/basic-use.ts)|Minimal "Hello World" example. Illustrates the use of the [LSODA](https://doi.org/10.1137/0904010) method.|
+|[basic-use.ts](./src/examples/basic-use.ts)|Minimal "Hello World" example. Illustrates the use of the [MRT](https://doi.org/10.1137/S1064827594276424) method.|
 |[check-methods.ts](./src/examples/check-methods.ts)| Checks the [performance](#performance) of numerical methods.|
 |[corr-probs.ts](./src/examples/corr-probs.ts)|Solves a set of problems with exact solutions and evaluate the deviation.|
 |[cyclic-model.ts](./src/examples/cyclic-model.ts)| Considers pharmacokinetic-pharmacodynamic (PK-PD) simulation and shows how to apply pipelines and cyclic models.|
@@ -640,6 +647,9 @@ node src/examples/basic-use.js
 * L. Petzold, "Automatic Selection of Methods for Solving Stiff and Nonstiff Systems of Ordinary Differential Equations," *SIAM J. Sci. Stat. Comput.*, 4(1), 136–148, 1983. [doi:10.1137/0904010](https://doi.org/10.1137/0904010)
 * A. C. Hindmarsh, "ODEPACK, A Systematized Collection of ODE Solvers," *Scientific Computing*, R. S. Stepleman et al. (eds.), North-Holland, Amsterdam, pp. 55–64, 1983. [link](https://computing.llnl.gov/sites/default/files/ODEPACK_pub1_u88007.pdf)
 * The LSODA solver is ported to TypeScript from the C library [liblsoda](https://github.com/sdwfrost/liblsoda)
+* A. C. Hindmarsh et al., "SUNDIALS: Suite of Nonlinear and Differential/Algebraic Equation Solvers," *ACM Trans. Math. Softw.*, 31(3), 363–396, 2005. [doi:10.1145/1089014.1089020](https://doi.org/10.1145/1089014.1089020)
+* S. D. Cohen and A. C. Hindmarsh, "CVODE, a Stiff/Nonstiff ODE Solver in C," *Computers in Physics*, 10(2), 138–143, 1996. [doi:10.1063/1.4822377](https://doi.org/10.1063/1.4822377)
+* The CVODE solver is ported to TypeScript from [SUNDIALS CVODE v7.5.0](https://github.com/LLNL/sundials)
 * T. Rang and L. Angermann, "New Rosenbrock W-Methods of Order 3 for Partial Differential Algebraic Equations of Index 1," *BIT Numer. Math.*, 45, 761–787, 2005. [doi:10.1007/s10543-005-0035-y](https://doi.org/10.1016/j.cam.2015.03.010)
 * E. Hairer and G. Wanner, *Solving Ordinary Differential Equations II: Stiff and Differential-Algebraic Problems*, Springer, 1996. [doi:10.1137/S1064827594276424](https://doi.org/10.1137/S1064827594276424)
 
@@ -648,3 +658,11 @@ node src/examples/basic-use.js
 We welcome contributions of all kinds - bug reports, feature requests, documentation updates, and pull requests.
 
 Before contributing, please read our [Contributing Guidelines](./CONTRIBUTING.md).
+
+## License
+
+This project is licensed under the [MIT License](./LICENSE).
+
+The LSODA solver is a TypeScript port of [liblsoda](https://github.com/sdwfrost/liblsoda).
+The CVODE solver is a TypeScript port of [SUNDIALS CVODE](https://github.com/LLNL/sundials).
+See [THIRD_PARTY_LICENSES](./THIRD_PARTY_LICENSES) for details on third-party code provenance.