Struct mathru::analysis::differential_equation::ordinary::ImplicitEuler

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

Solves an ODE using backward Euler

https://en.wikipedia.org/wiki/Backward_Euler_method

Example

For this example, we want to solve the following stiff ordinary differiential equation:

0 = -4(y(t) -2) - y(t)^{'} = f(t, y, y^{'})

The inial condition is $y(0) = 1.0$ and we solve it in the interval $\lbrack 0, 2\rbrack$.\ The following equation is the closed solution for this ODE:

y(t) = 2 - e^{-t}

use mathru::{
    algebra::linear::{Matrix, Vector},
    analysis::differential_equation::ordinary::{ImplicitEuler, ImplicitODE},
};

pub struct ImplicitODEExample
{
    time_span: (f64, f64),
    init_cond: Vector<f64>,
}

impl Default for ImplicitODEExample
{
    fn default() -> ImplicitODEExample
    {
        return ImplicitODEExample { time_span: (0.0, 2.0),
                                    init_cond: vector![1.0] };
    }
}

impl ImplicitODE<f64> for ImplicitODEExample
{
    fn func(self: &Self, _t: f64, x: &Vector<f64>) -> Vector<f64>
    {
        let result = (x * &-4.0) + 8.0;
        return result;
    }

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

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

    fn jacobian(self: &Self, _t: f64, _input: &Vector<f64>) -> Matrix<f64>
    {
        let jacobian = matrix![-4.0];
        return jacobian;
    }
}

// We instanciate Euler's backward algorithm with a stepsize of 0.001
let step_size: f64 = 0.0001;
let solver: ImplicitEuler<f64> = ImplicitEuler::new(step_size);

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

// Solve the ODE
let (t, x): (Vec<f64>, Vec<Vector<f64>>) = solver.solve(&problem).unwrap();

Implementations

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

pub fn new(step_size: T) -> ImplicitEuler<T>

Creates a backward Euler instance

pub fn solve<F>(&self, prob: &F) -> Result<(Vec<T>, Vec<Vector<T>>), ()> where
    F: ImplicitODE<T>, 

pub fn get_step_size(&self) -> &T

pub fn set_step_size(&mut self, step_size: T)

Trait Implementations

impl<T: Clone> Clone for ImplicitEuler<T>

pub fn clone(&self) -> ImplicitEuler<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 ImplicitEuler<T>

impl<T: Debug> Debug for ImplicitEuler<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for ImplicitEuler<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 ImplicitEuler<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.