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

//! Assertions for array

use ndarray::*;

use super::norm::*;
use super::types::*;

/// check two values are close in terms of the relative torrence
pub fn rclose<A: Scalar>(test: A, truth: A, rtol: A::Real) -> Result<A::Real, A::Real> {
    let dev = (test - truth).abs() / truth.abs();
    if dev < rtol {
        Ok(dev)
    } else {
        Err(dev)
    }
}

/// check two values are close in terms of the absolute torrence
pub fn aclose<A: Scalar>(test: A, truth: A, atol: A::Real) -> Result<A::Real, A::Real> {
    let dev = (test - truth).abs();
    if dev < atol {
        Ok(dev)
    } else {
        Err(dev)
    }
}

/// check two arrays are close in maximum norm
pub fn close_max<A, S1, S2, D>(
    test: &ArrayBase<S1, D>,
    truth: &ArrayBase<S2, D>,
    atol: A::Real,
) -> Result<A::Real, A::Real>
where
    A: Scalar,
    S1: Data<Elem = A>,
    S2: Data<Elem = A>,
    D: Dimension,
{
    let tol = (test - truth).norm_max();
    if tol < atol {
        Ok(tol)
    } else {
        Err(tol)
    }
}

/// check two arrays are close in L1 norm
pub fn close_l1<A, S1, S2, D>(
    test: &ArrayBase<S1, D>,
    truth: &ArrayBase<S2, D>,
    rtol: A::Real,
) -> Result<A::Real, A::Real>
where
    A: Scalar,
    S1: Data<Elem = A>,
    S2: Data<Elem = A>,
    D: Dimension,
{
    let tol = (test - truth).norm_l1() / truth.norm_l1();
    if tol < rtol {
        Ok(tol)
    } else {
        Err(tol)
    }
}

/// check two arrays are close in L2 norm
pub fn close_l2<A, S1, S2, D>(
    test: &ArrayBase<S1, D>,
    truth: &ArrayBase<S2, D>,
    rtol: A::Real,
) -> Result<A::Real, A::Real>
where
    A: Scalar,
    S1: Data<Elem = A>,
    S2: Data<Elem = A>,
    D: Dimension,
{
    let tol = (test - truth).norm_l2() / truth.norm_l2();
    if tol < rtol {
        Ok(tol)
    } else {
        Err(tol)
    }
}

macro_rules! generate_assert {
    ($assert:ident, $close:path) => {
        #[macro_export]
        macro_rules! $assert {
            ($test: expr,$truth: expr,$tol: expr) => {
                $crate::$close($test, $truth, $tol).unwrap();
            };
            ($test: expr,$truth: expr,$tol: expr; $comment: expr) => {
                $crate::$close($test, $truth, $tol).expect($comment);
            };
        }
    };
} // generate_assert!

generate_assert!(assert_rclose, rclose);
generate_assert!(assert_aclose, aclose);
generate_assert!(assert_close_max, close_max);
generate_assert!(assert_close_l1, close_l1);
generate_assert!(assert_close_l2, close_l2);