DE types

Discrete

DiffEqBase.AbstractDiscreteFunction — Type.

abstract type AbstractDiscreteFunction <: DiffEqBase.AbstractDiffEqFunction{iip}

DiffEqBase.DiscreteFunction — Type.

struct DiscreteFunction{iip, F, Ta, S} <: DiffEqBase.AbstractDiscreteFunction{iip}

DiffEqBase.AbstractDiscreteProblem — Type.

abstract type AbstractDiscreteProblem <: DiffEqBase.AbstractODEProblem{uType,tType,isinplace}

Base for types which define discrete problems.

DiffEqBase.DiscreteProblem — Type.

struct DiscreteProblem{uType, tType, isinplace, P, F, K} <: DiffEqBase.AbstractDiscreteProblem{uType,tType,isinplace}

Defines a discrete problem.

Fields

f
The function in the map.
u0
The initial condition.
tspan
The timespan for the problem.
p
The parameter values of the function.
kwargs
A callback to be applied to every solver which uses the problem.

ODE

DiffEqBase.AbstractODEFunction — Type.

abstract type AbstractODEFunction <: DiffEqBase.AbstractDiffEqFunction{iip}

DiffEqBase.ODEFunction — Type.

struct ODEFunction{iip, F, TMM, Ta, Tt, TJ, JP, TW, TWt, TPJ, S, TCV} <: DiffEqBase.AbstractODEFunction{iip}

DiffEqBase.AbstractODEProblem — Type.

abstract type AbstractODEProblem <: DiffEqBase.DEProblem

Base for types which define ODE problems.

DiffEqBase.ODEProblem — Type.

struct ODEProblem{uType, tType, isinplace, P, F, K, PT} <: DiffEqBase.AbstractODEProblem{uType,tType,isinplace}

Defines an ODE problem.

Fields

f
The ODE is du/dt = f(u,p,t).
u0
The initial condition is u(tspan[1]) = u0.
tspan
The solution u(t) will be computed for tspan[1] ≤ t ≤ tspan[2].
p
Constant parameters to be supplied as the second argument of f.
kwargs
A callback to be applied to every solver which uses the problem.
problem_type

DiffEqBase.StandardODEProblem — Type.

struct StandardODEProblem

DiffEqBase.AbstractODESolution — Type.

abstract type AbstractODESolution <: DiffEqBase.AbstractTimeseriesSolution{T,N}

DiffEqBase.ODESolution — Type.

struct ODESolution{T, N, uType, uType2, DType, tType, rateType, P, A, IType, DE} <: DiffEqBase.AbstractODESolution{T,N}

DiffEqBase.AbstractODEAlgorithm — Type.

abstract type AbstractODEAlgorithm <: DiffEqBase.DEAlgorithm

DiffEqBase.AbstractODEIntegrator — Type.

abstract type AbstractODEIntegrator <: DiffEqBase.DEIntegrator{Alg,IIP,U,T}

Dynamical ODEs

DiffEqBase.DynamicalODEFunction — Type.

struct DynamicalODEFunction{iip, F1, F2, TMM, Ta} <: DiffEqBase.AbstractODEFunction{iip}

DiffEqBase.AbstractDynamicalODEProblem — Type.

abstract type AbstractDynamicalODEProblem

DiffEqBase.DynamicalODEProblem — Type.

struct DynamicalODEProblem{iip} <: DiffEqBase.AbstractDynamicalODEProblem

Second-order ODEs

DiffEqBase.AbstractSecondOrderODEProblem — Type.

abstract type AbstractSecondOrderODEProblem <: DiffEqBase.AbstractODEProblem{uType,tType,isinplace}

DiffEqBase.SecondOrderODEProblem — Type.

struct SecondOrderODEProblem{iip} <: DiffEqBase.AbstractDynamicalODEProblem

DiffEqBase.AbstractSecondOrderODEAlgorithm — Type.

abstract type AbstractSecondOrderODEAlgorithm <: DiffEqBase.DEAlgorithm

DiffEqBase.AbstractSecondOrderODEIntegrator — Type.

abstract type AbstractSecondOrderODEIntegrator <: DiffEqBase.DEIntegrator{Alg,IIP,U,T}

Split ODEs

DiffEqBase.SplitFunction — Type.

struct SplitFunction{iip, F1, F2, TMM, C, Ta, Tt, TJ, JP, TW, TWt, TPJ, S, TCV} <: DiffEqBase.AbstractODEFunction{iip}

DiffEqBase.AbstractSplitODEProblem — Type.

abstract type AbstractSplitODEProblem

DiffEqBase.SplitODEProblem — Type.

struct SplitODEProblem{iip} <: DiffEqBase.AbstractSplitODEProblem

