mathru 0.16.2

Fundamental algorithms for scientific computing 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

use mathru::analysis::{Function, Jacobian, NewtonRaphson};
use mathru::{
    algebra::linear::{matrix::General, vector::Vector},
    vector,
};

/// Square root calculation with the Newton-Raphson method
///
/// ```math
/// y = x^{2}
/// ```
/// We define a new function which has a root
/// ```math
/// f(x) = x^{2} -y
/// ```
///
/// ```math
/// \frac{df(x)}{dx} = f'(x) = 2x
/// ```
///
fn main() {
    let x: f64 = Sqrt::sqrt(17.0);

    println!("Sqrt: {:?}", x);
}

struct Sqrt {
    y: f64,
}

impl Sqrt {
    ///
    ///
    ///
    pub fn sqrt(y: f64) -> f64 {
        let newton: NewtonRaphson<f64> = NewtonRaphson::default();

        let sqrt: Sqrt = Sqrt { y };

        let x: f64 = newton.find_root(&sqrt, &vector![y]).unwrap()[0];
        return x;
    }
}

impl Jacobian<f64> for Sqrt {
    fn jacobian(&self, x: &Vector<f64>) -> General<f64> {
        return General::from(x.clone().transpose()) * 2.0;
    }
}

impl Function<Vector<f64>> for Sqrt {
    type Codomain = Vector<f64>;
    fn eval(&self, x: &Vector<f64>) -> Self::Codomain {
        return x.clone().apply(&|x: &f64| -> f64 { return x * x - self.y });
    }
}