Trait OdeEquationsRef 

pub trait OdeEquationsRef<'a, ImplicitBounds: Sealed = Bounds<&'a Self>>: Op {
    type Mass: LinearOp<M = Self::M, V = Self::V, T = Self::T, C = Self::C>;
    type Rhs: NonLinearOp<M = Self::M, V = Self::V, T = Self::T, C = Self::C>;
    type Root: NonLinearOp<M = Self::M, V = Self::V, T = Self::T, C = Self::C>;
    type Init: ConstantOp<M = Self::M, V = Self::V, T = Self::T, C = Self::C>;
    type Out: NonLinearOp<M = Self::M, V = Self::V, T = Self::T, C = Self::C>;
    type Reset: NonLinearOp<M = Self::M, V = Self::V, T = Self::T, C = Self::C>;
}

this is the reference trait that defines the ODE equations of the form, this is used to define the ODE equations for a given lifetime. See OdeEquations for the main trait that defines the ODE equations.

$$ M \frac{dy}{dt} = F(t, y) y(t_0) = y_0(t_0) $$

The ODE equations are defined by:

• the right-hand side function F(t, y), which is given as a NonLinearOp using the Rhs associated type and OdeEquations::rhs function,
• the initial condition y_0(t_0), which is given as a ConstantOp using the Init associated type and OdeEquations::init function.

Optionally, the ODE equations can also include:

• the mass matrix M which is given as a LinearOp using the Mass associated type and the OdeEquations::mass function,
• the root function G(t, y) which is given as a NonLinearOp using the Root associated type and the OdeEquations::root function
• the output function H(t, y) which is given as a NonLinearOp using the Out associated type and the OdeEquations::out function

Required Associated Types

type Mass: LinearOp<M = Self::M, V = Self::V, T = Self::T, C = Self::C>

type Rhs: NonLinearOp<M = Self::M, V = Self::V, T = Self::T, C = Self::C>

type Root: NonLinearOp<M = Self::M, V = Self::V, T = Self::T, C = Self::C>

type Init: ConstantOp<M = Self::M, V = Self::V, T = Self::T, C = Self::C>

type Out: NonLinearOp<M = Self::M, V = Self::V, T = Self::T, C = Self::C>

type Reset: NonLinearOp<M = Self::M, V = Self::V, T = Self::T, C = Self::C>

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'a, T: OdeEquationsRef<'a>> OdeEquationsRef<'a> for &T

type Mass = <T as OdeEquationsRef<'a>>::Mass

type Rhs = <T as OdeEquationsRef<'a>>::Rhs

type Root = <T as OdeEquationsRef<'a>>::Root

type Init = <T as OdeEquationsRef<'a>>::Init

type Out = <T as OdeEquationsRef<'a>>::Out

type Reset = <T as OdeEquationsRef<'a>>::Reset

Implementors

impl<'a, 'b, Eqn, Method> OdeEquationsRef<'a> for AdjointEquations<'b, Eqn, Method>

where Eqn: OdeEquationsAdjoint, Method: OdeSolverMethod<'b, Eqn>,

type Rhs = &'a AdjointRhs<'b, Eqn, Method>

type Mass = &'a AdjointMass<'b, Eqn>

type Root = <Eqn as OdeEquationsRef<'a>>::Root

type Init = &'a AdjointInit<'b, Eqn, Method>

type Out = &'a AdjointOut<'b, Eqn, Method>

type Reset = <Eqn as OdeEquationsRef<'a>>::Reset

impl<'a, 'b, Eqn> OdeEquationsRef<'a> for SensEquations<'b, Eqn>

where Eqn: OdeEquationsImplicitSens,

type Rhs = &'a SensRhs<'b, Eqn>

type Mass = <Eqn as OdeEquationsRef<'a>>::Mass

type Root = <Eqn as OdeEquationsRef<'a>>::Root

type Init = &'a SensInit<'b, Eqn>

type Out = <Eqn as OdeEquationsRef<'a>>::Out

type Reset = <Eqn as OdeEquationsRef<'a>>::Reset

impl<'a, Eqn: OdeEquations> OdeEquationsRef<'a> for NoAug<Eqn>

type Mass = <Eqn as OdeEquationsRef<'a>>::Mass

type Rhs = <Eqn as OdeEquationsRef<'a>>::Rhs

type Root = <Eqn as OdeEquationsRef<'a>>::Root

type Init = <Eqn as OdeEquationsRef<'a>>::Init

type Out = <Eqn as OdeEquationsRef<'a>>::Out

type Reset = <Eqn as OdeEquationsRef<'a>>::Reset

impl<'a, M, Rhs, Init, Mass, Root, Out, Reset> OdeEquationsRef<'a> for OdeSolverEquations<M, Rhs, Init, Mass, Root, Out, Reset>

where M: Matrix, Rhs: Op<M = M, V = M::V, T = M::T, C = M::C>, Init: Op<M = M, V = M::V, T = M::T, C = M::C>, Mass: Op<M = M, V = M::V, T = M::T, C = M::C>, Root: Op<M = M, V = M::V, T = M::T, C = M::C>, Out: Op<M = M, V = M::V, T = M::T, C = M::C>, Reset: Op<M = M, V = M::V, T = M::T, C = M::C>, ParameterisedOp<'a, Rhs>: NonLinearOp<M = M, V = M::V, T = M::T, C = M::C>, ParameterisedOp<'a, Init>: ConstantOp<M = M, V = M::V, T = M::T, C = M::C>, ParameterisedOp<'a, Mass>: LinearOp<M = M, V = M::V, T = M::T, C = M::C>, ParameterisedOp<'a, Root>: NonLinearOp<M = M, V = M::V, T = M::T, C = M::C>, ParameterisedOp<'a, Out>: NonLinearOp<M = M, V = M::V, T = M::T, C = M::C>, ParameterisedOp<'a, Reset>: NonLinearOp<M = M, V = M::V, T = M::T, C = M::C>,

type Rhs = ParameterisedOp<'a, Rhs>

type Mass = ParameterisedOp<'a, Mass>

type Root = ParameterisedOp<'a, Root>

type Init = ParameterisedOp<'a, Init>

type Out = ParameterisedOp<'a, Out>

type Reset = ParameterisedOp<'a, Reset>

impl<'a, M: MatrixHost<T: DiffSlScalar>, CG: CodegenModule> OdeEquationsRef<'a> for DiffSl<M, CG>

type Mass = DiffSlMass<'a, M, CG>

type Rhs = DiffSlRhs<'a, M, CG>

type Root = DiffSlRoot<'a, M, CG>

type Init = DiffSlInit<'a, M, CG>

type Out = DiffSlOut<'a, M, CG>

type Reset = DiffSlReset<'a, M, CG>