# RODE Problems

`SciMLBase.RODEProblem`

— TypeDefines a random ordinary differential equation (RODE) problem. Documentation Page: https://diffeq.sciml.ai/stable/types/rode_types/

**Mathematical Specification of a RODE Problem**

To define a RODE Problem, you simply need to give the function $f$ and the initial condition $u_0$ which define an ODE:

\[\frac{du}{dt} = f(u,p,t,W(t))\]

where `W(t)`

is a random process. `f`

should be specified as `f(u,p,t,W)`

(or in-place as `f(du,u,p,t,W)`

), and `u₀`

should be an AbstractArray (or number) whose geometry matches the desired geometry of `u`

. Note that we are not limited to numbers or vectors for `u₀`

; one is allowed to provide `u₀`

as arbitrary matrices / higher dimension tensors as well.

**Constructors**

`RODEProblem(f::RODEFunction,u0,tspan,p=NullParameters();noise=WHITE_NOISE,rand_prototype=nothing,callback=nothing)`

`RODEProblem{isinplace}(f,u0,tspan,p=NullParameters();noise=WHITE_NOISE,rand_prototype=nothing,callback=nothing,mass_matrix=I)`

: Defines the RODE with the specified functions. The default noise is`WHITE_NOISE`

.`isinplace`

optionally sets whether the function is inplace or not. This is determined automatically, but not inferred.

Parameters are optional, and if not given then a `NullParameters()`

singleton will be used which will throw nice errors if you try to index non-existent parameters. Any extra keyword arguments are passed on to the solvers. For example, if you set a `callback`

in the problem, then that `callback`

will be added in every solve call.

For specifying Jacobians and mass matrices, see the DiffEqFunctions page.

**Fields**

`f`

: The drift function in the SDE.`u0`

: The initial condition.`tspan`

: The timespan for the problem.`p`

: The optional parameters for the problem. Defaults to`NullParameters`

.`noise`

: The noise process applied to the noise upon generation. Defaults to Gaussian white noise. For information on defining different noise processes, see the noise process documentation page`rand_prototype`

: A prototype type instance for the noise vector. It defaults to`nothing`

, which means the problem should be interpreted as having a noise vector whose size matches`u0`

.`kwargs`

: The keyword arguments passed onto the solves.

`SciMLBase.RODEFunction`

— Type`RODEFunction{iip,F,TMM,Ta,Tt,TJ,JVP,VJP,JP,SP,TW,TWt,TPJ,S,O,TCV} <: AbstractRODEFunction{iip}`

A representation of an RODE function `f`

, defined by:

\[M \frac{du}{dt} = f(u,p,t,W)dt\]

and all of its related functions, such as the Jacobian of `f`

, its gradient with respect to time, and more. For all cases, `u0`

is the initial condition, `p`

are the parameters, and `t`

is the independent variable.

**Constructor**

```
RODEFunction{iip,recompile}(f;
mass_matrix = __has_mass_matrix(f) ? f.mass_matrix : I,
analytic = __has_analytic(f) ? f.analytic : nothing,
tgrad= __has_tgrad(f) ? f.tgrad : nothing,
jac = __has_jac(f) ? f.jac : nothing,
jvp = __has_jvp(f) ? f.jvp : nothing,
vjp = __has_vjp(f) ? f.vjp : nothing,
jac_prototype = __has_jac_prototype(f) ? f.jac_prototype : nothing,
sparsity = __has_sparsity(f) ? f.sparsity : jac_prototype,
paramjac = __has_paramjac(f) ? f.paramjac : nothing,
syms = __has_syms(f) ? f.syms : nothing,
indepsym= __has_indepsym(f) ? f.indepsym : nothing,
colorvec = __has_colorvec(f) ? f.colorvec : nothing,
sys = __has_sys(f) ? f.sys : nothing)
```

Note that only the function `f`

itself is required. This function should be given as `f!(du,u,p,t)`

or `du = f(u,p,t)`

. See the section on `iip`

for more details on in-place vs out-of-place handling.

All of the remaining functions are optional for improving or accelerating the usage of `f`

. These include:

`mass_matrix`