Steady state problems

DiffEqBase.AbstractSteadyStateProblem — Type.

abstract type AbstractSteadyStateProblem <: DiffEqBase.DEProblem

Base for types which define steady state problems for ODE systems.

DiffEqBase.SteadyStateProblem — Type.

struct SteadyStateProblem{uType, isinplace, P, F, K} <: DiffEqBase.AbstractSteadyStateProblem{uType,isinplace}

Defines a steady state problem.

Fields

f
f: The function in the ODE.
u0
The initial guess for the steady state.
p
Parameter values for the ODE function.
kwargs

DiffEqBase.AbstractSteadyStateSolution — Type.

abstract type AbstractSteadyStateSolution <: DiffEqBase.AbstractNoTimeSolution{T,N}

DiffEqBase.SteadyStateSolution — Type.

struct SteadyStateSolution{T, N, uType, R, P, A} <: DiffEqBase.AbstractSteadyStateSolution{T,N}

DiffEqBase.AbstractSteadyStateAlgorithm — Type.

abstract type AbstractSteadyStateAlgorithm <: DiffEqBase.DEAlgorithm

DiffEqBase.AbstractSteadyStateIntegrator — Type.

abstract type AbstractSteadyStateIntegrator <: DiffEqBase.DEIntegrator{Alg,IIP,U,Nothing}

Boundary value problems

DiffEqBase.TwoPointBVPFunction — Type.

struct TwoPointBVPFunction{bF}

DiffEqBase.AbstractBVProblem — Type.

abstract type AbstractBVProblem <: DiffEqBase.AbstractODEProblem{uType,tType,isinplace}

Base for types which define BVP problems.

DiffEqBase.StandardBVProblem — Type.

struct StandardBVProblem

DiffEqBase.BVProblem — Type.

struct BVProblem{uType, tType, isinplace, P, F, bF, PT, K} <: DiffEqBase.AbstractBVProblem{uType,tType,isinplace}

DiffEqBase.TwoPointBVProblem — Type.

struct TwoPointBVProblem{iip}

Analytical problems

DiffEqBase.AbstractAnalyticalProblem — Type.

abstract type AbstractAnalyticalProblem <: DiffEqBase.AbstractODEProblem{uType,tType,isinplace}

DiffEqBase.AnalyticalProblem — Type.

struct AnalyticalProblem{uType, tType, isinplace, P, F, K} <: AbstractAnalyticalProblem{uType,tType,isinplace}

DiffEqBase.AbstractAnalyticalSolution — Type.

abstract type AbstractAnalyticalSolution <: DiffEqBase.AbstractTimeseriesSolution{T,N}

SDE

SDE problems are subtypes of RODE problems.

DiffEqBase.AbstractSDEFunction — Type.

abstract type AbstractSDEFunction <: DiffEqBase.AbstractDiffEqFunction{iip}

DiffEqBase.SDEFunction — Type.

struct SDEFunction{iip, F, G, TMM, Ta, Tt, TJ, JP, TW, TWt, TPJ, S, GG, TCV} <: DiffEqBase.AbstractSDEFunction{iip}

DiffEqBase.AbstractSDEProblem — Type.

abstract type AbstractSDEProblem <: DiffEqBase.AbstractRODEProblem{uType,tType,isinplace,ND}

Base for types which define SDE problems.

DiffEqBase.StandardSDEProblem — Type.

struct StandardSDEProblem

DiffEqBase.SDEProblem — Type.

struct SDEProblem{uType, tType, isinplace, P, NP, F, G, K, ND} <: DiffEqBase.AbstractSDEProblem{uType,tType,isinplace,ND}

DiffEqBase.AbstractSDEAlgorithm — Type.

abstract type AbstractSDEAlgorithm <: DiffEqBase.DEAlgorithm

DiffEqBase.AbstractSDEIntegrator — Type.

abstract type AbstractSDEIntegrator <: DiffEqBase.DEIntegrator{Alg,IIP,U,T}

Split SDEs

DiffEqBase.SplitSDEFunction — Type.

struct SplitSDEFunction{iip, F1, F2, G, TMM, C, Ta, Tt, TJ, JP, TW, TWt, TPJ, S, TCV} <: DiffEqBase.AbstractSDEFunction{iip}

DiffEqBase.AbstractSplitSDEProblem — Type.

abstract type AbstractSplitSDEProblem

DiffEqBase.SplitSDEProblem — Type.

struct SplitSDEProblem{iip} <: DiffEqBase.AbstractSplitSDEProblem

RODE

DiffEqBase.AbstractRODEFunction — Type.

abstract type AbstractRODEFunction <: DiffEqBase.AbstractDiffEqFunction{iip}

