sciforge 0.0.3

A comprehensive scientific computing library in pure Rust with zero dependencies
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

/// Trait for systems of ordinary differential equations.
pub trait DynamicalSystem {
    /// Number of state variables.
    fn dimension(&self) -> usize;
    /// Computes derivatives at time `t` and `state`, writing into `out`.
    fn derivatives(&self, t: f64, state: &[f64], out: &mut [f64]);
    /// Returns the initial state vector.
    fn initial_state(&self) -> Vec<f64>;
    /// Returns the integration time span (t0, tf).
    fn time_span(&self) -> (f64, f64);
}

/// Boxed derivative function signature.
pub type SystemFn = Box<dyn Fn(f64, &[f64], &mut [f64])>;

/// Generic model built from a closure.
pub struct SimpleModel {
    y0: Vec<f64>,
    t_span: (f64, f64),
    f: SystemFn,
}

impl SimpleModel {
    /// Creates a model from initial state, time span, and derivative function.
    pub fn new(y0: Vec<f64>, t_span: (f64, f64), f: SystemFn) -> Self {
        Self { y0, t_span, f }
    }
}

impl DynamicalSystem for SimpleModel {
    fn dimension(&self) -> usize {
        self.y0.len()
    }
    fn derivatives(&self, t: f64, state: &[f64], out: &mut [f64]) {
        (self.f)(t, state, out);
    }
    fn initial_state(&self) -> Vec<f64> {
        self.y0.clone()
    }
    fn time_span(&self) -> (f64, f64) {
        self.t_span
    }
}

/// Simple harmonic oscillator model.
pub struct HarmonicOscillator {
    /// Angular frequency.
    pub omega: f64,
    /// Initial displacement.
    pub x0: f64,
    /// Initial velocity.
    pub v0: f64,
    /// Integration time span.
    pub t_span: (f64, f64),
}

impl DynamicalSystem for HarmonicOscillator {
    fn dimension(&self) -> usize {
        2
    }
    fn derivatives(&self, _t: f64, state: &[f64], out: &mut [f64]) {
        out[0] = state[1];
        out[1] = -self.omega * self.omega * state[0];
    }
    fn initial_state(&self) -> Vec<f64> {
        vec![self.x0, self.v0]
    }
    fn time_span(&self) -> (f64, f64) {
        self.t_span
    }
}

/// Lotka-Volterra predator-prey model.
pub struct LotkaVolterra {
    /// Prey growth rate.
    pub alpha: f64,
    /// Predation rate.
    pub beta: f64,
    /// Predator reproduction rate per prey consumed.
    pub delta: f64,
    /// Predator mortality rate.
    pub gamma: f64,
    /// Initial prey population.
    pub prey0: f64,
    /// Initial predator population.
    pub pred0: f64,
    /// Integration time span.
    pub t_span: (f64, f64),
}

impl DynamicalSystem for LotkaVolterra {
    fn dimension(&self) -> usize {
        2
    }
    fn derivatives(&self, _t: f64, state: &[f64], out: &mut [f64]) {
        let x = state[0];
        let y = state[1];
        out[0] = self.alpha * x - self.beta * x * y;
        out[1] = self.delta * x * y - self.gamma * y;
    }
    fn initial_state(&self) -> Vec<f64> {
        vec![self.prey0, self.pred0]
    }
    fn time_span(&self) -> (f64, f64) {
        self.t_span
    }
}