Struct OdeSolverEquations 

pub struct OdeSolverEquations<M, Rhs, Init, Mass, Root, Out, Reset = UnitCallable<M>>
where
    M: Matrix,
{ /* private fields */ }

This struct implements the ODE equation trait OdeEquations for a given right-hand side op, mass op, optional root op, and initial condition function.

While the crate::OdeBuilder struct is the easiest way to define an ODE problem, occasionally a user might want to use their own structs that define the equations instead of closures or the DiffSL languave, and this can be done using OdeSolverEquations.

The main traits that you need to implement are the crate::Op and NonLinearOp trait, which define a nonlinear operator or function F that maps an input vector x to an output vector y, (i.e. y = F(x)). Once you have implemented this trait, you can then pass an instance of your struct to the rhs argument of the Self::new method. Once you have created an instance of OdeSolverEquations, you can then use crate::OdeBuilder::build_from_eqn to create a problem.

Implementations

impl<M, Rhs, Init, Mass, Root, Out, Reset> OdeSolverEquations<M, Rhs, Init, Mass, Root, Out, Reset>

where M: Matrix,

pub fn new( rhs: Rhs, init: Init, mass: Option<Mass>, root: Option<Root>, out: Option<Out>, reset: Option<Reset>, p: M::V, ) -> Self

Trait Implementations

impl<M, Rhs, Init, Mass, Root, Out, Reset> OdeEquations 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>, for<'a> ParameterisedOp<'a, Rhs>: NonLinearOp<M = M, V = M::V, T = M::T, C = M::C>, for<'a> ParameterisedOp<'a, Init>: ConstantOp<M = M, V = M::V, T = M::T, C = M::C>, for<'a> ParameterisedOp<'a, Mass>: LinearOp<M = M, V = M::V, T = M::T, C = M::C>, for<'a> ParameterisedOp<'a, Root>: NonLinearOp<M = M, V = M::V, T = M::T, C = M::C>, for<'a> ParameterisedOp<'a, Out>: NonLinearOp<M = M, V = M::V, T = M::T, C = M::C>, for<'a> ParameterisedOp<'a, Reset>: NonLinearOp<M = M, V = M::V, T = M::T, C = M::C>,

fn rhs(&self) -> ParameterisedOp<'_, Rhs>

returns the right-hand side function F(t, y) as a NonLinearOp

fn mass(&self) -> Option<ParameterisedOp<'_, Mass>>

returns the mass matrix M as a LinearOp

fn root(&self) -> Option<ParameterisedOp<'_, Root>>

returns the root function G(t, y) as a NonLinearOp

fn reset(&self) -> Option<ParameterisedOp<'_, Reset>>

returns the optional reset function R(y) as a NonLinearOp. When provided, this is called after a root event at index 0 to reset the state.

fn init(&self) -> ParameterisedOp<'_, Init>

returns the initial condition, i.e. y(t), where t is the initial time

fn out(&self) -> Option<ParameterisedOp<'_, Out>>

returns the output function H(t, y) as a NonLinearOp

fn set_params(&mut self, p: &Self::V)

sets the current parameters of the equations

fn get_params(&self, p: &mut Self::V)

gets the current parameters of the equations

fn set_model_index(&mut self, _m: usize)

sets the current model index of the equations

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<M, Rhs, Init, Mass, Root, Out, Reset> Op for OdeSolverEquations<M, Rhs, Init, Mass, Root, Out, Reset>

where M: Matrix, Init: Op<M = M, V = M::V, T = M::T, C = M::C>, Rhs: 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>,

type T = <M as MatrixCommon>::T

type V = <M as MatrixCommon>::V

type M = M

type C = <M as MatrixCommon>::C

fn nstates(&self) -> usize

Return the number of input states of the operator.

fn nout(&self) -> usize

Return the number of outputs of the operator.

fn nparams(&self) -> usize

Return the number of parameters of the operator.

fn statistics(&self) -> OpStatistics

Return statistics about the operator (e.g. how many times it was called, how many times the jacobian was computed, etc.)

fn context(&self) -> &Self::C

return the context of the operator