fraug/transforms/
dct.rs

1use crate::Dataset;
2use rayon::prelude::*;
3use rustdct::{DctPlanner};
4
5/// Discrete Cosine Transform (DCT-II) for time series data.
6/// Converts each real-valued time series in the dataset into DCT coefficients (real, frequency representation)
7pub fn dataset_dct(dataset: &Dataset, parallel: bool) -> Dataset {
8    let dct_features: Vec<Vec<f64>> = if parallel {
9        dataset
10            .features
11            .par_iter()
12            .map(|sample| {
13                let len = sample.len();
14                let mut planner = DctPlanner::new();
15                let dct = planner.plan_dct2(len);
16                let mut buffer = sample.clone();
17                dct.process_dct2(&mut buffer);
18                buffer
19            })
20            .collect()
21    } else {
22        dataset
23            .features
24            .iter()
25            .map(|sample| {
26                let len = sample.len();
27                let mut planner = DctPlanner::new();
28                let dct = planner.plan_dct2(len);
29                let mut buffer = sample.clone();
30                dct.process_dct2(&mut buffer);
31                buffer
32            })
33            .collect()
34    };
35
36    Dataset {
37        features: dct_features,
38        labels: dataset.labels.clone(),
39    }
40}
41
42/// Inverse Discrete Cosine Transform (DCT-III) for time series data.
43/// Reconstructs each time series from its DCT coefficients, recovering the original signal
44pub fn dataset_idct(dataset: &Dataset, parallel: bool) -> Dataset {
45    let time_features: Vec<Vec<f64>> = if parallel {
46        dataset
47            .features
48            .par_iter()
49            .map(|sample| {
50                let len = sample.len();
51                let mut planner = DctPlanner::new();
52                let idct = planner.plan_dct3(len);
53                let mut buffer = sample.clone();
54                idct.process_dct3(&mut buffer);
55                // normalize
56                let norm = 2.0 / (len as f64);
57                for v in &mut buffer {
58                    *v *= norm;
59                }
60                buffer
61            })
62            .collect()
63    } else {
64        dataset
65            .features
66            .iter()
67            .map(|sample| {
68                let len = sample.len();
69                let mut planner = DctPlanner::new();
70                let idct = planner.plan_dct3(len);
71                let mut buffer = sample.clone();
72                idct.process_dct3(&mut buffer);
73                let norm = 2.0 / (len as f64);
74                for v in &mut buffer {
75                    *v *= norm;
76                }
77                buffer
78            })
79            .collect()
80    };
81
82    Dataset {
83        features: time_features,
84        labels: dataset.labels.clone(),
85    }
86}