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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

/// Assert that two numbers are almost equal to each other.
///
/// On panic, this macro will print the values of the expressions with their
/// debug representations.
#[macro_export]
macro_rules! assert_almost_eq {
    ($a:expr, $b:expr, $prec:expr) => (
        let diff = ($a - $b).abs();
        if diff > $prec {
            panic!(format!(
                "assertion failed: `abs(left - right) = {:.1e} < {:e}`, \
                 (left: `{}`, right: `{}`)",
                diff, $prec, $a, $b));
        }
    );
}

/// Concatenate several iterative estimators into one.
///
/// `$name` is the name of the new struct. `$statistic` is the name of a
/// statistic and must exist as a method of the corresponding type `$estimator`.
/// `$estimator` must have an `add` method for adding new observations to the
/// sample (taking an `f64` as an argument). It must also implement `Default`.
///
/// If the short syntax is used, the fields will be named `$statistic`. Use the
/// long syntax and `$field` to give them explicit names. The long syntax also
/// supports calculating several statistics from one estimator.
///
/// For moments, only an estimator for the highest moment should be used and
/// reused for the lower moments (see the example below).
///
/// The following methods will be implemented: `new`, `add`, `$statistic`.
///
/// The following traits will be implemented: `Default`, `FromIterator<f64>`.
///
///
/// # Examples
///
/// ```
/// # extern crate core;
/// # #[macro_use] extern crate average;
/// # fn main() {
/// use average::{Min, Max, Estimate};
///
/// concatenate!(MinMax, [Min, min], [Max, max]);
///
/// let s: MinMax = (1..6).map(Into::into).collect();
///
/// assert_eq!(s.min(), 1.0);
/// assert_eq!(s.max(), 5.0);
/// # }
/// ```
///
/// The generated code looks roughly like this:
///
/// ```
/// # use average::{Min, Max, Estimate};
/// #
/// struct MinMax {
///     min: Min,
///     max: Max,
/// }
///
/// impl MinMax {
///     pub fn new() -> MinMax {
///         MinMax { min: Min::default(), max: Max::default() }
///     }
///
///     pub fn add(&mut self, x: f64) {
///         self.min.add(x);
///         self.max.add(x);
///     }
///
///     pub fn min(&self) -> f64 {
///         self.min.min()
///     }
///
///     pub fn max(&self) -> f64 {
///         self.max.max()
///     }
/// }
/// ```
///
/// If you want to calculate the mean, variance and the median in one pass, you
/// can do the following:
///
/// ```
/// # extern crate core;
/// # #[macro_use] extern crate average;
/// # fn main() {
/// use average::{Variance, Quantile, Estimate};
///
/// concatenate!(Estimator,
///     [Variance, variance, mean, sample_variance],
///     [Quantile, quantile, quantile]);
/// # }
/// ```
#[macro_export]
macro_rules! concatenate {
    ( $name:ident, $([$estimator:ident, $statistic:ident]),+ ) => {
        concatenate!( $name, $([$estimator, $statistic, $statistic]),* )
    };
    ( $name:ident, $( [$estimator:ident, $field:ident, $($statistic:ident),+] ),+ ) => {
        struct $name {
        $(
            $field: $estimator,
        )*
        }

        impl $name {
            #[inline]
            pub fn new() -> $name {
                $name {
                $(
                    $field: ::core::default::Default::default(),
                )*
                }
            }

            #[inline]
            pub fn add(&mut self, x: f64) {
                $(
                    self.$field.add(x);
                )*
            }

            $( $(
                #[inline]
                pub fn $statistic(&self) -> f64 {
                    self.$field.$statistic()
                }
            )* )*
        }

        impl Default for $name {
            fn default() -> $name {
                $name::new()
            }
        }

        impl_from_iterator!($name);
    };
}

/// Implement `FromIterator<f64>` for an iterative estimator.
#[macro_export]
macro_rules! impl_from_iterator {
    ( $name:ident ) => {
        impl ::core::iter::FromIterator<f64> for $name {
            fn from_iter<T>(iter: T) -> $name
                where T: IntoIterator<Item=f64>
            {
                let mut e = $name::new();
                for i in iter {
                    e.add(i);
                }
                e
            }
        }
    };
}