discrete_transforms 0.1.3

Library for Discrete Transforms
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

use std::f64;
use num_traits::float::Float;

#[derive(Debug)]
pub struct Dct1D {
    input: Vec<f64>
}

impl Dct1D {
    pub fn new() -> Dct1D {
        Dct1D {
            input: vec![]
        }
    }

    pub fn set_input(&mut self, input: Vec<f64>) -> &mut Self {
        self.input = input;

        self
    }

    pub fn forward(&mut self) -> Vec<f64> {
        let pi = f64::consts::PI;
        let mut output: Vec<f64> = Vec::new();

        for u in 0..8 {
            let mut coefficient: f64 = 0.0;

            for x in 0..8 {
                coefficient += self.input[x] * (u as f64 * pi / 16.0 * (2.0 * x as f64 + 1.0)).cos();
            }

            let cu = if u == 0 {
                1.0 / 2.0.sqrt()
            }
            else {
                1.0
            };

            coefficient = coefficient / 2.0 * cu;

            output.push(coefficient);
        }

        output
    }

    pub fn inverse(&mut self) -> Vec<f64> {
        let pi = f64::consts::PI;
        let mut output: Vec<f64> = Vec::new();

        for x in 0..8 {
            let mut output_temp: f64 = 0.0;

            for u in 0..8 {
                let cu = if u == 0 {
                    1.0 / 2.0.sqrt()
                }
                else {
                    1.0
                };

                output_temp += (u as f64 * pi / 16.0 * (2.0 * x as f64 + 1.0)).cos() * self.input[u] * cu;
            }

            output_temp /= 2.0;

            output.push(output_temp);
        }

        output
    }

}