Developer Extension API

mutable struct CallbackCache{conditionType, signType}

Preallocated scratch buffers used by the continuous-callback machinery. It holds the condition values and crossing signs evaluated during a step plus the per-component event masks for vector callbacks, so that locating and applying continuous-callback events is allocation-free. Integrators construct one (sized via max_vector_callback_length) when a problem has continuous callbacks.

EvalFunc(f)

Callable wrapper used by DiffEqBase solve dispatch to pass an already-prepared function object through interfaces that expect a function-like value.

Fields

• f: Wrapped callable object.

OrdinaryDiffEqTag

Tag type used by DiffEqBase's no-recompile wrappers for OrdinaryDiffEq-family solver dispatch.

apply_callback!(integrator, callback, cb_time, prev_sign, event_idx)

Apply a continuous callback at the determined event time.

For ContinuousCallback, the affect! or affect_neg! function is called based on the crossing direction (prev_sign):

• prev_sign < 0 (upcrossing): callback.affect!(integrator) is called
• prev_sign > 0 (downcrossing): callback.affect_neg!(integrator) is called

For VectorContinuousCallback, callback.affect! is called once with a length-callback.len view into the simultaneous_events::Vector{Int8} buffer from the callback cache:

callback.affect!(integrator, simultaneous_events)

Each element of simultaneous_events encodes both whether the event triggered and its crossing direction:

• 0: event did not trigger
• +1: event triggered via upcrossing (condition went from negative to positive)
• -1: event triggered via downcrossing (condition went from positive to negative)

Multiple events may be nonzero simultaneously when they occur at the same time. The affect_neg! field is not called for VectorContinuousCallback; the user's affect! function should handle both crossing directions using the sign information.

apply_discrete_callback!(integrator, callback...)

Apply discrete callback(s) to integrator: for each DiscreteCallback whose condition is true at the current (u, t), run its affect! and handle any saveat/save bookkeeping. Returns whether the discrete-callback set modified the integrator and whether a save was performed inside a callback, recursing over multiple callbacks while staying type-stable.

calculate_residuals(ũ, u₀, u₁, α, ρ, internalnorm, t)

Calculate element-wise residuals

\[\frac{ũ}{α+\max{|u₀|,|u₁|}*ρ}\]

calculate_residuals(E₁, E₂, u₀, u₁, α, ρ, δ, scalarnorm, t)

Return element-wise residuals

\[\frac{δ E₁ + E₂}{α+\max{scalarnorm(u₀),scalarnorm(u₁)}*ρ}.\]

DiffEqBase.calculate_residuals!(out, ũ, u₀, u₁, α, ρ, thread = Serial())

Save element-wise residuals

\[\frac{ũ}{α+\max{|u₀|,|u₁|}*ρ}\]

in out.

The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = Serial(), default) or use multiple threads (thread = Threaded()) when Julia is started with multiple threads.

calculate_residuals!(out, u₀, u₁, α, ρ, thread = Serial())

Save element-wise residuals

\[\frac{u₁ - u₀}{α+\max{|u₀|,|u₁|}*ρ}\]

in out.

The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = Serial(), default) or use multiple threads (thread = Threaded()) when Julia is started with multiple threads.

calculate_residuals!(out, E₁, E₂, u₀, u₁, α, ρ, δ, scalarnorm, thread = Serial())

Calculate element-wise residuals

\[\frac{δ E₁ + E₂}{α+\max{scalarnorm(u₀),scalarnorm(u₁)}*ρ}.\]

The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = Serial(), default) or use multiple threads (thread = Threaded()) when Julia is started with multiple threads.

check_prob_alg_pairing(prob, alg) -> nothing

Validate that alg is compatible with the problem type prob.

The check catches common dispatch mistakes before solver construction, including ODE algorithms passed to non-ODE problems, direct AD with algorithms that are not AD-compatible, and SDE noise-size mismatches.

Throws

• ProblemSolverPairingError: If the problem and algorithm families do not match.
• DirectAutodiffError: If the initial condition uses dual numbers but alg is not autodifferentiable.
• NoiseSizeIncompatibilityError: If SDE noise dimensions are inconsistent.

default_factorize(A)

Factorize matrix A for out-of-place stiff solver paths.

The default implementation uses unchecked LU factorization and is intended as a solver-author extension hook.

finalize!(cb::CallbackSet, u, t, integrator::DEIntegrator)

Recursively apply finalize! and return whether any modified u

find_callback_time(integrator, callback, callback_idx)

Locate, within the current step, the time at which a single continuous callback's event occurs. Returns the event time together with the crossing sign, whether an event occurred, and the relevant event indices; for a VectorContinuousCallback it also records the per-component event mask. The event time is found by rootfinding on the callback condition.

find_first_continuous_callback(integrator, callbacks...)

Scan the given continuous callbacks and return the bookkeeping for the one whose event fires earliest in the current step: the event time, crossing sign, whether an event occurred, the (vector-callback) event index, the identified callback index, and the number of callbacks. A generated method keeps the result type-stable for an arbitrary number of callbacks.

get_condition(integrator, callback, abst)

Evaluate a continuous callback's condition function for integrator at the absolute time abst, interpolating the state when abst != integrator.t and respecting the callback's idxs/cache so the evaluation is allocation-free where possible. Used by the rootfinding that locates continuous-callback event times.

get_tstops(integrator) -> Any

Return the timestep-stop data structure owned by integrator.

Integrator implementations specialize this accessor so callback and jump-process machinery can inspect pending tstops without depending on integrator fields.

get_tstops_array(integrator) -> AbstractVector

Return the array-like storage containing pending timestep stops for integrator.

get_tstops_max(integrator)

Return the largest pending timestep stop for integrator.

initialize!(cb::CallbackSet, u, t, integrator::DEIntegrator)

Recursively apply initialize! and return whether any modified u

max_vector_callback_length(cs::CallbackSet)

Return the VectorContinuousCallback in the callback set cs with the largest len, or nothing if the set contains none. Integrators use this to size the per-step CallbackCache buffers large enough for every vector callback.

max_vector_callback_length_int(cs::CallbackSet)
max_vector_callback_length_int(callbacks...)

Return the largest len among vector continuous callbacks.

Returns nothing when no vector continuous callback is present.

merge_problem_kwargs(prob; merge_callbacks=true, kwargs…)

Merges kwargs stored in prob.kwargs with the provided kwargs, following DiffEq's standard merging rules:

• Problem kwargs are merged first
• Passed kwargs take precedence (i.e., they override problem kwargs)
• If merge_callbacks=true and both prob and kwargs have callbacks, they are merged into a CallbackSet rather than one overriding the other

Returns the merged kwargs as a Base.pairs.

This function is intended for use by problem types that override __solve or __init and need to manually handle kwargs merging that would normally be done by solve_call or init_call.

prepare_alg(alg, u0, p, prob) -> alg

Return the algorithm object used for a solve after problem-dependent preparation.

This fallback returns alg unchanged. Solver packages specialize it when an algorithm needs to inspect the initial condition, parameters, or problem before dispatch reaches solve.

prob2dtmin(prob; use_end_time = true)
prob2dtmin(tspan, onet, use_end_time)

Compute the default minimum timestep implied by a problem or time span.

Arguments

• prob: Differential-equation problem with a tspan field.
• tspan: Tuple-like time span.
• onet: Unit step value used to preserve units for non-floating time types.
• use_end_time: Whether the end of the time span contributes to the floating point spacing calculation.

Returns

• A nonnegative minimum timestep with units compatible with the time span.

stripunits(x)

Return x with only its unit wrapper removed.

The default method returns x unchanged. Unitful extension packages specialize this function while preserving AD and uncertainty wrappers.

timedepentdtmin(integrator)
timedepentdtmin(t, dtmin)

Return the time-dependent minimum timestep at the current time.

Floating-point times are bounded below by machine spacing at t; other time types use abs(dtmin).

@tight_loop_macros loop_expr

Apply the DiffEqBase loop policy to loop_expr. Solver packages use this macro around scalar stage loops so DiffEqBase can select common loop annotations without duplicating them in every solver implementation.

Arguments

• loop_expr: loop expression to emit in the caller's scope, normally a for loop over state indices.

Returns

The escaped loop expression with the current DiffEqBase loop policy applied. The current policy preserves the expression unchanged; solver packages must not rely on that implementation detail.

Developer contract

The loop body must be valid under reordering and vectorization policies that a future DiffEqBase release may apply. Do not use the loop body for externally observable iteration ordering or cross-iteration dependencies. This is versioned solver-development API, not an application-facing loop macro.

Examples

using DiffEqBase: @tight_loop_macros

function add_one!(out, x)
    @tight_loop_macros for i in eachindex(out, x)
        @inbounds out[i] = x[i] + 1
    end
    return out
end

add_one!(zeros(2), [1.0, 2.0]) == [2.0, 3.0]

@OnDemandTableauExtract TableauType T
@OnDemandTableauExtract TableauType T T2

Construct TableauType from one or two scalar types and bind each field of the constructed tableau to a same-named local variable in the invocation scope. Solver implementations use this macro to expose coefficient fields to stage code without storing a runtime tableau object.

Arguments

• TableauType: concrete or parametric tableau type defined in the invoking module. Its field names determine the generated local bindings.
• T: scalar type passed as the first constructor argument.
• T2: optional scalar type passed as the second constructor argument, commonly used for time nodes.

Returns

An expression that constructs the tableau once and assigns every field value to a local variable with the corresponding field name.

Developer contract

TableauType must resolve in the invoking module and provide the selected constructor. Its field layout is part of the solver implementation using the macro. Invoke the macro inside a function before reading the generated names, and do not use those generated locals as application API.

Examples

using OrdinaryDiffEqCore: @OnDemandTableauExtract

struct ExampleTableau{T, T2}
    weight::T
    node::T2
