oxits 0.1.0

Time series classification and transformation library for Rust
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use crate::core::config::DistanceKind;
use crate::image::recurrence_plot::{RecurrencePlot, RecurrencePlotConfig};

/// Joint Recurrence Plot for multivariate time series.
///
/// Computes a recurrence plot for each feature independently,
/// then takes the element-wise product (Hadamard product) of all
/// per-feature recurrence plots.

#[derive(Debug, Clone)]
pub struct JointRecurrencePlotConfig {
    pub dimension: usize,
    pub time_delay: usize,
    pub threshold: Option<f64>,
    pub percentage: Option<f64>,
    pub distance: DistanceKind,
}

impl JointRecurrencePlotConfig {
    pub fn new() -> Self {
        Self {
            dimension: 1,
            time_delay: 1,
            threshold: None,
            percentage: None,
            distance: DistanceKind::Squared,
        }
    }
}

impl Default for JointRecurrencePlotConfig {
    fn default() -> Self {
        Self::new()
    }
}

pub struct JointRecurrencePlot;

impl JointRecurrencePlot {
    /// Transform multivariate time series into joint recurrence plot images.
    ///
    /// Input: (n_samples, n_features, n_timestamps)
    /// Output: (n_samples, n_points, n_points)
    pub fn transform(
        config: &JointRecurrencePlotConfig,
        x: &[Vec<Vec<f64>>],
    ) -> Vec<Vec<Vec<f64>>> {
        assert!(!x.is_empty(), "Input must have at least one sample");
        let n_features = x[0].len();
        assert!(n_features >= 1, "Must have at least one feature");

        let rp_config = RecurrencePlotConfig {
            dimension: config.dimension,
            time_delay: config.time_delay,
            threshold: config.threshold,
            percentage: config.percentage,
            distance: config.distance,
        };

        x.iter()
            .map(|sample| {
                // Compute RP for each feature
                let mut joint_rp: Option<Vec<Vec<f64>>> = None;

                for feat in sample {
                    let rps = RecurrencePlot::transform(&rp_config, std::slice::from_ref(feat));
                    let rp = &rps[0];

                    joint_rp = Some(match joint_rp {
                        None => rp.clone(),
                        Some(existing) => {
                            // Element-wise product
                            existing
                                .iter()
                                .zip(rp.iter())
                                .map(|(row_a, row_b)| {
                                    row_a
                                        .iter()
                                        .zip(row_b.iter())
                                        .map(|(&a, &b)| a * b)
                                        .collect()
                                })
                                .collect()
                        }
                    });
                }

                joint_rp.unwrap()
            })
            .collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_jrp_basic() {
        let config = JointRecurrencePlotConfig::new();
        // 1 sample, 2 features, 5 timestamps
        let x = vec![vec![
            vec![0.0, 1.0, 0.0, -1.0, 0.0],
            vec![1.0, 0.0, -1.0, 0.0, 1.0],
        ]];
        let result = JointRecurrencePlot::transform(&config, &x);
        assert_eq!(result.len(), 1);
        assert_eq!(result[0].len(), 5);
        assert_eq!(result[0][0].len(), 5);
    }

    #[test]
    fn test_jrp_symmetric() {
        let config = JointRecurrencePlotConfig::new();
        let x = vec![vec![vec![1.0, 2.0, 3.0, 4.0], vec![4.0, 3.0, 2.0, 1.0]]];
        let result = JointRecurrencePlot::transform(&config, &x);
        for i in 0..4 {
            for j in 0..4 {
                assert!(
                    (result[0][i][j] - result[0][j][i]).abs() < 1e-10,
                    "JRP should be symmetric"
                );
            }
        }
    }

    #[test]
    fn test_jrp_with_threshold() {
        let config = JointRecurrencePlotConfig {
            threshold: Some(1.0),
            ..JointRecurrencePlotConfig::new()
        };
        let x = vec![vec![vec![0.0, 0.5, 0.0, 2.0], vec![0.0, 0.5, 0.0, 2.0]]];
        let result = JointRecurrencePlot::transform(&config, &x);
        // Since both features use same data and threshold, product of binary RPs
        for row in &result[0] {
            for &v in row {
                assert!(v == 0.0 || v == 1.0, "Binary JRP should be 0 or 1");
            }
        }
    }
}