diffsol 0.16.1

A library for solving ordinary differential equations (ODEs) in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use diffsol::matrix::MatrixRef;
use diffsol::vector::VectorRef;
use diffsol::LinearSolver;
use diffsol::{
    DefaultDenseMatrix, DefaultSolver, Matrix, OdeEquationsImplicit, OdeSolverMethod,
    OdeSolverProblem,
};

macro_rules! bench_implicit {
    ($g:ident, $name:ident, $solver:ident, $ls:ident, $problem:ident, $m:ty) => {
        $g.bench_function(stringify!($name), |b| {
            b.iter(|| {
                let (problem, soln) = $problem::<$m>(false);
                let t_evals = soln
                    .solution_points
                    .iter()
                    .map(|sp| sp.t)
                    .collect::<Vec<_>>();
                $crate::common::$solver::<_, $ls<_>>(&problem, &t_evals);
            })
        });
    };
}
pub(crate) use bench_implicit;

macro_rules! bench_implicit_cg {
    ($g:ident, $name:ident, $solver:ident, $ls:ident, $problem:ident, $m:ty, $($N:expr),+ $(,)?) => {
        $(
            $g.bench_function(concat!(stringify!($name), "_", $N), |b| {
                b.iter(|| {
                    let (problem, soln) = $problem::<$m, $N>();
                    let t_evals = soln
                        .solution_points
                        .iter()
                        .map(|sp| sp.t)
                        .collect::<Vec<_>>();
                    $crate::common::$solver::<_, $ls<_>>(&problem, &t_evals);
                })
            });
        )+
    };
}
pub(crate) use bench_implicit_cg;

macro_rules! bench_implicit_rt {
    ($g:ident, $name:ident, $solver:ident, $ls:ident, $problem:ident, $m:ty, $($N:expr),+ $(,)?) => {
        $(
            $g.bench_function(concat!(stringify!($name), "_", $N), |b| {
                b.iter(|| {
                    let (problem, soln) = $problem::<$m>(false, $N);
                    let t_evals = soln
                        .solution_points
                        .iter()
                        .map(|sp| sp.t)
                        .collect::<Vec<_>>();
                    $crate::common::$solver::<_, $ls<_>>(&problem, &t_evals);
                })
            });
        )+
    };
}
pub(crate) use bench_implicit_rt;

macro_rules! bench_explicit {
    ($g:ident, $name:ident, $solver:ident, $problem:ident, $m:ty) => {
        $g.bench_function(stringify!($name), |b| {
            b.iter(|| {
                let (problem, soln) = $problem::<$m>(false);
                let t_evals = soln
                    .solution_points
                    .iter()
                    .map(|sp| sp.t)
                    .collect::<Vec<_>>();
                $crate::common::$solver::<_>(&problem, &t_evals);
            })
        });
    };
}
pub(crate) use bench_explicit;

pub(crate) fn bdf<Eqn, LS>(problem: &OdeSolverProblem<Eqn>, t_evals: &[Eqn::T])
where
    Eqn: OdeEquationsImplicit,
    Eqn::M: Matrix + DefaultSolver,
    Eqn::V: DefaultDenseMatrix,
    LS: LinearSolver<Eqn::M>,
    for<'a> &'a Eqn::V: VectorRef<Eqn::V>,
    for<'a> &'a Eqn::M: MatrixRef<Eqn::M>,
{
    let mut s = problem.bdf::<LS>().unwrap();
    let _y = s.solve_dense(t_evals);
}

pub(crate) fn esdirk34<Eqn, LS>(problem: &OdeSolverProblem<Eqn>, t_evals: &[Eqn::T])
where
    Eqn: OdeEquationsImplicit,
    Eqn::M: Matrix + DefaultSolver,
    Eqn::V: DefaultDenseMatrix,
    LS: LinearSolver<Eqn::M>,
    for<'a> &'a Eqn::V: VectorRef<Eqn::V>,
    for<'a> &'a Eqn::M: MatrixRef<Eqn::M>,
{
    let mut s = problem.esdirk34::<LS>().unwrap();
    let _y = s.solve_dense(t_evals);
}

pub(crate) fn tr_bdf2<Eqn, LS>(problem: &OdeSolverProblem<Eqn>, t_evals: &[Eqn::T])
where
    Eqn: OdeEquationsImplicit,
    Eqn::M: Matrix + DefaultSolver,
    Eqn::V: DefaultDenseMatrix,
    LS: LinearSolver<Eqn::M>,
    for<'a> &'a Eqn::V: VectorRef<Eqn::V>,
    for<'a> &'a Eqn::M: MatrixRef<Eqn::M>,
{
    let mut s = problem.tr_bdf2::<LS>().unwrap();
    let _y = s.solve_dense(t_evals);
}

pub(crate) fn tsit45<Eqn>(problem: &OdeSolverProblem<Eqn>, t_evals: &[Eqn::T])
where
    Eqn: OdeEquationsImplicit,
    Eqn::M: Matrix + DefaultSolver,
    Eqn::V: DefaultDenseMatrix,
    for<'a> &'a Eqn::V: VectorRef<Eqn::V>,
    for<'a> &'a Eqn::M: MatrixRef<Eqn::M>,
{
    let mut s = problem.tsit45().unwrap();
    let _y = s.solve_dense(t_evals);
}