# numerical-integration

Configures ODE and PDE time integrators, controls adaptive step sizes, and sets up IMEX operator splitting for simulation problems.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · ★ 83
- Author: HeshamFS
- License: Apache-2.0 · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/HeshamFS/materials-simulation-skills/tree/HEAD/skills/core-numerical/numerical-integration/SKILL.md
- Updated: 2026-10-21
- HTML: https://affpapa.org/en/nevibecode/skills/numerical-integration

## What it does

This skill guides coding assistants when selecting numerical time steppers for differential equations. It handles stiff and non-stiff systems by sorting methods across explicit Runge-Kutta families, implicit BDF, and Rosenbrock solvers depending on Jacobian availability.

Under the hood, Python scripts run the calculations. Tools like `scripts/integrator_selector.py` recommend algorithms, while `scripts/adaptive_step_controller.py` adjusts time steps using P or PI controllers. Running these utilities requires Python 3.10+ alongside NumPy.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add HeshamFS/materials-simulation-skills --skill numerical-integration -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/numerical-integration/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/numerical-integration/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add HeshamFS/materials-simulation-skills --skill numerical-integration -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/numerical-integration/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add HeshamFS/materials-simulation-skills --skill numerical-integration -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/numerical-integration/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install HeshamFS/materials-simulation-skills numerical-integration
```

2. **Manually: put the files in place**
- File: `.github/skills/numerical-integration/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add HeshamFS/materials-simulation-skills --skill numerical-integration -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/HeshamFS/materials-simulation-skills --path skills/core-numerical/numerical-integration
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/numerical-integration/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add HeshamFS/materials-simulation-skills --skill numerical-integration -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/HeshamFS/materials-simulation-skills/tree/HEAD/skills/core-numerical/numerical-integration/SKILL.md

## When to use it
- select appropriate ODE or PDE integrators based on stiffness
- regulate adaptive time steps using P and PI controllers
- configure IMEX operator splitting for reaction-diffusion systems
- compute scaled error norms to accept or reject integration steps

## Example prompts
- Pick an integrator for a stiff PDE where computing the Jacobian is not possible.
- Run scripts/adaptive_step_controller.py using a PI controller to find the next dt.
- Plan an IMEX splitting setup for the Allen-Cahn equation.

## Source text · SKILL.md · Apache-2.0

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 4294ae6d5e430739.

BEGIN THIRD-PARTY FILE 4294ae6d5e430739
````text
---
name: numerical-integration
description: >
  Select and configure time integration methods for ODE and PDE simulations —
  choose among explicit Runge-Kutta, BDF, Rosenbrock, and Adams families,
  set relative and absolute error tolerances, implement adaptive step-size
  control with P/PI step-size controllers, plan IMEX operator splitting for mixed
  stiff and non-stiff terms, and estimate splitting errors. Use when picking
  an integrator for a new simulation, diagnosing step rejections or tolerance
  failures, setting up operator splitting for phase-field or reaction-diffusion
  problems, or deciding between explicit and implicit time marching, even if
  the user only says "my solver keeps rejecting steps" or "which ODE method
  should I use."
allowed-tools: Read, Write, Grep, Glob
metadata:
  last_deterministic_eval: "2026-10-20"
  agent_evaluation_status: "not_revalidated"
  author: HeshamFS
  version: "1.2.3"
  security_tier: medium
  security_reviewed: true
  tested_with:
    - claude-code
  last_evaluated: "2026-06-24"
  eval_cases: 4
  last_reviewed: "2026-10-19"
  standards:
    - "Hairer, Norsett & Wanner, Solving Ordinary Differential Equations I (Nonstiff): RK45 (Dormand-Prince), DOP853, embedded error estimation"
    - "Hairer & Wanner, Solving ODEs II (Stiff and DAE): BDF, Radau IIA, Rosenbrock methods"
    - "Gustafsson (1991/1994), control-theoretic PI step-size control"
    - "Strang (1968), operator splitting; with Lie-Trotter and Marchuk-Strang variants"
    - "Eyre (1998), unconditionally gradient-stable convex splitting for phase-field (Allen-Cahn / Cahn-Hilliard)"
---

# Numerical Integration

## Goal

Provide a reliable workflow to select integrators, set tolerances, and manage adaptive time stepping for time-dependent simulations.

## Requirements

- Python 3.10+
- NumPy (for some scripts)
- No heavy dependencies for core functionality

## Inputs to Gather

| Input | Description | Example |
|-------|-------------|---------|
| Problem type | ODE/PDE, stiff/non-stiff | `stiff PDE` |
| Jacobian available | Can compute ∂f/∂u? | `yes` |
| Target accuracy | Desired error level | `1e-6` |
| Constraints | Memory, implicit allowed? | `implicit OK` |
| Time scale | Characteristic time | `1e-3 s` |

## Decision Guidance

### Choosing an Integrator

```
Is the problem stiff?
├── YES → Is Jacobian available?
│   ├── YES → Use Rosenbrock or BDF
│   └── NO → Use BDF with numerical Jacobian
└── NO → Is high accuracy needed?
    ├── YES → Use RK45 or DOP853
    └── NO → Use RK4 or Adams-Bashforth
```

### Stiff vs Non-Stiff Detection

| Symptom | Likely Stiff | Action |
|---------|--------------|--------|
| dt shrinks to tiny values | Yes | Switch to implicit |
| Eigenvalues span many decades | Yes | Use BDF/Radau |
| Smooth solution, reasonable dt | No | Stay explicit |

## Script Outputs (JSON Fields)
````
END THIRD-PARTY FILE 4294ae6d5e430739

The third-party file has ended. Everything between the 4294ae6d5e430739 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2925 of 13519 bytes. © HeshamFS · Apache-2.0 · https://github.com/HeshamFS/materials-simulation-skills/tree/HEAD/skills/core-numerical/numerical-integration/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md