stock-trek 0.4.0

Stock Trek time-series analysis
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use crate::statistics::{stats, stats_error::StatsError, stats_result::StatsResult, time_series};

#[derive(Clone, Default)]
pub struct TimeSeries;

impl TimeSeries {
    pub fn autocorrelation(&self, values: &[f64], lag: usize) -> StatsResult<f64> {
        time_series::autocorrelation(values, lag)
    }
    pub fn autocovariance(&self, values: &[f64], lag: usize) -> StatsResult<f64> {
        time_series::autocovariance(values, lag)
    }
    pub fn cross_correlation(&self, first: &[f64], second: &[f64], lag: isize) -> StatsResult<f64> {
        time_series::cross_correlation(first, second, lag)
    }
    pub fn partial_autocorrelation(&self, values: &[f64], max_lag: usize) -> StatsResult<Vec<f64>> {
        time_series::partial_autocorrelation(values, max_lag)
    }
}

pub fn autocorrelation(values: &[f64], lag: usize) -> StatsResult<f64> {
    let gamma_0 = time_series::autocovariance(values, 0)?;
    if gamma_0 == 0.0 {
        return Err(StatsError::ZeroVariance);
    }
    let gamma_k = time_series::autocovariance(values, lag)?;
    let autocorrelation = gamma_k / gamma_0;
    Ok(autocorrelation)
}

pub fn autocovariance(values: &[f64], lag: usize) -> StatsResult<f64> {
    let n = values.len();
    if n == 0 {
        return Err(StatsError::EmptyInput);
    }
    if lag >= n {
        return Err(StatsError::InvalidLag);
    }
    let mu = stats::mean(values)?;
    let sum: f64 = (lag..n)
        .map(|t| (values[t] - mu) * (values[t - lag] - mu))
        .sum();
    let autocovariance = sum / n as f64;
    Ok(autocovariance)
}

pub fn cross_correlation(first: &[f64], second: &[f64], lag: isize) -> StatsResult<f64> {
    let n = first.len();
    if n == 0 {
        return Err(StatsError::EmptyInput);
    }
    if n != second.len() {
        return Err(StatsError::MismatchedLengths);
    }
    let mean_x = stats::mean(first)?;
    let mean_y = stats::mean(second)?;
    let numerator: f64 = (0..n)
        .filter_map(|t| {
            let j = t as isize - lag;
            if j >= 0 && (j as usize) < n {
                Some((first[t] - mean_x) * (second[j as usize] - mean_y))
            } else {
                None
            }
        })
        .sum();
    let var_x = stats::variance(first, 0)?;
    let var_y = stats::variance(second, 0)?;
    let cross_correlation = numerator / (n as f64 * (var_x.sqrt() * var_y.sqrt()));
    Ok(cross_correlation)
}

pub fn partial_autocorrelation(values: &[f64], max_lag: usize) -> StatsResult<Vec<f64>> {
    let n = values.len();
    if n == 0 {
        return Err(StatsError::EmptyInput);
    }
    if max_lag >= n {
        return Err(StatsError::InvalidLag);
    }
    // Precompute ACF
    let acf = (0..=max_lag)
        .map(|k| time_series::autocorrelation(values, k))
        .collect::<Result<Vec<f64>, _>>()?;
    // Durbin–Levinson recursion
    let mut pacf = vec![0.0; max_lag + 1];
    let mut phi = vec![vec![0.0; max_lag + 1]; max_lag + 1];
    pacf[0] = 1.0;
    if max_lag >= 1 {
        phi[1][1] = acf[1];
        pacf[1] = acf[1];
    }
    for k in 2..=max_lag {
        let sum: f64 = (1..k).map(|j| phi[k - 1][j] * acf[k - j]).sum();
        let denom: f64 = 1.0 - (1..k).map(|j| phi[k - 1][j] * acf[j]).sum::<f64>();
        if denom == 0.0 {
            return Err(StatsError::ZeroVariance);
        }
        let phi_kk = (acf[k] - sum) / denom;
        phi[k][k] = phi_kk;
        for j in 1..k {
            phi[k][j] = phi[k - 1][j] - phi_kk * phi[k - 1][k - j];
        }
        pacf[k] = phi_kk;
    }
    Ok(pacf)
}