Exponential average iter

[janTatesa]

I suggest adding the following iterator

#[derive(Clone, Debug)]
struct ExponentialAverageIter<T, I> {
    last_item: Option<T>,
    iter: I,
    smoothing_factor: f64,
}

impl<T, I> Iterator for ExponentialAverageIter<T, I>
where
    T: Mul<f64, Output = T> + Add<Output = T> + Clone,
    I: Iterator<Item = T>,
{
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        self.iter
            .next()
            .map(|item| match self.last_item.take() {
                Some(rhs) => item * self.smoothing_factor + rhs * (self.smoothing_factor - 1.),
                None => item,
            })
            .inspect(|item| self.last_item = Some(item.clone()))
    }
}

trait Itertools: Iterator {
    fn exponential_average(self, smoothing_factor: f64) -> ExponentialAverageIter<Self::Item, Self>
    where
        Self: Sized,
    {
        ExponentialAverageIter {
            last_item: None,
            iter: self,
            smoothing_factor,
        }
    }
}

[phimuemue]

Hi there, thanks for the idea.

Unfortunately I think this is way too specific to belong into itertools.

Aside: Shouldn't it be item * self.smoothing_factor + rhs * (1. - self.smoothing_factor)?

And: I think this can be acchieved by scan (see here):

#[derive(Clone, Debug)]
struct ExponentialAverageIter<T, I> {
    last_item: Option<T>,
    iter: I,
    smoothing_factor: f64,
}

impl<T, I> Iterator for ExponentialAverageIter<T, I>
where
    T: std::ops::Mul<f64, Output = T> + std::ops::Add<Output = T> + Clone,
    I: Iterator<Item = T>,
{
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        self.iter
            .next()
            .map(|item| match self.last_item.take() {
                Some(rhs) => item * self.smoothing_factor + rhs * (1. - self.smoothing_factor),
                None => item,
            })
            .inspect(|item| self.last_item = Some(item.clone()))
    }
}

trait Itertools: Iterator {
    fn exponential_average(self, smoothing_factor: f64) -> ExponentialAverageIter<Self::Item, Self>
    where
        Self: Sized,
    {
        ExponentialAverageIter {
            last_item: None,
            iter: self,
            smoothing_factor,
        }
    }
}
impl<I:Iterator> Itertools for I {}

fn main() {
    dbg!([1.,2.,3.,4.].into_iter().exponential_average(0.75).collect::<Vec<_>>());
    dbg!([1.,2.,3.,4.].into_iter().scan(None, |old: &mut Option<f32>, new| {
        *old = match old {
            None => Some(new),
            Some(old) => Some(*old*0.25 + new*0.75),
        };
        old.clone()
    }).collect::<Vec<_>>());
}

[scottmcm]

As a meta-answer here, I would say that itertools shouldn't grow any of these kinds of statistics-y methods. That would be better done as a separate, numerics-focused crate that would provide these various kinds of running averages, good stable ways of computing variances, etc. There's more than enough things like that to make a full crate.