numint 0.2.0

ODE solvers and numerical integration 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
131
132
133
134
135
136

use std::fmt::Debug;

/// Index for indexing into ODE state.
#[derive(Copy, Clone)]
pub enum StateIndex {
    /// Represents a scalar index.
    ///
    /// This variant indicates that the ODE state is a single scalar value.
    Scalar(),

    /// Represents a vector index.
    ///
    /// This variant is used when indexing into a vector. The associated value specifies the index
    /// of the desired element.
    Vector(usize),

    /// Represents a matrix index.
    ///
    /// This variant is used when indexing into a matrix. The associated values specify the row and
    /// column indices of the desired element.
    Matrix(usize, usize),
}

/// Trait defining an ODE solver state (i.e. the dependent variable in an ODE).
///
/// Any type implementing this trait can be used as the dependent variable in an ODE.
///
/// This crate implements this trait for the following types:
///
/// * `f64`
/// * `Vec<f64>`
/// * `linalg_traits::Mat<f64>`
/// * `nalgebra::DVector<f64>`
/// * `nalgebra::SVector<f64, N>`
/// * `nalgebra::DMatrix<f64>`
/// * `nalgebra::SMatrix<f64, R, C>`
/// * `ndarray::Array1<f64>`
/// * `ndarray::Array2<f64>`
/// * `faer::Mat<f64>`
///
/// # Note on the lack of blanket implementations
///
/// We cannot perform blanket implementations using
/// [`linalg_traits::Scalar`](https://docs.rs/linalg-traits/latest/linalg_traits/trait.Scalar.html),
/// [`linalg_traits::Vector`](https://docs.rs/linalg-traits/latest/linalg_traits/trait.Vector.html),
/// and
/// [`linalg_traits::Matrix`](https://docs.rs/linalg-traits/latest/linalg_traits/trait.Matrix.html).
/// There is nothing restricting types from implementing a combination of these three traits, so the
/// compiler will not allow blanket implementations binding to these traits to avoid any potential
/// conflicting implementations.
pub trait OdeState: Clone + Debug {
    /// Addition (`self + other`).
    ///
    /// # Arguments
    ///
    /// * `other` - The other state to add to this state.
    ///
    /// # Returns
    ///
    /// Sum of this state with the other state (i.e. `self + other`).
    ///
    /// # Panics
    ///
    /// * If `self` and `other` are dynamically-sized types and do not have the same length (for
    ///   vectors) or shape (for matrices).
    fn add(&self, other: &Self) -> Self;

    /// In-place addition (`self += other`).
    ///
    /// # Arguments
    ///
    /// * `other` - The other state to add to this state.
    ///
    /// # Panics
    ///
    /// * If `self` and `other` are dynamically-sized types and do not have the same length (for
    ///   vectors) or shape (for matrices).
    fn add_assign(&mut self, other: &Self);

    /// Subtraction (`self + other`).
    ///
    /// # Arguments
    ///
    /// * `other` - The other state to subtract from this state.
    ///
    /// # Returns
    ///
    /// Difference of this state with the other state (i.e. `self - other`).
    ///
    /// # Panics
    ///
    /// * If `self` and `other` are dynamically-sized types and do not have the same length (for
    ///   vectors) or shape (for matrices).
    fn sub(&self, other: &Self) -> Self;

    /// In-place subtraction (`self -= other`).
    ///
    /// # Arguments
    ///
    /// * `other` - The other state to subtract from this state.
    ///
    /// # Panics
    ///
    /// * If `self` and `other` are dynamically-sized types and do not have the same length (for
    ///   vectors) or shape (for matrices).
    fn sub_assign(&mut self, other: &Self);

    /// Multiplication (`self * other`).
    ///
    /// # Arguments
    ///
    /// * `scalar` - The scalar to multiply this state by.
    ///
    /// # Returns
    ///
    /// Product of this state with the scalar (i.e. `self * scalar`).
    fn mul(&self, scalar: f64) -> Self;

    /// In-place multiplication (`self * other`).
    ///
    /// # Arguments
    ///
    /// * `scalar` - The scalar to multiply this state by.
    fn mul_assign(&mut self, scalar: f64);

    /// Get the value of the state variable at the specified index.
    ///
    /// # Arguments
    ///
    /// * `index` - Index of the state variable to retrieve.
    ///
    /// # Returns
    ///
    /// Value of the state variabe at the specified index.
    fn get_state_variable(&self, index: StateIndex) -> f64;
}