: the mass matrix`M`

represented in the ODE function. Can be used to determine that the equation is actually a differential-algebraic equation (DAE) if`M`

is singular. Note that in this case special solvers are required, see the DAE solver page for more details: https://diffeq.sciml.ai/stable/solvers/dae_solve/. Must be an AbstractArray or an AbstractSciMLOperator.`analytic(u0,p,t)`

: used to pass an analytical solution function for the analytical solution of the ODE. Generally only used for testing and development of the solvers.`tgrad(dT,u,p,t)`

or dT=tgrad(u,p,t): returns $\frac{\partial f(u,p,t)}{\partial t}$`jac(J,u,p,t)`

or`J=jac(u,p,t)`

: returns $\frac{df}{du}$`jvp(Jv,v,u,p,t)`

or`Jv=jvp(v,u,p,t)`

: returns the directional derivative$\frac{df}{du} v$`vjp(Jv,v,u,p,t)`

or`Jv=vjp(v,u,p,t)`

: returns the adjoint derivative$\frac{df}{du}^\ast v$`jac_prototype`

: a prototype matrix matching the type that matches the Jacobian. For example, if the Jacobian is tridiagonal, then an appropriately sized`Tridiagonal`

matrix can be used as the prototype and integrators will specialize on this structure where possible. Non-structured sparsity patterns should use a`SparseMatrixCSC`

with a correct sparsity pattern for the Jacobian. The default is`nothing`

, which means a dense Jacobian.`paramjac(pJ,u,p,t)`

: returns the parameter Jacobian $\frac{df}{dp}$.`syms`

: the symbol names for the elements of the equation. This should match`u0`

in size. For example, if`u0 = [0.0,1.0]`

and`syms = [:x, :y]`

, this will apply a canonical naming to the values, allowing`sol[:x]`

in the solution and automatically naming values in plots.`indepsym`

: the canonical naming for the independent variable. Defaults to nothing, which internally uses`t`

as the representation in any plots.`colorvec`

: a color vector according to the SparseDiffTools.jl definition for the sparsity pattern of the`jac_prototype`

. This specializes the Jacobian construction when using finite differences and automatic differentiation to be computed in an accelerated manner based on the sparsity pattern. Defaults to`nothing`

, which means a color vector will be internally computed on demand when required. The cost of this operation is highly dependent on the sparsity pattern.

**iip: In-Place vs Out-Of-Place**

For more details on this argument, see the ODEFunction documentation.

**recompile: Controlling Compilation and Specialization**

For more details on this argument, see the ODEFunction documentation.

**Fields**

The fields of the RODEFunction type directly match the names of the inputs.

## Solution Type

`SciMLBase.RODESolution`

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

Representation of the solution to an stochastic differential equation defined by an SDEProblem, or of a random ordinary differential equation defined by an RODEProblem.

**DESolution Interface**

For more information on interacting with `DESolution`

types, check out the Solution Handling page of the DifferentialEquations.jl documentation.

https://diffeq.sciml.ai/stable/basics/solution/

**Fields**

`u`

: the representation of the SDE or RODE solution. Given as an array of solutions, where`u[i]`

corresponds to the solution at time`t[i]`

. It is recommended in most cases one does not access`sol.u`

directly and instead use the array interface described in the Solution Handling page of the DifferentialEquations.jl documentation.`t`

: the time points corresponding to the saved values of the ODE solution.`W`

: the representation of the saved noise process from the solution. See the Noise Processes page of the DifferentialEquations.jl documentation for more details: https://diffeq.sciml.ai/stable/features/noise*process/ . Note that this noise is only saved in full if `save*noise=true` in the solver.`prob`

: the original SDEProblem/RODEProblem that was solved.`alg`

: the algorithm type used by the solver.`destats`

: statistics of the solver, such as the number of function evaluations required, number of Jacobians computed, and more.`retcode`

: the return code from the solver. Used to determine whether the solver solved successfully (`sol.retcode === :Success`

), whether it terminated due to a user-defined callback (`sol.retcode === :Terminated`

), or whether it exited due to an error. For more details, see the return code section of the DifferentialEquations.jl documentation.