Struct rgsl::types::ordinary_differential_equations::ODEiv2Step
source · pub struct ODEiv2Step { /* private fields */ }Implementations§
source§impl ODEiv2Step
impl ODEiv2Step
sourcepub fn new(t: &ODEiv2StepType, dim: usize) -> Option<ODEiv2Step>
pub fn new(t: &ODEiv2StepType, dim: usize) -> Option<ODEiv2Step>
This function returns a pointer to a newly allocated instance of a stepping function of type T for a system of dim dimensions. Please note that if you use a stepper method that requires access to a driver object, it is advisable to use a driver allocation method, which automatically allocates a stepper, too.
sourcepub fn reset(&mut self) -> GSLResult<()>
pub fn reset(&mut self) -> GSLResult<()>
This function resets the stepping function s. It should be used whenever the next use of s will not be a continuation of a previous step.
sourcepub fn name(&self) -> Option<String>
pub fn name(&self) -> Option<String>
This function returns a pointer to the name of the stepping function. For example,
println!("step method is '{}'", s.name().unwrap());would print something like step method is ‘rkf45’.
sourcepub fn order(&self) -> u32
pub fn order(&self) -> u32
This function returns the order of the stepping function on the previous step. The order can vary if the stepping function itself is adaptive.
sourcepub fn set_driver(&mut self, d: &ODEiv2Driver<'_>) -> GSLResult<()>
pub fn set_driver(&mut self, d: &ODEiv2Driver<'_>) -> GSLResult<()>
This function sets a pointer of the driver object d for stepper s, to allow the stepper to access control (and evolve) object through the driver object. This is a requirement for some steppers, to get the desired error level for internal iteration of stepper. Allocation of a driver object calls this function automatically.
sourcepub fn apply(
&mut self,
t: f64,
h: f64,
y: &mut [f64],
yerr: &mut [f64],
dydt_in: &[f64],
dydt_out: &mut [f64],
sys: &mut ODEiv2System<'_>
) -> GSLResult<()>
pub fn apply(
&mut self,
t: f64,
h: f64,
y: &mut [f64],
yerr: &mut [f64],
dydt_in: &[f64],
dydt_out: &mut [f64],
sys: &mut ODEiv2System<'_>
) -> GSLResult<()>
This function applies the stepping function s to the system of equations defined by sys, using the step-size h to advance the system from time t and state y to time t+h. The new state of the system is stored in y on output, with an estimate of the absolute error in each component stored in yerr. If the argument dydt_in is not null it should point an array containing the derivatives for the system at time t on input. This is optional as the derivatives will be computed internally if they are not provided, but allows the reuse of existing derivative information. On output the new derivatives of the system at time t+h will be stored in dydt_out if it is not null.
The stepping function returns enums::value::Failure if it is unable to compute the requested step. Also, if the user-supplied functions defined in the system sys return a status other than ::Value::Success the step will be aborted. In that case, the elements of y will be restored to their pre-step values and the error code from the user-supplied function will be returned. Failure may be due to a singularity in the system or too large step-size h. In that case the step should be attempted again with a smaller step-size, e.g. h/2.
If the driver object is not appropriately set via gsl_odeiv2_step_set_driver for those steppers that need it, the stepping function returns ::Fault. If the user-supplied functions defined in the system sys returns enums::value::BadFunc, the function returns immediately with the same return code. In this case the user must call gsl_odeiv2_step_reset before calling this function again.