eunoia 0.1.0

A library for creating area-proportional Euler and Venn diagrams
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

use std::borrow::Borrow;

#[cfg(test)]
pub fn approx_eq<I, J>(a: I, b: J, epsilon: f64) -> bool
where
    I: IntoIterator,
    J: IntoIterator,
    I::Item: Borrow<f64>,
    J::Item: Borrow<f64>,
{
    let mut a_iter = a.into_iter();
    let mut b_iter = b.into_iter();
    loop {
        match (a_iter.next(), b_iter.next()) {
            (Some(x), Some(y)) => {
                if (x.borrow() - y.borrow()).abs() > epsilon {
                    return false;
                }
            }
            (None, None) => return true,
            _ => return false, // different lengths
        }
    }
}

#[cfg(test)]
pub fn approx_eq_scalar(a: f64, b: f64, epsilon: f64) -> bool {
    (a - b).abs() <= epsilon
}

#[cfg(test)]
#[macro_export]
macro_rules! assert_approx_eq {
    // Special case for f64 literals or expressions that are clearly f64
    ($left:expr, $right:expr, $epsilon:expr) => {{
        $crate::_assert_approx_eq_impl!($left, $right, $epsilon)
    }};
    ($left:expr, $right:expr, $epsilon:expr, $($arg:tt)+) => {{
        $crate::_assert_approx_eq_impl!($left, $right, $epsilon, $($arg)+)
    }};
}

#[cfg(test)]
#[macro_export]
#[doc(hidden)]
macro_rules! _assert_approx_eq_impl {
    ($left:expr, $right:expr, $epsilon:expr) => {{
        // Helper trait to dispatch
        trait ApproxEqDispatch {
            fn approx_eq_dispatch(&self, other: &Self, epsilon: f64) -> bool;
        }

        impl ApproxEqDispatch for f64 {
            fn approx_eq_dispatch(&self, other: &Self, epsilon: f64) -> bool {
                $crate::test_utils::approx_eq_scalar(*self, *other, epsilon)
            }
        }

        impl<T> ApproxEqDispatch for &T
        where
            for<'a> &'a T: IntoIterator,
            for<'a> <&'a T as IntoIterator>::Item: std::borrow::Borrow<f64>,
        {
            fn approx_eq_dispatch(&self, other: &Self, epsilon: f64) -> bool {
                $crate::test_utils::approx_eq(*self, *other, epsilon)
            }
        }

        let eps = $epsilon;
        let left_val = &$left;
        let right_val = &$right;

        if !left_val.approx_eq_dispatch(right_val, eps) {
            panic!(
                "assertion failed: `approx_eq(left, right, epsilon)`\n  left: `{:?}`\n right: `{:?}`\nepsilon: `{:?}`",
                left_val, right_val, eps
            );
        }
    }};
    ($left:expr, $right:expr, $epsilon:expr, $($arg:tt)+) => {{
        trait ApproxEqDispatch {
            fn approx_eq_dispatch(&self, other: &Self, epsilon: f64) -> bool;
        }

        impl ApproxEqDispatch for f64 {
            fn approx_eq_dispatch(&self, other: &Self, epsilon: f64) -> bool {
                $crate::test_utils::approx_eq_scalar(*self, *other, epsilon)
            }
        }

        impl<T> ApproxEqDispatch for &T
        where
            for<'a> &'a T: IntoIterator,
            for<'a> <&'a T as IntoIterator>::Item: std::borrow::Borrow<f64>,
        {
            fn approx_eq_dispatch(&self, other: &Self, epsilon: f64) -> bool {
                $crate::test_utils::approx_eq(*self, *other, epsilon)
            }
        }

        let eps = $epsilon;
        let left_val = &$left;
        let right_val = &$right;

        if !left_val.approx_eq_dispatch(right_val, eps) {
            panic!(
                "assertion failed: `approx_eq(left, right, epsilon)`\n  left: `{:?}`\n right: `{:?}`\nepsilon: `{:?}`: {}",
                left_val, right_val, eps, format_args!($($arg)+)
            );
        }
    }};
}