use serde::{Deserialize, Serialize};
use std::collections::VecDeque;
pub const DEFAULT_LAGS: [usize; 16] = [
2, 3, 4, 5, 6, 7, 12, 14, 24, 28, 30, 52, 60, 90, 168, 365,
];
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct PeriodDetector {
pub lags: Vec<usize>,
pub alpha: f64,
pub min_observations: u64,
pub max_lag: usize,
pub buffer: VecDeque<f64>,
pub n: u64,
pub mean: f64,
pub var: f64,
pub cross: Vec<f64>,
}
impl PeriodDetector {
pub fn new() -> PeriodDetector {
PeriodDetector::with_params(None, 0.01, 50)
}
pub fn with_params(
lags: Option<Vec<usize>>,
alpha: f64,
min_observations: u64,
) -> PeriodDetector {
let lags = lags.unwrap_or_else(|| DEFAULT_LAGS.to_vec());
let max_lag = *lags.iter().max().expect("lags must be non-empty");
let n_lags = lags.len();
PeriodDetector {
lags,
alpha,
min_observations,
max_lag,
buffer: VecDeque::new(),
n: 0,
mean: 0.0,
var: 0.0,
cross: vec![0.0; n_lags],
}
}
pub fn step(&mut self, y: f64) -> Vec<(usize, f64)> {
self.buffer.push_back(y);
self.n += 1;
let diff = y - self.mean;
self.mean += self.alpha * diff;
self.var = (1.0 - self.alpha) * (self.var + self.alpha * diff * diff);
let mu = self.mean;
let var = self.var;
let nb = self.buffer.len();
for (li, &lag) in self.lags.iter().enumerate() {
if nb > lag {
let y_lagged = self.buffer[nb - (lag + 1)];
let cross = (y - mu) * (y_lagged - mu);
self.cross[li] = (1.0 - self.alpha) * self.cross[li] + self.alpha * cross;
}
}
if self.buffer.len() > self.max_lag + 1 {
self.buffer.pop_front();
}
if self.n < self.min_observations || var < 1e-12 {
return Vec::new();
}
let mut scores: Vec<(usize, f64)> = Vec::new();
for (li, &lag) in self.lags.iter().enumerate() {
if self.n > lag as u64 {
let acf = if var > 0.0 { self.cross[li] / var } else { 0.0 };
scores.push((lag, acf));
}
}
scores.sort_by(|a, b| {
b.1.abs()
.partial_cmp(&a.1.abs())
.unwrap_or(std::cmp::Ordering::Equal)
});
scores
}
}
impl Default for PeriodDetector {
fn default() -> PeriodDetector {
PeriodDetector::new()
}
}
pub fn top_periods(scores: &[(usize, f64)], threshold: f64, max_periods: usize) -> Vec<usize> {
scores
.iter()
.take(max_periods)
.filter(|(_, acf)| acf.abs() >= threshold)
.map(|&(lag, _)| lag)
.collect()
}