DiffEqBase.RODEFunction — Type.

struct RODEFunction{iip, F, TMM, Ta, Tt, TJ, JP, TW, TWt, TPJ, S, TCV} <: DiffEqBase.AbstractRODEFunction{iip}

DiffEqBase.AbstractRODEProblem — Type.

abstract type AbstractRODEProblem <: DiffEqBase.DEProblem

Base for types which define RODE problems.

DiffEqBase.RODEProblem — Type.

mutable struct RODEProblem{uType, tType, isinplace, P, NP, F, K, ND} <: DiffEqBase.AbstractRODEProblem{uType,tType,isinplace,ND}

DiffEqBase.AbstractRODESolution — Type.

abstract type AbstractRODESolution <: DiffEqBase.AbstractODESolution{T,N}

DiffEqBase.RODESolution — Type.

struct RODESolution{T, N, uType, uType2, DType, tType, randType, P, A, IType, DE} <: DiffEqBase.AbstractRODESolution{T,N}

DiffEqBase.AbstractRODEAlgorithm — Type.

abstract type AbstractRODEAlgorithm <: DiffEqBase.DEAlgorithm

DiffEqBase.AbstractRODEIntegrator — Type.

abstract type AbstractRODEIntegrator <: DiffEqBase.DEIntegrator{Alg,IIP,U,T}

DDE

DiffEqBase.AbstractDDEFunction — Type.

abstract type AbstractDDEFunction <: DiffEqBase.AbstractDiffEqFunction{iip}

DiffEqBase.DDEFunction — Type.

struct DDEFunction{iip, F, TMM, Ta, Tt, TJ, JP, TW, TWt, TPJ, S, TCV} <: DiffEqBase.AbstractDDEFunction{iip}

DiffEqBase.AbstractDDEProblem — Type.

abstract type AbstractDDEProblem <: DiffEqBase.DEProblem

Base for types which define DDE problems.

DiffEqBase.DDEProblem — Type.

struct DDEProblem{uType, tType, lType, lType2, isinplace, P, F, H, K} <: DiffEqBase.AbstractDDEProblem{uType,tType,lType,isinplace}

DiffEqBase.AbstractConstantLagDDEProblem — Type.

abstract type AbstractConstantLagDDEProblem <: DiffEqBase.AbstractDDEProblem{uType,tType,lType,isinplace}

DiffEqBase.AbstractDDESolution — Type.

abstract type AbstractDDESolution <: DiffEqBase.AbstractODESolution{T,N}

DiffEqBase.AbstractDDEAlgorithm — Type.

abstract type AbstractDDEAlgorithm <: DiffEqBase.DEAlgorithm

DiffEqBase.AbstractDDEIntegrator — Type.

abstract type AbstractDDEIntegrator <: DiffEqBase.DEIntegrator{Alg,IIP,U,T}

DiffEqBase.AbstractHistoryFunction — Type.

abstract type AbstractHistoryFunction <: Function

Base for types which define the history of a delay differential equation.

SDDE

DiffEqBase.AbstractSDDEFunction — Type.

abstract type AbstractSDDEFunction <: DiffEqBase.AbstractDiffEqFunction{iip}

DiffEqBase.SDDEFunction — Type.

struct SDDEFunction{iip, F, G, TMM, Ta, Tt, TJ, JP, TW, TWt, TPJ, S, GG, TCV} <: DiffEqBase.AbstractSDDEFunction{iip}

DiffEqBase.AbstractSDDEProblem — Type.

abstract type AbstractSDDEProblem <: DiffEqBase.DEProblem

Base for types which define SDDE problems.

DiffEqBase.SDDEProblem — Type.

struct SDDEProblem{uType, tType, lType, lType2, isinplace, P, NP, F, G, H, K, ND} <: DiffEqBase.AbstractSDDEProblem{uType,tType,lType,isinplace,ND}

DiffEqBase.AbstractConstantLagSDDEProblem — Type.

abstract type AbstractConstantLagSDDEProblem <: DiffEqBase.AbstractSDDEProblem{uType,tType,lType,isinplace,ND}

DiffEqBase.AbstractSDDEAlgorithm — Type.

abstract type AbstractSDDEAlgorithm <: DiffEqBase.DEAlgorithm

DiffEqBase.AbstractSDDEIntegrator — Type.

abstract type AbstractSDDEIntegrator <: DiffEqBase.DEIntegrator{Alg,IIP,U,T}

DAE

DiffEqBase.AbstractDAEFunction — Type.

abstract type AbstractDAEFunction <: DiffEqBase.AbstractDiffEqFunction{iip}

DiffEqBase.DAEFunction — Type.

