use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct RunningCov {
pub n: u64,
pub mean: Vec<f64>,
pub c: Vec<f64>,
}
impl RunningCov {
pub fn new() -> RunningCov {
RunningCov::default()
}
pub fn update(&mut self, y: &[f64]) -> (Vec<f64>, Vec<f64>) {
let n = y.len();
if self.n == 0 {
self.mean = vec![0.0; n];
self.c = vec![0.0; n * n];
}
self.n += 1;
let k = self.n as f64;
let delta: Vec<f64> = (0..n).map(|i| y[i] - self.mean[i]).collect();
for i in 0..n {
self.mean[i] += delta[i] / k;
}
let delta2: Vec<f64> = (0..n).map(|i| y[i] - self.mean[i]).collect();
for i in 0..n {
for j in 0..n {
self.c[i * n + j] += delta[i] * delta2[j];
}
}
let cov = if self.n < 2 {
vec![0.0; n * n]
} else {
self.c.iter().map(|&v| v / (k - 1.0)).collect()
};
(self.mean.clone(), cov)
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct EmaCov {
pub alpha: f64,
pub n: u64,
pub mean: Vec<f64>,
pub cov: Vec<f64>,
}
impl EmaCov {
pub fn new() -> EmaCov {
EmaCov::with_alpha(0.05)
}
pub fn with_alpha(alpha: f64) -> EmaCov {
EmaCov {
alpha,
n: 0,
mean: Vec::new(),
cov: Vec::new(),
}
}
pub fn update(&mut self, y: &[f64]) -> (Vec<f64>, Vec<f64>) {
let n = y.len();
if self.n == 0 {
self.mean = y.to_vec();
self.cov = vec![0.0; n * n];
self.n = 1;
return (y.to_vec(), vec![0.0; n * n]);
}
self.n += 1;
let alpha = self.alpha;
let delta: Vec<f64> = (0..n).map(|i| y[i] - self.mean[i]).collect();
for i in 0..n {
self.mean[i] += alpha * delta[i];
}
for i in 0..n {
for j in 0..n {
self.cov[i * n + j] =
(1.0 - alpha) * (self.cov[i * n + j] + alpha * delta[i] * delta[j]);
}
}
(self.mean.clone(), self.cov.clone())
}
}
impl Default for EmaCov {
fn default() -> EmaCov {
EmaCov::new()
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct LedoitWolfCov {
pub shrinkage: f64,
pub inner: EmaCov,
}
impl LedoitWolfCov {
pub fn new() -> LedoitWolfCov {
LedoitWolfCov::with_params(0.05, 0.5)
}
pub fn with_params(alpha: f64, shrinkage: f64) -> LedoitWolfCov {
LedoitWolfCov {
shrinkage,
inner: EmaCov::with_alpha(alpha),
}
}
pub fn update(&mut self, y: &[f64]) -> (Vec<f64>, Vec<f64>) {
let n = y.len();
let (mean, cov) = self.inner.update(y);
let mut shrunk = vec![0.0; n * n];
for i in 0..n {
for j in 0..n {
shrunk[i * n + j] = if i == j {
cov[i * n + j]
} else {
(1.0 - self.shrinkage) * cov[i * n + j]
};
}
}
(mean, shrunk)
}
}
impl Default for LedoitWolfCov {
fn default() -> LedoitWolfCov {
LedoitWolfCov::new()
}
}