flat 0.1.6

Project multi-dimensional data onto the **flat** textual plane.
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

use std::ops::{Add, Sub};
// We use this in the doc strings.
#[allow(unused_imports)]
use super::Histogram;

/// Render configuration specific to [`Histogram`]s.
///
/// ### Example
/// ```
/// # use flat::HistogramConfig;
/// let histogram_config = HistogramConfig {
///     ..HistogramConfig::default()
/// };
/// ```
#[derive(Debug, Default)]
pub struct HistogramConfig {}

/// Allows a type `T` to be used as the *primary* dimension of a [`Histogram`].
/// Consumers may choose to implement this to bin non-standard types in a histogram.
pub trait Binnable: PartialEq + PartialOrd + Add + Sub + Sized {
    /// Multiply this value (`self: T`) by the `rhs: usize`, resulting in another `T`.
    ///
    /// **Notice**: For *whole* types `T` (types that belong to ℤ) the resulting value **must** be rounded up.
    /// In other words, implement `multiply` using `ceil` for integer types.
    fn multiply(&self, rhs: usize) -> Self;

    /// Divide this value (`self: T`) by the `rhs: usize`, resulting in another `T`.
    ///
    /// **Notice**: For *whole* types `T` (types that belong to ℤ) the resulting value **must** be rounded up.
    /// In other words, implement `divide` using `ceil` for integer types.
    fn divide(&self, rhs: usize) -> Self;
}

macro_rules! impl_binnable {
    ($T:ty) => {
        impl Binnable for $T {
            fn multiply(&self, rhs: usize) -> Self {
                self * (rhs as $T)
            }

            fn divide(&self, rhs: usize) -> Self {
                self / (rhs as $T)
            }
        }
    };
}

impl_binnable!(f64);
impl_binnable!(f32);

macro_rules! impl_ceil_binnable {
    ($T:ty) => {
        impl Binnable for $T {
            fn multiply(&self, rhs: usize) -> Self {
                (*self as f64 * (rhs as f64)).ceil() as $T
            }

            fn divide(&self, rhs: usize) -> Self {
                (*self as f64 / (rhs as f64)).ceil() as $T
            }
        }
    };
}

impl_ceil_binnable!(isize);
impl_ceil_binnable!(i64);
impl_ceil_binnable!(i32);
impl_ceil_binnable!(i16);
impl_ceil_binnable!(i8);
impl_ceil_binnable!(usize);
impl_ceil_binnable!(u64);
impl_ceil_binnable!(u32);
impl_ceil_binnable!(u16);
impl_ceil_binnable!(u8);

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

    #[test]
    fn binnable_f64() {
        assert_eq!(0.0f64.multiply(0), 0.0);
        assert_eq!(1.0f64.multiply(0), 0.0);
        assert_eq!(1.5f64.multiply(0), 0.0);

        assert_eq!(0.0f64.multiply(1), 0.0);
        assert_eq!(1.0f64.multiply(1), 1.0);
        assert_eq!(1.5f64.multiply(1), 1.5);

        assert_eq!(0.0f64.divide(1), 0.0);
        assert_eq!(1.0f64.divide(1), 1.0);
        assert_eq!(1.5f64.divide(1), 1.5);

        assert_eq!(0.0f64.divide(2), 0.0);
        assert_eq!(1.0f64.divide(2), 0.5);
        assert_eq!(1.5f64.divide(2), 0.75);
    }

    #[test]
    fn binnable_i64() {
        assert_eq!(0i64.multiply(0), 0);
        assert_eq!(1i64.multiply(0), 0);
        assert_eq!(2i64.multiply(0), 0);

        assert_eq!(0i64.multiply(1), 0);
        assert_eq!(1i64.multiply(1), 1);
        assert_eq!(2i64.multiply(1), 2);

        assert_eq!(0i64.divide(1), 0);
        assert_eq!(1i64.divide(1), 1);
        assert_eq!(2i64.divide(1), 2);

        assert_eq!(0i64.divide(2), 0);
        assert_eq!(1i64.divide(2), 1);
        assert_eq!(2i64.divide(2), 1);
    }
}