use num_traits::{One, Zero};
use std::ops::{Add, Div};
pub struct Averager<T>
where
T: Add + Div + Zero + One + Copy,
{
sum: T,
count: T,
}
impl<T> Default for Averager<T>
where
T: Add<Output = T> + Div<Output = T> + Zero + One + Copy,
{
fn default() -> Self {
Self::new()
}
}
impl<T> Averager<T>
where
T: Add<Output = T> + Div<Output = T> + Zero + One + Copy,
{
pub fn new() -> Self {
Self {
sum: T::zero(),
count: T::zero(),
}
}
pub fn add(&mut self, value: T) {
self.sum = self.sum + value;
self.count = self.count + T::one();
}
pub fn add_weight(&mut self, value: T, weight: T) {
self.sum = self.sum + (value * weight);
self.count = self.count + weight;
}
pub fn average(&self) -> Option<T> {
if self.count.is_zero() {
return None;
}
Some(self.sum / self.count)
}
}
#[cfg(test)]
mod tests {
use super::*;
use approx::assert_relative_eq;
#[test]
fn empty_returns_none() {
let a = Averager::<f64>::new();
assert!(a.average().is_none());
}
#[test]
fn default_returns_none() {
let a = Averager::<f64>::default();
assert!(a.average().is_none());
}
#[test]
fn single_value_returns_that_value() {
let mut a = Averager::<f64>::new();
a.add(7.0);
assert_relative_eq!(a.average().unwrap(), 7.0);
}
#[test]
fn two_values_returns_mean() {
let mut a = Averager::<f64>::new();
a.add(3.0);
a.add(7.0);
assert_relative_eq!(a.average().unwrap(), 5.0);
}
#[test]
fn multiple_values_returns_mean() {
let mut a = Averager::<f64>::new();
for v in [1.0, 2.0, 3.0, 4.0, 5.0] {
a.add(v);
}
assert_relative_eq!(a.average().unwrap(), 3.0);
}
#[test]
fn weighted_single_value_returns_that_value() {
let mut a = Averager::<f64>::new();
a.add_weight(4.0, 10.0);
assert_relative_eq!(a.average().unwrap(), 4.0);
}
#[test]
fn weighted_average_two_values() {
let mut a = Averager::<f64>::new();
a.add_weight(0.0, 1.0);
a.add_weight(10.0, 3.0); assert_relative_eq!(a.average().unwrap(), 7.5);
}
#[test]
fn equal_weights_match_unweighted() {
let mut weighted = Averager::<f64>::new();
let mut unweighted = Averager::<f64>::new();
for v in [2.0, 5.0, 8.0] {
weighted.add_weight(v, 1.0);
unweighted.add(v);
}
assert_relative_eq!(
weighted.average().unwrap(),
unweighted.average().unwrap(),
epsilon = 1e-10
);
}
#[test]
fn integer_average() {
let mut a = Averager::<i32>::new();
a.add(4);
a.add(6);
assert_eq!(a.average().unwrap(), 5);
}
}