use crate::engine::config::MeanType;
#[derive(Clone, Debug, Default)]
pub struct RollingBuffer {
inner: std::collections::VecDeque<f32>,
cap: usize,
}
impl RollingBuffer {
pub fn new(cap: usize) -> Self {
RollingBuffer {
inner: std::collections::VecDeque::with_capacity(cap),
cap,
}
}
pub fn push(&mut self, v: f32) {
self.inner.push_back(v);
if self.inner.len() > self.cap {
self.inner.pop_front();
}
}
pub fn iter(&self) -> std::collections::vec_deque::Iter<'_, f32> {
self.inner.iter()
}
pub fn is_empty(&self) -> bool {
self.inner.is_empty()
}
pub fn len(&self) -> usize {
self.inner.len()
}
pub fn clear(&mut self) {
self.inner.clear();
}
pub fn last(&self) -> Option<f32> {
self.inner.back().copied()
}
pub fn from_values(cap: usize, values: &[f32]) -> Self {
let mut buf = RollingBuffer::new(cap);
for &v in values {
buf.push(v);
}
buf
}
}
pub fn rolling_mean(buf: &RollingBuffer) -> f32 {
if buf.is_empty() {
return 0.0;
}
let sum: f32 = buf.iter().sum();
sum / buf.len() as f32
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct WindowStats {
pub n: usize,
pub mean: f32,
pub std: f32,
pub min: f32,
pub max: f32,
pub latest: f32,
pub family: MeanType,
pub fam_center: f32,
pub fam_spread: f32,
}
impl WindowStats {
pub fn se(&self) -> Option<f32> {
(self.n > 0).then(|| self.std / (self.n as f32).sqrt())
}
pub fn score(&self) -> f32 {
self.family.restore(self.fam_center)
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct ReadingTrend {
n: usize,
sum_x: f64,
sum_y: f64,
sum_xx: f64,
sum_xy: f64,
}
impl ReadingTrend {
pub fn push(&mut self, y: f32) {
if !y.is_finite() {
return;
}
let x = self.n as f64;
let y = y as f64;
self.n += 1;
self.sum_x += x;
self.sum_y += y;
self.sum_xx += x * x;
self.sum_xy += x * y;
}
pub fn len(&self) -> usize {
self.n
}
pub fn slope(&self) -> Option<f32> {
if self.n < 2 {
return None;
}
let n = self.n as f64;
let denom = n * self.sum_xx - self.sum_x * self.sum_x;
if denom <= 0.0 {
return None;
}
Some(((n * self.sum_xy - self.sum_x * self.sum_y) / denom) as f32)
}
}
#[derive(Default)]
pub(crate) struct HistoryReplay {
pub window: Vec<(f32, f32, Option<f32>)>,
pub trend: ReadingTrend,
pub metric_windows: Vec<(String, Vec<f32>)>,
}
impl MeanType {
fn transform(self, x: f32) -> f32 {
match self {
MeanType::Arithmetic | MeanType::Median => x,
MeanType::SignedLog => x.signum() * (1.0 + x.abs()).ln(),
}
}
fn restore(self, y: f32) -> f32 {
match self {
MeanType::Arithmetic | MeanType::Median => y,
MeanType::SignedLog => y.signum() * (y.abs().exp() - 1.0),
}
}
}
const MAD_TO_SIGMA: f32 = 1.4826;
fn weighted_median(mut pairs: Vec<(f32, f32)>) -> f32 {
pairs.sort_by(|a, b| a.0.total_cmp(&b.0));
let half = pairs.iter().map(|(_, w)| *w).sum::<f32>() / 2.0;
let mut acc = 0.0;
for (i, (v, w)) in pairs.iter().enumerate() {
acc += *w;
if acc >= half || i + 1 == pairs.len() {
return *v;
}
}
0.0
}
pub fn rolling_stats(buf: &RollingBuffer) -> Option<WindowStats> {
rolling_stats_with(buf, MeanType::Arithmetic)
}
pub fn rolling_stats_with(buf: &RollingBuffer, family: MeanType) -> Option<WindowStats> {
rolling_stats_all(buf, family)
}
pub fn rolling_stats_tail(
buf: &RollingBuffer,
take: usize,
family: MeanType,
) -> Option<WindowStats> {
let take = take.min(buf.len());
if take == 0 {
return None;
}
if take == buf.len() {
return rolling_stats_all(buf, family);
}
let mut tail = RollingBuffer::new(take);
for v in buf.iter().skip(buf.len() - take) {
tail.push(*v);
}
rolling_stats_all(&tail, family)
}
fn rolling_stats_all(buf: &RollingBuffer, family: MeanType) -> Option<WindowStats> {
if buf.is_empty() {
return None;
}
let n = buf.len();
let mean = rolling_mean(buf);
let var = buf.iter().map(|v| (v - mean) * (v - mean)).sum::<f32>() / n as f32;
let (fam_center, fam_spread) = match family {
MeanType::Arithmetic => (mean, var.sqrt()),
MeanType::SignedLog => {
let gmean = buf.iter().map(|v| family.transform(*v)).sum::<f32>() / n as f32;
let gvar = buf
.iter()
.map(|v| {
let d = family.transform(*v) - gmean;
d * d
})
.sum::<f32>()
/ n as f32;
(gmean, gvar.sqrt())
}
MeanType::Median => {
let pairs: Vec<(f32, f32)> = buf.iter().map(|v| (*v, 1.0)).collect();
let center = weighted_median(pairs.clone());
let mad = weighted_median(
pairs
.iter()
.map(|(v, w)| ((v - center).abs(), *w))
.collect(),
);
(center, mad * MAD_TO_SIGMA)
}
};
Some(WindowStats {
n,
mean,
std: var.sqrt(),
min: buf.iter().copied().fold(f32::INFINITY, f32::min),
max: buf.iter().copied().fold(f32::NEG_INFINITY, f32::max),
latest: buf.last().unwrap_or(mean),
family,
fam_center,
fam_spread,
})
}
pub use crate::engine::config::SMOOTHING_WINDOW;
#[cfg(test)]
mod tests {
use super::*;
use crate::engine::config::MeanType;
#[test]
fn rolling_stats_tail_reads_only_the_last_take() {
let buf = RollingBuffer::from_values(5, &[10.0, 10.0, 10.0, 4.0, 6.0]);
let all = rolling_stats_with(&buf, MeanType::Arithmetic).unwrap();
assert_eq!(
(all.n, all.mean),
(5, 8.0),
"the whole buffer is the old reading"
);
let epoch = rolling_stats_tail(&buf, 2, MeanType::Arithmetic).unwrap();
assert_eq!((epoch.n, epoch.mean, epoch.std), (2, 5.0, 1.0));
assert_eq!(
epoch.latest, 6.0,
"the tail keeps the newest reading, not the tail's own order"
);
assert_eq!(
rolling_stats_tail(&buf, 0, MeanType::Arithmetic),
None,
"no reading on this policy ⇒ no reading, never a fabricated 0"
);
let one = rolling_stats_tail(&buf, 1, MeanType::Arithmetic).unwrap();
assert_eq!((one.n, one.mean, one.std), (1, 6.0, 0.0));
assert_eq!(one.score(), 6.0);
}
#[test]
fn rolling_mean_empty_is_zero() {
let buf = RollingBuffer::new(5);
assert_eq!(rolling_mean(&buf), 0.0);
}
#[test]
fn rolling_mean_is_windowed() {
let mut buf = RollingBuffer::new(3);
for v in [1.0, 2.0, 3.0, 4.0] {
buf.push(v);
}
assert_eq!(rolling_mean(&buf), 3.0);
}
#[test]
fn rolling_stats_empty_is_none() {
assert_eq!(rolling_stats(&RollingBuffer::new(5)), None);
}
#[test]
fn rolling_stats_reports_spread_and_se() {
let buf = RollingBuffer::from_values(5, &[40.0, 500.0, 40.0, 40.0, 40.0]);
let s = rolling_stats(&buf).unwrap();
assert_eq!(s.n, 5);
assert_eq!(s.mean, 132.0);
assert_eq!((s.min, s.max), (40.0, 500.0));
assert_eq!(s.latest, 40.0);
assert!((s.std - 184.0).abs() < 0.1, "std was {}", s.std);
let se = s.se().unwrap();
assert!((se - s.std / 5.0_f32.sqrt()).abs() < 1e-4, "se was {se}");
}
#[test]
fn rolling_stats_single_reading_has_no_observable_spread() {
let buf = RollingBuffer::from_values(5, &[300.0]);
let s = rolling_stats(&buf).unwrap();
assert_eq!((s.n, s.mean, s.std), (1, 300.0, 0.0));
assert_eq!((s.min, s.max), (300.0, 300.0));
assert_eq!(s.latest, 300.0);
assert_eq!(s.se(), Some(0.0));
}
#[test]
fn signed_log_damps_a_spike_without_dropping_it() {
let buf = RollingBuffer::from_values(5, &[40.0, 500.0, 40.0, 40.0, 40.0]);
let arith = rolling_stats_with(&buf, MeanType::Arithmetic).unwrap();
let damped = rolling_stats_with(&buf, MeanType::SignedLog).unwrap();
let score = damped.score();
assert!(score < arith.score(), "score was {score}");
assert!(score > 40.0, "the spike must still count: {score}");
let single =
rolling_stats_with(&RollingBuffer::from_values(1, &[-3.5]), MeanType::SignedLog)
.unwrap();
assert!((single.score() + 3.5).abs() < 1e-4);
}
#[test]
fn median_ignores_one_fluke_entirely() {
let buf = RollingBuffer::from_values(5, &[40.0, 500.0, 40.0, 40.0, 40.0]);
let s = rolling_stats_with(&buf, MeanType::Median).unwrap();
assert_eq!(s.fam_center, 40.0);
assert_eq!(s.score(), 40.0);
let mixed = RollingBuffer::from_values(3, &[10.0, 40.0, 90.0]);
let m = rolling_stats_with(&mixed, MeanType::Median).unwrap();
assert_eq!(m.fam_center, 40.0);
assert!(
(m.fam_spread - 30.0 * 1.4826).abs() < 1e-3,
"spread was {}",
m.fam_spread
);
assert_eq!(MeanType::default(), MeanType::Median);
assert_eq!(
rolling_stats_with(&buf, MeanType::Arithmetic)
.unwrap()
.score(),
rolling_stats(&buf).unwrap().score()
);
}
#[test]
fn the_trend_is_the_per_reading_least_squares_slope() {
let mut trend = ReadingTrend::default();
assert_eq!(trend.slope(), None, "one point is not a line");
trend.push(1.0);
assert_eq!(trend.slope(), None, "still one point");
for v in [2.0, 3.0, 4.0] {
trend.push(v);
}
assert_eq!(trend.len(), 4);
assert!(
(trend.slope().unwrap() - 1.0).abs() < 1e-6,
"slope was {:?}",
trend.slope()
);
let mut down = ReadingTrend::default();
for v in [4.0, 3.0, 2.0, 1.0] {
down.push(v);
}
assert!((down.slope().unwrap() + 1.0).abs() < 1e-6);
}
#[test]
fn a_non_finite_reading_does_not_move_the_line() {
let mut clean = ReadingTrend::default();
let mut noisy = ReadingTrend::default();
for v in [2.0, 4.0, 6.0] {
clean.push(v);
}
noisy.push(2.0);
noisy.push(f32::NAN);
noisy.push(4.0);
noisy.push(6.0);
assert_eq!(clean.len(), noisy.len());
assert_eq!(clean.slope(), noisy.slope());
}
}