fast_ode 0.1.3

Fast Runge-Kutta implementation for solving ordinary differential equations.
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

//! Some experiments why mathru::algebra::linear::Vector is so much slower than std::Vec
use mathru::{algebra::linear::Vector, vector};

fn vec_dgl(state: &[f64]) -> Vec<f64> {
    vec![state[0]]
}
pub fn vec_euler() -> f64 {
    let mut state = vec![1.];
    let dt = 0.01;
    for _ in 1..10000 {
        let diff = vec_dgl(&state);
        let x = state[0] + diff[0] * dt;
        //state = vec![x]
        state[0] = x;
        // for (diff, state) in diff.into_iter().zip(state.iter_mut()) {
        //     *state = *state + diff * dt;
        // }
    }
    state[0]
}

fn vector_dgl(state: &Vector<f64>) -> Vector<f64> {
    vector![*state.get(0)]
}
pub fn vector_euler() -> f64 {
    let mut state = vector![1.];
    let dt = 0.01;
    for _ in 1..10000 {
        let diff = vector_dgl(&state);
        let x = state.get(0) + *diff.get(0) * dt;
        state = vector![x];
        //state.set_slice(&vector![x], 0)
    }
    *state.get(0)
}

use super::*;
use test::Bencher;

#[bench]
fn bench_vec(b: &mut Bencher) {
    b.iter(vec_euler);
}
#[bench]
fn bench_vector(b: &mut Bencher) {
    b.iter(vector_euler);
}