rantlib 0.1.0

Analysis Library for Non-linear Dynamical Systems written 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

use super::ParameterAdapter;

#[derive(Clone, Copy)]
pub struct ParameterAdapter1DEven<State, Parameters> {
    pub start: f64,
    pub end: f64,
    pub construct_initial_state_and_parameters: fn(f64) -> (State, Parameters), // TODO: think of better strategy
}

impl<State, Parameters> ParameterAdapter<State, Parameters>
    for ParameterAdapter1DEven<State, Parameters>
{
    type Vector = (usize, usize);

    fn compute_initial_state_and_parameters(
        &self,
        (x, resolution): Self::Vector,
    ) -> (State, Parameters) {
        let x = lin_int(self.start, self.end, x, resolution);
        (self.construct_initial_state_and_parameters)(x)
    }
}

#[derive(Clone, Copy)]
pub struct ParameterAdapter2DEven<State, Parameters> {
    pub start: (f64, f64),
    pub end: (f64, f64),
    pub construct_initial_state_and_parameters: fn(f64, f64) -> (State, Parameters), // TODO: think of better strategy
}

impl<State, Parameters> ParameterAdapter<State, Parameters>
    for ParameterAdapter2DEven<State, Parameters>
{
    type Vector = [(usize, usize); 2];

    fn compute_initial_state_and_parameters(
        &self,
        [(x, resolution_x), (y, resolution_y)]: Self::Vector,
    ) -> (State, Parameters) {
        let x = lin_int(self.start.0, self.end.0, x, resolution_x);
        let y = lin_int(self.start.1, self.end.1, y, resolution_y);
        (self.construct_initial_state_and_parameters)(x, y)
    }
}

fn lin_int(a: f64, b: f64, x: usize, resolution: usize) -> f64 {
    a + (x as f64 / resolution as f64) * (b - a)
}