russell_lab 1.11.0

Scientific laboratory for linear algebra and numerical mathematics
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
137
138

use num_traits::{Num, NumCast};

/// Panics if two arrays (vectors) are not approximately equal to each other
///
/// # Panics
///
/// 1. Will panic if the dimensions are different
/// 2. Will panic if NAN, INFINITY, or NEG_INFINITY is found
/// 3. Will panic if the absolute difference of components is greater than the tolerance
///
/// # Examples
///
/// ## Accepts small error
///
/// ```
/// use russell_lab::array_approx_eq;
///
/// fn main() {
///     let u = vec![3.0000001, 2.0];
///     let v = vec![3.0,       2.0];
///     array_approx_eq(&u, &v, 1e-6);
/// }
/// ```
///
/// ## Panics on different value
///
/// ```should_panic
/// use russell_lab::array_approx_eq;
///
/// fn main() {
///     let u = vec![3.0000001, 2.0];
///     let v = vec![4.0,       2.0];
///     array_approx_eq(&u, &v, 1e-6);
/// }
/// ```
pub fn array_approx_eq<T>(u: &[T], v: &[T], tol: f64)
where
    T: Num + NumCast + Copy,
{
    let m = u.len();
    if m != v.len() {
        panic!("vector dimensions differ. {} != {}", m, v.len());
    }
    for i in 0..m {
        let ui = u[i].to_f64().unwrap();
        let vi = v[i].to_f64().unwrap();
        if ui.is_nan() {
            panic!("NaN found in the first vector");
        }
        if vi.is_nan() {
            panic!("NaN found in the second vector");
        }
        if ui.is_infinite() {
            panic!("Inf found in the first vector");
        }
        if vi.is_infinite() {
            panic!("Inf found in the second vector");
        }
        let diff = f64::abs(u[i].to_f64().unwrap() - v[i].to_f64().unwrap());
        if diff > tol {
            panic!("vectors are not approximately equal. diff[{}] = {:?}", i, diff);
        }
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#[cfg(test)]
mod tests {
    use super::array_approx_eq;

    #[test]
    #[should_panic(expected = "NaN found in the first vector")]
    fn panics_on_nan_1() {
        array_approx_eq(&[f64::NAN], &[2.5], 1e-1);
    }

    #[test]
    #[should_panic(expected = "NaN found in the second vector")]
    fn panics_on_nan_2() {
        array_approx_eq(&[2.5], &[f64::NAN], 1e-1);
    }

    #[test]
    #[should_panic(expected = "Inf found in the first vector")]
    fn panics_on_inf_1() {
        array_approx_eq(&[f64::INFINITY], &[2.5], 1e-1);
    }

    #[test]
    #[should_panic(expected = "Inf found in the second vector")]
    fn panics_on_inf_2() {
        array_approx_eq(&[2.5], &[f64::INFINITY], 1e-1);
    }

    #[test]
    #[should_panic(expected = "Inf found in the first vector")]
    fn panics_on_neg_inf_1() {
        array_approx_eq(&[f64::NEG_INFINITY], &[2.5], 1e-1);
    }

    #[test]
    #[should_panic(expected = "Inf found in the second vector")]
    fn panics_on_neg_inf_2() {
        array_approx_eq(&[2.5], &[f64::NEG_INFINITY], 1e-1);
    }

    #[test]
    #[should_panic(expected = "vector dimensions differ. 2 != 3")]
    fn array_approx_eq_works_1() {
        let u = &[0.0, 0.0];
        let v = &[0.0, 0.0, 0.0];
        array_approx_eq(u, v, 1e-15);
    }

    #[test]
    #[should_panic(expected = "vectors are not approximately equal. diff[0] = 1.5")]
    fn array_approx_eq_works_2() {
        let u = &[1.0, 2.0, 3.0, 4.0];
        let v = &[2.5, 1.0, 1.5, 2.0];
        array_approx_eq(u, v, 1e-15);
    }

    #[test]
    #[should_panic(expected = "vectors are not approximately equal. diff[2] =")]
    fn array_approx_eq_works_3() {
        let u = &[0.0, 0.0, 0.0];
        let v = &[0.0, 0.0, 1e-14];
        array_approx_eq(u, v, 1e-15);
    }

    #[test]
    fn array_approx_eq_works_4() {
        let u = &[0.0, 0.0, 0.0];
        let v = &[0.0, 0.0, 1e-15];
        array_approx_eq(u, v, 1e-15);
    }
}