Ordinary Differential Equation Calculator
Scalar first-order IVP y′=f(t,y) by Euler or classical RK4. rhs linear is y′=k y; poly is y′=p(t). Not rk45, not systems, not PDE, not CAS. Runs locally.
Enter values to calculate.
Live graph
Interactive plot
Trust summary CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance · all published methods
- Input interpretation
- Enter values to calculate.
- Result
- —
- Verified scope
- all published methods
- Assurance
- Core
- Declared partition coverage
- PASS · 7/7 declared partitions (exponential-range, shifted-time, scaled-results, numerical-range, euler, rk4, invalid-domain) · Matrix
- Numerical scope
- Relative 1e-8 comparison of y and exact against listed fixed-step references; not a whole-domain accuracy guarantee or a user-tolerance acceptance.
- Known limitations
- Core CVP does not include live graph, viewport, or pointer interaction.
- Model
- y(t1) of a scalar first-order IVP by Euler or RK4, with closed-form reference comparisons for linear and poly rhs, and an engine-linked Live graph of numerical y(t).
- Scope
- The Result Card includes an engine-linked Live graph of numerical y(t) using the same Overview / Focus template as Log (Overview window t0…t1; current point is published y(t1); same Euler/RK4 stepper as REST/MCP). Exact y(t1) is a reference when it differs. Not rk45, not systems, not PDE, not CAS.
- Verification
- Engine tested · Source checked · v1.1.1 · CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance · all published methods· View Manifest · CVP overview · Specification
- Versions
- Calculation 1.1.1 · CVP protocol 1.0.0-proposed · Evidence 2026-10-28.meta-metrics-v2
- Verification revision
- 2026-10-28.meta-metrics-v2 · 1/1 property · digest 1092bffa8354
- Legacy regression
- 9/9 tests · Production surface contract 5/5
- Trust layers
- Verification VERIFIED · Production CURRENT · Overall CVP state: VERIFIED under CVP 1.0.0-proposed
- Reference
- O1 model · O2 expected_values · O3 expected_values · O2 expected_values · O2 numerical_behavior
- Interfaces
- PASS · UI (SSR) / REST / MCP
- Supplemental domain review
- Not performed
- Named expert review
- Not performed
- CVP suite
- 141/141 golden · 2/2 CVP boundary · 17/17 invalid · 1/1 property · 2/2 metamorphic · 12/12 O3 · 8/8 cross-interface · 1/1 cross-calculator · 5/5 CVP contract · Manifest
- Sources
- ISO 80000-2:2019 Quantities and units — Mathematics
- CRC Standard Mathematical Tables — Euler and classical RK4
- Gilbert Strang, Calculus — 16.2 Differential Equations
- Evidence
- 3 legacy golden · 2 legacy boundary · legacy regression suite · 141/141 oracle-backed golden · 17/17 invalid · Artifact integrity PASS
- Semantic contract
- PASS
Full verification
Formulas
Core equations used by this calculator.
How to use
Choose method and rhs
Linear needs k (default 1). Poly needs coeffs. RK4 is fourth-order; Euler is first-order.
Enter y0, t0, t1, and n
t1 must differ from t0. Backward steps (t1 < t0) are allowed. The exact check is shown for linear and poly.
Example calculations
Common configurations with formula and result.
y′=y, y(0)=1 at t=1
rk4, n=40, k=1
y′=2t, y(0)=0 at t=1
poly coeffs 0,2
Ordinary Differential Equation calculator specification
Version 1.1.1 · Engine tested
- Engine tested 9/9 tests · Production surface contract 5/5
- Named expert review Not performed
- Calculation version 1.1.1
- Definition
- A scalar first-order initial-value problem y′=f(t,y), y(t0)=y0 is stepped to t1. This seed uses forward Euler or classical RK4. Linear rhs is y′=k y with exact y0 e^{k(t1−t0)}. Polynomial rhs is y′=p(t) with exact y0+∫p. Not a system, not second-order, not adaptive RK45, not a PDE, not a CAS.
- What it calculates
- y(t1) of a scalar first-order IVP by Euler or RK4, with closed-form reference comparisons for linear and poly rhs, and an engine-linked Live graph of numerical y(t).
- Inputs
- method
- rhs
- y0
- t0
- t1
- n?
- k?
- coeffs?
- Outputs
- y
- closed-form reference
- signed/absolute/relative difference
- step stability and warnings
- h
- n
- Formula
Euler / classical RK4- Assumptions
- The Result Card includes an engine-linked Live graph of numerical y(t) using the same Overview / Focus template as Log (Overview window t0…t1; current point is published y(t1); same Euler/RK4 stepper as REST/MCP). Exact y(t1) is a reference when it differs. Not rk45, not systems, not PDE, not CAS.
- Scalar first-order only
- Polynomial quadrature and baseline use exact dyadic intermediates over binary64 inputs and actual representable time nodes; output remains binary64, not symbolic.
- y, exact and signed difference publish12 significant digits; model inputs and h retain binary64 precision. The graph is sampled to at most257 points, not a complete trajectory export.
- Polynomial degree ≤ 8
- Units
- dimensionless
- Boundary conditions
- Use finite decimal numbers/text; explicit empty fields and modes do not default, aliases must agree, nonzero decimal underflow is rejected.
- n must be an integer in 1–10000; fractional steps and unrelated input fields are rejected.
- diagnostics reports signed/absolute/relative difference from the closed-form reference and step stability; accuracy_status=not_assessed is not a tolerance pass.
- Unrepresentable time grid, zero/nonfinite h, nonfinite step/reference/error or nonzero analytic underflow → NUMERICAL_RANGE_ERROR
- t1 = t0 → INVALID_INPUT
- n < 1 or n > 10000 → INVALID_INPUT
- unknown method (including rk45) → INVALID_MODE
- Example
- rk4 linear k=1 y0=1 t0=0 t1=1 n=40 → exact=e
- Validation cases
2 published on this page · 9/9 tests · Production surface contract 5/5 · View evidence
- method=rk4 rhs=linear k=1 y0=1 t0=0 t1=1 n=40 → exact=e
- method=rk45 rhs=linear y0=1 t0=0 t1=1 → INVALID_MODE
- Sources
- ISO 80000-2:2019 Quantities and units — MathematicsSupports: Mathematical symbols and notation. This standard is not numerical verification or an endorsement of this implementation.
- CRC Standard Mathematical Tables — Euler and classical RK4Supports: Forward Euler y ← y+h f; classical RK4 four-stage step; exact y0 e^{kΔt} for y′=ky
- Gilbert Strang, Calculus — 16.2 Differential Equations — Section 16.2, Numerical Methods (PDF page 13)Supports: Forward Euler and classical four-stage fourth-order Runge–Kutta for first-order initial-value problems, together with step-size accuracy and stability discussion. Mathematical reference only; not validation or endorsement of this implementation.
- ISO 80000-2:2019 Quantities and units — Mathematics
- Calculation version
- 1.1.1
Background
Interpretation and common distinctions.
What does this ordinary differential equation calculator compute?
A scalar first-order initial-value problem y′=f(t,y), y(t0)=y0 is stepped to t1. This calculator uses forward Euler or classical RK4. Linear rhs is y′=k y with exact y0 e^{k(t1−t0)}. Polynomial rhs is y′=p(t) with exact y0+∫p.
The published formula or method is Euler / classical RK4. The following references support the stated mathematics or method:
- Gilbert Strang, Calculus — 16.2 Differential Equations: Forward Euler and classical four-stage fourth-order Runge–Kutta for first-order initial-value problems, together with step-size accuracy and stability discussion. Mathematical reference only; not validation or endorsement of this implementation.
Which inputs and limits should you check?
Step size and stability matter. Successful integration is not a blanket accuracy guarantee; retain the method, step count, diagnostics, and complete trajectory.
The worked example uses rk4, n=40, k=1 with y = e. Compare it with the Example calculations and the complete result for the same inputs.
How can you verify and cite this result?
CalculatorX is responsible for this page. The mathematical references above explain the model; implementation checks and their scope are documented separately in the math.numerical.ode v1.1.1 Evidence and capability contract. Read the displayed verification and production state together with the specification's numerical limits.
Use the clean calculator URL to cite the tool. A shared input link identifies a particular calculation. Content updates, numerical verification, and domain reviews have separate dates and scopes.
How are precision, sharing and exports handled?
Euler and classical RK4 complete the requested fixed step count; this is not an adaptive accuracy acceptance. Compare the numerical result with the closed-form reference and inspect stability warnings. abs_err is a legacy signed numerical-minus-reference difference before12-digit publication rounding; diagnostics.absolute_error is its magnitude. Neither is a certified error bound. Inputs, coefficients and h retain binary64 precision; numerical and reference endpoints publish12 significant digits.
Polynomial degree0–8 is supported, with constant-first coefficients (a constant can be 2). Empty coefficient tokens are rejected. Exact dyadic intermediate evaluation and composite quadrature avoid polynomial cancellation and stage overflow; final endpoint/reference values must fit binary64. A nonzero polynomial endpoint/reference that projects to zero is refused. Linear fixed-step zero can occur through cancellation or underflow and is explicitly warned when the analytic reference is nonzero. The graph shows at most257 samples of the discrete trajectory; JSON/CSV contain the complete endpoint result, model inputs, diagnostics and warnings, not every step.
Ordinary editing computes locally. Opening a share URL sends its query inputs to the server, and inputs may appear in server or third-party logs. REST/MCP send inputs to the server. CSV/JSON downloads and clipboard actions are explicit; local calculation history may store results on this device. Clear removes the current form values; use the history controls to remove retained history. REST/MCP version pins request the supported current calculation contract. Ordinary page links restore inputs into the current engine and show a notice when the linked version differs; neither path provides a historical engine service.
Related tools
Other calculators in this family: Brent Method Calculator, Definite Integral Calculator, Euler Method Calculator, Gauss Quadrature Calculator, Golden Section Search Calculator, Nonlinear Equation Calculator, Numerical Derivative Calculator, Numerical Interpolation Calculator . Explore all Numerical Calculus.
Frequently asked questions
Key distinctions behind the calculation.
Does this solve systems, second-order, or adaptive RK45?
No. This seed is a scalar first-order IVP with euler or rk4. Systems, second-order, rk45, and PDE are INVALID_MODE.
Where does this run?
Locally in the browser by default. REST and MCP call the same ordinary-differential-equation engine. /euler-method and /runge-kutta are discovery URLs, not a second engine.