Struct mathru::analysis::differential_equation::ordinary::BogackiShampine32

pub struct BogackiShampine32<T> { /* fields omitted */ }

Solves an ODE using the Bogacki Shampine algorithm.

https://en.wikipedia.org/wiki/Bogacki-Shampine_method

Implementations

impl<T> BogackiShampine32<T> where
    T: Real, 

pub fn new(
    n_max: u32,
    h_0: T,
    fac: T,
    fac_min: T,
    fac_max: T,
    abs_tol: T,
    rel_tol: T
) -> BogackiShampine32<T>

Creates a Bogacki-Shampine 2 3 instance

pub fn solve<F>(
    &self,
    prob: &F
) -> Result<(Vec<T>, Vec<Vector<T>>), &'static str> where
    F: ExplicitODE<T>, 

Example

use mathru::{
    algebra::linear::{Matrix, Vector},
    analysis::differential_equation::ordinary::{BogackiShampine32, ExplicitODE},
    *,
};

// Define ODE
// $`y^{'} = ay = f(x, y) `$
// $`y = C a e^{at}`$
// $'y(t_{s}) = C a e^{at_s} => C = \frac{y(t_s)}{ae^{at_s}}`$
pub struct ExplicitODEProblem
{
    time_span: (f64, f64),
    init_cond: Vector<f64>,
}

impl Default for ExplicitODEProblem
{
    fn default() -> ExplicitODEProblem
    {
        ExplicitODEProblem { time_span: (0.0, 2.0),
                             init_cond: vector![0.5] }
    }
}

impl ExplicitODE<f64> for ExplicitODEProblem
{
    fn func(self: &Self, t: &f64, x: &Vector<f64>) -> Vector<f64>
    {
        return x * &2.0f64;
    }

    fn time_span(self: &Self) -> (f64, f64)
    {
        return self.time_span;
    }

    fn init_cond(self: &Self) -> Vector<f64>
    {
        return self.init_cond.clone();
    }
}

let problem: ExplicitODEProblem = ExplicitODEProblem::default();

let h_0: f64 = 0.0001;
let fac: f64 = 0.9;
let fac_min: f64 = 0.01;
let fac_max: f64 = 2.0;
let n_max: u32 = 100;
let abs_tol: f64 = 10e-6;
let rel_tol: f64 = 10e-3;

let solver: BogackiShampine32<f64> =
    BogackiShampine32::new(n_max, h_0, fac, fac_min, fac_max, abs_tol, rel_tol);

let (t, y): (Vec<f64>, Vec<Vector<f64>>) = solver.solve(&problem).unwrap();

pub fn get_abs_tol(&self) -> &T

pub fn get_rel_tol(&self) -> &T

pub fn set_abs_tol(&mut self, abs_tol: T)

pub fn set_rel_tol(&mut self, rel_tol: T)

Trait Implementations

impl<T: Clone> Clone for BogackiShampine32<T>

pub fn clone(&self) -> BogackiShampine32<T>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Copy> Copy for BogackiShampine32<T>

impl<T: Debug> Debug for BogackiShampine32<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for BogackiShampine32<T> where
    T: Real, 

pub fn default() -> BogackiShampine32<T>

Returns the "default value" for a type.

impl<'de, T> Deserialize<'de> for BogackiShampine32<T> where
    T: Deserialize<'de>, 

pub fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for BogackiShampine32<T> where
    T: Serialize, 

pub fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.