Struct OdeCallbacks 

pub struct OdeCallbacks<M: Matrix> { /* private fields */ }

ODE equations defined by C callbacks, see the module documentation.

Implementations

impl<M: Matrix> OdeCallbacks<M>

pub unsafe fn new( callbacks: OdeCallbacksDesc<M::T>, ctx: M::C, ) -> Result<Self, DiffsolError>

Create the equations from callbacks. All parameters are zero at the start.

This function takes ownership of callbacks.user_data, also if it returns an error. See the module documentation.

For sparse matrix types, this function finds the sparsity pattern of each derivative callback. To do this, it calls the callback with NaN inputs at the initial state and t = 0.

Safety

• Each function pointer in callbacks must be null or a valid function with the signature that the module documentation gives.
• Each function must stay valid until the equations are dropped.
• Each function must read and write only the array lengths in the table.
• If free_user_data is set, the equations own user_data. Do not free user_data yourself, and do not give it to other equations.
• If free_user_data is not set, user_data must stay valid until the equations are dropped.

pub fn take_callback_error(&self) -> Option<OdeCallbackError>

Take (and clear) the first error recorded while evaluating the callbacks.

Trait Implementations

impl<M: Matrix> Drop for OdeCallbacks<M>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<M: Matrix> OdeEquations for OdeCallbacks<M>

fn rhs(&self) -> OdeCallbacksRhs<'_, M>

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

fn mass(&self) -> Option<OdeCallbacksMass<'_, M>>

returns the mass matrix M as a LinearOp

fn root(&self) -> Option<OdeCallbacksRoot<'_, M>>

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

fn out(&self) -> Option<OdeCallbacksOut<'_, M>>

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

fn reset(&self) -> Option<OdeCallbacksReset<'_, M>>

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) -> OdeCallbacksInit<'_, M>

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

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

sets the current parameters of the equations

fn get_params(&self, p: &mut M::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: Matrix> OdeEquationsRef<'a> for OdeCallbacks<M>

type Mass = OdeCallbacksMass<'a, M>

type Rhs = OdeCallbacksRhs<'a, M>

type Root = OdeCallbacksRoot<'a, M>

type Init = OdeCallbacksInit<'a, M>

type Out = OdeCallbacksOut<'a, M>

type Reset = OdeCallbacksReset<'a, M>

impl<M: Matrix> Op for OdeCallbacks<M>

type T = <M as MatrixCommon>::T

type V = <M as MatrixCommon>::V

type M = M

type C = <M as MatrixCommon>::C

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

return the context of the operator

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.)