#![allow(clippy::many_single_char_names, clippy::too_many_arguments)]
use core::{
cmp::Ordering,
f64::consts::PI,
result::Result,
};
use alloc::{
collections::BTreeSet,
vec,
vec::Vec,
};
use libm::{sqrt, log as ln, exp, pow, sin, cos, round};
use crate::{constants::*, svd, Confidence, Error, Flair, Freq};
impl Freq {
pub fn secondly(n: usize) -> Result<Self, Error> {
match n {
10 => Ok(Freq::Secondly(n)),
_ => Err(Error::InvalidFreq(n)),
}
}
pub fn minutely(n: usize) -> Result<Self, Error> {
match n {
5 | 10 | 15 | 30 => Ok(Freq::Minutely(n)),
_ => Err(Error::InvalidFreq(n)),
}
}
pub fn hourly(n: usize) -> Result<Self, Error> {
match n {
1 | 12 => Ok(Freq::Hourly(n)),
_ => Err(Error::InvalidFreq(n)),
}
}
}
pub struct FlairStruct;
impl Flair for FlairStruct {
fn forecast(
y: &[f64],
frequency: &Freq,
horizon: usize,
n_samples: usize,
seed: u64,
covariates: Option<(&[f64], &[f64])>, ) -> Result<(Vec<Vec<f64>>, Confidence), Error>{
if y.is_empty() { return Err(Error::InvalidInput("y must not be empty")); }
if horizon < 1 { return Err(Error::InvalidInput("horizon must be >= 1")); }
if n_samples < 1 { return Err(Error::InvalidInput("n_samples must be >= 1")); }
if let Some((x_hist, x_future)) = covariates {
if x_hist.is_empty() || x_future.is_empty() {
return Err(Error::InvalidInput("covariates must not be empty"));
}
if x_hist.len() % y.len() != 0 {
return Err(Error::InvalidInput("x_historical length must be a multiple of y length"));
}
let k = x_hist.len() / y.len();
if x_future.len() != horizon * k {
return Err(Error::InvalidInput("x_future length must equal horizon * k"));
}
}
forecast(y, horizon, frequency, n_samples, seed)
}
fn forecast_mean(
y: &[f64],
frequency: &Freq,
horizon: usize,
n_samples: usize,
seed: u64,
_covariates: Option<(&[f64], &[f64])>,
) -> Result<(Vec<f64>, Confidence), Error>{
let (samples, conf) = forecast(y, horizon, frequency, n_samples, seed)?;
let mean = (0..horizon)
.map(|h| samples.iter().map(|s| s[h]).sum::<f64>() / n_samples as f64)
.collect();
Ok((mean, conf))
}
fn forecast_quantiles(
y: &[f64],
frequency: &Freq,
horizon: usize,
n_samples: usize,
seed: u64,
_covariates: Option<(&[f64], &[f64])>,
quantiles: &[f64],
) -> Result<(Vec<Vec<f64>>, Confidence), Error>{
if quantiles.is_empty() || quantiles.iter().any(|&q| !(0.0..=1.0).contains(&q)) {
return Err(Error::InvalidInput("quantiles must be non-empty and each value in [0.0, 1.0]"));
}
let (samples, conf) = forecast(y, horizon, frequency, n_samples, seed)?;
let result = quantiles.iter().map(|&q| {
(0..horizon).map(|h| {
let mut col: Vec<f64> = samples.iter().map(|s| s[h]).collect();
col.sort_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal));
let idx = round(q * (n_samples - 1) as f64) as usize;
col[idx]
}).collect()
}).collect();
Ok((result, conf))
}
}
fn get_period(frequency: &Freq) -> usize {
match frequency {
Freq::Secondly(10) => 6,
Freq::Minutely(5) => 12,
Freq::Minutely(10) => 6,
Freq::Minutely(15) => 4,
Freq::Minutely(30) => 48,
Freq::Hourly(1) => 24,
Freq::Hourly(12) => 2,
Freq::Daily => 7,
Freq::Weekly => 52,
Freq::Monthly => 12,
Freq::Quarterly => 4,
Freq::Yearly => 1,
_ => 1,
}
}
fn get_periods(frequency: &Freq) -> Vec<usize> {
match frequency {
Freq::Secondly(10) => vec![6],
Freq::Minutely(5) => vec![12, 288],
Freq::Minutely(10) => vec![6, 144],
Freq::Minutely(15) => vec![4, 96],
Freq::Minutely(30) => vec![48, 336],
Freq::Hourly(1) => vec![24, 168],
Freq::Hourly(12) => vec![2, 14],
Freq::Daily => vec![7, 365],
Freq::Weekly => vec![52],
Freq::Monthly => vec![12],
Freq::Quarterly => vec![4],
Freq::Yearly => vec![],
_ => vec![],
}
}
struct Rng(u64);
impl Rng {
fn new(seed: u64) -> Self {
Rng(if seed == 0 { 0xdeadbeefcafe1234 } else { seed })
}
fn next_u64(&mut self) -> u64 {
let mut x = self.0;
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
self.0 = x;
x
}
fn next_f64(&mut self) -> f64 {
(self.next_u64() >> 11) as f64 * (1.0 / (1u64 << 53) as f64)
}
fn randint(&mut self, n: usize) -> usize {
debug_assert!(n > 0);
self.next_u64() as usize % n
}
fn normal(&mut self) -> f64 {
let u1 = self.next_f64().max(1e-300);
let u2 = self.next_f64();
sqrt(-2.0 * ln(u1)) * cos(2.0 * PI * u2)
}
fn student_t(&mut self, nu: f64) -> f64 {
let z = self.normal();
let chi2: f64 = (0..nu.min(50.0) as usize).map(|_| { let n = self.normal(); n * n }).sum::<f64>();
let chi2 = chi2.max(EPS);
z / sqrt(chi2 / nu)
}
}
fn bc_lambda(y: &[f64]) -> f64 {
let yp: Vec<f64> = y.iter().copied().filter(|&v| v > 0.0).collect();
if yp.len() < MIN_POSITIVE_FOR_BC {
return 1.0;
}
let n = yp.len() as f64;
let log_sum: f64 = yp.iter().map(|&v| ln(v)).sum();
let llf = |lam: f64| -> f64 {
let yt: Vec<f64> = if lam.abs() < 1e-10 {
yp.iter().map(|&v| ln(v)).collect()
} else {
yp.iter().map(|&v| (pow(v, lam) - 1.0) / lam).collect()
};
let m = yt.iter().sum::<f64>() / n;
let var = yt.iter().map(|&v| pow(v - m, 2.0)).sum::<f64>() / n;
if var < EPS_LOG { return f64::NEG_INFINITY; }
(lam - 1.0) * log_sum - n / 2.0 * ln(var)
};
let phi = (sqrt(5.0_f64) - 1.0) / 2.0;
let (mut a, mut b) = (0.0f64, 1.0f64);
let mut c = b - phi * (b - a);
let mut d = a + phi * (b - a);
let mut fc = llf(c);
let mut fd = llf(d);
for _ in 0..60 {
if (b - a) < 1e-7 { break; }
if fc < fd { a = c; c = d; fc = fd; d = a + phi * (b - a); fd = llf(d); }
else { b = d; d = c; fd = fc; c = b - phi * (b - a); fc = llf(c); }
}
((a + b) / 2.0).clamp(0.0, 1.0)
}
fn bc(y: &[f64], lam: f64) -> Vec<f64> {
y.iter().map(|&v| {
let v = v.max(EPS_BOXCOX);
if lam == 0.0 { ln(v) } else { (pow(v, lam) - 1.0) / lam }
}).collect()
}
fn bc_inv(z: &[f64], lam: f64) -> Vec<f64> {
z.iter().map(|&v| {
if lam == 0.0 {
exp(v.clamp(-BC_EXP_CLIP, BC_EXP_CLIP))
} else {
pow((v * lam + 1.0).max(EPS), 1.0 / lam)
}
}).collect()
}
fn interp_nan(arr: &[f64]) -> Vec<f64> {
let valid: Vec<usize> = arr.iter().enumerate()
.filter(|&(_, &v)| !v.is_nan())
.map(|(i, _)| i)
.collect();
match valid.len() {
0 => vec![0.0; arr.len()],
1 => arr.iter().map(|&v| if v.is_nan() { arr[valid[0]] } else { v }).collect(),
_ => arr.iter().enumerate().map(|(i, &v)| {
if !v.is_nan() { return v; }
let lo = valid.partition_point(|&j| j < i);
if lo == 0 {
arr[valid[0]]
} else if lo == valid.len() {
arr[valid[valid.len() - 1]]
} else {
let x0 = valid[lo - 1];
let x1 = valid[lo];
let t = (i - x0) as f64 / (x1 - x0) as f64;
arr[x0] + t * (arr[x1] - arr[x0])
}
}).collect(),
}
}
fn logspace(lo: f64, hi: f64, n: usize) -> Vec<f64> {
(0..n).map(|i| pow(10.0_f64, lo + (hi - lo) * i as f64 / (n - 1) as f64)).collect()
}
fn slice_mean(v: &[f64]) -> f64 { v.iter().sum::<f64>() / v.len() as f64 }
fn ridge_sa(x_rows: &[Vec<f64>], y: &[f64]) -> Result<(Vec<f64>, Vec<f64>, f64, Vec<Vec<f64>>, Vec<f64>, Vec<f64>), Error> {
let m = x_rows.len();
let nf = x_rows[0].len();
let (u, s, vt) = svd::svd(x_rows);
let k = s.len();
let s2: Vec<f64> = s.iter().map(|&v| v * v).collect();
let uty: Vec<f64> = (0..k).map(|j| (0..m).map(|i| u[i][j] * y[i]).sum()).collect();
let alphas = logspace(ALPHA_LOG_MIN, ALPHA_LOG_MAX, N_ALPHAS);
let mut gcv = vec![0.0f64; N_ALPHAS];
for (ai, &a) in alphas.iter().enumerate() {
let d: Vec<f64> = s2.iter().map(|&v| v / (v + a)).collect();
let h: Vec<f64> = (0..m).map(|i| (0..k).map(|j| u[i][j] * u[i][j] * d[j]).sum()).collect();
let r: Vec<f64> = (0..m).map(|i| {
y[i] - (0..k).map(|j| u[i][j] * d[j] * uty[j]).sum::<f64>()
}).collect();
gcv[ai] = r.iter().zip(h.iter())
.map(|(&ri, &hi)| pow(ri / (1.0 - hi).max(EPS), 2.0))
.sum::<f64>() / m as f64;
}
let gcv_min = gcv.iter().cloned().fold(f64::INFINITY, f64::min);
let log_w: Vec<f64> = gcv.iter().map(|&g| -(g - gcv_min) / gcv_min.max(EPS)).collect();
let lw_max = log_w.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
let w_raw: Vec<f64> = log_w.iter().map(|&lw| exp(lw - lw_max)).collect();
let w_sum: f64 = w_raw.iter().sum();
let w: Vec<f64> = w_raw.iter().map(|&wi| wi / w_sum).collect();
let mut beta = vec![0.0f64; nf];
let mut d_avg = vec![0.0f64; k];
for (&wi, &a) in w.iter().zip(alphas.iter()) {
if wi < EPS_WEIGHT { continue; }
let d: Vec<f64> = s2.iter().map(|&v| v / (v + a)).collect();
let dvs: Vec<f64> = (0..k).map(|j| d[j] * uty[j] / s[j].max(EPS)).collect();
for col in 0..nf {
beta[col] += wi * (0..k).map(|j| vt[j][col] * dvs[j]).sum::<f64>();
}
for j in 0..k { d_avg[j] += wi * d[j]; }
}
let residuals: Vec<f64> = (0..m).map(|i| {
y[i] - x_rows[i].iter().zip(beta.iter()).map(|(&xi, &bi)| xi * bi).sum::<f64>()
}).collect();
let h_avg: Vec<f64> = (0..m).map(|i| (0..k).map(|j| u[i][j] * u[i][j] * d_avg[j]).sum()).collect();
let loo: Vec<f64> = residuals.iter().zip(h_avg.iter())
.map(|(&ri, &hi)| ri / (1.0 - hi).max(EPS) / sqrt((1.0 + hi).max(EPS)))
.collect();
Ok((beta, loo, gcv_min, vt, s, d_avg))
}
fn select_period(y: &[f64], n: usize, frequency: &Freq) -> (usize, Vec<usize>, usize, Vec<usize>) {
let period = get_period(frequency);
let cal = get_periods(frequency);
let mut candidates: Vec<usize> = if !cal.is_empty() {
cal.iter().copied().filter(|&p| p >= 1 && n / p >= MIN_COMPLETE).collect()
} else {
vec![]
};
if candidates.is_empty() {
let p = period.max(1);
candidates.push(if n / p >= MIN_COMPLETE { p } else { 1 });
}
let big_p = {
let min_cand = *candidates.iter().min().unwrap();
let t_max = n.min(MAX_COMPLETE * min_cand);
let y_sel = &y[y.len().saturating_sub(t_max)..];
let mean = slice_mean(y_sel);
let rss_null: f64 = y_sel.iter().map(|&v| pow(v - mean, 2.0)).sum();
let bic_null = t_max as f64 * ln((rss_null / t_max as f64).max(EPS_LOG)) + ln(t_max as f64);
let mut best_p = 1usize;
let mut best_bic = bic_null;
for &p_cand in &candidates {
let nc = t_max / p_cand;
if nc < MIN_COMPLETE { continue; }
let start = y_sel.len() - nc * p_cand;
let y_use = &y_sel[start..];
let mat_c: Vec<Vec<f64>> = (0..p_cand).map(|ph| (0..nc).map(|ci| y_use[ci * p_cand + ph]).collect()).collect();
let s = svd::svdvals(&mat_c);
let rss1: f64 = s.iter().skip(1).map(|&v| v * v).sum();
let t = (nc * p_cand) as f64;
let bic = t * ln((rss1 / t).max(EPS_LOG)) + (p_cand + nc - 1) as f64 * ln(t);
if bic < best_bic { best_bic = bic; best_p = p_cand; }
}
best_p
};
let secondary: Vec<usize> = cal.iter().copied().filter(|&p| p > big_p).collect();
(big_p, secondary, period, cal)
}
fn compute_shape2(l: &[f64], cp: usize, n_complete: usize) -> Option<Vec<f64>> {
let nc2 = n_complete / cp;
if nc2 < 2 { return None; }
let mut s2_raw = vec![0.0f64; cp];
for d in 0..cp {
let vals: Vec<f64> = (0..n_complete).filter(|&i| i % cp == d).map(|i| l[i]).collect();
s2_raw[d] = if vals.is_empty() { 1.0 } else { slice_mean(&vals) };
}
let raw_mean = slice_mean(&s2_raw);
if raw_mean < EPS { return None; }
s2_raw.iter_mut().for_each(|v| *v /= raw_mean);
let cos_b: Vec<f64> = (0..cp).map(|i| cos(2.0 * PI * i as f64 / cp as f64)).collect();
let sin_b: Vec<f64> = (0..cp).map(|i| sin(2.0 * PI * i as f64 / cp as f64)).collect();
let s2_c: Vec<f64> = s2_raw.iter().map(|&v| v - 1.0).collect();
let a = 2.0 * slice_mean(&s2_c.iter().zip(cos_b.iter()).map(|(&sc, &cb)| sc * cb).collect::<Vec<_>>());
let b = 2.0 * slice_mean(&s2_c.iter().zip(sin_b.iter()).map(|(&sc, &sb)| sc * sb).collect::<Vec<_>>());
let s2_harmonic: Vec<f64> = (0..cp).map(|i| 1.0 + a * cos_b[i] + b * sin_b[i]).collect();
let rss_flat: f64 = s2_c.iter().map(|&v| v * v).sum();
let rss_harm: f64 = s2_raw.iter().zip(s2_harmonic.iter()).map(|(&r, &h)| pow(r - h, 2.0)).sum();
let bic_flat = cp as f64 * ln((rss_flat / cp as f64).max(EPS_LOG));
let bic_harm = cp as f64 * ln((rss_harm / cp as f64).max(EPS_LOG)) + 2.0 * ln(cp as f64);
let s2_prior: Vec<f64> = if bic_harm < bic_flat { s2_harmonic } else { vec![1.0; cp] };
let w = nc2 as f64 / (nc2 as f64 + cp as f64);
let mut s2: Vec<f64> = s2_raw.iter().zip(s2_prior.iter())
.map(|(&r, &p)| (w * r + (1.0 - w) * p).max(EPS_SHAPE))
.collect();
let s2m = slice_mean(&s2);
s2.iter_mut().for_each(|v| *v /= s2m);
Some(s2)
}
fn estimate_shape(
mat: &[Vec<f64>],
n_complete: usize,
big_p: usize,
_secondary: &[usize],
_l: &[f64],
horizon: usize,
) -> (Vec<Vec<f64>>, Vec<Vec<f64>>, usize) {
let k = SHAPE_K.min(n_complete);
let mut s_global = vec![0.0f64; big_p];
for ph in 0..big_p {
let props: Vec<f64> = (n_complete - k..n_complete).map(|ci| {
let tot: f64 = (0..big_p).map(|p| mat[p][ci]).sum();
if tot > EPS { mat[ph][ci] / tot } else { 1.0 / big_p as f64 }
}).collect();
s_global[ph] = slice_mean(&props);
}
let sg_sum = s_global.iter().sum::<f64>().max(EPS);
s_global.iter_mut().for_each(|v| *v /= sg_sum);
let m = (horizon + big_p - 1) / big_p;
(vec![s_global.clone(); m], vec![s_global; n_complete], m)
}
fn estimate_phi(l_bc: &[f64]) -> f64 {
let n = l_bc.len();
if n < 3 { return 0.0; }
let dl: Vec<f64> = l_bc.windows(2).map(|w| w[1] - w[0]).collect();
if dl.len() < 5 { return 0.0; }
let mean = slice_mean(&dl);
let dl_c: Vec<f64> = dl.iter().map(|&v| v - mean).collect();
let c0: f64 = dl_c.iter().map(|&v| v * v).sum();
if c0 < EPS { return 0.0; }
let c1: f64 = dl_c.windows(2).map(|w| w[0] * w[1]).sum();
(c1 / c0).max(0.0)
}
fn compute_damped_trend(l_bc: &[f64], m: usize, n_complete: usize) -> Vec<f64> {
let phi = estimate_phi(l_bc).min(1.0 - EPS);
if phi <= EPS {
return vec![(n_complete as f64 - 1.0) / n_complete as f64; m];
}
(0..m).map(|j| {
let jf = (j + 1) as f64;
((n_complete as f64 - 1.0) + phi * (1.0 - pow(phi, jf)) / (1.0 - phi)) / n_complete as f64
}).collect()
}
fn compute_lwcp_leverages(
beta: &[f64],
l_innov: &[f64],
damped_trend: &[f64],
vt: &[Vec<f64>], s: &[f64], d_avg: &[f64], n_complete: usize,
m: usize,
nb: usize,
nf: usize,
max_cp: usize,
use_diff: bool,
) -> Vec<f64> {
let k = s.len();
let mut l_point: Vec<f64> = l_innov.to_vec();
l_point.resize(n_complete + m, 0.0);
(0..m).map(|j| {
let ti = n_complete + j;
let pred = beta[0]
+ beta[1] * damped_trend[j]
+ beta[nb] * l_point[ti - 1]
+ if max_cp >= 2 { beta[nb + 1] * l_point[ti - max_cp] } else { 0.0 };
l_point[ti] = pred;
let mut x_j = vec![0.0f64; nf];
x_j[0] = 1.0;
x_j[1] = damped_trend[j];
x_j[nb] = if use_diff { -l_point[ti - 1] } else { l_point[ti - 1] };
if max_cp >= 2 { x_j[nb + 1] = l_point[ti - max_cp]; }
let h: f64 = (0..k).map(|r| {
let v: f64 = (0..nf).map(|c| vt[r][c] * x_j[c]).sum();
let u_test = v / s[r].max(EPS);
u_test * u_test * d_avg[r]
}).sum();
h.clamp(0.0, 10.0)
}).collect()
}
fn compute_cross_periods(
secondary: &[usize],
big_p: usize,
period: usize,
n_complete: usize,
) -> (Vec<usize>, usize) {
let mut cp_set: BTreeSet<usize> = secondary.iter().filter_map(|&sp| {
let cp = if big_p >= 2 { sp / big_p } else { sp };
if cp >= 2 && cp <= n_complete / 2 { Some(cp) } else { None }
}).collect();
if big_p == 1 && period >= 2 && period <= n_complete / 2 { cp_set.insert(period); }
let cross_periods: Vec<usize> = cp_set.into_iter().collect();
let max_cp = cross_periods.iter().copied().max().unwrap_or(0);
(cross_periods, max_cp)
}
pub fn forecast(
y_raw: &[f64],
horizon: usize,
frequency: &Freq,
n_samples: usize,
seed: u64,
) -> Result<(Vec<Vec<f64>>, Confidence), Error> {
if y_raw.is_empty() { return Err(Error::InvalidInput("y must not be empty")); }
if horizon < 1 { return Err(Error::InvalidInput("horizon must be >= 1")); }
if n_samples < 1 { return Err(Error::InvalidInput("n_samples must be >= 1")); }
let mut rng = Rng::new(seed);
let mut y: Vec<f64> = interp_nan(y_raw);
let y_floor = y.iter().cloned().fold(f64::INFINITY, f64::min);
let y_shift = (1.0 - y_floor).max(1.0);
y.iter_mut().for_each(|v| *v += y_shift);
let n = y.len();
let (mut big_p, mut secondary, period, _cal) = select_period(&y, n, frequency);
let mut n_complete = n / big_p;
if n_complete < MIN_COMPLETE {
if big_p > 1 { big_p = 1; secondary.clear(); n_complete = n; }
if n_complete < MIN_COMPLETE {
let fc_val = y[n - 1] - y_shift;
let lookback = PHASE_NOISE_K.min(n);
let diffs: Vec<f64> = y[n - lookback..].windows(2).map(|w| w[1] - w[0]).collect();
let sigma = if diffs.is_empty() { EPS_SHAPE } else {
let m = slice_mean(&diffs);
sqrt(diffs.iter().map(|&d| pow(d - m, 2.0)).sum::<f64>() / diffs.len() as f64)
.max(EPS_SHAPE)
};
let samples = (0..n_samples).map(|_| {
(0..horizon).map(|_| {
let v = fc_val + rng.normal() * sigma;
v.clamp(fc_val - sigma * 10.0, fc_val + sigma * 10.0)
}).collect()
}).collect();
return Ok((samples, Confidence { rank1: None, gcv: None }));
}
}
if big_p > 1 {
let (_, max_cp_est) = compute_cross_periods(&secondary, big_p, period, n_complete);
let start_est = if max_cp_est >= 2 { max_cp_est } else { 1 };
let nf_est = 2 + 1 + if max_cp_est >= 2 { 1 } else { 0 }; if n_complete.saturating_sub(start_est) < 2 * nf_est {
big_p = 1;
secondary.clear();
n_complete = n;
}
}
if n_complete > MAX_COMPLETE {
y = y[y.len() - MAX_COMPLETE * big_p..].to_vec();
n_complete = MAX_COMPLETE;
}
let usable = n_complete * big_p;
let y_trim = &y[y.len() - usable..];
let mat: Vec<Vec<f64>> = (0..big_p)
.map(|ph| (0..n_complete).map(|ci| y_trim[ci * big_p + ph]).collect())
.collect();
let l: Vec<f64> = (0..n_complete)
.map(|ci| (0..big_p).map(|ph| mat[ph][ci]).sum())
.collect();
let (s_forecast, s_hist, m) = estimate_shape(&mat, n_complete, big_p, &secondary, &l, horizon);
let (cross_periods, mut max_cp) = compute_cross_periods(&secondary, big_p, period, n_complete);
let cp_main = cross_periods.first().copied().unwrap_or(0);
let s2 = if cp_main >= 2 { compute_shape2(&l, cp_main, n_complete) } else { None };
let use_deseason = s2.is_some();
let l_work: Vec<f64> = if use_deseason {
let s2r = s2.as_ref().unwrap();
(0..n_complete).map(|i| l[i] / s2r[i % cp_main].max(EPS)).collect()
} else {
l.clone()
};
let lam = bc_lambda(&l_work);
let l_bc = bc(&l_work, lam);
let last_l = l_bc[n_complete - 1];
let l_innov: Vec<f64> = l_bc.iter().map(|&v| v - last_l).collect();
let mut start = if max_cp >= 2 { max_cp.max(1) } else { 1 };
if max_cp >= 2 && n_complete.saturating_sub(start) < MIN_COMPLETE {
max_cp = 0;
start = 1;
}
let nb = 2usize; let n_lag = if max_cp >= 2 { 2 } else { 1 };
let nf = nb + n_lag;
let n_train = n_complete - start;
let use_diff = DIFF_TARGET && n_train >= 3;
let (x_rows, y_target): (Vec<Vec<f64>>, Vec<f64>) = if use_diff {
let yt: Vec<f64> = (start..n_complete).map(|ti| l_innov[ti] - l_innov[ti - 1]).collect();
let xr: Vec<Vec<f64>> = (start..n_complete).map(|ti| {
let mut row = vec![0.0f64; nf];
row[0] = 1.0;
row[1] = ti as f64 / n_complete as f64;
row[nb] = -l_innov[ti - 1]; if max_cp >= 2 { row[nb + 1] = l_innov[ti - max_cp]; }
row
}).collect();
(xr, yt)
} else {
let yt = l_innov[start..].to_vec();
let xr: Vec<Vec<f64>> = (start..n_complete).map(|ti| {
let mut row = vec![0.0f64; nf];
row[0] = 1.0;
row[1] = ti as f64 / n_complete as f64;
row[nb] = l_innov[ti - 1];
if max_cp >= 2 { row[nb + 1] = l_innov[ti - max_cp]; }
row
}).collect();
(xr, yt)
};
let (mut beta, loo_resid, gcv_min, vt_r, s_r, d_avg_r) = ridge_sa(&x_rows, &y_target)?;
if use_diff {
beta[nb] = 1.0 - beta[nb];
}
let damped_trend: Vec<f64> = compute_damped_trend(&l_bc, m, n_complete);
let h_test: Vec<f64> = compute_lwcp_leverages(
&beta, &l_innov, &damped_trend,
&vt_r, &s_r, &d_avg_r,
n_complete, m, nb, nf, max_cp, use_diff,
);
let loo_len = loo_resid.len();
let noise_pool: Vec<Vec<f64>> = if loo_len >= 4 {
let loo_mean = slice_mean(&loo_resid);
let loo_std = sqrt(loo_resid.iter().map(|&v| pow(v - loo_mean, 2.0)).sum::<f64>()
/ loo_len as f64).max(EPS);
let sigma2_loo = loo_resid.iter().map(|&v| pow(v - loo_mean, 2.0)).sum::<f64>()
/ loo_len as f64;
let loo_unit: Vec<f64> = loo_resid.iter().map(|&v| (v - loo_mean) / loo_std).collect();
(0..n_samples).map(|_| {
(0..m).map(|j| {
loo_unit[rng.randint(loo_len)] * sqrt(sigma2_loo * (1.0 + h_test[j]))
}).collect()
}).collect()
} else {
let nu = (n_train.saturating_sub(nf)).max(3) as f64;
let sigma2_loo = loo_resid.iter().map(|&v| v * v).sum::<f64>() / loo_len.max(1) as f64;
(0..n_samples).map(|_| {
(0..m).map(|j| {
rng.student_t(nu) * sqrt(sigma2_loo * (1.0 + h_test[j]))
}).collect()
}).collect()
};
let total = n_complete + m;
let mut l_paths: Vec<Vec<f64>> = (0..n_samples).map(|_| {
let mut v = l_innov.clone();
v.resize(total, 0.0);
v
}).collect();
for j in 0..m {
let ti = n_complete + j;
for si in 0..n_samples {
let pred = beta[0]
+ beta[1] * damped_trend[j] + beta[nb] * l_paths[si][ti - 1];
let pred = if max_cp >= 2 { pred + beta[nb + 1] * l_paths[si][ti - max_cp] } else { pred };
l_paths[si][ti] = pred + noise_pool[si][j];
}
}
let mut l_hat_all: Vec<Vec<f64>> = (0..n_samples).map(|si| {
bc_inv(&l_paths[si][n_complete..n_complete + m].iter().map(|&v| v + last_l).collect::<Vec<_>>(), lam)
}).collect();
if use_deseason {
let s2r = s2.as_ref().unwrap();
for lh in l_hat_all.iter_mut() {
for (j, v) in lh.iter_mut().enumerate() {
*v *= s2r[(n_complete + j) % cp_main];
}
}
}
let k_r = PHASE_NOISE_K.min(n_complete);
let fitted_clamp = {
let mut vals: Vec<f64> = Vec::new();
for ph in 0..big_p {
for ci in n_complete - k_r..n_complete {
let f = (s_hist[ci][ph] * l[ci]).abs();
if f > EPS { vals.push(f); }
}
}
if vals.is_empty() {
EPS_BOXCOX
} else {
vals.sort_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal));
let mid = vals.len() / 2;
let med = if vals.len() % 2 == 0 { (vals[mid - 1] + vals[mid]) / 2.0 } else { vals[mid] };
(med * 0.1_f64).max(EPS_BOXCOX)
}
};
let mut r_mat: Vec<Vec<f64>> = (0..big_p).map(|ph| {
(n_complete - k_r..n_complete).map(|ci| {
let fitted = s_hist[ci][ph] * l[ci];
(mat[ph][ci] - fitted) / fitted.abs().max(fitted_clamp)
}).collect()
}).collect();
if k_r >= 4 {
for ph in 0..big_p {
let mean = slice_mean(&r_mat[ph]);
let var = r_mat[ph].iter().map(|&v| pow(v - mean, 2.0)).sum::<f64>()
/ (k_r - 1) as f64;
let se_sq = var / k_r as f64;
let noise_fraction = (se_sq / (mean * mean + se_sq + EPS)).clamp(0.0, 1.0);
let shrink = mean * noise_fraction;
r_mat[ph].iter_mut().for_each(|v| *v -= shrink);
}
}
let col_idx: Vec<usize> = (0..n_samples).map(|_| rng.randint(k_r)).collect();
let step_idx: Vec<usize> = (0..horizon).map(|h| h / big_p).collect();
let phase_idx: Vec<usize> = (0..horizon).map(|h| h % big_p).collect();
let mut samples: Vec<Vec<f64>> = Vec::with_capacity(n_samples);
for si in 0..n_samples {
let path: Vec<f64> = (0..horizon).map(|h| {
let sj = step_idx[h];
let ph = phase_idx[h];
let phase_deflate = 1.0 / sqrt(1.0 + h_test[sj]);
let phase_noise = r_mat[ph][col_idx[si]] * phase_deflate;
l_hat_all[si][sj] * s_forecast[sj][ph] * (1.0 + phase_noise) - y_shift
}).collect();
samples.push(path);
}
let lookback = (horizon * 2).max(PHASE_NOISE_K).min(y_raw.len());
let valid_rec: Vec<f64> = y_raw[y_raw.len() - lookback..].iter().cloned().filter(|v| !v.is_nan()).collect();
let valid_all: Vec<f64> = y_raw.iter().cloned().filter(|v| !v.is_nan()).collect();
if !valid_rec.is_empty() && !valid_all.is_empty() {
let y_hi = valid_rec.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
let y_range = (y_hi - valid_rec.iter().cloned().fold(f64::INFINITY, f64::min)).max(EPS_SHAPE);
let y_floor = valid_all.iter().cloned().fold(f64::INFINITY, f64::min);
for path in &mut samples {
for v in path.iter_mut() {
if !v.is_finite() { *v = y_floor; }
else { *v = v.clamp(y_floor, y_hi + y_range); }
}
}
} else {
for path in &mut samples {
for v in path.iter_mut() {
if !v.is_finite() { *v = 0.0; }
}
}
}
let is_integer_series = y_raw.iter().filter(|v| !v.is_nan()).all(|&v| v == round(v));
if is_integer_series {
for path in &mut samples {
for v in path.iter_mut() {
*v = round(*v);
}
}
}
let rank1 = {
let s = svd::svdvals(&mat);
let total: f64 = s.iter().map(|&v| v * v).sum();
if total < EPS || big_p < 2 { None } else { Some(s[0] * s[0] / total) }
};
let conf = Confidence { rank1, gcv: Some(gcv_min) };
Ok((samples, conf))
}
pub fn forecast_quantiles(
y: &[f64],
horizon: usize,
frequency: &Freq,
n_samples: usize,
seed: u64,
quantiles: &[f64],
) -> Result<(Vec<Vec<f64>>, Confidence), Error> {
if quantiles.is_empty() || quantiles.iter().any(|&q| !(0.0..=1.0).contains(&q)) {
return Err(Error::InvalidInput("quantiles must be non-empty and each value in [0.0, 1.0]"));
}
let (samples, conf) = forecast(y, horizon, frequency, n_samples, seed)?;
let ns = samples.len();
let result = quantiles.iter().map(|&q| {
(0..horizon).map(|h| {
let mut col: Vec<f64> = samples.iter().map(|s| s[h]).collect();
col.sort_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal));
let idx = round(q * (ns - 1) as f64) as usize;
col[idx]
}).collect()
}).collect();
Ok((result, conf))
}
pub fn forecast_mean(
y: &[f64],
horizon: usize,
frequency: &Freq,
n_samples: usize,
seed: u64,
) -> Result<(Vec<f64>, Confidence), Error> {
let (samples, conf) = forecast(y, horizon, frequency, n_samples, seed)?;
let n = samples.len() as f64;
let mean = (0..horizon).map(|h| samples.iter().map(|s| s[h]).sum::<f64>() / n).collect();
Ok((mean, conf))
}
#[cfg(test)]
mod tests {
use super::*;
extern crate std;
use std::fs;
use alloc::format;
#[test]
fn output_shape() {
let y: Vec<f64> = (0..200).map(|i| sin(i as f64 * 0.26) * 3.0 + 10.0).collect();
let (s, _) = forecast(&y, 12, &Freq::Monthly, 50, 0).unwrap();
assert_eq!(s.len(), 50);
assert_eq!(s[0].len(), 12);
}
#[test]
fn bc_roundtrip() {
let y = vec![0.5f64, 1.0, 2.0, 5.0, 10.0];
for &lam in &[0.0f64, 0.3, 0.5, 1.0] {
let y2 = bc_inv(&bc(&y, lam), lam);
for (&a, &b) in y.iter().zip(y2.iter()) {
assert!((a - b).abs() < 1e-9, "λ={lam}: {a} -> {b}");
}
}
}
#[test]
fn error_cases() {
assert!(forecast(&[], 5, &Freq::hourly(1).unwrap(), 10, 0).is_err());
assert!(forecast(&[1.0, 2.0], 0, &Freq::hourly(1).unwrap(), 10, 0).is_err());
assert!(forecast(&[1.0, 2.0], 5, &Freq::hourly(1).unwrap(), 0, 0).is_err());
}
#[test]
fn forecast_mean_shape() {
let y: Vec<f64> = (0..100).map(|i| i as f64).collect();
let (m, _) = forecast_mean(&y, 7, &Freq::Daily, 20, 5).unwrap();
assert_eq!(m.len(), 7);
assert!(m.iter().all(|&v| v.is_finite()));
}
#[test]
fn forecast_quantiles_shape_and_order() {
let y: Vec<f64> = (0..200).map(|i| sin(i as f64 * 0.26) * 3.0 + 10.0).collect();
let qs = [0.1, 0.5, 0.9];
let (q, _) = forecast_quantiles(&y, 12, &Freq::Monthly, 100, 0, &qs).unwrap();
assert_eq!(q.len(), 3);
assert!(q.iter().all(|row| row.len() == 12));
for h in 0..12 {
assert!(q[0][h] <= q[1][h] && q[1][h] <= q[2][h]);
}
}
#[test]
fn forecast_quantiles_invalid_q() {
let y: Vec<f64> = (0..50).map(|i| i as f64).collect();
assert!(forecast_quantiles(&y, 5, &Freq::Monthly, 10, 0, &[0.5, 1.5]).is_err());
}
#[allow(dead_code)]
enum ParseMode { Col(usize), ColSkip(usize, usize), JapanTokyo }
struct Dataset {
file: &'static str,
frequency: Freq,
mode: ParseMode,
}
fn load(ds: &Dataset) -> Vec<f64> {
let path = format!("examples/dataset/{}", ds.file);
let content = fs::read_to_string(&path)
.unwrap_or_else(|_| panic!("{path} not found"));
match ds.mode {
ParseMode::Col(col) | ParseMode::ColSkip(col, _) => {
let skip = match ds.mode { ParseMode::ColSkip(_, s) => s, _ => 1 };
content.lines().skip(skip)
.filter_map(|l| l.split(',').nth(col)?.trim().trim_matches('"').parse::<f64>().ok())
.collect()
}
ParseMode::JapanTokyo => {
content.lines().skip(1)
.filter_map(|l| l.split(',').nth(2)?.trim().parse::<f64>().ok())
.collect()
}
}
}
fn datasets() -> Vec<Dataset> {
vec![
Dataset { file: "air_passengers.csv", frequency: Freq::Monthly, mode: ParseMode::Col(2) },
Dataset { file: "nottem.csv", frequency: Freq::Monthly, mode: ParseMode::Col(2) },
Dataset { file: "sunspot_year.csv", frequency: Freq::Yearly, mode: ParseMode::Col(2) },
Dataset { file: "noaa_temp_annual.csv", frequency: Freq::Yearly, mode: ParseMode::Col(1) },
Dataset { file: "noaa_temp_monthly.csv",frequency: Freq::Monthly, mode: ParseMode::Col(1) },
Dataset { file: "japan_demand_tokyo.csv", frequency: Freq::Hourly(1),mode: ParseMode::JapanTokyo },
]
}
#[test]
fn lwcp_vs_python_reference() {
let y: Vec<f64> = (0..144).map(|i| {
100.0 + 1.5 * i as f64 + 20.0 * sin(2.0 * PI * i as f64 / 12.0)
}).collect();
let py_mean = [310.5, 329.0, 343.2, 350.0, 348.1, 338.7,
325.0, 311.3, 301.9, 300.0, 306.8, 321.0];
let (samples, _) = forecast(&y, 12, &Freq::Monthly, 500, 0).unwrap();
let rs_mean: Vec<f64> = (0..12)
.map(|h| samples.iter().map(|s| s[h]).sum::<f64>() / samples.len() as f64)
.collect();
for h in 0..12 {
let diff = (rs_mean[h] - py_mean[h]).abs();
assert!(diff < 15.0,
"h={h}: rust={:.1} py={:.1} diff={:.1}", rs_mean[h], py_mean[h], diff);
}
}
#[test]
fn dataset_iter_no_crash() {
for ds in datasets() {
let y = load(&ds);
assert!(!y.is_empty(), "{}: empty", ds.file);
let (fc, _) = forecast_mean(&y, 12, &ds.frequency, 30, 0)
.unwrap_or_else(|e| panic!("{}: forecast error: {e:?}", ds.file));
assert_eq!(fc.len(), 12, "{}: wrong horizon", ds.file);
assert!(fc.iter().all(|v| v.is_finite()), "{}: non-finite output", ds.file);
}
}
}