Mercurial > hg > silvet

comparison bqvec/test/TestVectorOps.cpp @ 372:af71cbdab621 tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Update bqvec code
author Chris Cannam
date Tue, 19 Nov 2019 10:13:32 +0000
parents 5d0a2ebb4d17
children
comparison
equal deleted inserted replaced
371:426ce52ef096 372:af71cbdab621
1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ 1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
2 2
3 #include "VectorOpsComplex.h" 3 #include "bqvec/VectorOps.h"
4 4
5 #include <iostream> 5 #define BOOST_TEST_DYN_LINK
6 #include <cstdlib> 6 #define BOOST_TEST_MAIN
7 7
8 #include <time.h> 8 #include <boost/test/unit_test.hpp>
9 9
10 using namespace std; 10 #include <stdexcept>
11 11 #include <vector>
12 namespace breakfastquay { 12
13 13 using namespace breakfastquay;
14 namespace Test { 14
15 15 BOOST_AUTO_TEST_SUITE(TestVectorOps)
16 #ifdef _WIN32 16
17 #define drand48() (-1+2*((float)rand())/RAND_MAX) 17 #define COMPARE_ARRAY(a, b) \
18 #endif 18 for (int cmp_i = 0; cmp_i < (int)(sizeof(a)/sizeof(a[0])); ++cmp_i) { \
19 19 BOOST_CHECK_SMALL(a[cmp_i] - b[cmp_i], 1e-14); \
20 bool
21 testMultiply()
22 {
23 cerr << "testVectorOps: testing v_multiply complex" << endl;
24
25 const int N = 1024;
26 turbot_complex_sample_t target[N];
27 turbot_complex_sample_t src1[N];
28 turbot_complex_sample_t src2[N];
29
30 for (int i = 0; i < N; ++i) {
31 src1[i].re = drand48();
32 src1[i].im = drand48();
33 src2[i].re = drand48();
34 src2[i].im = drand48();
35 } 20 }
36 21
37 turbot_sample_t mean, first, last, total = 0; 22 #define COMPARE_N(a, b, n) \
38 for (int i = 0; i < N; ++i) { 23 for (int cmp_i = 0; cmp_i < n; ++cmp_i) { \
39 turbot_complex_sample_t result; 24 BOOST_CHECK_SMALL(a[cmp_i] - b[cmp_i], 1e-14); \
40 c_multiply(result, src1[i], src2[i]);
41 if (i == 0) first = result.re;
42 if (i == N-1) last = result.im;
43 total += result.re;
44 total += result.im;
45 } 25 }
46 mean = total / (N*2); 26
47 cerr << "Naive method: mean = " << mean << ", first = " << first 27 BOOST_AUTO_TEST_CASE(add)
48 << ", last = " << last << endl; 28 {
49 29 double a[] = { 1.0, 2.0, 3.0 };
50 v_multiply(target, src1, src2, N); 30 double b[] = { -1.0, 3.0, -4.5 };
51 total = 0; 31 double expected[] = { 0.0, 5.0, -1.5 };
52 32 v_add(a, b, 3);
53 for (int i = 0; i < N; ++i) { 33 COMPARE_N(a, expected, 3);
54 if (i == 0) first = target[i].re; 34 }
55 if (i == N-1) last = target[i].im; 35
56 total += target[i].re; 36 BOOST_AUTO_TEST_CASE(add_with_gain)
57 total += target[i].im; 37 {
58 } 38 double a[] = { 1.0, 2.0, 3.0 };
59 mean = total / (N*2); 39 double b[] = { -1.0, 3.0, -4.5 };
60 cerr << "v_multiply: mean = " << mean << ", first = " << first 40 double expected[] = { -0.5, 6.5, -3.75 };
61 << ", last = " << last << endl; 41 v_add_with_gain(a, b, 1.5, 3);
62 42 COMPARE_N(a, expected, 3);
63 int iterations = 50000; 43 }
64 cerr << "Iterations: " << iterations << endl; 44
65 45 BOOST_AUTO_TEST_CASE(subtract)
66 cerr << "CLOCKS_PER_SEC = " << CLOCKS_PER_SEC << endl; 46 {
67 float divisor = float(CLOCKS_PER_SEC) / 1000.f; 47 double a[] = { 1.0, 2.0, 3.0 };
68 48 double b[] = { -1.0, 3.0, -4.5 };
69 clock_t start = clock(); 49 double expected[] = { 2.0, -1.0, 7.5 };
70 50 v_subtract(a, b, 3);
71 for (int j = 0; j < iterations; ++j) { 51 COMPARE_N(a, expected, 3);
72 for (int i = 0; i < N; ++i) { 52 }
73 c_multiply(target[i], src1[i], src2[i]); 53
74 } 54 BOOST_AUTO_TEST_CASE(increment)
75 } 55 {
76 56 double a[] = { -1.0, 3.0, -4.5 };
77 clock_t end = clock(); 57 double incr = -0.5;
78 58 double expected[] = { -1.5, 2.5, -5.0 };
79 cerr << "Time for naive method: " << float(end - start)/divisor << endl; 59 v_increment(a, incr, 3);
80 60 COMPARE_N(a, expected, 3);
81 start = clock(); 61 }
82 62
83 for (int j = 0; j < iterations; ++j) { 63 BOOST_AUTO_TEST_CASE(scale)
84 v_multiply(target, src1, src2, N); 64 {
85 } 65 double a[] = { -1.0, 3.0, -4.5 };
86 66 double scale = -0.5;
87 end = clock(); 67 double expected[] = { 0.5, -1.5, 2.25 };
88 68 v_scale(a, scale, 3);
89 cerr << "Time for v_multiply: " << float(end - start)/divisor << endl; 69 COMPARE_N(a, expected, 3);
90 70 }
91 return true; 71
92 } 72 BOOST_AUTO_TEST_CASE(multiply)
93 73 {
94 bool 74 double a[] = { 1.0, 2.0, 3.0 };
95 testPolarToCart() 75 double b[] = { -1.0, 3.0, -4.5 };
96 { 76 double expected[] = { -1.0, 6.0, -13.5 };
97 cerr << "testVectorOps: testing v_polar_to_cartesian" << endl; 77 v_multiply(a, b, 3);
98 78 COMPARE_N(a, expected, 3);
99 const int N = 1024; 79 }
100 turbot_complex_sample_t target[N]; 80
101 turbot_sample_t mag[N]; 81 BOOST_AUTO_TEST_CASE(multiply_to)
102 turbot_sample_t phase[N]; 82 {
103 83 double a[] = { 1.0, 2.0, 3.0 };
104 for (int i = 0; i < N; ++i) { 84 double b[] = { -1.0, 3.0, -4.5 };
105 mag[i] = drand48(); 85 double o[3];
106 phase[i] = (drand48() * M_PI * 2) - M_PI; 86 double expected[] = { -1.0, 6.0, -13.5 };
107 } 87 v_multiply_to(o, a, b, 3);
108 88 COMPARE_N(o, expected, 3);
109 turbot_sample_t mean, first, last, total = 0; 89 }
110 for (int i = 0; i < N; ++i) { 90
111 turbot_sample_t real = mag[i] * cos(phase[i]); 91 BOOST_AUTO_TEST_CASE(multiply_and_add)
112 turbot_sample_t imag = mag[i] * sin(phase[i]); 92 {
113 if (i == 0) first = real; 93 double a[] = { 1.0, 2.0, 3.0 };
114 if (i == N-1) last = imag; 94 double b[] = { -1.0, 3.0, -4.5 };
115 total += real; 95 double c[] = { 3.0, -1.0, 4.0 };
116 total += imag; 96 double expected[] = { 2.0, 5.0, -9.5 };
117 } 97 v_multiply_and_add(c, a, b, 3);
118 mean = total / (N*2); 98 COMPARE_N(c, expected, 3);
119 cerr << "Naive method: mean = " << mean << ", first = " << first 99 }
120 << ", last = " << last << endl; 100
121 101 BOOST_AUTO_TEST_CASE(divide)
122 v_polar_to_cartesian(target, mag, phase, N); 102 {
123 103 double a[] = { 1.0, 2.0, 3.0 };
124 total = 0; 104 double b[] = { -1.0, 3.0, -4.5 };
125 105 double expected[] = { -1.0, 2.0/3.0, 3.0/-4.5 };
126 for (int i = 0; i < N; ++i) { 106 v_divide(a, b, 3);
127 if (i == 0) first = target[i].re; 107 COMPARE_N(a, expected, 3);
128 if (i == N-1) last = target[i].im; 108 }
129 total += target[i].re; 109
130 total += target[i].im; 110 BOOST_AUTO_TEST_CASE(sum)
131 } 111 {
132 mean = total / (N*2); 112 double a[] = { 1.0, 2.0, -3.5 };
133 cerr << "v_polar_to_cartesian: mean = " << mean << ", first = " << first 113 double s = v_sum(a, 3);
134 << ", last = " << last << endl; 114 BOOST_CHECK_EQUAL(s, -0.5);
135 115 }
136 int iterations = 10000; 116
137 cerr << "Iterations: " << iterations << endl; 117 BOOST_AUTO_TEST_CASE(multiply_and_sum)
138 118 {
139 cerr << "CLOCKS_PER_SEC = " << CLOCKS_PER_SEC << endl; 119 double a[] = { 2.0, 0.0, -1.5 };
140 float divisor = float(CLOCKS_PER_SEC) / 1000.f; 120 double b[] = { 3.0, 4.0, 5.0 };
141 121 double s = v_multiply_and_sum(a, b, 3);
142 clock_t start = clock(); 122 BOOST_CHECK_EQUAL(s, -1.5);
143 123 }
144 for (int j = 0; j < iterations; ++j) { 124
145 for (int i = 0; i < N; ++i) { 125 BOOST_AUTO_TEST_CASE(log)
146 target[i].re = mag[i] * cos(phase[i]); 126 {
147 target[i].im = mag[i] * sin(phase[i]); 127 double a[] = { 1.0, 1.0 / M_E, M_E };
148 } 128 double expected[] = { 0.0, -1.0, 1.0 };
149 } 129 v_log(a, 3);
150 130 COMPARE_N(a, expected, 3);
151 clock_t end = clock(); 131 }
152 132
153 cerr << "Time for naive method: " << float(end - start)/divisor << endl; 133 BOOST_AUTO_TEST_CASE(exp)
154 134 {
155 start = clock(); 135 double a[] = { 0.0, -1.0, 2.0 };
156 136 double expected[] = { 1.0, 1.0 / M_E, M_E * M_E };
157 for (int j = 0; j < iterations; ++j) { 137 v_exp(a, 3);
158 v_polar_to_cartesian(target, mag, phase, N); 138 COMPARE_N(a, expected, 3);
159 } 139 }
160 140
161 end = clock(); 141 BOOST_AUTO_TEST_CASE(sqrt)
162 142 {
163 cerr << "Time for v_polar_to_cartesian: " << float(end - start)/divisor << endl; 143 double a[] = { 0.0, 1.0, 4.0 };
164 144 double expected[] = { 0.0, 1.0, 2.0 };
165 return true; 145 v_sqrt(a, 3);
166 } 146 COMPARE_N(a, expected, 3);
167 147 }
168 bool 148
169 testPolarToCartInterleaved() 149 BOOST_AUTO_TEST_CASE(square)
170 { 150 {
171 cerr << "testVectorOps: testing v_polar_interleaved_to_cartesian" << endl; 151 double a[] = { 0.0, 1.5, -2.0 };
172 152 double expected[] = { 0.0, 2.25, 4.0 };
173 const int N = 1024; 153 v_square(a, 3);
174 turbot_complex_sample_t target[N]; 154 COMPARE_N(a, expected, 3);
175 turbot_sample_t source[N*2]; 155 }
176 156
177 for (int i = 0; i < N; ++i) { 157 BOOST_AUTO_TEST_CASE(abs)
178 source[i*2] = drand48(); 158 {
179 source[i*2+1] = (drand48() * M_PI * 2) - M_PI; 159 double a[] = { -1.9, 0.0, 0.01, -0.0 };
180 } 160 double expected[] = { 1.9, 0.0, 0.01, 0.0 };
181 161 v_abs(a, 4);
182 turbot_sample_t mean, first, last, total = 0; 162 COMPARE_N(a, expected, 4);
183 for (int i = 0; i < N; ++i) { 163 }
184 turbot_sample_t real = source[i*2] * cos(source[i*2+1]); 164
185 turbot_sample_t imag = source[i*2] * sin(source[i*2+1]); 165 BOOST_AUTO_TEST_CASE(mean)
186 if (i == 0) first = real; 166 {
187 if (i == N-1) last = imag; 167 double a[] = { -1.0, 1.6, 3.0 };
188 total += real; 168 double s = v_mean(a, 3);
189 total += imag; 169 BOOST_CHECK_EQUAL(s, 1.2);
190 } 170 }
191 mean = total / (N*2); 171
192 cerr << "Naive method: mean = " << mean << ", first = " << first 172 BOOST_AUTO_TEST_CASE(interleave_1)
193 << ", last = " << last << endl; 173 {
194 174 double a[] = { 1.0, 2.0, 3.0 };
195 v_polar_interleaved_to_cartesian(target, source, N); 175 double *ch[] = { a };
196 176 double o[3];
197 total = 0; 177 double expected[] = { 1.0, 2.0, 3.0 };
198 178 v_interleave(o, ch, 1, 3);
199 for (int i = 0; i < N; ++i) { 179 COMPARE_N(o, expected, 3);
200 if (i == 0) first = target[i].re; 180 }
201 if (i == N-1) last = target[i].im; 181
202 total += target[i].re; 182 BOOST_AUTO_TEST_CASE(interleave_2)
203 total += target[i].im; 183 {
204 } 184 double a[] = { 1.0, 2.0, 3.0 };
205 mean = total / (N*2); 185 double b[] = { 4.0, 5.0, 6.0 };
206 cerr << "v_polar_interleaved_to_cartesian: mean = " << mean << ", first = " << first 186 double *ch[] = { a, b };
207 << ", last = " << last << endl; 187 double o[6];
208 188 double expected[] = { 1.0, 4.0, 2.0, 5.0, 3.0, 6.0 };
209 int iterations = 10000; 189 v_interleave(o, ch, 2, 3);
210 cerr << "Iterations: " << iterations << endl; 190 COMPARE_N(o, expected, 6);
211 191 }
212 cerr << "CLOCKS_PER_SEC = " << CLOCKS_PER_SEC << endl; 192
213 float divisor = float(CLOCKS_PER_SEC) / 1000.f; 193 BOOST_AUTO_TEST_CASE(interleave_3)
214 194 {
215 clock_t start = clock(); 195 double a[] = { 1.0, 2.0 };
216 196 double b[] = { 3.0, 4.0 };
217 for (int j = 0; j < iterations; ++j) { 197 double c[] = { 5.0, 6.0 };
218 for (int i = 0; i < N; ++i) { 198 double *ch[] = { a, b, c };
219 target[i].re = source[i*2] * cos(source[i*2+1]); 199 double o[6];
220 target[i].im = source[i*2] * sin(source[i*2+1]); 200 double expected[] = { 1.0, 3.0, 5.0, 2.0, 4.0, 6.0 };
221 } 201 v_interleave(o, ch, 3, 2);
222 } 202 COMPARE_N(o, expected, 6);
223 203 }
224 clock_t end = clock(); 204
225 205 BOOST_AUTO_TEST_CASE(deinterleave_1)
226 cerr << "Time for naive method: " << float(end - start)/divisor << endl; 206 {
227 207 double a[] = { 1.0, 2.0, 3.0 };
228 start = clock(); 208 double o[3];
229 209 double *oo[] = { o };
230 for (int j = 0; j < iterations; ++j) { 210 double *expected[] = { a };
231 v_polar_interleaved_to_cartesian(target, source, N); 211 v_deinterleave(oo, a, 1, 3);
232 } 212 COMPARE_N(oo[0], expected[0], 3);
233 213 }
234 end = clock(); 214
235 215 BOOST_AUTO_TEST_CASE(deinterleave_2)
236 cerr << "Time for v_polar_interleaved_to_cartesian: " << float(end - start)/divisor << endl; 216 {
237 217 double a[] = { 1.0, 4.0, 2.0, 5.0, 3.0, 6.0 };
238 return true; 218 double o1[3], o2[3];
239 } 219 double *oo[] = { o1, o2 };
240 220 double e1[] = { 1.0, 2.0, 3.0 }, e2[] = { 4.0, 5.0, 6.0 };
241 bool 221 double *expected[] = { e1, e2 };
242 testVectorOps() 222 v_deinterleave(oo, a, 2, 3);
243 { 223 COMPARE_N(oo[0], expected[0], 3);
244 if (!testMultiply()) return false; 224 COMPARE_N(oo[1], expected[1], 3);
245 if (!testPolarToCart()) return false; 225 }
246 if (!testPolarToCartInterleaved()) return false; 226
247 227 BOOST_AUTO_TEST_CASE(deinterleave_3)
248 return true; 228 {
249 } 229 double a[] = { 1.0, 3.0, 5.0, 2.0, 4.0, 6.0 };
250 230 double o1[2], o2[2], o3[2];
251 } 231 double *oo[] = { o1, o2, o3 };
252 232 double e1[] = { 1.0, 2.0 }, e2[] = { 3.0, 4.0 }, e3[] = { 5.0, 6.0 };
253 } 233 double *expected[] = { e1, e2, e3 };
254 234 v_deinterleave(oo, a, 3, 2);
235 COMPARE_N(oo[0], expected[0], 2);
236 COMPARE_N(oo[1], expected[1], 2);
237 COMPARE_N(oo[2], expected[2], 2);
238 }
239
240 BOOST_AUTO_TEST_CASE(mix_1)
241 {
242 double a[] = { 1.0, 2.0, 3.0 };
243 double *ch[] = { a };
244 double o[3];
245 double expected[] = { 1.0, 2.0, 3.0 };
246 v_mix(o, ch, 1, 3);
247 COMPARE_N(o, expected, 3);
248 }
249
250 BOOST_AUTO_TEST_CASE(mix_2)
251 {
252 double a[] = { 1.0, 2.0, 3.0 };
253 double b[] = { 4.0, 5.0, 6.0 };
254 double *ch[] = { a, b };
255 double o[6];
256 double expected[] = { 2.5, 3.5, 4.5 };
257 v_mix(o, ch, 2, 3);
258 COMPARE_N(o, expected, 3);
259 }
260
261 BOOST_AUTO_TEST_CASE(mix_3)
262 {
263 double a[] = { 1.0, 2.0 };
264 double b[] = { 3.0, 4.0 };
265 double c[] = { 5.0, 6.0 };
266 double *ch[] = { a, b, c };
267 double o[6];
268 double expected[] = { 3.0, 4.0 };
269 v_mix(o, ch, 3, 2);
270 COMPARE_N(o, expected, 2);
271 }
272
273 BOOST_AUTO_TEST_CASE(reconfigure_1_2)
274 {
275 double a[] = { 1.0, 2.0, 3.0 };
276 double *aa[] = { a };
277 double o1[3], o2[3];
278 double *oo[] = { o1, o2 };
279 double e1[] = { 1.0, 2.0, 3.0 };
280 double e2[] = { 1.0, 2.0, 3.0 };
281 double *expected[] = { e1, e2 };
282 v_reconfigure_channels(oo, 2, aa, 1, 3);
283 COMPARE_N(oo[0], expected[0], 3);
284 COMPARE_N(oo[1], expected[1], 3);
285 }
286
287 BOOST_AUTO_TEST_CASE(reconfigure_2_1)
288 {
289 double a1[] = { 1.0, 2.0, 3.0 };
290 double a2[] = { 4.0, 5.0, 6.0 };
291 double *aa[] = { a1, a2 };
292 double o1[3];
293 double *oo[] = { o1 };
294 double e1[] = { 2.5, 3.5, 4.5 };
295 double *expected[] = { e1 };
296 v_reconfigure_channels(oo, 1, aa, 2, 3);
297 COMPARE_N(oo[0], expected[0], 3);
298 }
299
300 BOOST_AUTO_TEST_CASE(reconfigure_3_1)
301 {
302 double a1[] = { 1.0, 2.0 };
303 double a2[] = { 3.0, 4.0 };
304 double a3[] = { 5.0, 6.0 };
305 double *aa[] = { a1, a2, a3 };
306 double o1[2];
307 double *oo[] = { o1 };
308 double e1[] = { 3.0, 4.0 };
309 double *expected[] = { e1 };
310 v_reconfigure_channels(oo, 1, aa, 3, 2);
311 COMPARE_N(oo[0], expected[0], 2);
312 }
313
314 BOOST_AUTO_TEST_CASE(reconfigure_1_3)
315 {
316 double a[] = { 1.0, 2.0, 3.0 };
317 double *aa[] = { a };
318 double o1[3], o2[3], o3[3];
319 double *oo[] = { o1, o2, o3 };
320 double e1[] = { 1.0, 2.0, 3.0 };
321 double e2[] = { 1.0, 2.0, 3.0 };
322 double e3[] = { 1.0, 2.0, 3.0 };
323 double *expected[] = { e1, e2, e3 };
324 v_reconfigure_channels(oo, 3, aa, 1, 3);
325 COMPARE_N(oo[0], expected[0], 3);
326 COMPARE_N(oo[1], expected[1], 3);
327 COMPARE_N(oo[2], expected[2], 3);
328 }
329
330 BOOST_AUTO_TEST_CASE(reconfigure_2_3)
331 {
332 double a1[] = { 1.0, 2.0, 3.0 };
333 double a2[] = { 4.0, 5.0, 6.0 };
334 double *aa[] = { a1, a2 };
335 double o1[3], o2[3], o3[3];
336 double *oo[] = { o1, o2, o3 };
337 double e1[] = { 1.0, 2.0, 3.0 };
338 double e2[] = { 0.0, 0.0, 0.0 };
339 double e3[] = { 4.0, 5.0, 6.0 };
340 double *expected[] = { e1, e2, e3 };
341 v_reconfigure_channels(oo, 3, aa, 2, 3);
342 COMPARE_N(oo[0], expected[0], 3);
343 COMPARE_N(oo[1], expected[1], 3);
344 COMPARE_N(oo[2], expected[2], 3);
345 }
346
347 BOOST_AUTO_TEST_CASE(reconfigure_3_2)
348 {
349 double a1[] = { 1.0, 2.0, 3.0 };
350 double a2[] = { 4.0, 5.0, 6.0 };
351 double a3[] = { 7.0, 8.0, 9.0 };
352 double *aa[] = { a1, a2, a3 };
353 double o1[3], o2[3];
354 double *oo[] = { o1, o2 };
355 double e1[] = { 1.0, 2.0, 3.0 };
356 double e2[] = { 7.0, 8.0, 9.0 };
357 double *expected[] = { e1, e2 };
358 v_reconfigure_channels(oo, 2, aa, 3, 3);
359 COMPARE_N(oo[0], expected[0], 3);
360 COMPARE_N(oo[1], expected[1], 3);
361 }
362
363 BOOST_AUTO_TEST_CASE(reconfigure_3_3)
364 {
365 double a1[] = { 1.0, 2.0, 3.0 };
366 double a2[] = { 4.0, 5.0, 6.0 };
367 double a3[] = { 7.0, 8.0, 9.0 };
368 double *aa[] = { a1, a2, a3 };
369 double o1[3], o2[3], o3[3];
370 double *oo[] = { o1, o2, o3 };
371 double e1[] = { 1.0, 2.0, 3.0 };
372 double e2[] = { 4.0, 5.0, 6.0 };
373 double e3[] = { 7.0, 8.0, 9.0 };
374 double *expected[] = { e1, e2, e3 };
375 v_reconfigure_channels(oo, 3, aa, 3, 3);
376 COMPARE_N(oo[0], expected[0], 3);
377 COMPARE_N(oo[1], expected[1], 3);
378 COMPARE_N(oo[2], expected[2], 3);
379 }
380
381 BOOST_AUTO_TEST_CASE(reconfigure_1_2_inplace)
382 {
383 double a1[] = { 1.0, 2.0, 3.0 };
384 double a2[3];
385 double *aa[] = { a1, a2 };
386 double e1[] = { 1.0, 2.0, 3.0 };
387 double e2[] = { 1.0, 2.0, 3.0 };
388 double *expected[] = { e1, e2 };
389 v_reconfigure_channels_inplace(aa, 2, 1, 3);
390 COMPARE_N(aa[0], expected[0], 3);
391 COMPARE_N(aa[1], expected[1], 3);
392 }
393
394 BOOST_AUTO_TEST_CASE(reconfigure_2_1_inplace)
395 {
396 double a1[] = { 1.0, 2.0, 3.0 };
397 double a2[] = { 4.0, 5.0, 6.0 };
398 double *aa[] = { a1, a2 };
399 double e1[] = { 2.5, 3.5, 4.5 };
400 double *expected[] = { e1 };
401 v_reconfigure_channels_inplace(aa, 1, 2, 3);
402 COMPARE_N(aa[0], expected[0], 3);
403 }
404
405 BOOST_AUTO_TEST_CASE(reconfigure_3_1_inplace)
406 {
407 double a1[] = { 1.0, 2.0 };
408 double a2[] = { 3.0, 4.0 };
409 double a3[] = { 5.0, 6.0 };
410 double *aa[] = { a1, a2, a3 };
411 double e1[] = { 3.0, 4.0 };
412 double *expected[] = { e1 };
413 v_reconfigure_channels_inplace(aa, 1, 3, 2);
414 COMPARE_N(aa[0], expected[0], 2);
415 }
416
417 BOOST_AUTO_TEST_CASE(reconfigure_1_3_inplace)
418 {
419 double a1[] = { 1.0, 2.0, 3.0 };
420 double a2[3], a3[3];
421 double *aa[] = { a1, a2, a3 };
422 double e1[] = { 1.0, 2.0, 3.0 };
423 double e2[] = { 1.0, 2.0, 3.0 };
424 double e3[] = { 1.0, 2.0, 3.0 };
425 double *expected[] = { e1, e2, e3 };
426 v_reconfigure_channels_inplace(aa, 3, 1, 3);
427 COMPARE_N(aa[0], expected[0], 3);
428 COMPARE_N(aa[1], expected[1], 3);
429 COMPARE_N(aa[2], expected[2], 3);
430 }
431
432 BOOST_AUTO_TEST_CASE(reconfigure_2_3_inplace)
433 {
434 double a1[] = { 1.0, 2.0, 3.0 };
435 double a2[] = { 4.0, 5.0, 6.0 };
436 double a3[3];
437 double *aa[] = { a1, a2, a3 };
438 double e1[] = { 1.0, 2.0, 3.0 };
439 double e2[] = { 4.0, 5.0, 6.0 };
440 double e3[] = { 0.0, 0.0, 0.0 };
441 double *expected[] = { e1, e2, e3 };
442 v_reconfigure_channels_inplace(aa, 3, 2, 3);
443 COMPARE_N(aa[0], expected[0], 3);
444 COMPARE_N(aa[1], expected[1], 3);
445 COMPARE_N(aa[2], expected[2], 3);
446 }
447
448 BOOST_AUTO_TEST_CASE(reconfigure_3_2_inplace)
449 {
450 double a1[] = { 1.0, 2.0, 3.0 };
451 double a2[] = { 4.0, 5.0, 6.0 };
452 double a3[] = { 7.0, 8.0, 9.0 };
453 double *aa[] = { a1, a2, a3 };
454 double e1[] = { 1.0, 2.0, 3.0 };
455 double e2[] = { 4.0, 5.0, 6.0 };
456 double *expected[] = { e1, e2 };
457 v_reconfigure_channels_inplace(aa, 2, 3, 3);
458 COMPARE_N(aa[0], expected[0], 3);
459 COMPARE_N(aa[1], expected[1], 3);
460 }
461
462 BOOST_AUTO_TEST_CASE(reconfigure_3_3_inplace)
463 {
464 double a1[] = { 1.0, 2.0, 3.0 };
465 double a2[] = { 4.0, 5.0, 6.0 };
466 double a3[] = { 7.0, 8.0, 9.0 };
467 double *aa[] = { a1, a2, a3 };
468 double e1[] = { 1.0, 2.0, 3.0 };
469 double e2[] = { 4.0, 5.0, 6.0 };
470 double e3[] = { 7.0, 8.0, 9.0 };
471 double *expected[] = { e1, e2, e3 };
472 v_reconfigure_channels_inplace(aa, 3, 3, 3);
473 COMPARE_N(aa[0], expected[0], 3);
474 COMPARE_N(aa[1], expected[1], 3);
475 COMPARE_N(aa[2], expected[2], 3);
476 }
477
478 BOOST_AUTO_TEST_CASE(fftshift)
479 {
480 double a[] = { 0.1, 2.0, -0.3, 4.0 };
481 double e[] = { -0.3, 4.0, 0.1, 2.0 };
482 v_fftshift(a, 4);
483 COMPARE_N(a, e, 4);
484 }
485
486 BOOST_AUTO_TEST_SUITE_END()
487