synfx_dsp/
test.rs

1// Copyright (c) 2022 Weird Constructor <weirdconstructor@gmail.com>
2// This file is a part of synfx-dsp. Released under GPL-3.0-or-later.
3// See README.md and COPYING for details.
4
5/*! Provides you with some useful macros for testing DSP code.
6
7*/
8
9/// This macro allows you to float compare two vectors to a precision of `0.0001`.
10#[macro_export]
11macro_rules! assert_vec_feq {
12    ($vec:expr, $cmp_vec:expr) => {
13        let cmp_vec = $cmp_vec;
14        let res: Vec<f32> = $vec.iter().copied().collect();
15
16        for (i, (s, scmp)) in res.iter().zip(cmp_vec.iter()).enumerate() {
17            if (s - scmp).abs() > 0.0001 {
18                panic!(
19                    r#"
20table_left: {:?}
21
22table_right: {:?}
23
24assertion failed: `(left[{}] == right[{}])`
25      left: `{:?}`,
26     right: `{:?}`"#,
27                    &res[i..],
28                    &(cmp_vec[i..]),
29                    i,
30                    i,
31                    s,
32                    scmp
33                )
34            }
35        }
36    };
37}
38
39/// This macro allows you to float compare two vectors to a precision of `0.0001`,
40/// only every `$decimate` element will be looked at though. Useful for keeping the fixed
41/// value tables in your DSP code small.
42#[macro_export]
43macro_rules! assert_decimated_feq {
44    ($vec:expr, $decimate:expr, $cmp_vec:expr) => {
45        let cmp_vec = $cmp_vec;
46        let res: Vec<f32> = $vec.iter().step_by($decimate).copied().collect();
47
48        for (i, (s, scmp)) in res.iter().zip(cmp_vec.iter()).enumerate() {
49            if (s - scmp).abs() > 0.0001 {
50                panic!(
51                    r#"
52table_left: {:?}
53
54table_right: {:?}
55
56assertion failed: `(left[{}] == right[{}])`
57      left: `{:?}`,
58     right: `{:?}`"#,
59                    &res[i..],
60                    &(cmp_vec[i..]),
61                    i,
62                    i,
63                    s,
64                    scmp
65                )
66            }
67        }
68    };
69}
70
71/// Calculates the (linear) slope between consequtive values in `$vec` and compares the slopes
72/// with `$cmp_vec` with a precision of `0.0001`.
73#[macro_export]
74macro_rules! assert_slope_feq {
75    ($vec:expr, $cmp_vec:expr) => {
76        let cmp_vec = $cmp_vec;
77        let mut res: Vec<f32> = vec![];
78        let mut prev = 0.0;
79        for (i, s) in $vec.iter().enumerate() {
80            let delta = *s - prev;
81            if i > 0 {
82                res.push(delta);
83            }
84            prev = *s;
85        }
86
87        let res: Vec<f32> = res.iter().copied().collect();
88
89        for (i, (s, scmp)) in res.iter().zip(cmp_vec.iter()).enumerate() {
90            if (s - scmp).abs() > 0.0001 {
91                panic!(
92                    r#"
93table_left: {:?}
94
95table_right: {:?}
96
97assertion failed: `(left[{}] == right[{}])`
98      left: `{:?}`,
99     right: `{:?}`"#,
100                    &res[i..],
101                    &(cmp_vec[i..]),
102                    i,
103                    i,
104                    s,
105                    scmp
106                )
107            }
108        }
109    };
110}
111
112/// Calculates the (linear) slope between consequtive values in `$vec` and compares the slopes
113/// with `$cmp_vec` with a precision of `0.0001`. This macro only looks at every `$decimate` slope.
114#[macro_export]
115macro_rules! assert_decimated_slope_feq {
116    ($vec:expr, $decimate:expr, $cmp_vec:expr) => {
117        let cmp_vec = $cmp_vec;
118        let mut res: Vec<f32> = vec![];
119        let mut prev = 0.0;
120        for (i, s) in $vec.iter().enumerate() {
121            let delta = *s - prev;
122            if i > 0 {
123                res.push(delta);
124            }
125            prev = *s;
126        }
127
128        let res: Vec<f32> = res.iter().step_by($decimate).copied().collect();
129
130        for (i, (s, scmp)) in res.iter().zip(cmp_vec.iter()).enumerate() {
131            if (s - scmp).abs() > 0.0001 {
132                panic!(
133                    r#"
134table_left: {:?}
135
136table_right: {:?}
137
138assertion failed: `(left[{}] == right[{}])`
139      left: `{:?}`,
140     right: `{:?}`"#,
141                    &res[i..],
142                    &(cmp_vec[i..]),
143                    i,
144                    i,
145                    s,
146                    scmp
147                )
148            }
149        }
150    };
151}
152
153/// Calculates the (linear) slope between consequtive values in `$vec` and compares the slopes
154/// with `$cmp_vec` with a precision of `0.0000001`. This macro only looks at every `$decimate` slope.
155#[macro_export]
156macro_rules! assert_decimated_slope_feq_fine {
157    ($vec:expr, $decimate:expr, $cmp_vec:expr) => {
158        let cmp_vec = $cmp_vec;
159        let mut res: Vec<f32> = vec![];
160        let mut prev = 0.0;
161        for (i, s) in $vec.iter().enumerate() {
162            let delta = *s - prev;
163            if i > 0 {
164                res.push(delta);
165            }
166            prev = *s;
167        }
168
169        let res: Vec<f32> = res.iter().step_by($decimate).copied().collect();
170
171        for (i, (s, scmp)) in res.iter().zip(cmp_vec.iter()).enumerate() {
172            if (s - scmp).abs() > 0.0000001 {
173                panic!(
174                    r#"
175table_left: {:?}
176
177table_right: {:?}
178
179assertion failed: `(left[{}] == right[{}])`
180      left: `{:?}`,
181     right: `{:?}`"#,
182                    &res[i..],
183                    &(cmp_vec[i..]),
184                    i,
185                    i,
186                    s,
187                    scmp
188                )
189            }
190        }
191    };
192}
193
194/// Calculates the (linear) slope between consequtive values in `$vec` and compares the slopes
195/// with `$cmp_vec` with a precision of `0.000000001`. This macro only looks at every `$decimate` slope.
196#[macro_export]
197macro_rules! assert_decimated_slope_feq_sfine {
198    ($vec:expr, $decimate:expr, $cmp_vec:expr) => {
199        let cmp_vec = $cmp_vec;
200        let mut res: Vec<f32> = vec![];
201        let mut prev = 0.0;
202        for (i, s) in $vec.iter().enumerate() {
203            let delta = *s - prev;
204            if i > 0 {
205                res.push(delta);
206            }
207            prev = *s;
208        }
209
210        let res: Vec<f32> = res.iter().step_by($decimate).copied().collect();
211
212        for (i, (s, scmp)) in res.iter().zip(cmp_vec.iter()).enumerate() {
213            if (s - scmp).abs() > 0.000000001 {
214                panic!(
215                    r#"
216table_left: {:?}
217
218table_right: {:?}
219
220assertion failed: `(left[{}] == right[{}])`
221      left: `{:?}`,
222     right: `{:?}`"#,
223                    &res[i..],
224                    &(cmp_vec[i..]),
225                    i,
226                    i,
227                    s,
228                    scmp
229                )
230            }
231        }
232    };
233}
synfx_dsp/test.rs

synfx_dsp/
test.rs
