HomeCalculatorsMathNumerical CalculusOrdinary Differential Equation Calculator
Math calculator

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.

Instant result
Result
—

Enter values to calculate.

Inputs—
Mode—
Formula—
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.0 · CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance · all published methods· View Manifest · CVP overview · Specification
Versions
Calculation 1.1.0 · CVP protocol 1.0.0-proposed · Evidence 2026-10-13.ode-machine-contract-decimal-v3
Verification revision
2026-10-13.ode-machine-contract-decimal-v3 · 1/1 property · digest 1db1ab47c2db
Legacy regression
9/9 tests · Production surface contract 6/6
Trust layers
Verification VERIFIED · Production CURRENT · Overall CVP state: VERIFIED under CVP 1.0.0-proposed
Reference
O1 model · O3 expected_values · O2 expected_values · O2 numerical_behavior
Interfaces
PASS · UI (SSR) / REST / MCP — ui-ssr is query-result HTML, not a live browser session. Error-path engine·REST·MCP 2/2 (status, code, calculation_version). SSR compared on URL-canonical requested calculations; empty query is idle (not an error) and JSON-typed object/array inputs are REST/MCP-only.
Supplemental domain review
Not performed
Named expert review
Not performed
CVP suite
39/39 golden · 2/2 CVP boundary · 17/17 invalid · 1/1 property · 12/12 O3 · 8/8 cross-interface · 1/1 cross-calculator · 6/6 CVP contract · Manifest
Sources
Sources
Evidence
3 legacy golden · 2 legacy boundary · legacy regression suite · 39/39 oracle-backed golden · 17/17 invalid · Artifact integrity PASS
This calculator CURRENT · Public schema 1.1.0 matches · Semantic contract ✓ · Production attested · Public/cache ✓ · Origin ✓
Semantic contract
PASS
Full verification

Manifest identity, reference classes, interfaces, suite, and production records.

Formulas

Core equations used by this calculator.

Eulery ← y + h f(t,y)
RK4y ← y + (h/6)(k1+2k2+2k3+k4)
iDefault n = 20 steps, max 10 000. Polynomial coefficients are constant-first. Discovery /euler-method and /runge-kutta lock the method.

How to use

1

Choose method and rhs

Linear needs k (default 1). Poly needs coeffs. RK4 is fourth-order; Euler is first-order.

2

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 = e
2.718…
ϟ

y′=2t, y(0)=0 at t=1

poly coeffs 0,2

y = 1
1

Ordinary Differential Equation calculator specification

Version 1.1.0 · Engine tested

Calculation status

Review policy · Evidence

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 degree ≤ 8
Units
  • dimensionless
Boundary conditions
  • 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 6/6 · 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 — Mathematics
    Supports: Mathematical symbols and notation. This standard is not numerical verification or an endorsement of this implementation.
  • CRC Standard Mathematical Tables — Euler and classical RK4
    Supports: 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.
Calculation version
1.1.0

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.0 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.

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.

→ Brent Method Calculator Brent’s method (golden section plus inverse parabolic interpolation) for a minimum of a polynomial, sin, or exp on [a, b]. Same engine as One-Dimensional Optimization. Not root-finding Brent. Runs locally. › → Definite Integral Calculator Composite trapezoid, Simpson 1/3, or Gauss–Legendre of a polynomial, sin, or exp on [a, b]. Not indefinite symbolic integrate. Runs locally. › → Euler Method Calculator Forward Euler for a scalar first-order IVP y′=f(t,y). Same engine as Ordinary Differential Equation. Not RK4, not rk45, not a system. Runs locally. › → Gauss Quadrature Calculator n-point Gauss–Legendre quadrature of a polynomial, sin, or exp on [a, b]. Same engine as Definite Integral. Not indefinite CAS. Runs locally. › → Golden Section Search Calculator Golden-section search for a minimum of a polynomial, sin, or exp on [a, b]. Same engine as One-Dimensional Optimization. Not Brent, not multivariate. Runs locally. › → Nonlinear Equation Calculator Find one approximate real zero of a polynomial or sin x with Newton, bisection, or secant. Uses the Numerical Root engine. Runs locally. › → Numerical Derivative Calculator Finite-difference derivative of a polynomial, sin, or exp, plus a numeric two-sided limit. Central, forward, backward, or limit. Discovery /two-sided-limit. Not symbolic d/dx. Runs locally. › → Numerical Interpolation Calculator Piecewise-linear, Lagrange, or natural cubic spline of tabulated (x, y). Not regression, not CAS. Runs locally. ›

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.