end
ExampleTableau(::Type{T}, ::Type{T2}) where {T, T2} =
    ExampleTableau(one(T), convert(T2, 1 // 2))

function coefficients(T, T2)
    @OnDemandTableauExtract ExampleTableau T T2
    return weight, node
end

coefficients(Float64, Float64) == (1.0, 0.5)

@fold function_definition

Declare function_definition foldable using Base.@assume_effects :foldable. OrdinaryDiffEq solver packages use this macro for deterministic tableau and coefficient constructors that the compiler may evaluate at compile time.

Arguments

• function_definition: a function definition whose result depends only on its arguments and immutable global constants.

Returns

The escaped function definition wrapped in the Julia foldability annotation.

Developer contract

Only annotate functions that are deterministic, effect-free, and safe to evaluate or eliminate at compile time. Incorrect use can cause invalid compiler optimizations; functions that mutate external state, perform I/O, inspect mutable globals, or depend on task state must not use @fold.

Examples

using OrdinaryDiffEqCore: @fold

@fold function coefficient_pair(::Type{T}) where {T}
    return convert(T, 1 // 2), one(T)
end

coefficient_pair(Float64) == (0.5, 1.0)

OrdinaryDiffEqAlgorithm <: SciMLBase.AbstractODEAlgorithm

Abstract supertype of every ODE algorithm defined in the OrdinaryDiffEq.jl ecosystem. A solver sublibrary defines a concrete algorithm by subtyping one of the more specific abstract types below (adaptive / implicit / exponential / …) rather than this root directly. Trait functions such as isadaptive, isimplicit, isfsal, and alg_order dispatch on this hierarchy.

Extension contract

A solver subtype must provide an alg_cache method and matching initialize! and perform_step! methods. It should also define alg_order and override only the traits whose behavior differs from the defaults. The cache type must be either an OrdinaryDiffEqConstantCache or an OrdinaryDiffEqMutableCache.

Example

using OrdinaryDiffEqCore: OrdinaryDiffEqAlgorithm

struct MyEuler <: OrdinaryDiffEqAlgorithm end
OrdinaryDiffEqCore.alg_order(::MyEuler) = 1
OrdinaryDiffEqCore.isfsal(::MyEuler) = false

OrdinaryDiffEqAdaptiveAlgorithm <: OrdinaryDiffEqAlgorithm

Abstract supertype for explicit ODE algorithms that support adaptive step-size control (they carry an embedded error estimate). Subtyping this makes isadaptive return true.

An adaptive algorithm must also provide an error estimate in perform_step! and a controller-compatible alg_order. Use OrdinaryDiffEqAdaptiveImplicitAlgorithm instead when each step solves a nonlinear system.

Example

using OrdinaryDiffEqCore: OrdinaryDiffEqAdaptiveAlgorithm

struct MyAdaptive <: OrdinaryDiffEqAdaptiveAlgorithm end
OrdinaryDiffEqCore.alg_order(::MyAdaptive) = 4
@assert OrdinaryDiffEqCore.isadaptive(MyAdaptive())

OrdinaryDiffEqCompositeAlgorithm <: OrdinaryDiffEqAlgorithm

Abstract supertype for algorithms that dispatch between several sub-algorithms at runtime (see CompositeAlgorithm). Used by automatic stiffness switching and by the default solver.

OrdinaryDiffEqImplicitAlgorithm <: OrdinaryDiffEqAlgorithm

Abstract supertype for implicit ODE algorithms (those that solve a nonlinear system each step). Subtyping this makes isimplicit return true.

An implicit algorithm must provide the nonlinear-solver cache and stage methods expected by alg_cache, initialize!, and perform_step!. Its package should document the accepted nlsolve and linear-solver options and whether Jacobian reuse is supported by alg_can_repeat_jac.

Example

using OrdinaryDiffEqCore: OrdinaryDiffEqImplicitAlgorithm

struct MyImplicit <: OrdinaryDiffEqImplicitAlgorithm end
OrdinaryDiffEqCore.alg_order(::MyImplicit) = 2
@assert OrdinaryDiffEqCore.isimplicit(MyImplicit())

OrdinaryDiffEqAdaptiveImplicitAlgorithm <: OrdinaryDiffEqAdaptiveAlgorithm

Abstract supertype for implicit ODE algorithms with adaptive step-size control.

OrdinaryDiffEqNewtonAlgorithm <: OrdinaryDiffEqImplicitAlgorithm

Abstract supertype for fixed-step implicit algorithms whose implicit stages are solved with a (quasi-)Newton nonlinear solver (see AbstractNLSolver).

OrdinaryDiffEqNewtonAdaptiveAlgorithm <: OrdinaryDiffEqAdaptiveImplicitAlgorithm

Abstract supertype for adaptive implicit algorithms solved with a Newton nonlinear solver. Distinguished from OrdinaryDiffEqNewtonAlgorithm by supporting Jacobian reuse across steps (alg_can_repeat_jac is true).

OrdinaryDiffEqRosenbrockAlgorithm <: OrdinaryDiffEqImplicitAlgorithm

Abstract supertype for fixed-step Rosenbrock (and Rosenbrock-W) methods, which use the Jacobian directly through linear solves rather than a Newton iteration.

OrdinaryDiffEqRosenbrockAdaptiveAlgorithm <: OrdinaryDiffEqAdaptiveImplicitAlgorithm

Abstract supertype for adaptive Rosenbrock / Rosenbrock-W methods.

NewtonAlgorithm

Union of OrdinaryDiffEqNewtonAlgorithm and OrdinaryDiffEqNewtonAdaptiveAlgorithm, i.e. every implicit algorithm that drives its stages with a Newton nonlinear solver. Used as a dispatch handle for the Newton/W-matrix machinery.

RosenbrockAlgorithm

Union of OrdinaryDiffEqRosenbrockAlgorithm and OrdinaryDiffEqRosenbrockAdaptiveAlgorithm, i.e. every Rosenbrock / Rosenbrock-W method.

OrdinaryDiffEqExponentialAlgorithm <: OrdinaryDiffEqAlgorithm

Abstract supertype for exponential integrators that evaluate matrix-function (e.g. exp, φ) actions of the (linearized) operator each step.

OrdinaryDiffEqAdaptiveExponentialAlgorithm <: OrdinaryDiffEqAdaptiveAlgorithm

Abstract supertype for exponential integrators with adaptive step-size control.

OrdinaryDiffEqLinearExponentialAlgorithm <: OrdinaryDiffEqExponentialAlgorithm

Abstract supertype for exponential integrators specialized to (semi)linear problems u' = A u (+ B(t)) where the operator action can be applied directly.

ExponentialAlgorithm

Union of OrdinaryDiffEqExponentialAlgorithm and OrdinaryDiffEqAdaptiveExponentialAlgorithm.

OrdinaryDiffEqAdamsVarOrderVarStepAlgorithm <: OrdinaryDiffEqAdaptiveAlgorithm

Abstract supertype for variable-order variable-step Adams (multistep) methods. For these algorithms the current order lives on the cache, so get_current_alg_order / get_current_adaptive_order read cache.order rather than a fixed algorithm order.

DAEAlgorithm <: SciMLBase.AbstractDAEAlgorithm

Abstract supertype for fully-implicit DAE algorithms (solving f(du, u, p, t) = 0), e.g. DFBDF, DImplicitEuler. Distinct from the mass-matrix DAE path, which reuses the ODE algorithm types with a singular mass matrix.

OrdinaryDiffEqPartitionedAlgorithm <: OrdinaryDiffEqAlgorithm

Abstract supertype for partitioned / dynamical-ODE algorithms (e.g. symplectic and Nyström methods) that split the state into position/velocity partitions.

OrdinaryDiffEqAdaptivePartitionedAlgorithm <: OrdinaryDiffEqAdaptiveAlgorithm

Abstract supertype for partitioned / dynamical-ODE algorithms with adaptive step-size control.

PartitionedAlgorithm

Union of OrdinaryDiffEqPartitionedAlgorithm and OrdinaryDiffEqAdaptivePartitionedAlgorithm.

OrdinaryDiffEqImplicitSecondOrderAlgorithm <: OrdinaryDiffEqImplicitAlgorithm

Abstract supertype for implicit second-order (dynamical) ODE algorithms.

OrdinaryDiffEqAdaptiveImplicitSecondOrderAlgorithm <: OrdinaryDiffEqAdaptiveImplicitAlgorithm

Abstract supertype for adaptive implicit second-order (dynamical) ODE algorithms.

ImplicitSecondOrderAlgorithm

Union of OrdinaryDiffEqImplicitSecondOrderAlgorithm and OrdinaryDiffEqAdaptiveImplicitSecondOrderAlgorithm.

StochasticDiffEqAlgorithm <: SciMLBase.AbstractSDEAlgorithm

Abstract supertype of every SDE algorithm in the StochasticDiffEq.jl ecosystem. Defined here in OrdinaryDiffEqCore so that the shared integrator machinery can dispatch on it.

StochasticDiffEqAdaptiveAlgorithm <: StochasticDiffEqAlgorithm

Abstract supertype for SDE algorithms supporting adaptive step-size control.

StochasticDiffEqCompositeAlgorithm <: StochasticDiffEqAlgorithm

Abstract supertype for composite (runtime-switching) SDE algorithms.

StochasticDiffEqNewtonAlgorithm <: StochasticDiffEqAlgorithm

Abstract supertype for fixed-step implicit SDE algorithms solved with a Newton nonlinear solver.

StochasticDiffEqNewtonAdaptiveAlgorithm <: StochasticDiffEqAdaptiveAlgorithm

Abstract supertype for adaptive implicit SDE algorithms solved with a Newton nonlinear solver.

StochasticDiffEqRODEAlgorithm <: SciMLBase.AbstractRODEAlgorithm

Abstract supertype for random ODE (RODE) algorithms.

StochasticDiffEqRODEAdaptiveAlgorithm <: StochasticDiffEqRODEAlgorithm

Abstract supertype for adaptive RODE algorithms.

StochasticDiffEqRODECompositeAlgorithm <: StochasticDiffEqRODEAlgorithm

Abstract supertype for composite (runtime-switching) RODE algorithms.

StochasticDiffEqJumpAlgorithm <: StochasticDiffEqAlgorithm

Abstract supertype for SDE algorithms that additionally integrate jump terms.

StochasticDiffEqJumpAdaptiveAlgorithm <: StochasticDiffEqAlgorithm

Abstract supertype for adaptive jump-SDE algorithms.

StochasticDiffEqJumpNewtonAdaptiveAlgorithm <: StochasticDiffEqJumpAdaptiveAlgorithm

Abstract supertype for adaptive implicit (Newton) jump-SDE algorithms.

StochasticDiffEqJumpDiffusionAlgorithm <: StochasticDiffEqAlgorithm

Abstract supertype for jump-diffusion algorithms.

StochasticDiffEqJumpDiffusionAdaptiveAlgorithm <: StochasticDiffEqAlgorithm

Abstract supertype for adaptive jump-diffusion algorithms.

StochasticDiffEqJumpNewtonDiffusionAdaptiveAlgorithm <: StochasticDiffEqJumpDiffusionAdaptiveAlgorithm

Abstract supertype for adaptive implicit (Newton) jump-diffusion algorithms.

CompositeAlgorithm(algs, choice_function)

A composite algorithm that chooses between multiple ODE solvers based on a user-defined choice function. This allows for adaptive algorithm switching based on problem characteristics or performance metrics.

Arguments

• algs: Tuple or array of ODE algorithms to choose from
• choice_function: Function that determines which algorithm to use at each step

The choice function receives the integrator and should return an index indicating which algorithm to use. This enables sophisticated algorithm switching strategies based on solution behavior, step size, or other criteria.

CompositeCache(caches, choice_function, current) <: OrdinaryDiffEqCache

Cache used by CompositeAlgorithm. Holds the tuple of sub-caches, the choice_function that selects the active algorithm, and the index current of the currently-active sub-cache.

Fields

• caches: Tuple of caches for the component algorithms.
• choice_function: Function selecting the active component algorithm.
• current: Index of the active component cache.

Developer API

This is a solver-developer extension type for shared composite-cache machinery. End-user code should call solve and use solution APIs, rather than construct CompositeCache values or access cache fields.

AutoSwitchCache

Mutable state backing a stiffness-based AutoSwitch choice function. It counts consecutive stiff/nonstiff step diagnostics (count, successive_switches), stores the two candidate algorithms (nonstiffalg/stiffalg), the switching thresholds (maxstiffstep/maxnonstiffstep, nonstifftol/stifftol), and which branch is currently active (is_stiffalg, current). Called on the integrator to return the index of the algorithm to use for the next step.

isautoswitch(alg) -> Bool

Return whether alg is a composite algorithm whose choice function is an AutoSwitch stiffness detector.

default_autoswitch(AS::AutoSwitchCache, integrator) -> Int

Choose, for the automatic default solver, the index of the algorithm to use next given the auto-switch state AS and the current integrator. Extended by the default-solver sublibrary; the generic method is only a stub.

unwrap_alg(integrator, is_stiff)
unwrap_alg(alg, is_stiff)

Return the concrete algorithm actually driving the current step. For a non-composite algorithm this is alg itself; for a CompositeAlgorithm it selects the active constituent based on the current cache index or, for a two-member auto-switch pair, on the is_stiff flag.

isdefaultalg(alg) -> Bool

Return whether alg is the automatic default algorithm wrapper. Used to route the stiffness auto-switching logic through its specialized default path.

is_composite_algorithm(alg) -> Bool

Return whether alg dispatches between several sub-algorithms at runtime.

Arguments

• alg: An algorithm instance.

Returns

true for an OrdinaryDiffEqCompositeAlgorithm, and false otherwise.

Rules

Sibling solver packages with their own composite-algorithm type must extend this trait to return true for that type.

is_composite_cache(cache) -> Bool

Return whether cache isa CompositeCache, i.e. whether it wraps several sub-caches for a composite algorithm.

Developer API

This inspection trait is for solver implementations extending composite-cache machinery. End-user code should call solve and use solution APIs, rather than inspect cache constructors or fields.

is_constant_cache(cache) -> Bool

Return whether cache is an out-of-place (OrdinaryDiffEqConstantCache) cache. For composite/default caches it reflects the active constituent cache.

Developer API

This inspection trait is for solver implementations extending cache machinery. End-user code should call solve and use solution APIs, rather than inspect cache constructors or fields.

alg_order(alg) -> Int

Return the order of accuracy of alg. Solver sublibraries define this for each concrete algorithm; for a CompositeAlgorithm it is the maximum over the constituent algorithms.

alg_maximum_order(alg) -> Int

Return the maximum order the algorithm can attain. Equal to alg_order for fixed-order methods; for composite algorithms it is the maximum over the constituents.

alg_adaptive_order(alg) -> Int

Return the order used for the adaptive error estimate of alg. The generic fallback is alg_order(alg) - 1; it is deliberately conservative because it tracks the realized error better than the embedded-estimate order.

alg_stability_size(alg) -> Real

Return the (real-axis) linear stability region size of alg, used by stabilized/auto-switching heuristics to decide whether an explicit method is stable for the current step. Solver sublibraries define it per algorithm.

alg_extrapolates(alg) -> Bool

Return whether alg needs an extrapolated initial guess for its implicit/predictor stage (false by default). Algorithms that do set this to true so the integrator computes uprev2/extrapolant state for them.

alg_can_repeat_jac(alg) -> Bool

Return whether alg may reuse a Jacobian/W factorization across steps rather than recomputing every step. true for adaptive Newton algorithms, false otherwise.

alg_autodiff(alg)

Return the automatic-differentiation choice (an ADTypes.jl AbstractADType) that alg uses to build Jacobians. Implicit-solver sublibraries define this for their algorithms; see also get_current_alg_autodiff for composite algorithms.

alg_difftype(alg)

Return the finite-difference type (e.g. Val{:forward}) configured on alg's AutoFiniteDiff autodiff choice, used when differentiating by finite differences.

isfsal(alg) -> Bool

Return whether alg is a FSAL ("first same as last") method, i.e. the last stage derivative of one step equals the first of the next so it can be reused. Explicit RK methods are FSAL by default (true); the integrator reuses fsallast as the next fsalfirst accordingly.

fsal_typeof(alg, rate_prototype)

Return the type used to store the FSAL derivative for alg given a rate_prototype. Defaults to typeof(rate_prototype); overridden by algorithms whose FSAL slot differs from the ordinary rate type.

isimplicit(alg) -> Bool

Return whether alg solves an implicit (nonlinear) system each step. false for explicit methods; true for implicit ones. For a CompositeAlgorithm it is true if any constituent is implicit.

isadaptive(alg) -> Bool

Return whether alg performs adaptive step-size control. true for algorithms subtyping an …Adaptive… abstract type, false otherwise.

isdtchangeable(alg) -> Bool

Return whether alg allows the step size dt to change between steps (true by default). Multistep-style methods that require a fixed grid set this to false.

ismultistep(alg) -> Bool

Return whether alg is a multistep method (uses solution history from more than the previous step). false by default.

dt_required(alg) -> Bool

Return whether alg requires the user to supply a dt (true by default). Only fully-adaptive or callback-driven algorithms may relax this.

uses_uprev(alg, adaptive::Bool) -> Bool

Return whether alg uses the previous step value uprev directly (as opposed to only via the FSAL history). true by default; used to decide whether the uprev cache slot must be maintained.

has_autodiff(alg) -> Bool

Return whether alg carries an autodiff field configuring Jacobian differentiation (false for explicit methods).

has_special_newton_error(alg) -> Bool

Return whether alg supplies its own Newton-iteration error estimate rather than the generic one (false by default).

has_dtnew_modification(alg) -> Bool

Return whether alg post-processes the controller's proposed dtnew via a dtnew_modification hook (false by default).

has_stiff_interpolation(alg) -> Bool

Return whether alg provides a special interpolant for its stiff branch (false by default).

allows_null_u0(alg) -> Bool

Return whether alg supports an empty (zero-length) initial condition u0 (false by default).

isaposteriori(alg) -> Bool

Return whether alg uses a-posteriori (rather than embedded) error estimation (false by default).

isdiscretealg(alg) -> Bool

Return whether alg is a discrete-time / map-iteration algorithm rather than a continuous ODE solver (false by default).

isdiscretecache(cache) -> Bool

Return whether cache belongs to a discrete-time / map-iteration algorithm rather than a continuous ODE solver (false by default). Companion to isdiscretealg.

isdp8(alg) -> Bool

Return whether alg is the DP8 method. Used to special-case its FSAL / dense handling (false by default).

isesdirk(alg) -> Bool

Return whether alg is an ESDIRK (explicit-first-stage singly-diagonally-implicit Runge–Kutta) method (false by default).

isfirk(alg) -> Bool

Return whether alg is a fully-implicit Runge–Kutta (FIRK) method (false by default).

isnewton(nlsolver) -> Bool

Return whether the nonlinear solver nlsolver is a Newton-type solver (as opposed to a fixed-point / functional iteration), which determines whether a W-matrix is formed and updated.

isWmethod(alg) -> Bool

Return whether alg is a W-method, i.e. it remains correct with an inexact (stale) Jacobian in its W matrix (false by default). Rosenbrock-W methods set this true.

is_mass_matrix_alg(alg) -> Bool

Return whether alg supports solving mass-matrix ODEs/DAEs M u' = f (false by default; true for Rosenbrock and appropriate Newton methods).

issplit(alg) -> Bool

Return whether alg treats the RHS as a split function (e.g. IMEX f = f1 + f2). false by default.

only_diagonal_mass_matrix(alg) -> Bool

Return whether alg only supports diagonal (not general) mass matrices (false by default). Used to decide FSAL reevaluation.

standardtag(alg) -> Bool

Return whether alg uses the standard ForwardDiff tagging (a custom tag type for Dual numbers) when building Jacobians. Used by the differentiation machinery to pick the AD config.

concrete_jac(alg)

Return the concrete_jac setting of alg: true/false forces whether a concrete Jacobian matrix is materialized, nothing lets the solver decide (e.g. based on the chosen linear solver).

fac_default_gamma(alg) -> Bool

Return whether the PredictiveController should apply the plain gamma safety factor without the Newton-iteration correction for alg (false by default; true for FIRK methods).

default_linear_interpolation(alg, prob) -> Bool

Return whether the solver should default to (cheaper) linear interpolation instead of the algorithm's Hermite/dense interpolant for alg on prob. true for DAEs, discrete problems, and RODE/SDE problems.

get_current_alg_order(alg, cache) -> Int

Return the order currently in effect for alg given its cache. Equal to alg_order for fixed-order methods; for variable-order methods (Adams/BDF) it reads the order stored on the cache.

get_current_adaptive_order(alg, cache) -> Int

Return the order used for the current step's adaptive error estimate given alg and its cache (order-aware analogue of alg_adaptive_order for variable-order methods).

get_current_alg_autodiff(alg, cache)

Return the autodiff choice active for the current step. Equals alg_autodiff(alg) for simple algorithms; for a CompositeAlgorithm it selects the currently-active constituent via cache.current.

get_chunksize(alg) -> Val

Return the ForwardDiff chunk size configured on alg's autodiff choice, as a Val. Val(0) means "let ForwardDiff choose".

_get_fdtype(AD)

Return the finite-difference type parameter (e.g. Val{:forward}) of an AutoFiniteDiff type/instance AD.

_get_fwd_chunksize(AD) -> Val

Return, as a Val, the ForwardDiff chunk size encoded in the AutoForwardDiff type/instance AD (Val(0) when unspecified).

_get_fwd_chunksize_int(AD) -> Int

Return the ForwardDiff chunk size encoded in the AutoForwardDiff type/instance AD as a plain Int (0 when unspecified).

_fixup_ad(ad, args...)

Internal helper that adjusts an autodiff choice ad to be consistent with the problem/solver context (e.g. disabling AD when it is not applicable). Returns the possibly-modified autodiff choice.

diffdir(integrator) -> Int

Return the finite-difference direction (+1 or -1) to use for time derivatives, chosen so the stencil stays inside the integration interval near an endpoint.

error_constant(integrator, order) -> Real

Return the leading error constant of the current method at the given order, used when scaling the local error estimate. Dispatches on integrator.alg.

constvalue(x)

Strip any ForwardDiff/unit wrapper from x (or a type T) down to its underlying numeric value, taking the real part for Complex so that a scalar constant can be compared/used unambiguously. Used e.g. for eigenvalue estimates.

unitfulvalue(x)

Return the unit-stripped numeric value of x (delegates to SciMLBase.unitfulvalue). Used where a bare number is needed from a possibly Unitful quantity.

COEFFICIENT_MULTISTEP

MethodType value for coefficient-form multistep (e.g. BDF) methods.

CompiledFloats

Union{Float32, Float64} — the floating-point element types for which the solvers provide fully precompiled specializations.

Convergence

NLStatus value (1) indicating the nonlinear solve converged.

DifferentialVarsUndefined

Sentinel returned by get_differential_vars when the differential vs algebraic split cannot be determined (the mass matrix is not diagonal). In that case dense output falls back to linear interpolation.

DIRK

MethodType value for diagonally-implicit Runge–Kutta stage systems.

Divergence

NLStatus value (-2) indicating the nonlinear iteration diverged.

FastConvergence

NLStatus value (2) indicating the nonlinear solve converged quickly.

GLM

MethodType value for general linear methods.

MethodType

@enum classifying how an implicit algorithm forms its W = M/(γΔt) - J matrix and stage system. One of DIRK, COEFFICIENT_MULTISTEP, NORDSIECK_MULTISTEP, or GLM. The nonlinear solver uses it to scale γW appropriately in OrdinaryDiffEqNonlinearSolve.nlsolve!.

NLStatus

@enum reporting the outcome/convergence quality of a nonlinear solve, ordered from best to worst: FastConvergence (2), Convergence (1), SlowConvergence (0), VerySlowConvergence (-1), Divergence (-2). A non-positive value means the solve failed (OrdinaryDiffEqNonlinearSolve.nlsolvefail).

NORDSIECK_MULTISTEP

MethodType value for Nordsieck-form multistep methods.

SlowConvergence

NLStatus value (0) indicating slow convergence. Also aliased as TryAgain.

TryAgain

Alias for SlowConvergence; a sentinel NLStatus signalling that the step should be retried (e.g. with a fresh Jacobian).

VerySlowConvergence

NLStatus value (-1) indicating very slow convergence; treated as a failure.

AbstractNLSolver{algType, iip}

Abstract supertype of the nonlinear solver object that implicit algorithms use to solve their implicit stage equations. Concrete subtypes (e.g. NLSolver in OrdinaryDiffEqNonlinearSolve) are built with OrdinaryDiffEqNonlinearSolve.build_nlsolver and driven with OrdinaryDiffEqNonlinearSolve.nlsolve!. The type parameters are the nonlinear-solver algorithm type and the in-place flag iip.

AbstractNLSolverAlgorithm

Abstract supertype of the algorithm objects that configure a nonlinear solver (e.g. NLNewton, NLFunctional, NLAnderson). Passed as the nlsolve keyword of an implicit algorithm and consumed internally by OrdinaryDiffEqNonlinearSolve.build_nlsolver.

AbstractNLSolverCache

Abstract supertype of the mutable cache held by an AbstractNLSolver, storing the W-matrix, factorizations, residual buffers, and per-iteration state.

nlsolve_f(f, alg)

Return the RHS function that the nonlinear solver should use for alg. For split problems (e.g. IMEX) this selects the implicit part f.f1; otherwise it returns f unchanged.

get_W(nlsolver)

Return the W = M/(γΔt) - J matrix (or its factorization) held by the nonlinear solver's cache.

set_new_W!(nlsolver, val::Bool) -> Bool

Set the flag recording whether a fresh W was just computed for this step and return val. Read via get_new_W! to decide whether to reset the Newton convergence estimate.

set_W_γdt!(nlsolver, W_γdt)

Store the γΔt value at which the current W was formed and return it. A change in γΔt beyond get_new_W_γdt_cutoff triggers a W refactorization.

get_new_W_γdt_cutoff(nlsolver)

Return the relative-change threshold on γΔt above which the nonlinear solver recomputes/refactorizes W rather than reusing the existing one.

isfirstcall(nlsolver) -> Bool

Return whether this is the first nonlinear solve of the current step (so a fresh W/initial guess is needed).

isfirststage(nlsolver) -> Bool

Return whether the nonlinear solver is on the first implicit stage of a multi-stage method (used to decide predictor/W reuse).

isJcurrent(nlsolver, integrator) -> Bool

Return whether the Jacobian stored on the solver is current for the present integrator state (so it need not be recomputed).

resize_J_W!(nlsolver, integrator, i)

Resize the Jacobian and W matrices held by nlsolver to length i after the state size changes (e.g. from a resize! callback). No-op fallback.

resize_nlsolver!(integrator, i)

Resize the nonlinear solver's internal buffers to state length i after the state size changes. No-op fallback.

default_nlsolve(alg, isinplace, u, initprob, autodiff = false, chunksize = Val(0))

Return the nonlinear solver to use for a DAE-initialization problem initprob. If alg is already a concrete nonlinear-solve algorithm it is returned as-is; otherwise a sensible default is constructed from the arguments.

build_nlsolver(alg, [nlalg,] u, uprev, p, t, dt, f, rate_prototype,
               uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits, γ, c, [α,]
               iip, verbose) -> AbstractNLSolver

Construct the nonlinear solver used by an implicit integrator algorithm.

Arguments

• alg: the implicit ODE, DAE, or stochastic integrator algorithm that owns the stage equation and differentiation configuration.
• nlalg: optional nonlinear-solver algorithm. When omitted, alg.nlsolve is used.
• u, uprev: current- and previous-state prototypes used to size solver workspaces.
• p, t, dt: problem parameters, initial time, and initial step size.
• f: the ODE or DAE function used by the implicit stage equation.
• rate_prototype: derivative prototype used to size rate workspaces.
• uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits: unitless scalar types chosen by the integrator cache constructor.
• γ, c: diagonal stage coefficient and stage abscissa.
• α: optional stage scaling; defaults to 1.
• iip: Val(true) for an in-place problem and Val(false) for an out-of-place problem.
• verbose: the integrator's differential-equation verbosity configuration.

Returns

An OrdinaryDiffEqCore.AbstractNLSolver. Its concrete type and cache are implementation details; solver packages should retain the returned object and operate on it through the documented nonlinear-solver interfaces. The factory may retain aliases to the supplied prototypes as solver-owned workspace.

Failure behavior

Unsupported nonlinear-solver algorithms fail by dispatch. A homotopy nonlinear solver requested for a DAE throws ArgumentError; failures from Jacobian, linear-solver, or inner nonlinear-solver initialization propagate to the caller.

Solver-author usage

Implicit algorithm cache constructors call this factory once with their real algorithm and problem prototypes, then pass the returned object to nlsolve! for each stage. For example, a DIRK cache constructor uses the form

nlsolver = build_nlsolver(
    alg, u, uprev, p, t, dt, f, rate_prototype,
    uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits,
    gamma, stage_abscissa, iip, verbose
)

nlsolve!(
    nlsolver::AbstractNLSolver, integrator, cache = nothing,
    repeat_step = false
)

Solve

\[dt⋅f(innertmp + γ⋅z, p, t + c⋅dt) + outertmp = z\]

where dt is the step size and γ and c are stage constants.

Arguments

• nlsolver: a solver returned by build_nlsolver, or another OrdinaryDiffEqCore.AbstractNLSolver implementation of this driver contract.
• integrator: the current differential-equation integrator.
• cache: the owning implicit algorithm's cache. Newton-type solvers require it for W updates; fixed-point solvers may leave it as nothing.
• repeat_step: whether this solve is retrying the same integrator step after a rejection.

Mutation and return value

The solve updates the nonlinear iterate, convergence estimate, status, failure counters, and solver workspace. It may update the integrator state while forming a new W, and its postamble updates integrator statistics and force_stepfail. The return value is the result of the solver's SciMLBase.postamble! method; the solvers constructed by build_nlsolver return the converged stage increment z.

Failure behavior

Non-convergence is recorded in the solver status rather than thrown: inspect it with nlsolvefail. A stale-Jacobian failure is retried once with a fresh Jacobian. Calling a Newton-type solver without cache throws ArgumentError, and exceptions raised by residual, Jacobian, or linear-solver evaluations propagate.

Extension contract

Custom nonlinear solvers extend compute_step! and initial_η, and provide the AbstractNLSolver state queried by the documented OrdinaryDiffEqCore nonlinear-solver hooks. Candidate acceptance and finalization are dispatched through OrdinaryDiffEqCore.apply_step! and SciMLBase.postamble!.

Whether innertmp and outertmp is used for the evaluation is controlled by setting nlsolver.method. In both cases the variable name is actually nlsolver.tmp.

nlsolvefail(nlsolver::AbstractNLSolver) -> Bool
nlsolvefail(status::NLStatus) -> Bool

Return whether a nonlinear solve failed.

Arguments

• nlsolver: a nonlinear solver whose current outcome is stored in its status property.
• status: an OrdinaryDiffEqCore.NLStatus to classify directly.

Returns

true for a non-positive status (SlowConvergence, VerySlowConvergence, or Divergence) and false for Convergence or FastConvergence. Sibling solver packages use this predicate after nlsolve! to decide whether to abandon the current integrator step.

markfirststage!(nlsolver::AbstractNLSolver) -> Nothing

Mark nlsolver as being on the first implicit stage of the current integrator step.

This mutates the solver's stage state when its algorithm tracks one and is a no-op otherwise. Predictor and W-reuse logic may query the marker through OrdinaryDiffEqCore.isfirststage. The marker is cleared by nlsolve!'s postamble after a solve.

du_alias_or_new(nlsolver::AbstractNLSolver, rate_prototype)

Return a derivative buffer compatible with rate_prototype.

Arguments

• nlsolver: the nonlinear solver that may already own a reusable derivative workspace.
• rate_prototype: the integrator's derivative prototype and the template for a newly allocated buffer.

Returns

The solver-owned derivative workspace when one is available; otherwise zero(rate_prototype). The returned object is mutable solver workspace when it aliases an existing buffer, so callers may use it while constructing their integrator cache but must not retain it beyond the nonlinear solver's lifetime.

can_smooth_est(nlsolver::AbstractNLSolver) -> Bool

Return whether nlsolver can reuse its current W linear solve for an implicit method's smoothed error estimate.

This capability query does not expose the nonlinear solver's cache or factorization representation. A solver-author caller must use the ordinary embedded estimate when this function returns false.

compute_step!(nlsolver, integrator[, γW]) -> residual_norm

Compute one candidate nonlinear iteration and return its scaled residual or increment norm.

Arguments

• nlsolver: the nonlinear solver whose candidate iterate and workspace are updated.
• integrator: the differential-equation integrator that supplies the current state, tolerances, right-hand side, and statistics.
• γW: the current γ * dt scaling for Newton-type methods. Fixed-point methods omit this argument.

Returns

A finite, nonnegative norm when a candidate iteration was computed. Returning a non-finite value reports divergence to nlsolve!. This function mutates the candidate iterate and its workspace and may update the integrator's nonlinear evaluation statistics. The shared driver calls OrdinaryDiffEqCore.apply_step! after accepting the candidate.

Solver packages that subtype OrdinaryDiffEqCore.AbstractNLSolver extend this function to participate in the shared nlsolve! convergence loop.

initial_η(nlsolver, integrator) -> η

Return the initial convergence-rate estimate η for a fresh nonlinear solve. Functional/Anderson solvers reuse the previous ηold; the Newton solver method derives it from the tolerance. The return value must be a finite nonnegative number compatible with the integrator tolerances.

Solver packages that define an OrdinaryDiffEqCore.AbstractNLSolver subtype extend this function when their initial estimate differs from the default tolerance-based rule. The function does not mutate the solver or integrator and is consumed by nlsolve!.

anderson(z, cache) -> accelerated_z

Return an Anderson-accelerated iterate for the fixed-point iteration z = g(z).

z is the current iterate and cache is the Anderson workspace initialized by the calling nonlinear solver. The function updates the workspace's iteration history but returns the accelerated state rather than mutating z. Solver packages that reuse this helper own the workspace's construction and lifetime; no concrete Anderson cache type is part of this API.

Linear-algebra failures while updating or solving the history least-squares system propagate to the caller.

anderson!(z, cache) -> Nothing

Update the current iterate z of the fixed-point iteration z = g(z) in place using Anderson acceleration.

cache is the Anderson workspace initialized by the calling nonlinear solver. Both z and the workspace history are mutated. Solver packages that reuse this helper own the workspace's construction and lifetime; no concrete Anderson cache type is part of this API. Linear-algebra failures propagate to the caller.

build_J_W(alg, u, uprev, p, t, dt, f, jac_config, ::Type{uEltypeNoUnits}, ::Val{iip}) -> (J, W)

Allocate and return the Jacobian J and the linear-system matrix W = M/(γΔt) - J (or their operator/factorization prototypes) for algorithm alg. Handles user-provided jac_prototype / W_prototypeSciMLOperators, the mass matrix M, and the linear vs nonlinear function case; the resulting W carries the eltype that calc_W/calc_W! will later produce. Val{iip} selects the in-place branch.

build_uf(alg, nf, t, p, ::Val{iip})

Return the wrapper object used to differentiate the RHS nf with respect to the state: a UJacobianWrapper for the in-place case (Val{true}) or a UDerivativeWrapper for the out-of-place case (Val{false}). Carries the current t and p, which are updated before each Jacobian evaluation.

build_jac_config(alg, f, uf, du1, uprev, u, tmp, du2)

Construct the differentiation configuration used to compute the state Jacobian of f via jacobian! (a DifferentiationInterface preparation, or nothing when the problem supplies its own jac/Wfact). For finite differencing it returns forward/backward-direction configs so diffdir can pick the in-domain stencil.

build_grad_config(alg, f, tf, du1, t)

Construct the differentiation configuration used to compute the time derivative ∂f/∂t (needed by Rosenbrock methods) via the tf time-gradient wrapper. Returns nothing when f provides an analytic tgrad; for finite differencing it returns forward/backward-direction configs.

calc_J(integrator, cache, next_step::Bool = false)

Return a new Jacobian object.

If integrator.f has a custom Jacobian update function, then it will be called. Otherwise, either automatic or finite differencing will be used depending on the uf object of the cache. If next_step, then it will evaluate the Jacobian at the next step.

calc_J!(J, integrator, cache, next_step::Bool = false) -> J

Update the Jacobian object J.

If integrator.f has a custom Jacobian update function, then it will be called. Otherwise, either automatic or finite differencing will be used depending on the cache. If next_step, then it will evaluate the Jacobian at the next step.

calc_tderivative(integrator, cache) -> dT

Out-of-place counterpart of calc_tderivative!: compute and return the time derivative ∂f/∂t at the current step.

calc_tderivative!(integrator, cache, dtd1, repeat_step)

Compute the time derivative dT = ∂f/∂t in place (using the analytic tgrad when available, else autodiff/finite differences) and store the Rosenbrock right-hand side linsolve_tmp = fsalfirst + dtd1·dT on the cache. Skipped when repeat_step is true.

calc_rosenbrock_differentiation(integrator, cache, dtgamma, repeat_step)

Non-mutating (OOP) version of calc_rosenbrock_differentiation!. Returns (dT, W) where dT is the time derivative and W is the factorized system matrix. Supports Jacobian reuse for W-methods via jac_reuse in the cache.

calc_rosenbrock_differentiation!(integrator, cache, dtd1, dtgamma, repeat_step) -> new_W

Compute (in place) the Jacobian, the factorized W = M/(dtgamma) - J, and the time derivative needed by a Rosenbrock step, honoring Jacobian reuse for W-methods. Returns whether a fresh W was formed. Skips the work on a repeated step.

jacobian!(J, f, x, fx, integrator, jac_config)

Compute the Jacobian of f at x into J in place, using the AD backend or finite differences configured in jac_config (respecting the finite-difference direction). fx is a preallocated RHS buffer. No-op for an empty state.

jacobian2W!(W, mass_matrix, dtgamma, J) -> nothing

Form the linear-system matrix W = M/dtgamma - J in place from the Jacobian J and mass matrix M (with M = I handled specially), using scalar-indexed, broadcast, or allocating paths depending on the array type (dense, sparse, GPU).

update_W!(integrator, cache, dtgamma, repeat_step, newJW = nothing)
update_W!(nlsolver, integrator, cache, dtgamma, repeat_step, newJW = nothing)

Recompute/refactorize the nonlinear solver's W = M/dtgamma - J when needed for a Newton solve, deciding whether the Jacobian and/or the factorization must be refreshed (newJW can force the decision). No-op for non-Newton solvers.

resize_jac_config!(cache, integrator)

Resize the Jacobian differentiation configuration on cache to match a changed state length (e.g. after a resize! callback), rebuilding the AD/finite-difference configs for the new size.

resize_grad_config!(cache, integrator)

Resize the time-derivative differentiation configuration on cache to match a changed state length.

dolinsolve(integrator, linsolve; A = nothing, linu = nothing, b = nothing, reltol = …) -> linres

Solve the linear system with the LinearSolve.jl cache linsolve, optionally resetting its matrix A, unknown linu, right-hand side b, and tolerance reltol (see set_linear_reltol!). Charges stats.nf for the Jacobian-vector products the solve applied (see drain_jvp_count!) and returns the LinearSolve result.

wrapprecs(linsolver, W, weight) -> linsolver

Attach a diagonal (weight-based) left/right preconditioner to linsolver when it supports precs and none was supplied, returning the reconfigured solver; otherwise return linsolver unchanged.

default_krylov_warm_start(linsolver) -> linsolver

Resolve a Krylov linear solver left at LinearSolve.WarmStart.Auto to the mode appropriate for a Newton-based integrator, LinearSolve.WarmStart.Hegedus (Hegedüs-scaled reuse of the previous solution — the recommended mode for the sequence of correlated preconditioned solves inside a Newton iteration).

Only the Auto default is resolved: an explicit WarmStart.None/Previous/ Hegedus or a non-Krylov solver is returned unchanged. This is called on the Newton nonlinear-solver path only; Rosenbrock/W-method integrators never call it, so their Auto solver stays a cold start (warm starting is unsafe there — no outer Newton iteration absorbs the within-tolerance stage-solve perturbation).

Warm starting the Newton path is only sound because LinearSolve discards a Hegedüs guess that cannot reduce the residual (SciML/LinearSolve.jl#1123). The guess is a previous Newton increment, and those converge to round-off; without that check the rescaling amplified last-ulp input differences by ~1e13 (SciML/OrdinaryDiffEq.jl#4034). The [compat] floor on LinearSolve is what guarantees the check is present.

is_always_new(alg) -> Bool

Return whether alg (or its nonlinear-solver algorithm) requests a fresh W computed on every solve, i.e. its always_new field is true (false when the field is absent).

islinearfunction(integrator) -> Tuple{Bool, Bool}

return the tuple (is_linear_wrt_odealg, islinearodefunction).

islinearfunction(f, alg) -> Tuple{Bool, Bool}

return the tuple (is_linear_wrt_odealg, islinearodefunction).

issuccess_W(W) -> Bool

Return whether the factorized system matrix W is nonsingular / the factorization succeeded. For a Factorization it forwards to LinearAlgebra.issuccess; for a scalar W it checks !iszero(W); otherwise it returns true.

drain_jvp_count!(integrator, alg, W) -> nothing

Add the Jacobian-vector products accumulated in W's JVP operator to integrator.stats.nf and reset the tally, so each product is counted once no matter how many Ws share the operator.

Nothing is counted when no JVPCache is involved: a W whose Jacobian is a concrete matrix or a user-supplied MatrixOperator applies a stored matrix and evaluates f zero times.

jvp_counter(W) -> JVPCache or nothing

The JVPCache whose products W applies, or nothing when W costs no RHS evaluations per product. A WOperator uses its jacvec when it has one and its J otherwise, which is what LinearAlgebra.mul! does with it.

set_linear_reltol!(linsolve, reltol) -> linsolve

Point the LinearSolve.jl cache linsolve at relative tolerance reltol.

SciMLBase.solve!(::LinearCache, alg; kwargs...) takes its tolerances from the cache and drops any handed to it as keywords, so solve!(linsolve; reltol) sets nothing and an iterative solve keeps running at LinearSolve's sqrt(eps) default however tight or loose the integrator is. LinearSolve.update_tolerances! is the entry point that does take effect.

Solvers that need a concrete A are left alone: a factorization has no tolerance to set and update_tolerances! throws for one. A non-scalar reltol (per-component tolerances) is left alone too — LinearCache holds a single scalar tolerance and the iterative solvers compare against a scalar bound.

OrdinaryDiffEqCache <: SciMLBase.DECache

Abstract supertype of every solver cache. A cache holds the per-solve scratch state (stage values, temporaries, tableau, nonlinear solver, …) associated with an algorithm. Concrete caches are built by alg_cache and subtype either OrdinaryDiffEqConstantCache or OrdinaryDiffEqMutableCache.

OrdinaryDiffEqConstantCache <: OrdinaryDiffEqCache

Abstract supertype for out-of-place ("constant") caches used when the state is immutable (e.g. Numbers, StaticArrays). These allocate fresh values each step instead of mutating in place. is_constant_cache returns true for them.

OrdinaryDiffEqMutableCache <: OrdinaryDiffEqCache

Abstract supertype for in-place ("mutable") caches used when the state is a mutable array. Their scratch fields are preallocated and reused each step.

StochasticDiffEqCache <: SciMLBase.DECache

Abstract supertype of every SDE/RODE solver cache. Analogue of OrdinaryDiffEqCache for the StochasticDiffEq.jl solvers; concrete caches subtype StochasticDiffEqConstantCache or StochasticDiffEqMutableCache.

StochasticDiffEqConstantCache <: StochasticDiffEqCache

Abstract supertype for out-of-place SDE/RODE caches (immutable state).

StochasticDiffEqMutableCache <: StochasticDiffEqCache

Abstract supertype for in-place SDE/RODE caches (preallocated, mutated in place).

DefaultCache <: OrdinaryDiffEqCache

Specialized composite cache used by the automatic default solver. It lazily holds up to six candidate sub-caches (cache1…cache6) constructed on demand from args, together with the choice_function and the current selected index, avoiding compilation of every candidate up front.

strip_cache(cache)

Return a lightweight copy of cache with all fields set to nothing, used by SciMLBase.strip_interpolation to drop the (potentially large) working buffers from a solution's interpolation object before serialization. Has a special path for DefaultCache.

Developer API

Solver extensions may specialize this hook for their cache types. End-user code should call solve and use solution APIs, rather than construct caches or depend on cache fields and their serialized representation.

@cache struct MyCache ... end

Macro used to define a mutable solver cache. It emits the given struct definition and additionally generates a full_cache(c::MyCache) method returning the tuple of its resizable buffer fields (those typed uType, rateType, kType, uNoUnitsType, or the du/dual_du of a DiffCacheType). That full_cache tuple is what the resize!/deleteat! integrator interface iterates over when the state length changes.

alg_cache(alg, u, rate_prototype, uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits, uprev, uprev2, f, t, dt, reltol, p, calck, ::Val{iip}, verbose)

Construct and return the internal solver cache for alg.

This is a developer extension point for solver packages. Each solver sublibrary defines a method for its algorithm type that allocates stage buffers, tableau data, nonlinear-solver state, and other per-solve scratch storage. The Val{iip} argument selects the in-place or out-of-place cache branch.

Examples

Solver packages extend alg_cache for their algorithm type:

import OrdinaryDiffEqCore: alg_cache

function alg_cache(
        alg::MyAlgorithm, u, rate_prototype, ::Type{uEltypeNoUnits},
        ::Type{uBottomEltypeNoUnits}, ::Type{tTypeNoUnits}, uprev, uprev2, f, t,
        dt, reltol, p, calck, ::Val{iip}, verbose
    ) where {
        uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits, iip,
    }
    return MyAlgorithmCache(u, rate_prototype)
end

get_fsalfirstlast(cache, u)

Return the (fsalfirst, fsallast) derivative buffers for cache, allocating zeros of the shape of u for constant caches. Used to set up FSAL storage when initializing the integrator.

get_fresh_jacobian(integrator, cache)

Return a Jacobian suitable for numerical-instability diagnostics. Cache-specific packages may specialize this hook when the stored Jacobian is unavailable or stale. Diagnostic evaluation must not increment solver work statistics.

IRI1 perform_step! implementation (constant cache, out-of-place)

This implements a drift-implicit weak order 2 stochastic Runge-Kutta method based on the RI1 scheme with theta-method implicitization of the drift.

IRI1 perform_step! implementation (mutable cache, in-place)

perform_step!(integrator, cache, repeat_step = false)

Advance the integrator by one step using algorithm cache, writing the proposed new state into integrator.u and the error estimate into integrator.EEst. This is the core routine each solver sublibrary implements for its cache type; repeat_step indicates the step is being retried after a rejection.

apply_step!(integrator)

Commit an accepted step: copy u into uprev, advance dt to the proposed step size (if allowed), refresh the FSAL derivative, shorten dt to the next tstop, and accept any noise process. Called by the integrator loop after a step is accepted.

check_error!(integrator)

Run check_error, store the resulting code in integrator.sol.retcode, and return that code.

When the code is not ReturnCode.Success, the common implementation also calls the solver's postamble! hook so pending bookkeeping and finalization are performed before the solve exits. A successful check updates the return code but does not finalize the integrator.

check_error(integrator)

Inspect integrator and return the ReturnCode that describes whether integration may continue.

The common implementation preserves an existing terminal return code and checks for a NaN step size, iteration limits, a step size at or below dtmin, a user-supplied instability predicate, and failed nonlinear steps. It does not mutate integrator.sol.retcode; use check_error! when the solution must be updated. Concrete integrators may specialize the checks while preserving the return-code contract.

Diagnostics for detected failures are emitted through report_integrator_failure, which the solver stack implements; this function only performs detection.

last_step_failed(integrator) -> Bool

Return whether the preceding attempted solver step failed to converge.

Concrete differential-equation integrators may specialize this hook when their step controller tracks a recoverable failed attempt. check_error uses it to convert a non-adaptive repeated failure into ReturnCode.ConvergenceFailure. The default is false.

Example

SciMLBase.last_step_failed(integrator::MyIntegrator) = integrator.last_step_failed

postamble!(integrator)

Finalize a differential-equation integrator after its solve loop terminates. Solver packages specialize this hook to perform final bookkeeping that must run on normal completion and on an error return. The default generic function has no method; an integrator implementation that requires finalization must provide one.

Example

function SciMLBase.postamble!(integrator::MyIntegrator)
    flush_pending_save!(integrator)
    return nothing
end

set_discontinuity(integrator) -> dt

Return the sub-step Δt at which a continuous callback's root lies within the current step (a discontinuity to stop at), or a negative value if there is none in (0, 1)·dt.

increment_accept!(stats)

Increment the accepted-step counter stats.naccept by one.

increment_reject!(stats)

Increment the rejected-step counter stats.nreject by one.

increment_nf!(stats, amt = 1)

Increment the RHS-evaluation counter stats.nf by amt.

ode_determine_initdt(u0, t, tdir, dtmax, abstol, reltol, internalnorm, prob, integrator) -> dt

Compute an automatic initial step size for prob using the standard Hairer–Nørsett–Wanner heuristic (based on the norms of f and its derivative at u0), respecting dtmax, the tolerances, and the integration direction tdir.

_determine_initdt(integrator) -> dt

Convenience wrapper that calls ode_determine_initdt with the fields of integrator (state, tolerances, norm, problem).

_ode_init(prob, alg, timeseries_init = (), ts_init = (), ks_init = (); kwargs...)

Internal implementation of __init for ODE/DAE/SDE/RODE problems. This is separated from __init so that SDE packages can call it directly, bypassing method dispatch (which would otherwise re-enter SDE's more specific __init).

_initialize_dae!(integrator, prob, alg, ::Val{iip})

Run the DAE / mass-matrix initialization: adjust u0 (and du0) so the algebraic constraints and initialization equations of prob are satisfied to tolerance, using the initialization algorithm alg (e.g. CheckInit, BrownFullBasicInit, OverrideInit). Val{iip} selects the in-place branch.

find_algebraic_vars_eqs(M)

Find algebraic variables (zero columns) and algebraic equations (zero rows) from mass matrix. Returns (algebraic_vars, algebraic_eqs) as boolean arrays (true = algebraic).

Works on CPU and GPU arrays. Sparse specialization (O(nnz)) is provided in OrdinaryDiffEqCoreSparseArraysExt.

get_differential_vars(f, idxs, timeseries::uType)

Returns an array of booleans for which values are the differential variables vs algebraic variables. Returns nothing for the cases where all variables are differential variables. Returns DifferentialVarsUndefined if it cannot be determined (i.e. the mass matrix is not diagonal).

handle_callback_modifiers!(integrator)

Hook invoked after a callback modifies the integrator state, letting the algorithm react (e.g. re-evaluate FSAL). No-op for a plain ODEIntegrator; extended by integrators that need to respond to callback-induced changes.

resolve_stage_step_limiters(alg, stage_limiter, step_limiter, verbose_spec)

Resolve the effective (stage_limiter!, step_limiter!) from the solve-level stage_limiter/step_limiter keywords. A non-trivial per-algorithm stage_limiter!/step_limiter! field is still honored (with a deprecation warning) when the matching keyword is not supplied. alg should be the concrete method (e.g. unwrapped from MethodOfSteps). Supplying stage_limiter to a method for which has_stage_limiter is false triggers the stage_limiter_unused verbosity toggle, which defaults to ErrorLevel (it errors) and can be lowered to WarnLevel/Silent to allow it.

trivial_limiter!(u, integrator, p, t)

No-op stage/step limiter used when no solve-level limiter is supplied.

DEOptions

Mutable container of resolved common solver options, stored on a running integrator as integrator.opts.

Fields

• abstol, reltol, internalnorm, and internalopnorm control error tests.
• dtmin, dtmax, failfactor, force_dtmin, advance_to_tstop, and stop_at_next_tstop control time-step selection.
• tstops, saveat, d_discontinuities, and their corresponding caches manage scheduled times.
• save_everystep, save_idxs, dense, save_on, save_start, save_end, save_noise, save_discretes, and save_end_user control output.
• callback, isoutofdomain, and unstable_check configure step checks.
• maxiters, verbose, and the progress fields configure reporting.

Rules

Solver implementations may read or update these fields while stepping, but must preserve the queue invariants maintained by the initialization and time-stop hooks. Application code should configure these options through solve or init, rather than constructing DEOptions directly.

DummyController()

Placeholder controller for algorithms that manage step-size selection themselves (BDF, Nordsieck, Leaping, …). Selecting it makes setup_controller_cache hand back a DummyControllerCache whose dispatch methods fall through to the algorithm-level stepsize_controller! / step_accept_controller! / step_reject_controller! methods that own the actual logic. The per-knob accessors (get_qmin etc.) fall back to fields on integrator.alg for SDE algorithms still using this transitional path.

New code should prefer dedicated controllers like OrdinaryDiffEqBDF.BDFController or OrdinaryDiffEqNordsieck.JVODEController, which expose the knobs as real, settable controller fields.

Rules

Extend the controller dispatch hooks for an algorithm that owns its step-size logic. Do not select DummyController for new algorithms when a dedicated controller can represent their parameters.

initialize_tstops(::Type{T}, tstops, d_discontinuities, tspan) -> BinaryHeap{T}

Build the internal directional time-stop queue for a solver integrator.

Arguments

• T::Type: Element type of the queue.
• tstops: Iterable of requested stopping times.
• d_discontinuities: Iterable of derivative-discontinuity times.
• tspan::Tuple: Integration start and end times.

Returns

• BinaryHeap{T}: Directional times strictly inside tspan, followed by the final time.

Rules

• Times are stored multiplied by the integration direction, so pop! visits the next physical time for both forward and reverse integrations.
• Entries at or outside the initial and final bounds are discarded; the final bound is inserted exactly once.
• Solver authors implementing a custom init path must use this helper so tstops and derivative discontinuities preserve the standard ordering semantics.

Example

tstops_internal = initialize_tstops(Float64, (0.25, 0.75), (), (0.0, 1.0))

initialize_saveat(::Type{T}, saveat, tspan) -> BinaryHeap{T}

Build the internal directional queue of output times for a solver integrator.

Arguments

• T::Type: Element type of the queue.
• saveat: A positive output interval or iterable of requested output times.
• tspan::Tuple: Integration start and end times.

Returns

• BinaryHeap{T}: Directional output times accepted by the standard saveat rules.

Rules

• A scalar saveat is treated as a positive interval in the integration direction.
• An iterable saveat contributes only times strictly after the initial bound and at or before the final bound.
• Solver authors implementing a custom init path must use this helper to preserve forward and reverse integration semantics.

Example

saveat_internal = initialize_saveat(Float64, 0.1, (0.0, 1.0))

initialize_d_discontinuities(::Type{T}, d_discontinuities, tspan) -> BinaryHeap{T}

Build the internal directional queue of derivative-discontinuity times.

Arguments

• T::Type: Element type of the queue.
• d_discontinuities: Iterable of derivative-discontinuity times.
• tspan::Tuple: Integration start and end times; its direction determines queue order.

Returns

• BinaryHeap{T}: Requested discontinuities at or after the initial time in the integration direction, stored directionally.

Rules

• Entries before the initial time in the integration direction are discarded. Entries at the initial time and beyond the final time are retained.
• Solver authors use this queue only when their initialization path supports the d_discontinuities solve keyword.

Example

discontinuities = initialize_d_discontinuities(Float64, (0.5,), (0.0, 1.0))

fix_dt_at_bounds!(integrator)

Clamp integrator.dt to the active dtmin and dtmax bounds while preserving the integration direction.

Arguments

• integrator: An OrdinaryDiffEq integrator with dt, tdir, and time-step bound options.

Returns

• nothing

Rules

• Call this from a solver-specific stepping or initialization path after modifying dt directly.
• The result lies between the active dtmin and dtmax bounds in the direction of integration.

Example

integrator.dt = proposed_dt
fix_dt_at_bounds!(integrator)

handle_tstop!(integrator)

Process the current time stop after a solver step. This removes reached stops, sets integrator.just_hit_tstop, and handles a fixed-step integrator that crossed a stop by interpolating back to it.

Arguments

• integrator: An OrdinaryDiffEq integrator that has just advanced its time state.

Returns

• nothing

Rules

• Solver authors that own a stepping loop should call this after advancing time.
• Duplicate stops at the current time are consumed together.
• A fixed-step integrator that crosses a stop is interpolated back to the stop; a time-step-changeable integrator crossing a stop is an invariant violation.

Example

perform_step!(integrator, cache, false)
handle_tstop!(integrator)

OrdinaryDiffEqInterpolation{cacheType} <: SciMLBase.AbstractDiffEqInterpolation

Abstract supertype for the dense-output interpolation object attached to a solution. Given a saved timeseries plus derivative (k) history it evaluates the continuous extension. See InterpolationData for the concrete type.

InterpolationData(f, timeseries, ts, ks, alg_choice, dense, cache, differential_vars, sensitivitymode)

Concrete OrdinaryDiffEqInterpolation storing everything needed to evaluate the continuous solution: the RHS f, the saved states timeseries at times ts, the stage-derivative history ks, the per-step alg_choice (for composite algorithms), whether dense output is available, the solver cache, the differential_vars mask (for DAEs), and a sensitivitymode flag. Calling (interp)(tvals, idxs, deriv, p, continuity) performs the interpolation.

DerivativeOrderNotPossibleError <: Exception

Thrown when a dense-output interpolation is asked for a derivative order higher than the interpolant supports (Hermite interpolation supports up to order 3).

ode_interpolant(Θ, dt, y₀, y₁, k, cache, idxs, T::Type{Val{deriv}}, differential_vars)

Evaluate the out-of-place dense-output interpolant at fraction Θ ∈ [0, 1] of a step of length dt from y₀ to y₁, using the stage-derivative history k and the algorithm cache. idxs selects components (or nothing for all), deriv is the derivative order, and differential_vars masks algebraic components for DAEs. Solver sublibraries add methods for their cache types; the fallback is Hermite (or linear when k is empty).

ode_interpolant!(out, Θ, dt, y₀, y₁, k, cache, idxs, T::Type{Val{deriv}}, differential_vars)

In-place version of ode_interpolant: write the interpolated value into out.

hermite_interpolant(Θ, dt, y₀, y₁, k, ::Val{mutable}, idxs, T::Type{Val{deriv}}, differential_vars)

Evaluate the cubic-Hermite interpolant (or its deriv-th derivative) between y₀ and y₁ from the endpoint derivatives k[1], k[2]. Algebraic components (differential_vars false) fall back to linear interpolation.

Herimte Interpolation, chosen if no other dispatch for ode_interpolant

Herimte Interpolation, chosen if no other dispatch for ode_interpolant

Herimte Interpolation, chosen if no other dispatch for ode_interpolant

hermite_interpolant!(out, Θ, dt, y₀, y₁, k, idxs, T::Type{Val{deriv}}, differential_vars)

In-place cubic-Hermite interpolation, writing into out. See hermite_interpolant.

interpolation_differential_vars(differential_vars, y₀, idxs)

Resolve the per-component differential-vs-algebraic mask actually used by the interpolant, given the problem's differential_vars, the value y₀, and the selected idxs. Returns true when all selected components are differential, false when the mask is undefined (forcing linear interpolation), or the appropriate (sub)mask otherwise.

current_interpolant(t, integrator, idxs, deriv)

Evaluate the dense-output interpolant of the current step at absolute time(s) t (mapping to Θ = (t - tprev)/dt), for components idxs and derivative order deriv. Out-of-place.

current_extrapolant(t, integrator, idxs = nothing, deriv = Val{0})

Evaluate the extrapolant of the current step at absolute time(s) t, i.e. the continuous extension used to extrapolate beyond an accepted step (maps to Θ = (t - tprev)/(t_cur - tprev)). Out-of-place.

current_extrapolant!(val, t, integrator, idxs = nothing, deriv = Val{0})

In-place version of current_extrapolant: write the result into val.

ode_addsteps!(k, integrator, ...)
ode_addsteps!(k, t, uprev, u, dt, f, p, cache, always_calc_begin = false, allow_calc_end = true, force_calc_end = false)

Ensure the stage-derivative array k for the current step is fully populated so the dense-output interpolant can be evaluated. Solver sublibraries add methods that compute their method-specific extra k stages on demand.

_ode_interpolant(Θ, dt, y₀, y₁, k, cache, idxs, T, differential_vars)

Low-level out-of-place interpolation kernel dispatched on the cache type. The generic fallback performs cubic Hermite interpolation (linear when there are fewer than two stage derivatives). Solver sublibraries specialize this for their own dense-output formulas.

_ode_interpolant!(out, Θ, dt, y₀, y₁, k, cache, idxs, T, differential_vars)

In-place counterpart of _ode_interpolant; writes into out.

An Efficient Runge-Kutta (4,5) Pair by P.Bogacki and L.F.Shampine Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28

Called to add the extra k9, k10, k11 steps for the Order 5 interpolation when needed

An Efficient Runge-Kutta (4,5) Pair by P.Bogacki and L.F.Shampine Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28

Called to add the extra k9, k10, k11 steps for the Order 5 interpolation when needed

_ode_addsteps!(k, t, uprev, u, dt, f, p, cache, always_calc_begin = false, allow_calc_end = true, force_calc_end = false)

Generic fallback for ode_addsteps! that fills k[1], k[2] with the RHS at the step endpoints (f(uprev, p, t) and f(u, p, t+dt)), sufficient for cubic-Hermite dense output.

accept_noise!(W, dt, u, p, setup)

Advance/accept the noise process W over the accepted step of size dt (the Brownian bridge/random values for [t, t+dt] are committed). No-op when W is nothing (pure ODE). Extended by StochasticDiffEq for NoiseProcess types.

reject_noise!(W, dt, u, p)

Roll back the noise process W after a rejected step of size dt so it can be re-sampled consistently on the retry. No-op when W is nothing.

save_noise!(W)

Persist the current value of the noise process W into its saved history. No-op when W is nothing.

reinit_noise!(W, dt)

Reset the noise process W to its initial state for a fresh integration with step dt (used by reinit!). No-op when W is nothing.

noise_curt(W)

Return the current time of the noise process W, or nothing when W is nothing. Used to check whether the noise has already advanced to the current integrator time.

is_noise_saveable(W) -> Bool

Return whether the noise process W supports saving its trajectory (false when W is nothing).

Utility function to help generating consistent docstrings across the package.

explicit_rk_docstring(description, name; references = "", extra_keyword_description = "", extra_keyword_default = "") -> String

Convenience wrapper over generic_solver_docstring for explicit Runge–Kutta methods. Prepends the standard stage_limiter! / step_limiter! / thread keywords (and any extra_keyword_*) and fills in the "Explicit Runge-Kutta Method" solver class.

differentiation_rk_docstring(description, name, solver_class; references = "", extra_keyword_description = "", extra_keyword_default = "") -> String

Convenience wrapper over generic_solver_docstring for implicit / Rosenbrock methods that take differentiation options. Prepends the standard autodiff, concrete_jac, and linsolve keywords (and any extra_keyword_*) with their descriptions.

AbstractJ

Supertype for the objects that evaluate the iterated stochastic integrals J needed by higher order SDE solvers.

All stochastic iterated integrals are written in the Stratonovich sense, as indicated by the J. An AbstractJ is produced from a problem and an algorithm by get_Jalg and is then evaluated with get_iterated_I (out-of-place) or get_iterated_I! (in-place, storing the result in the object's J field).

Subtypes: AbstractJDiagonal, AbstractJCommute, and the Lévy area algorithms of StochasticDiffEqLevyArea together with IteratedIntegralAlgorithm_iip.

AbstractJCommute <: AbstractJ

Iterated-integral evaluators for commutative noise, where the Lévy area terms cancel and the integrals reduce to the outer product 1/2 ΔW ΔWᵀ.

Subtypes: JCommute_oop, JCommute_iip.

AbstractJDiagonal <: AbstractJ

Iterated-integral evaluators for diagonal (or scalar) noise, where the integrals reduce to 1/2 ΔWᵢ² componentwise and no Lévy area approximation is required.

Subtypes: JDiagonal_oop, JDiagonal_iip.

DiffEqNLSolveTag

ForwardDiff tag type used for the Jacobians of the nonlinear solves inside the SDE integrators.

Tagging the duals keeps derivatives taken by the integrator distinguishable from derivatives a user takes through solve, which is what allows nested differentiation to work (see the ForwardDiff.jl documentation on tags).

IICommutative()

Iterated-integral strategy that assumes the noise is commutative.

Under commutative noise the Lévy area terms cancel and the iterated integrals reduce to 1/2 ΔW ΔWᵀ, which is cheap and exact for that problem class. Selecting this for a genuinely non-commutative problem silently loses the method's strong order, so use IILevyArea unless commutativity is known to hold.

IIFNLSolveFunc(f)

Wrapper holding the residual function f of an IIF nonlinear solve.

NLSOLVEJL_SETUP returns one of these from its Val{:init} call so that the in-place residual f(resid, u) can later be turned into a NonlinearProblem without recapturing the surrounding cache.

IILevyArea()

Iterated-integral strategy that approximates the Lévy area numerically.

This is the general-purpose choice: the number of terms is selected automatically from the step size and the requested accuracy, and an appropriate simulation algorithm is picked by StochasticDiffEqLevyArea.optimal_algorithm. It is more expensive than IICommutative but does not assume anything about the noise structure.

Ihat2(...)

Approximation of the second-order multiple stochastic integral used by the weak order 2 schemes.

Only the generic function lives here; the methods are defined in StochasticDiffEqWeak alongside the cache types they dispatch on, because their argument lists differ between the DRI/RI (Rößler) and RDI families.

IteratedIntegralAlgorithm_iip(ΔW, levyalg)

In-place wrapper around a StochasticDiffEqLevyArea iterated-integral algorithm.

StochasticDiffEqLevyArea's algorithms are allocating; this wrapper pairs one of them (levyalg) with a preallocated length(ΔW) × length(ΔW) buffer J, so that get_iterated_I! can serve in-place solvers with general non-commutative noise.

IteratedIntegralApprox

Supertype for the strategies used to approximate the iterated stochastic integrals (Lévy areas) that higher order SDE solvers need for non-diagonal noise.

An algorithm carries its choice in the ii_approx field, and get_Jalg turns that choice plus the problem's noise structure into the concrete AbstractJ object that computes the integrals.

Subtypes: IICommutative, IILevyArea.

JCommute_iip(ΔW)

In-place iterated-integral evaluator for commutative noise, preallocated to a length(ΔW) × length(ΔW) matrix.

get_iterated_I! writes 1/2 * vec(ΔW) * vec(ΔW)' into the J field.

JCommute_oop()

Out-of-place iterated-integral evaluator for commutative noise.

get_iterated_I returns a freshly allocated 1/2 .* vec(ΔW) .* vec(ΔW)'.

JDiagonal_iip(ΔW)

In-place iterated-integral evaluator for diagonal noise, preallocated to the shape of the Brownian increment ΔW.

get_iterated_I! writes 1/2 * ΔW^2 into the J field.

JDiagonal_oop()

Out-of-place iterated-integral evaluator for diagonal noise.

get_iterated_I returns a freshly allocated 1/2 .* ΔW .* ΔW.

NLSOLVEJL_SETUP(; autodiff = AutoForwardDiff())

Nonlinear-solver setup used by the IIF (implicit integrating factor) methods.

The name is historical — the solve is no longer performed by NLsolve.jl but by SimpleTrustRegion from SimpleNonlinearSolve.jl. A setup object is callable in two ways: setup(Val{:init}, f, u0_prototype) wraps f in an IIFNLSolveFunc, and setup(wrapped_f, u0) solves f(resid, u) = 0 starting from u0 and returns the root.

Keyword Arguments

• autodiff: ADTypes.jl backend used for the Jacobian of the inner solve (default: AutoForwardDiff()).

SDEAlgTypes

Union of the algorithm supertypes that the SDE integrator loop handles, i.e. StochasticDiffEqAlgorithm and StochasticDiffEqRODEAlgorithm.

Used to constrain SDEIntegrator and to write methods that apply to both SDE and RODE algorithms at once.

SDEIntegrator

The integrator type for SDE and RODE problems: an ODEIntegrator specialized to an algorithm in SDEAlgTypes.

SDE integration reuses OrdinaryDiffEqCore's integrator machinery and adds the noise process in the W field (and P for jump problems), so this alias is what SDE-specific methods — resizing, noise cache handling, the interpolation and step interface — dispatch on.

SDEOptions

Alias for OrdinaryDiffEqCore.DEOptions, the container holding the solver options (tolerances, callbacks, save settings) of a running integrator.

Kept as its own name for downstream packages such as StochasticDelayDiffEq that were written against the pre-migration StochasticDiffEq.SDEOptions.

DiffCache(u)
DiffCache(u, nlsolve)
DiffCache(u, ::Type{Val{chunk_size}})
DiffCache(T, size, ::Type{Val{chunk_size}})

Dual-buffered cache holding both a plain array and a ForwardDiff.Dual array of the same shape.

An in-place function that must work both on ordinary numbers and on duals cannot use a single preallocated buffer, because the element types differ. DiffCache stores one buffer of each and SciMLBase.get_du picks the right one from the element type at the call site.

The chunk size defaults to ForwardDiff.pickchunksize(length(u)), or is taken from the nonlinear solver via get_chunksize when one is supplied.

@cache struct MyAlgCache{...} <: StochasticDiffEqMutableCache
    ...
end

Define an SDE solver cache and generate its buffer accessors.

resize! on an integrator has to grow or shrink every buffer a cache holds, and the noise machinery has to know which of them are noise-shaped rather than state-shaped. Rather than writing those accessors by hand for each cache, @cache emits them from the declared field types:

• full_cache — fields typed uType, rateType, kType, or uNoUnitsType, plus the du/dual_du pair of a DiffCacheType field and the duals of JCType and GCType fields.
• rand_cache — fields typed randType.
• ratenoise_cache — fields typed rateNoiseType or rateNoiseCollectionType.
• jac_iter — fields typed JType or WType.

Fields whose type parameter is none of the above are left out of all four accessors, which is the correct behavior for scalars, tableaus, and nonlinear solver objects.

StochasticCompositeAlgorithm(algs, choice_function)

Algorithm that switches between the members of algs from step to step.

choice_function(integrator) returns the index into algs of the member to use for the next step; the matching cache is held in a StochasticCompositeCache and selected through its current field.

This is the mechanism behind the automatic stiffness-switching solvers — see AutoAlgSwitch, which pairs a nonstiff and a stiff algorithm with an AutoSwitch choice function.

StochasticCompositeCache(caches, choice_function, current)

Cache of a StochasticCompositeAlgorithm.

Holds one member cache per member algorithm in caches, the choice_function that selects among them, and current, the index chosen for the step being taken. unwrap_alg and get_current_alg_order read current so that perform_step! and the adaptivity see the member that is actually running.

TauLeapingDrift{C, R, RateCache, IIP}(c, rate, rate_cache)

Callable that presents the drift of a tau-leaping jump problem as an ordinary ODE right-hand side.

The drift is ν ⋅ a(u) written in terms of the RegularJump pieces: rate is the propensity function a and c is the stoichiometry function that applies the jump counts. The wrapper evaluates c(u, p, t, rate(u, p, t), nothing), which is exactly the function the implicit tau-leaping methods hand to their nonlinear solver.

The IIP type parameter selects the calling convention: out-of-place instances are called as drift(u, p, t), in-place ones as drift(du, u, p, t) and use rate_cache as scratch space for the propensities.

_resolve_rng(rng, seed, prob) -> (rng, seed, rng_provided)

Resolve the RNG and seed for an SDE/RODE integration from the user-provided rng and seed kwargs plus the problem's stored seed.

_sde_init(prob, alg; kwargs...) -> SDEIntegrator

Build the SDEIntegrator for prob and alg.

This is the body of SciMLBase.__init for SDE, RODE, and jump problems: it resolves the options and the RNG, allocates the solution object, the algorithm cache (alg_cache) and the noise process, and returns the integrator positioned at the initial condition. solve is init followed by solve!, so every documented solve keyword is accepted here.

It is exposed separately from __init so that downstream packages which build on the SDE integrator (for example StochasticDelayDiffEq) can construct one without going through SciMLBase.__init dispatch.

_z_prototype(alg, rand_prototype, iip::Bool) -> rand_prototype2

Compute the Z process prototype for algorithms that need an extra Brownian process. Default: use rand_prototype itself as Z prototype (same shape as W). Solver subpackages override this for algorithms with special Z requirements (e.g., PL1WM, RKMilGeneral, W2Ito1).

_z_prototype(alg, rand_prototype, iip::Bool, dt) -> rand_prototype2

Step-size aware form of _z_prototype, used when the size of the Z process depends on the step size — as it does for Lévy area truncations, where the number of retained series terms is chosen from the accuracy the step size demands.

dt is the initial step size as passed to solve, which is zero when the caller left it to be determined automatically. Since the Z prototype must be built before the initial step size is known, an algorithm that sizes from dt needs a fallback for that case.

Defaults to the three-argument form, so an override only has to be added by algorithms that actually need the step size.

addat_noise!(integrator, cache, idxs) -> nothing

Insert new components at positions idxs in the noise process of integrator.

The counterpart of deleteat_noise!, called from addat! on the integrator. Space is made in every noise buffer and in the cached increments of the interpolation stacks, and the new slots are filled with freshly sampled increments through fill_new_noise_caches!.

alg_cache(
    alg, prob, u, ΔW, ΔZ, p, rate_prototype, noise_rate_prototype,
    jump_rate_prototype, ::Type{uEltypeNoUnits}, ::Type{uBottomEltypeNoUnits},
    ::Type{tTypeNoUnits}, uprev, f, t, dt, ::Type{Val{iip}}, verbose
)

Construct the per-algorithm cache used by perform_step!.

This is the main extension point for SDE solver subpackages: each algorithm defines a cache type (usually with the @cache macro, which also generates the full_cache, rand_cache, and ratenoise_cache accessors used for resize!) and one alg_cache method that allocates it. The Val{iip} argument selects the in-place or out-of-place variant, and the *NoUnits type arguments give the element types the error estimates should be computed in.

The fallback method defined here errors, pointing at the solver subpackage that needs to be loaded for alg.

alg_compatible(prob, alg) -> Bool

Whether alg can solve prob.

solve consults this trait before setting up an integrator and errors with a descriptive message when it returns false. Solver subpackages add methods for the problem classes their algorithm supports, for example a Milstein-type method that requires diagonal noise:

alg_compatible(prob::SciMLBase.AbstractSDEProblem, alg::RKMil) = is_diagonal_noise(prob)

For a StochasticCompositeAlgorithm the result is the maximum over its members, and for a JumpProblem compatibility additionally requires that the algorithm supports_regular_jumps whenever the problem carries a RegularJump.

alg_control_rate(alg) -> Bool

Whether the adaptive step-size controller of alg acts on the jump/leap rate rather than on the usual solution error estimate.

Tau-leaping methods choose dt from how much the propensities are allowed to change over a step, so they override this to true and the integrator routes step-size control through the leap-specific controller instead of the standard EEst path.

alg_mass_matrix_compatible(alg) -> Bool

Whether alg can solve a problem with a non-identity mass matrix.

solve errors when a mass matrix is supplied to an algorithm for which this is false. The implicit theta-method solvers accept a mass matrix only in the configurations for which the discretization stays consistent (symplectic, or theta == 1) and throw a descriptive error otherwise.

alg_stability_size(alg) -> Real

Radius of the (deterministic) stability region of alg along the negative real axis.

This is the scale used by the automatic stiffness detection of AutoSwitch: the stiffness ratio is abs(eigen_est * dt / alg_stability_size(alg)), so an algorithm participating in a stiffness-switching composite must report a nonzero value. The default of 0 means "not characterized", and is overridden per algorithm in the solver subpackages.

alg_can_repeat_jac(alg) -> Bool

Whether alg may reuse a Jacobian across a rejected-and-repeated step.

When true the integrator keeps the factorized W matrix after a step rejection instead of recomputing it, which is the common case. Algorithms whose stage structure changes between attempts must override this to false.

alg_needs_extra_process(alg) -> Bool

Whether alg needs a second noise process ΔZ alongside the Brownian increment ΔW.

Higher order schemes (for example the Rößler SRA/SRI families) require an auxiliary independent process to approximate the extra stochastic integrals appearing in their order conditions. When this trait is true the integrator allocates and resizes the Z process in addition to W, so solver subpackages must set it for any algorithm that reads integrator.W.dZ.

For a StochasticCompositeAlgorithm the result is the maximum over its members, so the extra process is present if any member needs it.

calc_threepoint_random(sq3dt, quantile, dW_scaled)

Three-point discrete random variable replacing the Brownian increment in a weak (moment-matching) scheme.

Returns -sq3dt, 0, or +sq3dt depending on where the standardized increment dW_scaled falls relative to quantile. Unlike the two-point variable of calc_twopoint_random this matches the fourth moment of the Gaussian as well, which weak order 2 schemes require.

sq3dt is sqrt(3dt), and quantile is the (negative) standard-normal quantile that gives the zero outcome its correct probability.

calc_threepoint_random!(_dW, sq3dt, quantile, dW_scaled) -> nothing

In-place form of calc_threepoint_random, writing the discrete increments into _dW.

calc_twopoint_random(sqdt, dW)

Two-point discrete random variable replacing the Brownian increment in a weak (moment-matching) scheme.

Returns ±sqdt, taking the sign of dW, so the result has the same mean and variance as the Brownian increment while taking only two values. Weak-order methods may substitute such a variable because they only need the moments of the noise to match, and sampling two points is cheaper than sampling a Gaussian.

sqdt is sqrt(dt). See calc_threepoint_random for the variant that also matches the fourth moment.

calc_twopoint_random!(_dW, sqdt, dW) -> nothing

In-place form of calc_twopoint_random, writing the discrete increments into _dW.

concrete_prob(prob) -> prob

The underlying differential equation problem carried by prob.

For an SDEProblem, RODEProblem, or DiscreteProblem this is prob itself; for a JumpProblem it is the wrapped prob.prob. Setup code that needs to inspect the problem's f, u0, or tspan goes through this so it works uniformly with and without a jump wrapper.

deleteat_noise!(integrator, cache, idxs) -> nothing

Delete the components idxs from the noise process of integrator.

The counterpart of addat_noise!, called from deleteat! on the integrator: the same components are removed from every noise buffer and from the cached increments in the interpolation stacks, keeping the process dimension in step with the shrunken state.

delta_default(alg) -> Real

Default value of the delta option for alg.

delta is the SDE-specific mixing parameter of the adaptive error estimate: it weighs the drift (deterministic) error contribution against the diffusion (stochastic) one when the two are combined into a single EEst. A value of 1 uses the drift estimate at full strength.

Solver subpackages override this for algorithms whose published adaptivity scheme prescribes a different weighting.

determine_chunksize(u, alg) -> Int
determine_chunksize(u, CS) -> Int

ForwardDiff chunk size to use when differentiating with respect to a state like u.

A nonzero explicitly configured chunk size CS (or the one reported by get_chunksize for alg) is used as-is; 0 means "not configured" and falls back to ForwardDiff.pickchunksize(length(u)).

fill_new_noise_caches!(integrator, c, scaling_factor, idxs) -> nothing

Sample fresh noise increments into positions idxs of a cached noise entry c.

c is one entry of the noise process's interpolation stacks (W.S₁/W.S₂), a tuple whose first element is the step's scaling factor and whose remaining elements hold the cached ΔW and, when alg_needs_extra_process holds, ΔZ values. The new values are drawn from the process's own distribution so that the extended path has the correct law.

Used by resize_noise! and addat_noise! whenever the state grows.

get_chunksize(x) -> Int

ForwardDiff chunk size configured on x, or 0 when x does not configure one.

0 is the "unset" sentinel that makes determine_chunksize fall back to ForwardDiff.pickchunksize.

get_current_alg_order(alg, cache) -> Real

Strong order of the algorithm that is currently being stepped with.

For a plain algorithm this is just alg_order(alg). For a StochasticCompositeAlgorithm it is the order of the member algorithm selected by cache.current, so that adaptivity uses the order of the method that actually took the step rather than the order of the composite as a whole.

get_Jalg(ΔW, dt, prob, alg) -> AbstractJ

Select the iterated-integral evaluator to use for prob with alg.

The choice combines the algorithm's ii_approx field — an IteratedIntegralApprox — with the problem's noise structure and whether it is in-place:

• IILevyArea uses a diagonal evaluator when the noise is diagonal or scalar, and otherwise the StochasticDiffEqLevyArea algorithm chosen by optimal_algorithm(length(ΔW), dt) (wrapped in IteratedIntegralAlgorithm_iip for in-place problems).
• IICommutative uses a diagonal evaluator for diagonal/scalar noise and a commutative evaluator otherwise.
• Any other ii_approx is taken to be a concrete Lévy area algorithm and is used directly.

A solver subpackage can override the choice for a specific algorithm by adding a method, e.g. get_Jalg(ΔW, dt, prob, alg::MySolver) = MronRoe().

get_iterated_I(dt, dW, dZ, alg, p = nothing, c = 1, γ = 1 // 1)

Evaluate and return the Stratonovich iterated stochastic integrals for the step, out of place.

Arguments

• dt: The step size.
• dW, dZ: The Brownian increment and, where the method needs one, the auxiliary increment for the step.
• alg: The AbstractJ evaluator, as produced by get_Jalg.
• p: Number of terms in the Lévy area series. nothing (the default) selects it automatically from the requested accuracy ε = c * dt^(γ + 1/2).
• c, γ: Constant and exponent of that accuracy target, normally the constant and strong order of the calling solver.

See get_iterated_I! for the in-place form.

get_iterated_I!(dt, dW, dZ, alg, p = nothing, c = 1, γ = 1 // 1)

In-place form of get_iterated_I: compute the Stratonovich iterated stochastic integrals for the step and store them in alg.J, returning nothing.

is_split_step(alg) -> Bool

Whether alg is a split-step method, i.e. one that advances the drift to an intermediate state before applying the diffusion rather than adding both contributions to the same base point.

The split-step solvers (ISSEM, ISSEulerHeun) override this to true; the integrator uses it to select the matching residual and error-estimate paths.

resize_noise!(integrator, cache, bot_idx, i) -> nothing

Resize the noise process of integrator to length i after the state was resized.

All of the noise process's buffers (dW, dWtilde, dWtmp, curW, the dZ family when alg_needs_extra_process holds, and the cached increments in the interpolation stacks S₁/S₂) are grown or shrunk together. New entries from bot_idx up to i are filled with freshly sampled increments via fill_new_noise_caches! so the process stays consistent with the already generated path.

This is called from the resize! integrator interface; see deleteat_noise! and addat_noise! for the index-wise variants.

supports_regular_jumps(alg) -> Bool

Whether alg can integrate a JumpProblem that carries a RegularJump.

Regular jumps are leaped over with a Poisson count per step rather than simulated one event at a time, which only some SDE integrators implement. The default is false; EM and ImplicitEM override it to true in their subpackages. alg_compatible uses this trait to reject a RegularJump problem paired with an algorithm that cannot handle it.

AutoAlgSwitch(nonstiffalg, stiffalg; kwargs...) -> StochasticCompositeAlgorithm

Build a stiffness-switching composite of nonstiffalg and stiffalg.

This is the constructor behind the Auto* SDE solvers (for example AutoSOSRI2): it wraps the two algorithms in a StochasticCompositeAlgorithm whose choice function is an AutoSwitch. All keyword arguments are forwarded to AutoSwitch.

alg = AutoAlgSwitch(SOSRI(), ImplicitEM(); maxstiffstep = 5)

AutoSwitch(
    nonstiffalg, stiffalg; maxstiffstep = 10, maxnonstiffstep = 3,
    nonstifftol = 9 // 10, stifftol = 9 // 10, dtfac = 2,
    stiffalgfirst = false, switch_max = 5
)

Choice function that switches a StochasticCompositeAlgorithm between a nonstiff and a stiff method based on an online stiffness estimate.

Each step the estimate abs(eigen_est * dt / alg_stability_size(alg)) is compared against a tolerance. Consecutive verdicts are counted, and the algorithm is only switched once the count exceeds the corresponding threshold, which prevents thrashing on a borderline problem.

Keyword Arguments

• maxstiffstep: Number of consecutive stiff verdicts required before switching to stiffalg (default: 10).
• maxnonstiffstep: Number of consecutive nonstiff verdicts required before switching back to nonstiffalg (default: 3).
• nonstifftol, stifftol: Stiffness-ratio tolerances used while the nonstiff and the stiff algorithm is active, respectively (default: 9//10 for both).
• dtfac: Factor applied to dt at a switch — dt is multiplied by it when moving to the stiff method and divided by it when moving back (default: 2).
• stiffalgfirst: Start with stiffalg instead of nonstiffalg (default: false).
• switch_max: Number of successive nonstiff verdicts after which the error check is re-enabled (default: 5).

Use AutoAlgSwitch to build the composite algorithm directly.

unwrap_alg(integrator, is_nlsolve) -> alg

The concrete algorithm that integrator should use for the current step.

For a plain algorithm this is integrator.alg itself. For a StochasticCompositeAlgorithm it is the currently selected member: the stiff member when is_nlsolve is true under AutoSwitch-style stiffness switching, and the member indicated by integrator.cache.current otherwise.

perform_step! implementations call this instead of reading integrator.alg directly so that they work unchanged inside a composite algorithm.

checkSRAOrder(RosslerSRI)

Determines whether the order conditions are met via the tableaus of the SRA method.

checkSRIOrder(RosslerSRI)

Determines whether the order conditions are met via the tableaus of the SRI method.

constructExplicitSKenCarp()

Constructs the tableau type for the explicit part of SKenCarp as a RosslerSRA tableau.

constructSKenCarp()

Constructs the tableau type for the implicit SKenCarp method as a RosslerSRA tableau.

constructSOSRA()

Constructs the taleau type for the SOSRA method.

constructSOSRA2()

Constructs the taleau type for the SOSRA method.

constructSRA1()

Constructs the taleau type for the SRA1 method.

constructSRA2()

Constructs the taleau type for the SRA2 method.

constructSRA3()

Constructs the taleau type for the SRA3 method.

constructSRIOpt1()

Opti6-12-11-10-01-47

constructSRIOpt2()

Opti6-12-11-10-01-47

constructSRIW1()

Constructs the tableau type for the SRIW1 method.

constructSRIW2()

Constructs the tableau type for the SRIW1 method.

du_cache(cache::SRACache)

Return derivative and noise-work buffers stored by an SRACache. This is a developer extension hook for the SRA cache implementation.

Returns

A tuple of internal work buffers. Its order and contents are a solver-internal contract and must not be used by application code.

u_cache(cache::SRACache)

Return additional mutable state buffers for an SRACache. Solver implementations use this developer hook when resizing or inspecting a high-order SRA cache.

Returns

An empty tuple for SRACache; user code must not rely on cache-hook tuple layouts.

user_cache(cache::SRACache)

Return the user-state buffers stored by an SRACache. This developer hook is used by solver infrastructure; application code should not depend on its tuple layout.

Returns

A tuple containing the current and previous user states plus internal temporaries. Its order and contents are only a solver-extension contract.

ESDIRKIMEXCache <: SDIRKMutableCache

In-place solver cache for the ESDIRK-IMEX methods. Holds the stage values zs, stage-derivative buffers ks, error temporary atmp, nonlinear solver nlsolver, tableau tab, step limiter, and the extra history slots (uprev2/uprev3/tprev2) and algebraic_vars mask.

ESDIRKIMEXConstantCache <: OrdinaryDiffEqConstantCache

Out-of-place solver cache for the ESDIRK-IMEX methods. Holds the nonlinear solver nlsolver, the Butcher tableau tab, and the extra history slots uprev3 / tprev2 used by the embedded error estimate. Declared public so downstream IMEX solvers can reuse the ESDIRK-IMEX step.

ImplicitEulerESDIRKIMEXTableau(T, T2)

Construct the single-stage ESDIRK-IMEX Butcher tableau whose implicit part is the implicit Euler method (element types T for coefficients, T2 for abscissae). Used as the base tableau for the implicit-Euler IMEX splitting scheme.

BS3Cache <: OrdinaryDiffEqMutableCache

In-place solver cache for the Bogacki–Shampine 3(2) method (BS3), holding its stage buffers, embedded-error temporaries, tableau (BS3ConstantCache), and the stage/step limiters and threading option. Declared public because other sublibraries (e.g. the Adams–Bashforth–Moulton starters) reuse the BS3 step.

BS3ConstantCache{T, T2} <: OrdinaryDiffEqConstantCache

Developer-only tableau cache for the Bogacki-Shampine 3(2) method (BS3). Sibling solver packages obtain it through alg_cache; application code should use BS3() rather than depend on this cache representation.

RK4Cache <: OrdinaryDiffEqMutableCache

In-place solver cache for the classical 4th-order Runge–Kutta method (RK4), holding its four stage buffers, error/temporary buffers, and the stage/step limiters and threading option.

RK4ConstantCache <: OrdinaryDiffEqConstantCache

Out-of-place solver cache for the classical 4th-order Runge–Kutta method (RK4). Carries no state (the coefficients are compile-time constants).

RosenbrockMutableCache <: OrdinaryDiffEqMutableCache

Abstract supertype for the in-place caches of the Rosenbrock (and Rosenbrock-W) methods. Concrete Rosenbrock caches subtype this; the shared integrator interface dispatches on it to access the stage buffers, Jacobian/W matrices, and differentiation configs common to the Rosenbrock family. Declared public so cross-sublibrary references to the Rosenbrock cache hierarchy are recognized as a supported extension point.

Tsit5Cache <: OrdinaryDiffEqMutableCache

In-place solver cache for the Tsitouras 5(4) method (Tsit5), holding its stage buffers k1…k7, temporaries, embedded-error buffer, and the stage/step limiters and threading option. Declared public so other sublibraries can reuse the Tsit5 step.

Tsit5ConstantCache <: OrdinaryDiffEqConstantCache

Out-of-place solver cache for the Tsitouras 5(4) method (Tsit5). Carries no mutable state (the tableau coefficients are generated on demand).