struct DAEFunction{iip, F, Ta, Tt, TJ, JP, TW, TWt, TPJ, S, TCV} <: DiffEqBase.AbstractDAEFunction{iip}

DiffEqBase.AbstractDAEProblem — Type.

abstract type AbstractDAEProblem <: DiffEqBase.DEProblem

Base for types which define DAE problems.

DiffEqBase.DAEProblem — Type.

struct DAEProblem{uType, duType, tType, isinplace, P, F, K, D} <: DiffEqBase.AbstractDAEProblem{uType,duType,tType,isinplace}

DiffEqBase.AbstractDAESolution — Type.

abstract type AbstractDAESolution <: DiffEqBase.AbstractODESolution{T,N}

DiffEqBase.DAESolution — Type.

struct DAESolution{T, N, uType, duType, uType2, DType, tType, P, A, ID, DE} <: DiffEqBase.AbstractDAESolution{T,N}

DiffEqBase.AbstractDAEAlgorithm — Type.

abstract type AbstractDAEAlgorithm <: DiffEqBase.DEAlgorithm

DiffEqBase.AbstractDAEIntegrator — Type.

abstract type AbstractDAEIntegrator <: DiffEqBase.DEIntegrator{Alg,IIP,U,T}

PDE

DiffEqBase.AbstractPDEProblem — Type.

abstract type AbstractPDEProblem <: DiffEqBase.DEProblem

Base for types which define PDE problems.

DiffEqBase.PDEProblem — Type.

struct PDEProblem{P, E, S} <: DiffEqBase.AbstractPDEProblem

Jump problems

DiffEqBase.AbstractJumpProblem — Type.

abstract type AbstractJumpProblem <: DiffEqBase.DEProblem

Base for types which define jump problems.

Noise problems

DiffEqBase.AbstractNoiseProblem — Type.

abstract type AbstractNoiseProblem <: DiffEqBase.DEProblem

DiffEqBase.NoiseProblem — Type.

struct NoiseProblem{N<:DiffEqBase.AbstractNoiseProcess, T, K} <: DiffEqBase.AbstractNoiseProblem

Basic problems (for testing?)

Linear

DiffEqBase.AbstractLinearProblem — Type.

abstract type AbstractLinearProblem <: DiffEqBase.DEProblem

Base for types which define linear systems.

DiffEqBase.LinearProblem — Type.

struct LinearProblem{uType, isinplace, F, bType, P, K} <: DiffEqBase.AbstractLinearProblem{bType,isinplace}

DiffEqBase.AbstractLinearSolution — Type.

abstract type AbstractLinearSolution <: DiffEqBase.AbstractNoTimeSolution{T,N}

DiffEqBase.LinearSolution — Type.

struct LinearSolution{T, N, uType, R, P, A} <: DiffEqBase.AbstractLinearSolution{T,N}

DiffEqBase.AbstractLinearAlgorithm — Type.

abstract type AbstractLinearAlgorithm <: DiffEqBase.DEAlgorithm

Nonlinear

DiffEqBase.AbstractNonlinearProblem — Type.

abstract type AbstractNonlinearProblem <: DiffEqBase.DEProblem

Base for types which define nonlinear systems.

DiffEqBase.NonlinearProblem — Type.

struct NonlinearProblem{uType, isinplace, P, F, K} <: DiffEqBase.AbstractNonlinearProblem{uType,isinplace}

DiffEqBase.AbstractNonlinearSolution — Type.

abstract type AbstractNonlinearSolution <: DiffEqBase.AbstractNoTimeSolution{T,N}

DiffEqBase.AbstractNonlinearAlgorithm — Type.

abstract type AbstractNonlinearAlgorithm <: DiffEqBase.DEAlgorithm

Quadrature

DiffEqBase.AbstractQuadratureProblem — Type.

abstract type AbstractQuadratureProblem <: DiffEqBase.DEProblem

Base for types which define integrals suitable for quadrature.

DiffEqBase.QuadratureProblem — Type.

struct QuadratureProblem{isinplace, P, F, L, U, K} <: DiffEqBase.AbstractQuadratureProblem{isinplace}

DiffEqBase.AbstractQuadratureSolution — Type.

abstract type AbstractQuadratureSolution <: DiffEqBase.AbstractNoTimeSolution{T,N}

DiffEqBase.AbstractQuadratureAlgorithm — Type.

abstract type AbstractQuadratureAlgorithm <: DiffEqBase.DEAlgorithm

Sensitivity problems

DiffEqBase.DESensitivity — Type.

abstract type DESensitivity

DiffEqBase.AbstractSensitivitySolution — Type.

abstract type AbstractSensitivitySolution