1 /* ************************************************************************
2 * Copyright 2013 Advanced Micro Devices, Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 * ************************************************************************/
16
17
18 #include <gtest/gtest.h>
19 #include<math.h>
20
21 #include "test_constants.h"
22 #include "fftw_transform.h"
23 #include "cl_transform.h"
24 #include "typedefs.h"
25 #include "accuracy_test_common.h"
26 #include <stdexcept>
27 #include <vector>
28
29 /*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
30 /*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
31 class accuracy_test_pow2_single : public ::testing::Test {
32 protected:
accuracy_test_pow2_single()33 accuracy_test_pow2_single(){}
~accuracy_test_pow2_single()34 virtual ~accuracy_test_pow2_single(){}
SetUp()35 virtual void SetUp(){}
TearDown()36 virtual void TearDown(){
37 }
38 };
39
40 /*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
41 /*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
42 class accuracy_test_pow2_double : public ::testing::Test {
43 protected:
accuracy_test_pow2_double()44 accuracy_test_pow2_double(){}
~accuracy_test_pow2_double()45 virtual ~accuracy_test_pow2_double(){}
SetUp()46 virtual void SetUp(){}
TearDown()47 virtual void TearDown(){
48 }
49 };
50
51 namespace power2
52 {
53 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
54 // ^^^^^^^^^^^^^^^^^^^^^^^ normal 1D ^^^^^^^^^^^^^^^^^^^^^^ //
55 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
56
57 // *****************************************************
58 // *****************************************************
59 template< class T, class cl_T, class fftw_T >
normal_1D_forward_in_place_complex_planar_to_complex_planar()60 void normal_1D_forward_in_place_complex_planar_to_complex_planar()
61 {
62 std::vector<size_t> lengths;
63 lengths.push_back( normal2 );
64 size_t batch = 1;
65 std::vector<size_t> input_strides;
66 std::vector<size_t> output_strides;
67 size_t input_distance = 0;
68 size_t output_distance = 0;
69 layout::buffer_layout_t in_layout = layout::complex_planar;
70 layout::buffer_layout_t out_layout = layout::complex_planar;
71 placeness::placeness_t placeness = placeness::in_place;
72 direction::direction_t direction = direction::forward;
73
74 data_pattern pattern = sawtooth;
75 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
76 }
77
TEST_F(accuracy_test_pow2_single,normal_1D_forward_in_place_complex_planar_to_complex_planar)78 TEST_F(accuracy_test_pow2_single, normal_1D_forward_in_place_complex_planar_to_complex_planar)
79 {
80 try { normal_1D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
81 catch( const std::exception& err ) { handle_exception(err); }
82 }
83
TEST_F(accuracy_test_pow2_double,normal_1D_forward_in_place_complex_planar_to_complex_planar)84 TEST_F(accuracy_test_pow2_double, normal_1D_forward_in_place_complex_planar_to_complex_planar)
85 {
86 try { normal_1D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
87 catch( const std::exception& err ) { handle_exception(err); }
88 }
89
90 // *****************************************************
91 // *****************************************************
92 template< class T, class cl_T, class fftw_T >
normal_1D_backward_in_place_complex_planar_to_complex_planar()93 void normal_1D_backward_in_place_complex_planar_to_complex_planar()
94 {
95 std::vector<size_t> lengths;
96 lengths.push_back( normal2 );
97 size_t batch = 1;
98 std::vector<size_t> input_strides;
99 std::vector<size_t> output_strides;
100 size_t input_distance = 0;
101 size_t output_distance = 0;
102 layout::buffer_layout_t in_layout = layout::complex_planar;
103 layout::buffer_layout_t out_layout = layout::complex_planar;
104 placeness::placeness_t placeness = placeness::in_place;
105 direction::direction_t direction = direction::backward;
106
107 data_pattern pattern = sawtooth;
108 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
109 }
110
TEST_F(accuracy_test_pow2_single,normal_1D_backward_in_place_complex_planar_to_complex_planar)111 TEST_F(accuracy_test_pow2_single, normal_1D_backward_in_place_complex_planar_to_complex_planar)
112 {
113 try { normal_1D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
114 catch( const std::exception& err ) { handle_exception(err); }
115 }
116
TEST_F(accuracy_test_pow2_double,normal_1D_backward_in_place_complex_planar_to_complex_planar)117 TEST_F(accuracy_test_pow2_double, normal_1D_backward_in_place_complex_planar_to_complex_planar)
118 {
119 try { normal_1D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
120 catch( const std::exception& err ) { handle_exception(err); }
121 }
122
123 // *****************************************************
124 // *****************************************************
125 template< class T, class cl_T, class fftw_T >
normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved()126 void normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved()
127 {
128 std::vector<size_t> lengths;
129 lengths.push_back( normal2 );
130 size_t batch = 1;
131 std::vector<size_t> input_strides;
132 std::vector<size_t> output_strides;
133 size_t input_distance = 0;
134 size_t output_distance = 0;
135 layout::buffer_layout_t in_layout = layout::complex_interleaved;
136 layout::buffer_layout_t out_layout = layout::complex_interleaved;
137 placeness::placeness_t placeness = placeness::in_place;
138 direction::direction_t direction = direction::forward;
139
140 data_pattern pattern = sawtooth;
141 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
142 }
143
TEST_F(accuracy_test_pow2_single,normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved)144 TEST_F(accuracy_test_pow2_single, normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
145 {
146 try { normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
147 catch( const std::exception& err ) { handle_exception(err); }
148 }
149
TEST_F(accuracy_test_pow2_double,normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved)150 TEST_F(accuracy_test_pow2_double, normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
151 {
152 try { normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
153 catch( const std::exception& err ) { handle_exception(err); }
154 }
155
156 // *****************************************************
157 // *****************************************************
158 template< class T, class cl_T, class fftw_T >
len65536_1D_forward_in_place_complex_interleaved_to_complex_interleaved()159 void len65536_1D_forward_in_place_complex_interleaved_to_complex_interleaved()
160 {
161 std::vector<size_t> lengths;
162 lengths.push_back( 65536 );
163 size_t batch = 1;
164 std::vector<size_t> input_strides;
165 std::vector<size_t> output_strides;
166 size_t input_distance = 0;
167 size_t output_distance = 0;
168 layout::buffer_layout_t in_layout = layout::complex_interleaved;
169 layout::buffer_layout_t out_layout = layout::complex_interleaved;
170 placeness::placeness_t placeness = placeness::in_place;
171 direction::direction_t direction = direction::backward;
172
173 data_pattern pattern = sawtooth;
174 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
175 }
176
TEST_F(accuracy_test_pow2_single,len65536_1D_forward_in_place_complex_interleaved_to_complex_interleaved)177 TEST_F(accuracy_test_pow2_single, len65536_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
178 {
179 try { normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
180 catch( const std::exception& err ) { handle_exception(err); }
181 }
182
TEST_F(accuracy_test_pow2_double,len65536_1D_forward_in_place_complex_interleaved_to_complex_interleaved)183 TEST_F(accuracy_test_pow2_double, len65536_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
184 {
185 try { normal_1D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
186 catch( const std::exception& err ) { handle_exception(err); }
187 }
188 // *****************************************************
189 // *****************************************************
190 template< class T, class cl_T, class fftw_T >
normal_1D_backward_in_place_complex_interleaved_to_complex_interleaved()191 void normal_1D_backward_in_place_complex_interleaved_to_complex_interleaved()
192 {
193 std::vector<size_t> lengths;
194 lengths.push_back( normal2 );
195 size_t batch = 1;
196 std::vector<size_t> input_strides;
197 std::vector<size_t> output_strides;
198 size_t input_distance = 0;
199 size_t output_distance = 0;
200 layout::buffer_layout_t in_layout = layout::complex_interleaved;
201 layout::buffer_layout_t out_layout = layout::complex_interleaved;
202 placeness::placeness_t placeness = placeness::in_place;
203 direction::direction_t direction = direction::backward;
204
205 data_pattern pattern = sawtooth;
206 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
207 }
208
TEST_F(accuracy_test_pow2_single,normal_1D_backward_in_place_complex_interleaved_to_complex_interleaved)209 TEST_F(accuracy_test_pow2_single, normal_1D_backward_in_place_complex_interleaved_to_complex_interleaved)
210 {
211 try { normal_1D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
212 catch( const std::exception& err ) { handle_exception(err); }
213 }
214
TEST_F(accuracy_test_pow2_double,normal_1D_backward_in_place_complex_interleaved_to_complex_interleaved)215 TEST_F(accuracy_test_pow2_double, normal_1D_backward_in_place_complex_interleaved_to_complex_interleaved)
216 {
217 try { normal_1D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
218 catch( const std::exception& err ) { handle_exception(err); }
219 }
220
221 // *****************************************************
222 // *****************************************************
223 template< class T, class cl_T, class fftw_T >
normal_1D_forward_out_of_place_complex_planar_to_complex_planar()224 void normal_1D_forward_out_of_place_complex_planar_to_complex_planar()
225 {
226 std::vector<size_t> lengths;
227 lengths.push_back( normal2 );
228 size_t batch = 1;
229 std::vector<size_t> input_strides;
230 std::vector<size_t> output_strides;
231 size_t input_distance = 0;
232 size_t output_distance = 0;
233 layout::buffer_layout_t in_layout = layout::complex_planar;
234 layout::buffer_layout_t out_layout = layout::complex_planar;
235 placeness::placeness_t placeness = placeness::out_of_place;
236 direction::direction_t direction = direction::forward;
237
238 data_pattern pattern = sawtooth;
239 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
240 }
241
TEST_F(accuracy_test_pow2_single,normal_1D_forward_out_of_place_complex_planar_to_complex_planar)242 TEST_F(accuracy_test_pow2_single, normal_1D_forward_out_of_place_complex_planar_to_complex_planar)
243 {
244 try { normal_1D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
245 catch( const std::exception& err ) { handle_exception(err); }
246 }
247
TEST_F(accuracy_test_pow2_double,normal_1D_forward_out_of_place_complex_planar_to_complex_planar)248 TEST_F(accuracy_test_pow2_double, normal_1D_forward_out_of_place_complex_planar_to_complex_planar)
249 {
250 try { normal_1D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
251 catch( const std::exception& err ) { handle_exception(err); }
252 }
253
254 // *****************************************************
255 // *****************************************************
256 template< class T, class cl_T, class fftw_T >
normal_1D_backward_out_of_place_complex_planar_to_complex_planar()257 void normal_1D_backward_out_of_place_complex_planar_to_complex_planar()
258 {
259 std::vector<size_t> lengths;
260 lengths.push_back( normal2 );
261 size_t batch = 1;
262 std::vector<size_t> input_strides;
263 std::vector<size_t> output_strides;
264 size_t input_distance = 0;
265 size_t output_distance = 0;
266 layout::buffer_layout_t in_layout = layout::complex_planar;
267 layout::buffer_layout_t out_layout = layout::complex_planar;
268 placeness::placeness_t placeness = placeness::out_of_place;
269 direction::direction_t direction = direction::backward;
270
271 data_pattern pattern = sawtooth;
272 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
273 }
274
TEST_F(accuracy_test_pow2_single,normal_1D_backward_out_of_place_complex_planar_to_complex_planar)275 TEST_F(accuracy_test_pow2_single, normal_1D_backward_out_of_place_complex_planar_to_complex_planar)
276 {
277 try { normal_1D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
278 catch( const std::exception& err ) { handle_exception(err); }
279 }
280
TEST_F(accuracy_test_pow2_double,normal_1D_backward_out_of_place_complex_planar_to_complex_planar)281 TEST_F(accuracy_test_pow2_double, normal_1D_backward_out_of_place_complex_planar_to_complex_planar)
282 {
283 try { normal_1D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
284 catch( const std::exception& err ) { handle_exception(err); }
285 }
286
287 // *****************************************************
288 // *****************************************************
289 template< class T, class cl_T, class fftw_T >
normal_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved()290 void normal_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
291 {
292 std::vector<size_t> lengths;
293 lengths.push_back( normal2 );
294 size_t batch = 1;
295 std::vector<size_t> input_strides;
296 std::vector<size_t> output_strides;
297 size_t input_distance = 0;
298 size_t output_distance = 0;
299 layout::buffer_layout_t in_layout = layout::complex_interleaved;
300 layout::buffer_layout_t out_layout = layout::complex_interleaved;
301 placeness::placeness_t placeness = placeness::out_of_place;
302 direction::direction_t direction = direction::forward;
303
304 data_pattern pattern = sawtooth;
305 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
306 }
307
TEST_F(accuracy_test_pow2_single,normal_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)308 TEST_F(accuracy_test_pow2_single, normal_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
309 {
310 try { normal_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
311 catch( const std::exception& err ) { handle_exception(err); }
312 }
313
TEST_F(accuracy_test_pow2_double,normal_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)314 TEST_F(accuracy_test_pow2_double, normal_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
315 {
316 try { normal_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
317 catch( const std::exception& err ) { handle_exception(err); }
318 }
319
320 // *****************************************************
321 // *****************************************************
322 template< class T, class cl_T, class fftw_T >
normal_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved()323 void normal_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
324 {
325 std::vector<size_t> lengths;
326 lengths.push_back( normal2 );
327 size_t batch = 1;
328 std::vector<size_t> input_strides;
329 std::vector<size_t> output_strides;
330 size_t input_distance = 0;
331 size_t output_distance = 0;
332 layout::buffer_layout_t in_layout = layout::complex_interleaved;
333 layout::buffer_layout_t out_layout = layout::complex_interleaved;
334 placeness::placeness_t placeness = placeness::out_of_place;
335 direction::direction_t direction = direction::backward;
336
337 data_pattern pattern = sawtooth;
338 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
339 }
340
TEST_F(accuracy_test_pow2_single,normal_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)341 TEST_F(accuracy_test_pow2_single, normal_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
342 {
343 try { normal_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
344 catch( const std::exception& err ) { handle_exception(err); }
345 }
346
TEST_F(accuracy_test_pow2_double,normal_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)347 TEST_F(accuracy_test_pow2_double, normal_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
348 {
349 try { normal_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
350 catch( const std::exception& err ) { handle_exception(err); }
351 }
352
353 // *****************************************************
354 // *****************************************************
355 template< class T, class cl_T, class fftw_T >
normal_1D_forward_out_of_place_complex_planar_to_complex_interleaved()356 void normal_1D_forward_out_of_place_complex_planar_to_complex_interleaved()
357 {
358 std::vector<size_t> lengths;
359 lengths.push_back( normal2 );
360 size_t batch = 1;
361 std::vector<size_t> input_strides;
362 std::vector<size_t> output_strides;
363 size_t input_distance = 0;
364 size_t output_distance = 0;
365 layout::buffer_layout_t in_layout = layout::complex_planar;
366 layout::buffer_layout_t out_layout = layout::complex_interleaved;
367 placeness::placeness_t placeness = placeness::out_of_place;
368 direction::direction_t direction = direction::forward;
369
370 data_pattern pattern = sawtooth;
371 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
372 }
373
TEST_F(accuracy_test_pow2_single,normal_1D_forward_out_of_place_complex_planar_to_complex_interleaved)374 TEST_F(accuracy_test_pow2_single, normal_1D_forward_out_of_place_complex_planar_to_complex_interleaved)
375 {
376 try { normal_1D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
377 catch( const std::exception& err ) { handle_exception(err); }
378 }
379
TEST_F(accuracy_test_pow2_double,normal_1D_forward_out_of_place_complex_planar_to_complex_interleaved)380 TEST_F(accuracy_test_pow2_double, normal_1D_forward_out_of_place_complex_planar_to_complex_interleaved)
381 {
382 try { normal_1D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
383 catch( const std::exception& err ) { handle_exception(err); }
384 }
385
386 // *****************************************************
387 // *****************************************************
388 template< class T, class cl_T, class fftw_T >
normal_1D_backward_out_of_place_complex_planar_to_complex_interleaved()389 void normal_1D_backward_out_of_place_complex_planar_to_complex_interleaved()
390 {
391 std::vector<size_t> lengths;
392 lengths.push_back( normal2 );
393 size_t batch = 1;
394 std::vector<size_t> input_strides;
395 std::vector<size_t> output_strides;
396 size_t input_distance = 0;
397 size_t output_distance = 0;
398 layout::buffer_layout_t in_layout = layout::complex_planar;
399 layout::buffer_layout_t out_layout = layout::complex_interleaved;
400 placeness::placeness_t placeness = placeness::out_of_place;
401 direction::direction_t direction = direction::backward;
402
403 data_pattern pattern = sawtooth;
404 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
405 }
406
TEST_F(accuracy_test_pow2_single,normal_1D_backward_out_of_place_complex_planar_to_complex_interleaved)407 TEST_F(accuracy_test_pow2_single, normal_1D_backward_out_of_place_complex_planar_to_complex_interleaved)
408 {
409 try { normal_1D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
410 catch( const std::exception& err ) { handle_exception(err); }
411 }
412
TEST_F(accuracy_test_pow2_double,normal_1D_backward_out_of_place_complex_planar_to_complex_interleaved)413 TEST_F(accuracy_test_pow2_double, normal_1D_backward_out_of_place_complex_planar_to_complex_interleaved)
414 {
415 try { normal_1D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
416 catch( const std::exception& err ) { handle_exception(err); }
417 }
418
419 // *****************************************************
420 // *****************************************************
421 template< class T, class cl_T, class fftw_T >
normal_1D_forward_out_of_place_complex_interleaved_to_complex_planar()422 void normal_1D_forward_out_of_place_complex_interleaved_to_complex_planar()
423 {
424 std::vector<size_t> lengths;
425 lengths.push_back( normal2 );
426 size_t batch = 1;
427 std::vector<size_t> input_strides;
428 std::vector<size_t> output_strides;
429 size_t input_distance = 0;
430 size_t output_distance = 0;
431 layout::buffer_layout_t in_layout = layout::complex_interleaved;
432 layout::buffer_layout_t out_layout = layout::complex_planar;
433 placeness::placeness_t placeness = placeness::out_of_place;
434 direction::direction_t direction = direction::forward;
435
436 data_pattern pattern = sawtooth;
437 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
438 }
439
TEST_F(accuracy_test_pow2_single,normal_1D_forward_out_of_place_complex_interleaved_to_complex_planar)440 TEST_F(accuracy_test_pow2_single, normal_1D_forward_out_of_place_complex_interleaved_to_complex_planar)
441 {
442 try { normal_1D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
443 catch( const std::exception& err ) { handle_exception(err); }
444 }
445
TEST_F(accuracy_test_pow2_double,normal_1D_forward_out_of_place_complex_interleaved_to_complex_planar)446 TEST_F(accuracy_test_pow2_double, normal_1D_forward_out_of_place_complex_interleaved_to_complex_planar)
447 {
448 try { normal_1D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
449 catch( const std::exception& err ) { handle_exception(err); }
450 }
451
452 // *****************************************************
453 // *****************************************************
454 template< class T, class cl_T, class fftw_T >
normal_1D_backward_out_of_place_complex_interleaved_to_complex_planar()455 void normal_1D_backward_out_of_place_complex_interleaved_to_complex_planar()
456 {
457 std::vector<size_t> lengths;
458 lengths.push_back( normal2 );
459 size_t batch = 1;
460 std::vector<size_t> input_strides;
461 std::vector<size_t> output_strides;
462 size_t input_distance = 0;
463 size_t output_distance = 0;
464 layout::buffer_layout_t in_layout = layout::complex_interleaved;
465 layout::buffer_layout_t out_layout = layout::complex_planar;
466 placeness::placeness_t placeness = placeness::out_of_place;
467 direction::direction_t direction = direction::backward;
468
469 data_pattern pattern = sawtooth;
470 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
471 }
472
TEST_F(accuracy_test_pow2_single,normal_1D_backward_out_of_place_complex_interleaved_to_complex_planar)473 TEST_F(accuracy_test_pow2_single, normal_1D_backward_out_of_place_complex_interleaved_to_complex_planar)
474 {
475 try { normal_1D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
476 catch( const std::exception& err ) { handle_exception(err); }
477 }
478
TEST_F(accuracy_test_pow2_double,normal_1D_backward_out_of_place_complex_interleaved_to_complex_planar)479 TEST_F(accuracy_test_pow2_double, normal_1D_backward_out_of_place_complex_interleaved_to_complex_planar)
480 {
481 try { normal_1D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
482 catch( const std::exception& err ) { handle_exception(err); }
483 }
484
485 // *****************************************************
486 // *****************************************************
487 template< class T, class cl_T, class fftw_T >
normal_1D_in_place_real_to_hermitian_interleaved()488 void normal_1D_in_place_real_to_hermitian_interleaved()
489 {
490 std::vector<size_t> lengths;
491 lengths.push_back( normal2 );
492 size_t batch = 1;
493 std::vector<size_t> input_strides;
494 std::vector<size_t> output_strides;
495 size_t input_distance = 0;
496 size_t output_distance = 0;
497 layout::buffer_layout_t layout = layout::hermitian_interleaved;
498 placeness::placeness_t placeness = placeness::in_place;
499
500 data_pattern pattern = sawtooth;
501 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
502 }
503
TEST_F(accuracy_test_pow2_single,normal_1D_in_place_real_to_hermitian_interleaved)504 TEST_F(accuracy_test_pow2_single, normal_1D_in_place_real_to_hermitian_interleaved)
505 {
506 try { normal_1D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
507 catch( const std::exception& err ) { handle_exception(err); }
508 }
509
TEST_F(accuracy_test_pow2_double,normal_1D_in_place_real_to_hermitian_interleaved)510 TEST_F(accuracy_test_pow2_double, normal_1D_in_place_real_to_hermitian_interleaved)
511 {
512 try { normal_1D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
513 catch( const std::exception& err ) { handle_exception(err); }
514 }
515
516 // *****************************************************
517 // *****************************************************
518 template< class T, class cl_T, class fftw_T >
normal_1D_in_place_hermitian_interleaved_to_real()519 void normal_1D_in_place_hermitian_interleaved_to_real()
520 {
521 std::vector<size_t> lengths;
522 lengths.push_back( normal2 );
523 size_t batch = 1;
524 std::vector<size_t> input_strides;
525 std::vector<size_t> output_strides;
526 size_t input_distance = 0;
527 size_t output_distance = 0;
528 layout::buffer_layout_t layout = layout::hermitian_interleaved;
529 placeness::placeness_t placeness = placeness::in_place;
530
531 data_pattern pattern = sawtooth;
532 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
533 }
534
TEST_F(accuracy_test_pow2_single,normal_1D_in_place_hermitian_interleaved_to_real)535 TEST_F(accuracy_test_pow2_single, normal_1D_in_place_hermitian_interleaved_to_real)
536 {
537 try { normal_1D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
538 catch( const std::exception& err ) { handle_exception(err); }
539 }
540
TEST_F(accuracy_test_pow2_double,normal_1D_in_place_hermitian_interleaved_to_real)541 TEST_F(accuracy_test_pow2_double, normal_1D_in_place_hermitian_interleaved_to_real)
542 {
543 try { normal_1D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
544 catch( const std::exception& err ) { handle_exception(err); }
545 }
546
547 // *****************************************************
548 // *****************************************************
549 template< class T, class cl_T, class fftw_T >
normal_1D_out_of_place_real_to_hermitian_interleaved()550 void normal_1D_out_of_place_real_to_hermitian_interleaved()
551 {
552 std::vector<size_t> lengths;
553 lengths.push_back( normal2 );
554 size_t batch = 1;
555 std::vector<size_t> input_strides;
556 std::vector<size_t> output_strides;
557 size_t input_distance = 0;
558 size_t output_distance = 0;
559 layout::buffer_layout_t layout = layout::hermitian_interleaved;
560 placeness::placeness_t placeness = placeness::out_of_place;
561
562 data_pattern pattern = sawtooth;
563 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
564 }
565
TEST_F(accuracy_test_pow2_single,normal_1D_out_of_place_real_to_hermitian_interleaved)566 TEST_F(accuracy_test_pow2_single, normal_1D_out_of_place_real_to_hermitian_interleaved)
567 {
568 try { normal_1D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
569 catch( const std::exception& err ) { handle_exception(err); }
570 }
571
TEST_F(accuracy_test_pow2_double,normal_1D_out_of_place_real_to_hermitian_interleaved)572 TEST_F(accuracy_test_pow2_double, normal_1D_out_of_place_real_to_hermitian_interleaved)
573 {
574 try { normal_1D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
575 catch( const std::exception& err ) { handle_exception(err); }
576 }
577
578 // *****************************************************
579 // *****************************************************
580 template< class T, class cl_T, class fftw_T >
normal_1D_out_of_place_hermitian_interleaved_to_real()581 void normal_1D_out_of_place_hermitian_interleaved_to_real()
582 {
583 std::vector<size_t> lengths;
584 lengths.push_back( normal2 );
585 size_t batch = 1;
586 std::vector<size_t> input_strides;
587 std::vector<size_t> output_strides;
588 size_t input_distance = 0;
589 size_t output_distance = 0;
590 layout::buffer_layout_t layout = layout::hermitian_interleaved;
591 placeness::placeness_t placeness = placeness::out_of_place;
592
593 data_pattern pattern = sawtooth;
594 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
595 }
596
TEST_F(accuracy_test_pow2_single,normal_1D_out_of_place_hermitian_interleaved_to_real)597 TEST_F(accuracy_test_pow2_single, normal_1D_out_of_place_hermitian_interleaved_to_real)
598 {
599 try { normal_1D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
600 catch( const std::exception& err ) { handle_exception(err); }
601 }
602
TEST_F(accuracy_test_pow2_double,normal_1D_out_of_place_hermitian_interleaved_to_real)603 TEST_F(accuracy_test_pow2_double, normal_1D_out_of_place_hermitian_interleaved_to_real)
604 {
605 try { normal_1D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
606 catch( const std::exception& err ) { handle_exception(err); }
607 }
608
609 // *****************************************************
610 // *****************************************************
611 template< class T, class cl_T, class fftw_T >
normal_1D_out_of_place_real_to_hermitian_planar()612 void normal_1D_out_of_place_real_to_hermitian_planar()
613 {
614 std::vector<size_t> lengths;
615 lengths.push_back( normal2 );
616 size_t batch = 1;
617 std::vector<size_t> input_strides;
618 std::vector<size_t> output_strides;
619 size_t input_distance = 0;
620 size_t output_distance = 0;
621 layout::buffer_layout_t layout = layout::hermitian_planar;
622 placeness::placeness_t placeness = placeness::out_of_place;
623
624 data_pattern pattern = sawtooth;
625 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
626 }
627
TEST_F(accuracy_test_pow2_single,normal_1D_out_of_place_real_to_hermitian_planar)628 TEST_F(accuracy_test_pow2_single, normal_1D_out_of_place_real_to_hermitian_planar)
629 {
630 try { normal_1D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
631 catch( const std::exception& err ) { handle_exception(err); }
632 }
633
TEST_F(accuracy_test_pow2_double,normal_1D_out_of_place_real_to_hermitian_planar)634 TEST_F(accuracy_test_pow2_double, normal_1D_out_of_place_real_to_hermitian_planar)
635 {
636 try { normal_1D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
637 catch( const std::exception& err ) { handle_exception(err); }
638 }
639
640 // *****************************************************
641 // *****************************************************
642 template< class T, class cl_T, class fftw_T >
normal_1D_out_of_place_hermitian_planar_to_real()643 void normal_1D_out_of_place_hermitian_planar_to_real()
644 {
645 std::vector<size_t> lengths;
646 lengths.push_back( normal2 );
647 size_t batch = 1;
648 std::vector<size_t> input_strides;
649 std::vector<size_t> output_strides;
650 size_t input_distance = 0;
651 size_t output_distance = 0;
652 layout::buffer_layout_t layout = layout::hermitian_planar;
653 placeness::placeness_t placeness = placeness::out_of_place;
654
655 data_pattern pattern = sawtooth;
656 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
657 }
658
TEST_F(accuracy_test_pow2_single,normal_1D_out_of_place_hermitian_planar_to_real)659 TEST_F(accuracy_test_pow2_single, normal_1D_out_of_place_hermitian_planar_to_real)
660 {
661 try { normal_1D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
662 catch( const std::exception& err ) { handle_exception(err); }
663 }
664
TEST_F(accuracy_test_pow2_double,normal_1D_out_of_place_hermitian_planar_to_real)665 TEST_F(accuracy_test_pow2_double, normal_1D_out_of_place_hermitian_planar_to_real)
666 {
667 try { normal_1D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
668 catch( const std::exception& err ) { handle_exception(err); }
669 }
670
671 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
672 // ^^^^^^^^^^^^^^^^^^^^^^^ small 1D ^^^^^^^^^^^^^^^^^^^^^^^ //
673 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
674
675 // *****************************************************
676 // *****************************************************
677 template< class T, class cl_T, class fftw_T >
small_1D_forward_in_place_complex_planar_to_complex_planar()678 void small_1D_forward_in_place_complex_planar_to_complex_planar()
679 {
680 std::vector<size_t> lengths;
681 lengths.push_back( small2 );
682 size_t batch = 1;
683 std::vector<size_t> input_strides;
684 std::vector<size_t> output_strides;
685 size_t input_distance = 0;
686 size_t output_distance = 0;
687 layout::buffer_layout_t in_layout = layout::complex_planar;
688 layout::buffer_layout_t out_layout = layout::complex_planar;
689 placeness::placeness_t placeness = placeness::in_place;
690 direction::direction_t direction = direction::forward;
691
692 data_pattern pattern = sawtooth;
693 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
694 }
695
TEST_F(accuracy_test_pow2_single,small_1D_forward_in_place_complex_planar_to_complex_planar)696 TEST_F(accuracy_test_pow2_single, small_1D_forward_in_place_complex_planar_to_complex_planar)
697 {
698 try { small_1D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
699 catch( const std::exception& err ) { handle_exception(err); }
700 }
701
TEST_F(accuracy_test_pow2_double,small_1D_forward_in_place_complex_planar_to_complex_planar)702 TEST_F(accuracy_test_pow2_double, small_1D_forward_in_place_complex_planar_to_complex_planar)
703 {
704 try { small_1D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
705 catch( const std::exception& err ) { handle_exception(err); }
706 }
707
708 // *****************************************************
709 // *****************************************************
710 template< class T, class cl_T, class fftw_T >
small_1D_backward_in_place_complex_planar_to_complex_planar()711 void small_1D_backward_in_place_complex_planar_to_complex_planar()
712 {
713 std::vector<size_t> lengths;
714 lengths.push_back( small2 );
715 size_t batch = 1;
716 std::vector<size_t> input_strides;
717 std::vector<size_t> output_strides;
718 size_t input_distance = 0;
719 size_t output_distance = 0;
720 layout::buffer_layout_t in_layout = layout::complex_planar;
721 layout::buffer_layout_t out_layout = layout::complex_planar;
722 placeness::placeness_t placeness = placeness::in_place;
723 direction::direction_t direction = direction::backward;
724
725 data_pattern pattern = sawtooth;
726 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
727 }
728
TEST_F(accuracy_test_pow2_single,small_1D_backward_in_place_complex_planar_to_complex_planar)729 TEST_F(accuracy_test_pow2_single, small_1D_backward_in_place_complex_planar_to_complex_planar)
730 {
731 try { small_1D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
732 catch( const std::exception& err ) { handle_exception(err); }
733 }
734
TEST_F(accuracy_test_pow2_double,small_1D_backward_in_place_complex_planar_to_complex_planar)735 TEST_F(accuracy_test_pow2_double, small_1D_backward_in_place_complex_planar_to_complex_planar)
736 {
737 try { small_1D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
738 catch( const std::exception& err ) { handle_exception(err); }
739 }
740
741 // *****************************************************
742 // *****************************************************
743 template< class T, class cl_T, class fftw_T >
small_1D_forward_in_place_complex_interleaved_to_complex_interleaved()744 void small_1D_forward_in_place_complex_interleaved_to_complex_interleaved()
745 {
746 std::vector<size_t> lengths;
747 lengths.push_back( small2 );
748 size_t batch = 1;
749 std::vector<size_t> input_strides;
750 std::vector<size_t> output_strides;
751 size_t input_distance = 0;
752 size_t output_distance = 0;
753 layout::buffer_layout_t in_layout = layout::complex_interleaved;
754 layout::buffer_layout_t out_layout = layout::complex_interleaved;
755 placeness::placeness_t placeness = placeness::in_place;
756 direction::direction_t direction = direction::forward;
757
758 data_pattern pattern = sawtooth;
759 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
760 }
761
TEST_F(accuracy_test_pow2_single,small_1D_forward_in_place_complex_interleaved_to_complex_interleaved)762 TEST_F(accuracy_test_pow2_single, small_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
763 {
764 try { small_1D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
765 catch( const std::exception& err ) { handle_exception(err); }
766 }
767
TEST_F(accuracy_test_pow2_double,small_1D_forward_in_place_complex_interleaved_to_complex_interleaved)768 TEST_F(accuracy_test_pow2_double, small_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
769 {
770 try { small_1D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
771 catch( const std::exception& err ) { handle_exception(err); }
772 }
773
774 // *****************************************************
775 // *****************************************************
776 template< class T, class cl_T, class fftw_T >
small_1D_backward_in_place_complex_interleaved_to_complex_interleaved()777 void small_1D_backward_in_place_complex_interleaved_to_complex_interleaved()
778 {
779 std::vector<size_t> lengths;
780 lengths.push_back( small2 );
781 size_t batch = 1;
782 std::vector<size_t> input_strides;
783 std::vector<size_t> output_strides;
784 size_t input_distance = 0;
785 size_t output_distance = 0;
786 layout::buffer_layout_t in_layout = layout::complex_interleaved;
787 layout::buffer_layout_t out_layout = layout::complex_interleaved;
788 placeness::placeness_t placeness = placeness::in_place;
789 direction::direction_t direction = direction::backward;
790
791 data_pattern pattern = sawtooth;
792 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
793 }
794
TEST_F(accuracy_test_pow2_single,small_1D_backward_in_place_complex_interleaved_to_complex_interleaved)795 TEST_F(accuracy_test_pow2_single, small_1D_backward_in_place_complex_interleaved_to_complex_interleaved)
796 {
797 try { small_1D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
798 catch( const std::exception& err ) { handle_exception(err); }
799 }
800
TEST_F(accuracy_test_pow2_double,small_1D_backward_in_place_complex_interleaved_to_complex_interleaved)801 TEST_F(accuracy_test_pow2_double, small_1D_backward_in_place_complex_interleaved_to_complex_interleaved)
802 {
803 try { small_1D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
804 catch( const std::exception& err ) { handle_exception(err); }
805 }
806
807 // *****************************************************
808 // *****************************************************
809 template< class T, class cl_T, class fftw_T >
small_1D_forward_out_of_place_complex_planar_to_complex_planar()810 void small_1D_forward_out_of_place_complex_planar_to_complex_planar()
811 {
812 std::vector<size_t> lengths;
813 lengths.push_back( small2 );
814 size_t batch = 1;
815 std::vector<size_t> input_strides;
816 std::vector<size_t> output_strides;
817 size_t input_distance = 0;
818 size_t output_distance = 0;
819 layout::buffer_layout_t in_layout = layout::complex_planar;
820 layout::buffer_layout_t out_layout = layout::complex_planar;
821 placeness::placeness_t placeness = placeness::out_of_place;
822 direction::direction_t direction = direction::forward;
823
824 data_pattern pattern = sawtooth;
825 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
826 }
827
TEST_F(accuracy_test_pow2_single,small_1D_forward_out_of_place_complex_planar_to_complex_planar)828 TEST_F(accuracy_test_pow2_single, small_1D_forward_out_of_place_complex_planar_to_complex_planar)
829 {
830 try { small_1D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
831 catch( const std::exception& err ) { handle_exception(err); }
832 }
833
TEST_F(accuracy_test_pow2_double,small_1D_forward_out_of_place_complex_planar_to_complex_planar)834 TEST_F(accuracy_test_pow2_double, small_1D_forward_out_of_place_complex_planar_to_complex_planar)
835 {
836 try { small_1D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
837 catch( const std::exception& err ) { handle_exception(err); }
838 }
839
840 // *****************************************************
841 // *****************************************************
842 template< class T, class cl_T, class fftw_T >
small_1D_backward_out_of_place_complex_planar_to_complex_planar()843 void small_1D_backward_out_of_place_complex_planar_to_complex_planar()
844 {
845 std::vector<size_t> lengths;
846 lengths.push_back( small2 );
847 size_t batch = 1;
848 std::vector<size_t> input_strides;
849 std::vector<size_t> output_strides;
850 size_t input_distance = 0;
851 size_t output_distance = 0;
852 layout::buffer_layout_t in_layout = layout::complex_planar;
853 layout::buffer_layout_t out_layout = layout::complex_planar;
854 placeness::placeness_t placeness = placeness::out_of_place;
855 direction::direction_t direction = direction::backward;
856
857 data_pattern pattern = sawtooth;
858 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
859 }
860
TEST_F(accuracy_test_pow2_single,small_1D_backward_out_of_place_complex_planar_to_complex_planar)861 TEST_F(accuracy_test_pow2_single, small_1D_backward_out_of_place_complex_planar_to_complex_planar)
862 {
863 try { small_1D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
864 catch( const std::exception& err ) { handle_exception(err); }
865 }
866
TEST_F(accuracy_test_pow2_double,small_1D_backward_out_of_place_complex_planar_to_complex_planar)867 TEST_F(accuracy_test_pow2_double, small_1D_backward_out_of_place_complex_planar_to_complex_planar)
868 {
869 try { small_1D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
870 catch( const std::exception& err ) { handle_exception(err); }
871 }
872
873 // *****************************************************
874 // *****************************************************
875 template< class T, class cl_T, class fftw_T >
small_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved()876 void small_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
877 {
878 std::vector<size_t> lengths;
879 lengths.push_back( small2 );
880 size_t batch = 1;
881 std::vector<size_t> input_strides;
882 std::vector<size_t> output_strides;
883 size_t input_distance = 0;
884 size_t output_distance = 0;
885 layout::buffer_layout_t in_layout = layout::complex_interleaved;
886 layout::buffer_layout_t out_layout = layout::complex_interleaved;
887 placeness::placeness_t placeness = placeness::out_of_place;
888 direction::direction_t direction = direction::forward;
889
890 data_pattern pattern = sawtooth;
891 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
892 }
893
TEST_F(accuracy_test_pow2_single,small_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)894 TEST_F(accuracy_test_pow2_single, small_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
895 {
896 try { small_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
897 catch( const std::exception& err ) { handle_exception(err); }
898 }
899
TEST_F(accuracy_test_pow2_double,small_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)900 TEST_F(accuracy_test_pow2_double, small_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
901 {
902 try { small_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
903 catch( const std::exception& err ) { handle_exception(err); }
904 }
905
906 // *****************************************************
907 // *****************************************************
908 template< class T, class cl_T, class fftw_T >
small_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved()909 void small_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
910 {
911 std::vector<size_t> lengths;
912 lengths.push_back( small2 );
913 size_t batch = 1;
914 std::vector<size_t> input_strides;
915 std::vector<size_t> output_strides;
916 size_t input_distance = 0;
917 size_t output_distance = 0;
918 layout::buffer_layout_t in_layout = layout::complex_interleaved;
919 layout::buffer_layout_t out_layout = layout::complex_interleaved;
920 placeness::placeness_t placeness = placeness::out_of_place;
921 direction::direction_t direction = direction::backward;
922
923 data_pattern pattern = sawtooth;
924 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
925 }
926
TEST_F(accuracy_test_pow2_single,small_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)927 TEST_F(accuracy_test_pow2_single, small_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
928 {
929 try { small_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
930 catch( const std::exception& err ) { handle_exception(err); }
931 }
932
TEST_F(accuracy_test_pow2_double,small_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)933 TEST_F(accuracy_test_pow2_double, small_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
934 {
935 try { small_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
936 catch( const std::exception& err ) { handle_exception(err); }
937 }
938
939 // *****************************************************
940 // *****************************************************
941 template< class T, class cl_T, class fftw_T >
small_1D_forward_out_of_place_complex_planar_to_complex_interleaved()942 void small_1D_forward_out_of_place_complex_planar_to_complex_interleaved()
943 {
944 std::vector<size_t> lengths;
945 lengths.push_back( small2 );
946 size_t batch = 1;
947 std::vector<size_t> input_strides;
948 std::vector<size_t> output_strides;
949 size_t input_distance = 0;
950 size_t output_distance = 0;
951 layout::buffer_layout_t in_layout = layout::complex_planar;
952 layout::buffer_layout_t out_layout = layout::complex_interleaved;
953 placeness::placeness_t placeness = placeness::out_of_place;
954 direction::direction_t direction = direction::forward;
955
956 data_pattern pattern = sawtooth;
957 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
958 }
959
TEST_F(accuracy_test_pow2_single,small_1D_forward_out_of_place_complex_planar_to_complex_interleaved)960 TEST_F(accuracy_test_pow2_single, small_1D_forward_out_of_place_complex_planar_to_complex_interleaved)
961 {
962 try { small_1D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
963 catch( const std::exception& err ) { handle_exception(err); }
964 }
965
TEST_F(accuracy_test_pow2_double,small_1D_forward_out_of_place_complex_planar_to_complex_interleaved)966 TEST_F(accuracy_test_pow2_double, small_1D_forward_out_of_place_complex_planar_to_complex_interleaved)
967 {
968 try { small_1D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
969 catch( const std::exception& err ) { handle_exception(err); }
970 }
971
972 // *****************************************************
973 // *****************************************************
974 template< class T, class cl_T, class fftw_T >
small_1D_backward_out_of_place_complex_planar_to_complex_interleaved()975 void small_1D_backward_out_of_place_complex_planar_to_complex_interleaved()
976 {
977 std::vector<size_t> lengths;
978 lengths.push_back( small2 );
979 size_t batch = 1;
980 std::vector<size_t> input_strides;
981 std::vector<size_t> output_strides;
982 size_t input_distance = 0;
983 size_t output_distance = 0;
984 layout::buffer_layout_t in_layout = layout::complex_planar;
985 layout::buffer_layout_t out_layout = layout::complex_interleaved;
986 placeness::placeness_t placeness = placeness::out_of_place;
987 direction::direction_t direction = direction::backward;
988
989 data_pattern pattern = sawtooth;
990 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
991 }
992
TEST_F(accuracy_test_pow2_single,small_1D_backward_out_of_place_complex_planar_to_complex_interleaved)993 TEST_F(accuracy_test_pow2_single, small_1D_backward_out_of_place_complex_planar_to_complex_interleaved)
994 {
995 try { small_1D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
996 catch( const std::exception& err ) { handle_exception(err); }
997 }
998
TEST_F(accuracy_test_pow2_double,small_1D_backward_out_of_place_complex_planar_to_complex_interleaved)999 TEST_F(accuracy_test_pow2_double, small_1D_backward_out_of_place_complex_planar_to_complex_interleaved)
1000 {
1001 try { small_1D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
1002 catch( const std::exception& err ) { handle_exception(err); }
1003 }
1004
1005 // *****************************************************
1006 // *****************************************************
1007 template< class T, class cl_T, class fftw_T >
small_1D_forward_out_of_place_complex_interleaved_to_complex_planar()1008 void small_1D_forward_out_of_place_complex_interleaved_to_complex_planar()
1009 {
1010 std::vector<size_t> lengths;
1011 lengths.push_back( small2 );
1012 size_t batch = 1;
1013 std::vector<size_t> input_strides;
1014 std::vector<size_t> output_strides;
1015 size_t input_distance = 0;
1016 size_t output_distance = 0;
1017 layout::buffer_layout_t in_layout = layout::complex_interleaved;
1018 layout::buffer_layout_t out_layout = layout::complex_planar;
1019 placeness::placeness_t placeness = placeness::out_of_place;
1020 direction::direction_t direction = direction::forward;
1021
1022 data_pattern pattern = sawtooth;
1023 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1024 }
1025
TEST_F(accuracy_test_pow2_single,small_1D_forward_out_of_place_complex_interleaved_to_complex_planar)1026 TEST_F(accuracy_test_pow2_single, small_1D_forward_out_of_place_complex_interleaved_to_complex_planar)
1027 {
1028 try { small_1D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
1029 catch( const std::exception& err ) { handle_exception(err); }
1030 }
1031
TEST_F(accuracy_test_pow2_double,small_1D_forward_out_of_place_complex_interleaved_to_complex_planar)1032 TEST_F(accuracy_test_pow2_double, small_1D_forward_out_of_place_complex_interleaved_to_complex_planar)
1033 {
1034 try { small_1D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
1035 catch( const std::exception& err ) { handle_exception(err); }
1036 }
1037
1038 // *****************************************************
1039 // *****************************************************
1040 template< class T, class cl_T, class fftw_T >
small_1D_backward_out_of_place_complex_interleaved_to_complex_planar()1041 void small_1D_backward_out_of_place_complex_interleaved_to_complex_planar()
1042 {
1043 std::vector<size_t> lengths;
1044 lengths.push_back( small2 );
1045 size_t batch = 1;
1046 std::vector<size_t> input_strides;
1047 std::vector<size_t> output_strides;
1048 size_t input_distance = 0;
1049 size_t output_distance = 0;
1050 layout::buffer_layout_t in_layout = layout::complex_interleaved;
1051 layout::buffer_layout_t out_layout = layout::complex_planar;
1052 placeness::placeness_t placeness = placeness::out_of_place;
1053 direction::direction_t direction = direction::backward;
1054
1055 data_pattern pattern = sawtooth;
1056 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1057 }
1058
TEST_F(accuracy_test_pow2_single,small_1D_backward_out_of_place_complex_interleaved_to_complex_planar)1059 TEST_F(accuracy_test_pow2_single, small_1D_backward_out_of_place_complex_interleaved_to_complex_planar)
1060 {
1061 try { small_1D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
1062 catch( const std::exception& err ) { handle_exception(err); }
1063 }
1064
TEST_F(accuracy_test_pow2_double,small_1D_backward_out_of_place_complex_interleaved_to_complex_planar)1065 TEST_F(accuracy_test_pow2_double, small_1D_backward_out_of_place_complex_interleaved_to_complex_planar)
1066 {
1067 try { small_1D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
1068 catch( const std::exception& err ) { handle_exception(err); }
1069 }
1070
1071 // *****************************************************
1072 // *****************************************************
1073 template< class T, class cl_T, class fftw_T >
small_1D_in_place_real_to_hermitian_interleaved()1074 void small_1D_in_place_real_to_hermitian_interleaved()
1075 {
1076 std::vector<size_t> lengths;
1077 lengths.push_back( small2 );
1078 size_t batch = 1;
1079 std::vector<size_t> input_strides;
1080 std::vector<size_t> output_strides;
1081 size_t input_distance = 0;
1082 size_t output_distance = 0;
1083 layout::buffer_layout_t layout = layout::hermitian_interleaved;
1084 placeness::placeness_t placeness = placeness::in_place;
1085
1086 data_pattern pattern = sawtooth;
1087 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
1088 }
1089
TEST_F(accuracy_test_pow2_single,small_1D_in_place_real_to_hermitian_interleaved)1090 TEST_F(accuracy_test_pow2_single, small_1D_in_place_real_to_hermitian_interleaved)
1091 {
1092 try { small_1D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
1093 catch( const std::exception& err ) { handle_exception(err); }
1094 }
1095
TEST_F(accuracy_test_pow2_double,small_1D_in_place_real_to_hermitian_interleaved)1096 TEST_F(accuracy_test_pow2_double, small_1D_in_place_real_to_hermitian_interleaved)
1097 {
1098 try { small_1D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
1099 catch( const std::exception& err ) { handle_exception(err); }
1100 }
1101
1102 // *****************************************************
1103 // *****************************************************
1104 template< class T, class cl_T, class fftw_T >
small_1D_in_place_hermitian_interleaved_to_real()1105 void small_1D_in_place_hermitian_interleaved_to_real()
1106 {
1107 std::vector<size_t> lengths;
1108 lengths.push_back( small2 );
1109 size_t batch = 1;
1110 std::vector<size_t> input_strides;
1111 std::vector<size_t> output_strides;
1112 size_t input_distance = 0;
1113 size_t output_distance = 0;
1114 layout::buffer_layout_t layout = layout::hermitian_interleaved;
1115 placeness::placeness_t placeness = placeness::in_place;
1116
1117 data_pattern pattern = sawtooth;
1118 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
1119 }
1120
TEST_F(accuracy_test_pow2_single,small_1D_in_place_hermitian_interleaved_to_real)1121 TEST_F(accuracy_test_pow2_single, small_1D_in_place_hermitian_interleaved_to_real)
1122 {
1123 try { small_1D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
1124 catch( const std::exception& err ) { handle_exception(err); }
1125 }
1126
TEST_F(accuracy_test_pow2_double,small_1D_in_place_hermitian_interleaved_to_real)1127 TEST_F(accuracy_test_pow2_double, small_1D_in_place_hermitian_interleaved_to_real)
1128 {
1129 try { small_1D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
1130 catch( const std::exception& err ) { handle_exception(err); }
1131 }
1132
1133 // *****************************************************
1134 // *****************************************************
1135 template< class T, class cl_T, class fftw_T >
small_1D_out_of_place_real_to_hermitian_interleaved()1136 void small_1D_out_of_place_real_to_hermitian_interleaved()
1137 {
1138 std::vector<size_t> lengths;
1139 lengths.push_back( small2 );
1140 size_t batch = 1;
1141 std::vector<size_t> input_strides;
1142 std::vector<size_t> output_strides;
1143 size_t input_distance = 0;
1144 size_t output_distance = 0;
1145 layout::buffer_layout_t layout = layout::hermitian_interleaved;
1146 placeness::placeness_t placeness = placeness::out_of_place;
1147
1148 data_pattern pattern = sawtooth;
1149 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
1150 }
1151
TEST_F(accuracy_test_pow2_single,small_1D_out_of_place_real_to_hermitian_interleaved)1152 TEST_F(accuracy_test_pow2_single, small_1D_out_of_place_real_to_hermitian_interleaved)
1153 {
1154 try { small_1D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
1155 catch( const std::exception& err ) { handle_exception(err); }
1156 }
1157
TEST_F(accuracy_test_pow2_double,small_1D_out_of_place_real_to_hermitian_interleaved)1158 TEST_F(accuracy_test_pow2_double, small_1D_out_of_place_real_to_hermitian_interleaved)
1159 {
1160 try { small_1D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
1161 catch( const std::exception& err ) { handle_exception(err); }
1162 }
1163
1164 // *****************************************************
1165 // *****************************************************
1166 template< class T, class cl_T, class fftw_T >
small_1D_out_of_place_hermitian_interleaved_to_real()1167 void small_1D_out_of_place_hermitian_interleaved_to_real()
1168 {
1169 std::vector<size_t> lengths;
1170 lengths.push_back( small2 );
1171 size_t batch = 1;
1172 std::vector<size_t> input_strides;
1173 std::vector<size_t> output_strides;
1174 size_t input_distance = 0;
1175 size_t output_distance = 0;
1176 layout::buffer_layout_t layout = layout::hermitian_interleaved;
1177 placeness::placeness_t placeness = placeness::out_of_place;
1178
1179 data_pattern pattern = sawtooth;
1180 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
1181 }
1182
TEST_F(accuracy_test_pow2_single,small_1D_out_of_place_hermitian_interleaved_to_real)1183 TEST_F(accuracy_test_pow2_single, small_1D_out_of_place_hermitian_interleaved_to_real)
1184 {
1185 try { small_1D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
1186 catch( const std::exception& err ) { handle_exception(err); }
1187 }
1188
TEST_F(accuracy_test_pow2_double,small_1D_out_of_place_hermitian_interleaved_to_real)1189 TEST_F(accuracy_test_pow2_double, small_1D_out_of_place_hermitian_interleaved_to_real)
1190 {
1191 try { small_1D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
1192 catch( const std::exception& err ) { handle_exception(err); }
1193 }
1194
1195 // *****************************************************
1196 // *****************************************************
1197 template< class T, class cl_T, class fftw_T >
small_1D_out_of_place_real_to_hermitian_planar()1198 void small_1D_out_of_place_real_to_hermitian_planar()
1199 {
1200 std::vector<size_t> lengths;
1201 lengths.push_back( small2 );
1202 size_t batch = 1;
1203 std::vector<size_t> input_strides;
1204 std::vector<size_t> output_strides;
1205 size_t input_distance = 0;
1206 size_t output_distance = 0;
1207 layout::buffer_layout_t layout = layout::hermitian_planar;
1208 placeness::placeness_t placeness = placeness::out_of_place;
1209
1210 data_pattern pattern = sawtooth;
1211 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
1212 }
1213
TEST_F(accuracy_test_pow2_single,small_1D_out_of_place_real_to_hermitian_planar)1214 TEST_F(accuracy_test_pow2_single, small_1D_out_of_place_real_to_hermitian_planar)
1215 {
1216 try { small_1D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
1217 catch( const std::exception& err ) { handle_exception(err); }
1218 }
1219
TEST_F(accuracy_test_pow2_double,small_1D_out_of_place_real_to_hermitian_planar)1220 TEST_F(accuracy_test_pow2_double, small_1D_out_of_place_real_to_hermitian_planar)
1221 {
1222 try { small_1D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
1223 catch( const std::exception& err ) { handle_exception(err); }
1224 }
1225
1226 // *****************************************************
1227 // *****************************************************
1228 template< class T, class cl_T, class fftw_T >
small_1D_out_of_place_hermitian_planar_to_real()1229 void small_1D_out_of_place_hermitian_planar_to_real()
1230 {
1231 std::vector<size_t> lengths;
1232 lengths.push_back( small2 );
1233 size_t batch = 1;
1234 std::vector<size_t> input_strides;
1235 std::vector<size_t> output_strides;
1236 size_t input_distance = 0;
1237 size_t output_distance = 0;
1238 layout::buffer_layout_t layout = layout::hermitian_planar;
1239 placeness::placeness_t placeness = placeness::out_of_place;
1240
1241 data_pattern pattern = sawtooth;
1242 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
1243 }
1244
TEST_F(accuracy_test_pow2_single,small_1D_out_of_place_hermitian_planar_to_real)1245 TEST_F(accuracy_test_pow2_single, small_1D_out_of_place_hermitian_planar_to_real)
1246 {
1247 try { small_1D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
1248 catch( const std::exception& err ) { handle_exception(err); }
1249 }
1250
TEST_F(accuracy_test_pow2_double,small_1D_out_of_place_hermitian_planar_to_real)1251 TEST_F(accuracy_test_pow2_double, small_1D_out_of_place_hermitian_planar_to_real)
1252 {
1253 try { small_1D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
1254 catch( const std::exception& err ) { handle_exception(err); }
1255 }
1256
1257 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
1258 // ^^^^^^^^^^^^^^^^^^^^^^^ large 1D ^^^^^^^^^^^^^^^^^^^^^^^ //
1259 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
1260
1261 // *****************************************************
1262 // *****************************************************
1263 template< class T, class cl_T, class fftw_T >
large_1D_forward_in_place_complex_planar_to_complex_planar()1264 void large_1D_forward_in_place_complex_planar_to_complex_planar()
1265 {
1266 std::vector<size_t> lengths;
1267 lengths.push_back( large2 );
1268 size_t batch = 1;
1269 std::vector<size_t> input_strides;
1270 std::vector<size_t> output_strides;
1271 size_t input_distance = 0;
1272 size_t output_distance = 0;
1273 layout::buffer_layout_t in_layout = layout::complex_planar;
1274 layout::buffer_layout_t out_layout = layout::complex_planar;
1275 placeness::placeness_t placeness = placeness::in_place;
1276 direction::direction_t direction = direction::forward;
1277
1278 data_pattern pattern = sawtooth;
1279 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1280 }
1281
TEST_F(accuracy_test_pow2_single,large_1D_forward_in_place_complex_planar_to_complex_planar)1282 TEST_F(accuracy_test_pow2_single, large_1D_forward_in_place_complex_planar_to_complex_planar)
1283 {
1284 try { large_1D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
1285 catch( const std::exception& err ) { handle_exception(err); }
1286 }
1287
TEST_F(accuracy_test_pow2_double,large_1D_forward_in_place_complex_planar_to_complex_planar)1288 TEST_F(accuracy_test_pow2_double, large_1D_forward_in_place_complex_planar_to_complex_planar)
1289 {
1290 try { large_1D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
1291 catch( const std::exception& err ) { handle_exception(err); }
1292 }
1293
1294 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
1295 // ^^^^^^^^^^^^^^^^^^^^^^^ huge 1D ^^^^^^^^^^^^^^^^^^^^^^^ //
1296 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
1297
1298 // *****************************************************
1299 // *****************************************************
1300 //TESTS disabled by default since they take a long time to execute
1301 //TO enable this tests
1302 //1. make sure ENV CLFFT_REQUEST_LIB_NOMEMALLOC=1
1303 //2. pass --gtest_also_run_disabled_tests to TEST.exe
1304
1305 #define CLFFT_TEST_HUGE
1306 #ifdef CLFFT_TEST_HUGE
1307
1308 #define HUGE_TEST_MAKE(test_name, len, bat) \
1309 template< class T, class cl_T, class fftw_T > \
1310 void test_name() \
1311 { \
1312 std::vector<size_t> lengths; \
1313 lengths.push_back( len ); \
1314 size_t batch = bat; \
1315 \
1316 std::vector<size_t> input_strides; \
1317 std::vector<size_t> output_strides; \
1318 size_t input_distance = 0; \
1319 size_t output_distance = 0; \
1320 layout::buffer_layout_t in_layout = layout::complex_planar; \
1321 layout::buffer_layout_t out_layout = layout::complex_planar; \
1322 placeness::placeness_t placeness = placeness::in_place; \
1323 direction::direction_t direction = direction::forward; \
1324 \
1325 data_pattern pattern = sawtooth; \
1326 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness ); \
1327 }
1328
1329 #define SP_HUGE_TEST(test_name, len, bat) \
1330 \
1331 HUGE_TEST_MAKE(test_name, len, bat) \
1332 \
1333 TEST_F(accuracy_test_pow2_single, test_name) \
1334 { \
1335 try { test_name< float, cl_float, fftwf_complex >(); } \
1336 catch( const std::exception& err ) { handle_exception(err); } \
1337 }
1338
1339 #define DP_HUGE_TEST(test_name, len, bat) \
1340 \
1341 HUGE_TEST_MAKE(test_name, len, bat) \
1342 \
1343 TEST_F(accuracy_test_pow2_double, test_name) \
1344 { \
1345 try { test_name< double, cl_double, fftw_complex >(); } \
1346 catch( const std::exception& err ) { handle_exception(err); } \
1347 }
1348
1349 SP_HUGE_TEST( DISABLED_huge_sp_test_1, 1048576, 11 )
1350 SP_HUGE_TEST( DISABLED_huge_sp_test_2, 1048576*2, 7 )
1351 SP_HUGE_TEST( DISABLED_huge_sp_test_3, 1048576*4, 3 )
1352 SP_HUGE_TEST( DISABLED_huge_sp_test_4, 1048576*8, 5 )
1353 SP_HUGE_TEST( DISABLED_huge_sp_test_5, 1048576*16, 3 )
1354 SP_HUGE_TEST( DISABLED_huge_sp_test_6, 1048576*32, 2 )
1355 SP_HUGE_TEST( DISABLED_huge_sp_test_7, 1048576*64, 1 )
1356
1357 DP_HUGE_TEST( DISABLED_huge_dp_test_1, 524288, 11 )
1358 DP_HUGE_TEST( DISABLED_huge_dp_test_2, 524288*2, 7 )
1359 DP_HUGE_TEST( DISABLED_huge_dp_test_3, 524288*4, 3 )
1360 DP_HUGE_TEST( DISABLED_huge_dp_test_4, 524288*8, 5 )
1361 DP_HUGE_TEST( DISABLED_huge_dp_test_5, 524288*16, 3 )
1362 DP_HUGE_TEST( DISABLED_huge_dp_test_6, 524288*32, 2 )
1363 DP_HUGE_TEST( DISABLED_huge_dp_test_7, 524288*64, 1 )
1364
1365 SP_HUGE_TEST( DISABLED_large_sp_test_1, 8192, 11 )
1366 SP_HUGE_TEST( DISABLED_large_sp_test_2, 8192*2, 7 )
1367 SP_HUGE_TEST( DISABLED_large_sp_test_3, 8192*4, 3 )
1368 SP_HUGE_TEST( DISABLED_large_sp_test_4, 8192*8, 5 )
1369 SP_HUGE_TEST( DISABLED_large_sp_test_5, 8192*16, 3 )
1370 SP_HUGE_TEST( DISABLED_large_sp_test_6, 8192*32, 21 )
1371 SP_HUGE_TEST( DISABLED_large_sp_test_7, 8192*64, 17 )
1372
1373 DP_HUGE_TEST( DISABLED_large_dp_test_1, 4096, 11 )
1374 DP_HUGE_TEST( DISABLED_large_dp_test_2, 4096*2, 7 )
1375 DP_HUGE_TEST( DISABLED_large_dp_test_3, 4096*4, 3 )
1376 DP_HUGE_TEST( DISABLED_large_dp_test_4, 4096*8, 5 )
1377 DP_HUGE_TEST( DISABLED_large_dp_test_5, 4096*16, 3 )
1378 DP_HUGE_TEST( DISABLED_large_dp_test_6, 4096*32, 21 )
1379 DP_HUGE_TEST( DISABLED_large_dp_test_7, 4096*64, 17 )
1380
1381 #endif
1382
1383 // *****************************************************
1384 // *****************************************************
1385 template< class T, class cl_T, class fftw_T >
large_1D_backward_in_place_complex_planar_to_complex_planar()1386 void large_1D_backward_in_place_complex_planar_to_complex_planar()
1387 {
1388 std::vector<size_t> lengths;
1389 lengths.push_back( large2 );
1390 size_t batch = 1;
1391 std::vector<size_t> input_strides;
1392 std::vector<size_t> output_strides;
1393 size_t input_distance = 0;
1394 size_t output_distance = 0;
1395 layout::buffer_layout_t in_layout = layout::complex_planar;
1396 layout::buffer_layout_t out_layout = layout::complex_planar;
1397 placeness::placeness_t placeness = placeness::in_place;
1398 direction::direction_t direction = direction::backward;
1399
1400 data_pattern pattern = sawtooth;
1401 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1402 }
1403
TEST_F(accuracy_test_pow2_single,large_1D_backward_in_place_complex_planar_to_complex_planar)1404 TEST_F(accuracy_test_pow2_single, large_1D_backward_in_place_complex_planar_to_complex_planar)
1405 {
1406 try { large_1D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
1407 catch( const std::exception& err ) { handle_exception(err); }
1408 }
1409
TEST_F(accuracy_test_pow2_double,large_1D_backward_in_place_complex_planar_to_complex_planar)1410 TEST_F(accuracy_test_pow2_double, large_1D_backward_in_place_complex_planar_to_complex_planar)
1411 {
1412 try { large_1D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
1413 catch( const std::exception& err ) { handle_exception(err); }
1414 }
1415
1416 // *****************************************************
1417 // *****************************************************
1418 template< class T, class cl_T, class fftw_T >
large_1D_forward_in_place_complex_interleaved_to_complex_interleaved()1419 void large_1D_forward_in_place_complex_interleaved_to_complex_interleaved()
1420 {
1421 std::vector<size_t> lengths;
1422 lengths.push_back( large2 );
1423 size_t batch = 1;
1424 std::vector<size_t> input_strides;
1425 std::vector<size_t> output_strides;
1426 size_t input_distance = 0;
1427 size_t output_distance = 0;
1428 layout::buffer_layout_t in_layout = layout::complex_interleaved;
1429 layout::buffer_layout_t out_layout = layout::complex_interleaved;
1430 placeness::placeness_t placeness = placeness::in_place;
1431 direction::direction_t direction = direction::forward;
1432
1433 data_pattern pattern = sawtooth;
1434 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1435 }
1436
TEST_F(accuracy_test_pow2_single,large_1D_forward_in_place_complex_interleaved_to_complex_interleaved)1437 TEST_F(accuracy_test_pow2_single, large_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
1438 {
1439 try { large_1D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
1440 catch( const std::exception& err ) { handle_exception(err); }
1441 }
1442
TEST_F(accuracy_test_pow2_double,large_1D_forward_in_place_complex_interleaved_to_complex_interleaved)1443 TEST_F(accuracy_test_pow2_double, large_1D_forward_in_place_complex_interleaved_to_complex_interleaved)
1444 {
1445 try { large_1D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
1446 catch( const std::exception& err ) { handle_exception(err); }
1447 }
1448
1449 // *****************************************************
1450 // *****************************************************
1451 template< class T, class cl_T, class fftw_T >
large_1D_backward_in_place_complex_interleaved_to_complex_interleaved()1452 void large_1D_backward_in_place_complex_interleaved_to_complex_interleaved()
1453 {
1454 std::vector<size_t> lengths;
1455 lengths.push_back( large2 );
1456 size_t batch = 1;
1457 std::vector<size_t> input_strides;
1458 std::vector<size_t> output_strides;
1459 size_t input_distance = 0;
1460 size_t output_distance = 0;
1461 layout::buffer_layout_t in_layout = layout::complex_interleaved;
1462 layout::buffer_layout_t out_layout = layout::complex_interleaved;
1463 placeness::placeness_t placeness = placeness::in_place;
1464 direction::direction_t direction = direction::backward;
1465
1466 data_pattern pattern = sawtooth;
1467 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1468 }
1469
TEST_F(accuracy_test_pow2_single,large_1D_backward_in_place_complex_interleaved_to_complex_interleaved)1470 TEST_F(accuracy_test_pow2_single, large_1D_backward_in_place_complex_interleaved_to_complex_interleaved)
1471 {
1472 try { large_1D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
1473 catch( const std::exception& err ) { handle_exception(err); }
1474 }
1475
TEST_F(accuracy_test_pow2_double,large_1D_backward_in_place_complex_interleaved_to_complex_interleaved)1476 TEST_F(accuracy_test_pow2_double, large_1D_backward_in_place_complex_interleaved_to_complex_interleaved)
1477 {
1478 try { large_1D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
1479 catch( const std::exception& err ) { handle_exception(err); }
1480 }
1481
1482 // *****************************************************
1483 // *****************************************************
1484 template< class T, class cl_T, class fftw_T >
large_1D_forward_out_of_place_complex_planar_to_complex_planar()1485 void large_1D_forward_out_of_place_complex_planar_to_complex_planar()
1486 {
1487 std::vector<size_t> lengths;
1488 lengths.push_back( large2 );
1489 size_t batch = 1;
1490 std::vector<size_t> input_strides;
1491 std::vector<size_t> output_strides;
1492 size_t input_distance = 0;
1493 size_t output_distance = 0;
1494 layout::buffer_layout_t in_layout = layout::complex_planar;
1495 layout::buffer_layout_t out_layout = layout::complex_planar;
1496 placeness::placeness_t placeness = placeness::out_of_place;
1497 direction::direction_t direction = direction::forward;
1498
1499 data_pattern pattern = sawtooth;
1500 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1501 }
1502
TEST_F(accuracy_test_pow2_single,large_1D_forward_out_of_place_complex_planar_to_complex_planar)1503 TEST_F(accuracy_test_pow2_single, large_1D_forward_out_of_place_complex_planar_to_complex_planar)
1504 {
1505 try { large_1D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
1506 catch( const std::exception& err ) { handle_exception(err); }
1507 }
1508
TEST_F(accuracy_test_pow2_double,large_1D_forward_out_of_place_complex_planar_to_complex_planar)1509 TEST_F(accuracy_test_pow2_double, large_1D_forward_out_of_place_complex_planar_to_complex_planar)
1510 {
1511 try { large_1D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
1512 catch( const std::exception& err ) { handle_exception(err); }
1513 }
1514
1515 // *****************************************************
1516 // *****************************************************
1517 template< class T, class cl_T, class fftw_T >
large_1D_backward_out_of_place_complex_planar_to_complex_planar()1518 void large_1D_backward_out_of_place_complex_planar_to_complex_planar()
1519 {
1520 std::vector<size_t> lengths;
1521 lengths.push_back( large2 );
1522 size_t batch = 1;
1523 std::vector<size_t> input_strides;
1524 std::vector<size_t> output_strides;
1525 size_t input_distance = 0;
1526 size_t output_distance = 0;
1527 layout::buffer_layout_t in_layout = layout::complex_planar;
1528 layout::buffer_layout_t out_layout = layout::complex_planar;
1529 placeness::placeness_t placeness = placeness::out_of_place;
1530 direction::direction_t direction = direction::backward;
1531
1532 data_pattern pattern = sawtooth;
1533 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1534 }
1535
TEST_F(accuracy_test_pow2_single,large_1D_backward_out_of_place_complex_planar_to_complex_planar)1536 TEST_F(accuracy_test_pow2_single, large_1D_backward_out_of_place_complex_planar_to_complex_planar)
1537 {
1538 try { large_1D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
1539 catch( const std::exception& err ) { handle_exception(err); }
1540 }
1541
TEST_F(accuracy_test_pow2_double,large_1D_backward_out_of_place_complex_planar_to_complex_planar)1542 TEST_F(accuracy_test_pow2_double, large_1D_backward_out_of_place_complex_planar_to_complex_planar)
1543 {
1544 try { large_1D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
1545 catch( const std::exception& err ) { handle_exception(err); }
1546 }
1547
1548 // *****************************************************
1549 // *****************************************************
1550 template< class T, class cl_T, class fftw_T >
large_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved()1551 void large_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
1552 {
1553 std::vector<size_t> lengths;
1554 lengths.push_back( large2 );
1555 size_t batch = 1;
1556 std::vector<size_t> input_strides;
1557 std::vector<size_t> output_strides;
1558 size_t input_distance = 0;
1559 size_t output_distance = 0;
1560 layout::buffer_layout_t in_layout = layout::complex_interleaved;
1561 layout::buffer_layout_t out_layout = layout::complex_interleaved;
1562 placeness::placeness_t placeness = placeness::out_of_place;
1563 direction::direction_t direction = direction::forward;
1564
1565 data_pattern pattern = sawtooth;
1566 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1567 }
1568
TEST_F(accuracy_test_pow2_single,large_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)1569 TEST_F(accuracy_test_pow2_single, large_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
1570 {
1571 try { large_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
1572 catch( const std::exception& err ) { handle_exception(err); }
1573 }
1574
TEST_F(accuracy_test_pow2_double,large_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)1575 TEST_F(accuracy_test_pow2_double, large_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
1576 {
1577 try { large_1D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
1578 catch( const std::exception& err ) { handle_exception(err); }
1579 }
1580
1581 // *****************************************************
1582 // *****************************************************
1583 template< class T, class cl_T, class fftw_T >
large_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved()1584 void large_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
1585 {
1586 std::vector<size_t> lengths;
1587 lengths.push_back( large2 );
1588 size_t batch = 1;
1589 std::vector<size_t> input_strides;
1590 std::vector<size_t> output_strides;
1591 size_t input_distance = 0;
1592 size_t output_distance = 0;
1593 layout::buffer_layout_t in_layout = layout::complex_interleaved;
1594 layout::buffer_layout_t out_layout = layout::complex_interleaved;
1595 placeness::placeness_t placeness = placeness::out_of_place;
1596 direction::direction_t direction = direction::backward;
1597
1598 data_pattern pattern = sawtooth;
1599 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1600 }
1601
TEST_F(accuracy_test_pow2_single,large_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)1602 TEST_F(accuracy_test_pow2_single, large_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
1603 {
1604 try { large_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
1605 catch( const std::exception& err ) { handle_exception(err); }
1606 }
1607
TEST_F(accuracy_test_pow2_double,large_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)1608 TEST_F(accuracy_test_pow2_double, large_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
1609 {
1610 try { large_1D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
1611 catch( const std::exception& err ) { handle_exception(err); }
1612 }
1613
1614 // *****************************************************
1615 // *****************************************************
1616 template< class T, class cl_T, class fftw_T >
large_1D_forward_out_of_place_complex_planar_to_complex_interleaved()1617 void large_1D_forward_out_of_place_complex_planar_to_complex_interleaved()
1618 {
1619 std::vector<size_t> lengths;
1620 lengths.push_back( large2 );
1621 size_t batch = 1;
1622 std::vector<size_t> input_strides;
1623 std::vector<size_t> output_strides;
1624 size_t input_distance = 0;
1625 size_t output_distance = 0;
1626 layout::buffer_layout_t in_layout = layout::complex_planar;
1627 layout::buffer_layout_t out_layout = layout::complex_interleaved;
1628 placeness::placeness_t placeness = placeness::out_of_place;
1629 direction::direction_t direction = direction::forward;
1630
1631 data_pattern pattern = sawtooth;
1632 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1633 }
1634
TEST_F(accuracy_test_pow2_single,large_1D_forward_out_of_place_complex_planar_to_complex_interleaved)1635 TEST_F(accuracy_test_pow2_single, large_1D_forward_out_of_place_complex_planar_to_complex_interleaved)
1636 {
1637 try { large_1D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
1638 catch( const std::exception& err ) { handle_exception(err); }
1639 }
1640
TEST_F(accuracy_test_pow2_double,large_1D_forward_out_of_place_complex_planar_to_complex_interleaved)1641 TEST_F(accuracy_test_pow2_double, large_1D_forward_out_of_place_complex_planar_to_complex_interleaved)
1642 {
1643 try { large_1D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
1644 catch( const std::exception& err ) { handle_exception(err); }
1645 }
1646
1647 // *****************************************************
1648 // *****************************************************
1649 template< class T, class cl_T, class fftw_T >
large_1D_backward_out_of_place_complex_planar_to_complex_interleaved()1650 void large_1D_backward_out_of_place_complex_planar_to_complex_interleaved()
1651 {
1652 std::vector<size_t> lengths;
1653 lengths.push_back( large2 );
1654 size_t batch = 1;
1655 std::vector<size_t> input_strides;
1656 std::vector<size_t> output_strides;
1657 size_t input_distance = 0;
1658 size_t output_distance = 0;
1659 layout::buffer_layout_t in_layout = layout::complex_planar;
1660 layout::buffer_layout_t out_layout = layout::complex_interleaved;
1661 placeness::placeness_t placeness = placeness::out_of_place;
1662 direction::direction_t direction = direction::backward;
1663
1664 data_pattern pattern = sawtooth;
1665 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1666 }
1667
TEST_F(accuracy_test_pow2_single,large_1D_backward_out_of_place_complex_planar_to_complex_interleaved)1668 TEST_F(accuracy_test_pow2_single, large_1D_backward_out_of_place_complex_planar_to_complex_interleaved)
1669 {
1670 try { large_1D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
1671 catch( const std::exception& err ) { handle_exception(err); }
1672 }
1673
TEST_F(accuracy_test_pow2_double,large_1D_backward_out_of_place_complex_planar_to_complex_interleaved)1674 TEST_F(accuracy_test_pow2_double, large_1D_backward_out_of_place_complex_planar_to_complex_interleaved)
1675 {
1676 try { large_1D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
1677 catch( const std::exception& err ) { handle_exception(err); }
1678 }
1679
1680 // *****************************************************
1681 // *****************************************************
1682 template< class T, class cl_T, class fftw_T >
large_1D_forward_out_of_place_complex_interleaved_to_complex_planar()1683 void large_1D_forward_out_of_place_complex_interleaved_to_complex_planar()
1684 {
1685 std::vector<size_t> lengths;
1686 lengths.push_back( large2 );
1687 size_t batch = 1;
1688 std::vector<size_t> input_strides;
1689 std::vector<size_t> output_strides;
1690 size_t input_distance = 0;
1691 size_t output_distance = 0;
1692 layout::buffer_layout_t in_layout = layout::complex_interleaved;
1693 layout::buffer_layout_t out_layout = layout::complex_planar;
1694 placeness::placeness_t placeness = placeness::out_of_place;
1695 direction::direction_t direction = direction::forward;
1696
1697 data_pattern pattern = sawtooth;
1698 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1699 }
1700
TEST_F(accuracy_test_pow2_single,large_1D_forward_out_of_place_complex_interleaved_to_complex_planar)1701 TEST_F(accuracy_test_pow2_single, large_1D_forward_out_of_place_complex_interleaved_to_complex_planar)
1702 {
1703 try { large_1D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
1704 catch( const std::exception& err ) { handle_exception(err); }
1705 }
1706
TEST_F(accuracy_test_pow2_double,large_1D_forward_out_of_place_complex_interleaved_to_complex_planar)1707 TEST_F(accuracy_test_pow2_double, large_1D_forward_out_of_place_complex_interleaved_to_complex_planar)
1708 {
1709 try { large_1D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
1710 catch( const std::exception& err ) { handle_exception(err); }
1711 }
1712
1713 // *****************************************************
1714 // *****************************************************
1715 template< class T, class cl_T, class fftw_T >
large_1D_backward_out_of_place_complex_interleaved_to_complex_planar()1716 void large_1D_backward_out_of_place_complex_interleaved_to_complex_planar()
1717 {
1718 std::vector<size_t> lengths;
1719 lengths.push_back( large2 );
1720 size_t batch = 1;
1721 std::vector<size_t> input_strides;
1722 std::vector<size_t> output_strides;
1723 size_t input_distance = 0;
1724 size_t output_distance = 0;
1725 layout::buffer_layout_t in_layout = layout::complex_interleaved;
1726 layout::buffer_layout_t out_layout = layout::complex_planar;
1727 placeness::placeness_t placeness = placeness::out_of_place;
1728 direction::direction_t direction = direction::backward;
1729
1730 data_pattern pattern = sawtooth;
1731 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1732 }
1733
TEST_F(accuracy_test_pow2_single,large_1D_backward_out_of_place_complex_interleaved_to_complex_planar)1734 TEST_F(accuracy_test_pow2_single, large_1D_backward_out_of_place_complex_interleaved_to_complex_planar)
1735 {
1736 try { large_1D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
1737 catch( const std::exception& err ) { handle_exception(err); }
1738 }
1739
TEST_F(accuracy_test_pow2_double,large_1D_backward_out_of_place_complex_interleaved_to_complex_planar)1740 TEST_F(accuracy_test_pow2_double, large_1D_backward_out_of_place_complex_interleaved_to_complex_planar)
1741 {
1742 try { large_1D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
1743 catch( const std::exception& err ) { handle_exception(err); }
1744 }
1745
1746 // *****************************************************
1747 // *****************************************************
1748 template< class T, class cl_T, class fftw_T >
large_1D_in_place_real_to_hermitian_interleaved()1749 void large_1D_in_place_real_to_hermitian_interleaved()
1750 {
1751 std::vector<size_t> lengths;
1752 lengths.push_back( large2 );
1753 size_t batch = 1;
1754 std::vector<size_t> input_strides;
1755 std::vector<size_t> output_strides;
1756 size_t input_distance = 0;
1757 size_t output_distance = 0;
1758 layout::buffer_layout_t layout = layout::hermitian_interleaved;
1759 placeness::placeness_t placeness = placeness::in_place;
1760
1761 data_pattern pattern = sawtooth;
1762 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
1763 }
1764
TEST_F(accuracy_test_pow2_single,large_1D_in_place_real_to_hermitian_interleaved)1765 TEST_F(accuracy_test_pow2_single, large_1D_in_place_real_to_hermitian_interleaved)
1766 {
1767 try { large_1D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
1768 catch( const std::exception& err ) { handle_exception(err); }
1769 }
1770
TEST_F(accuracy_test_pow2_double,large_1D_in_place_real_to_hermitian_interleaved)1771 TEST_F(accuracy_test_pow2_double, large_1D_in_place_real_to_hermitian_interleaved)
1772 {
1773 try { large_1D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
1774 catch( const std::exception& err ) { handle_exception(err); }
1775 }
1776
1777 // *****************************************************
1778 // *****************************************************
1779 template< class T, class cl_T, class fftw_T >
large_1D_4M_in_place_real_to_hermitian_interleaved()1780 void large_1D_4M_in_place_real_to_hermitian_interleaved()
1781 {
1782 std::vector<size_t> lengths;
1783 lengths.push_back( 4194304 );
1784 size_t batch = 1;
1785 std::vector<size_t> input_strides;
1786 std::vector<size_t> output_strides;
1787 size_t input_distance = 0;
1788 size_t output_distance = 0;
1789 layout::buffer_layout_t layout = layout::hermitian_interleaved;
1790 placeness::placeness_t placeness = placeness::in_place;
1791
1792 data_pattern pattern = sawtooth;
1793 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
1794 }
1795
TEST_F(accuracy_test_pow2_single,large_1D_4M_in_place_real_to_hermitian_interleaved)1796 TEST_F(accuracy_test_pow2_single, large_1D_4M_in_place_real_to_hermitian_interleaved)
1797 {
1798 try { large_1D_4M_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
1799 catch( const std::exception& err ) { handle_exception(err); }
1800 }
1801
TEST_F(accuracy_test_pow2_double,large_1D_4M_in_place_real_to_hermitian_interleaved)1802 TEST_F(accuracy_test_pow2_double, large_1D_4M_in_place_real_to_hermitian_interleaved)
1803 {
1804 try { large_1D_4M_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
1805 catch( const std::exception& err ) { handle_exception(err); }
1806 }
1807 // *****************************************************
1808 // *****************************************************
1809 template< class T, class cl_T, class fftw_T >
large_1D_in_place_hermitian_interleaved_to_real()1810 void large_1D_in_place_hermitian_interleaved_to_real()
1811 {
1812 std::vector<size_t> lengths;
1813 lengths.push_back( large2 );
1814 size_t batch = 1;
1815 std::vector<size_t> input_strides;
1816 std::vector<size_t> output_strides;
1817 size_t input_distance = 0;
1818 size_t output_distance = 0;
1819 layout::buffer_layout_t layout = layout::hermitian_interleaved;
1820 placeness::placeness_t placeness = placeness::in_place;
1821
1822 data_pattern pattern = sawtooth;
1823 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
1824 }
1825
TEST_F(accuracy_test_pow2_single,large_1D_in_place_hermitian_interleaved_to_real)1826 TEST_F(accuracy_test_pow2_single, large_1D_in_place_hermitian_interleaved_to_real)
1827 {
1828 try { large_1D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
1829 catch( const std::exception& err ) { handle_exception(err); }
1830 }
1831
TEST_F(accuracy_test_pow2_double,large_1D_in_place_hermitian_interleaved_to_real)1832 TEST_F(accuracy_test_pow2_double, large_1D_in_place_hermitian_interleaved_to_real)
1833 {
1834 try { large_1D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
1835 catch( const std::exception& err ) { handle_exception(err); }
1836 }
1837
1838 // *****************************************************
1839 // *****************************************************
1840 template< class T, class cl_T, class fftw_T >
large_1D_out_of_place_real_to_hermitian_interleaved()1841 void large_1D_out_of_place_real_to_hermitian_interleaved()
1842 {
1843 std::vector<size_t> lengths;
1844 lengths.push_back( large2 );
1845 size_t batch = 1;
1846 std::vector<size_t> input_strides;
1847 std::vector<size_t> output_strides;
1848 size_t input_distance = 0;
1849 size_t output_distance = 0;
1850 layout::buffer_layout_t layout = layout::hermitian_interleaved;
1851 placeness::placeness_t placeness = placeness::out_of_place;
1852
1853 data_pattern pattern = sawtooth;
1854 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
1855 }
1856
TEST_F(accuracy_test_pow2_single,large_1D_out_of_place_real_to_hermitian_interleaved)1857 TEST_F(accuracy_test_pow2_single, large_1D_out_of_place_real_to_hermitian_interleaved)
1858 {
1859 try { large_1D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
1860 catch( const std::exception& err ) { handle_exception(err); }
1861 }
1862
TEST_F(accuracy_test_pow2_double,large_1D_out_of_place_real_to_hermitian_interleaved)1863 TEST_F(accuracy_test_pow2_double, large_1D_out_of_place_real_to_hermitian_interleaved)
1864 {
1865 try { large_1D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
1866 catch( const std::exception& err ) { handle_exception(err); }
1867 }
1868
1869 // *****************************************************
1870 // *****************************************************
1871 template< class T, class cl_T, class fftw_T >
large_1D_out_of_place_hermitian_interleaved_to_real()1872 void large_1D_out_of_place_hermitian_interleaved_to_real()
1873 {
1874 std::vector<size_t> lengths;
1875 lengths.push_back( large2 );
1876 size_t batch = 1;
1877 std::vector<size_t> input_strides;
1878 std::vector<size_t> output_strides;
1879 size_t input_distance = 0;
1880 size_t output_distance = 0;
1881 layout::buffer_layout_t layout = layout::hermitian_interleaved;
1882 placeness::placeness_t placeness = placeness::out_of_place;
1883
1884 data_pattern pattern = sawtooth;
1885 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
1886 }
1887
TEST_F(accuracy_test_pow2_single,large_1D_out_of_place_hermitian_interleaved_to_real)1888 TEST_F(accuracy_test_pow2_single, large_1D_out_of_place_hermitian_interleaved_to_real)
1889 {
1890 try { large_1D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
1891 catch( const std::exception& err ) { handle_exception(err); }
1892 }
1893
TEST_F(accuracy_test_pow2_double,large_1D_out_of_place_hermitian_interleaved_to_real)1894 TEST_F(accuracy_test_pow2_double, large_1D_out_of_place_hermitian_interleaved_to_real)
1895 {
1896 try { large_1D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
1897 catch( const std::exception& err ) { handle_exception(err); }
1898 }
1899
1900 // *****************************************************
1901 // *****************************************************
1902 template< class T, class cl_T, class fftw_T >
large_1D_out_of_place_real_to_hermitian_planar()1903 void large_1D_out_of_place_real_to_hermitian_planar()
1904 {
1905 std::vector<size_t> lengths;
1906 lengths.push_back( large2 );
1907 size_t batch = 1;
1908 std::vector<size_t> input_strides;
1909 std::vector<size_t> output_strides;
1910 size_t input_distance = 0;
1911 size_t output_distance = 0;
1912 layout::buffer_layout_t layout = layout::hermitian_planar;
1913 placeness::placeness_t placeness = placeness::out_of_place;
1914
1915 data_pattern pattern = sawtooth;
1916 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
1917 }
1918
TEST_F(accuracy_test_pow2_single,large_1D_out_of_place_real_to_hermitian_planar)1919 TEST_F(accuracy_test_pow2_single, large_1D_out_of_place_real_to_hermitian_planar)
1920 {
1921 try { large_1D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
1922 catch( const std::exception& err ) { handle_exception(err); }
1923 }
1924
TEST_F(accuracy_test_pow2_double,large_1D_out_of_place_real_to_hermitian_planar)1925 TEST_F(accuracy_test_pow2_double, large_1D_out_of_place_real_to_hermitian_planar)
1926 {
1927 try { large_1D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
1928 catch( const std::exception& err ) { handle_exception(err); }
1929 }
1930
1931 // *****************************************************
1932 // *****************************************************
1933 template< class T, class cl_T, class fftw_T >
large_1D_out_of_place_hermitian_planar_to_real()1934 void large_1D_out_of_place_hermitian_planar_to_real()
1935 {
1936 std::vector<size_t> lengths;
1937 lengths.push_back( large2 );
1938 size_t batch = 1;
1939 std::vector<size_t> input_strides;
1940 std::vector<size_t> output_strides;
1941 size_t input_distance = 0;
1942 size_t output_distance = 0;
1943 layout::buffer_layout_t layout = layout::hermitian_planar;
1944 placeness::placeness_t placeness = placeness::out_of_place;
1945
1946 data_pattern pattern = sawtooth;
1947 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
1948 }
1949
TEST_F(accuracy_test_pow2_single,large_1D_out_of_place_hermitian_planar_to_real)1950 TEST_F(accuracy_test_pow2_single, large_1D_out_of_place_hermitian_planar_to_real)
1951 {
1952 try { large_1D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
1953 catch( const std::exception& err ) { handle_exception(err); }
1954 }
1955
TEST_F(accuracy_test_pow2_double,large_1D_out_of_place_hermitian_planar_to_real)1956 TEST_F(accuracy_test_pow2_double, large_1D_out_of_place_hermitian_planar_to_real)
1957 {
1958 try { large_1D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
1959 catch( const std::exception& err ) { handle_exception(err); }
1960 }
1961
1962 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
1963 // ^^^^^^^^^^^^^^^^^^^^^^^ normal 2D ^^^^^^^^^^^^^^^^^^^^^^ //
1964 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
1965
1966 // *****************************************************
1967 // *****************************************************
1968 template< class T, class cl_T, class fftw_T >
normal_2D_forward_in_place_complex_planar_to_complex_planar()1969 void normal_2D_forward_in_place_complex_planar_to_complex_planar()
1970 {
1971 std::vector<size_t> lengths;
1972 lengths.push_back( normal2 );
1973 lengths.push_back( normal2 );
1974 size_t batch = 1;
1975 std::vector<size_t> input_strides;
1976 std::vector<size_t> output_strides;
1977 size_t input_distance = 0;
1978 size_t output_distance = 0;
1979 layout::buffer_layout_t in_layout = layout::complex_planar;
1980 layout::buffer_layout_t out_layout = layout::complex_planar;
1981 placeness::placeness_t placeness = placeness::in_place;
1982 direction::direction_t direction = direction::forward;
1983
1984 data_pattern pattern = sawtooth;
1985 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
1986 }
1987
TEST_F(accuracy_test_pow2_single,normal_2D_forward_in_place_complex_planar_to_complex_planar)1988 TEST_F(accuracy_test_pow2_single, normal_2D_forward_in_place_complex_planar_to_complex_planar)
1989 {
1990 try { normal_2D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
1991 catch( const std::exception& err ) { handle_exception(err); }
1992 }
1993
TEST_F(accuracy_test_pow2_double,normal_2D_forward_in_place_complex_planar_to_complex_planar)1994 TEST_F(accuracy_test_pow2_double, normal_2D_forward_in_place_complex_planar_to_complex_planar)
1995 {
1996 try { normal_2D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
1997 catch( const std::exception& err ) { handle_exception(err); }
1998 }
1999
2000 // *****************************************************
2001 // *****************************************************
2002 template< class T, class cl_T, class fftw_T >
normal_2D_backward_in_place_complex_planar_to_complex_planar()2003 void normal_2D_backward_in_place_complex_planar_to_complex_planar()
2004 {
2005 std::vector<size_t> lengths;
2006 lengths.push_back( normal2 );
2007 lengths.push_back( normal2 );
2008 size_t batch = 1;
2009 std::vector<size_t> input_strides;
2010 std::vector<size_t> output_strides;
2011 size_t input_distance = 0;
2012 size_t output_distance = 0;
2013 layout::buffer_layout_t in_layout = layout::complex_planar;
2014 layout::buffer_layout_t out_layout = layout::complex_planar;
2015 placeness::placeness_t placeness = placeness::in_place;
2016 direction::direction_t direction = direction::backward;
2017
2018 data_pattern pattern = sawtooth;
2019 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2020 }
2021
TEST_F(accuracy_test_pow2_single,normal_2D_backward_in_place_complex_planar_to_complex_planar)2022 TEST_F(accuracy_test_pow2_single, normal_2D_backward_in_place_complex_planar_to_complex_planar)
2023 {
2024 try { normal_2D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
2025 catch( const std::exception& err ) { handle_exception(err); }
2026 }
2027
TEST_F(accuracy_test_pow2_double,normal_2D_backward_in_place_complex_planar_to_complex_planar)2028 TEST_F(accuracy_test_pow2_double, normal_2D_backward_in_place_complex_planar_to_complex_planar)
2029 {
2030 try { normal_2D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
2031 catch( const std::exception& err ) { handle_exception(err); }
2032 }
2033
2034 // *****************************************************
2035 // *****************************************************
2036 template< class T, class cl_T, class fftw_T >
normal_2D_forward_in_place_complex_interleaved_to_complex_interleaved()2037 void normal_2D_forward_in_place_complex_interleaved_to_complex_interleaved()
2038 {
2039 std::vector<size_t> lengths;
2040 lengths.push_back( normal2 );
2041 lengths.push_back( normal2 );
2042 size_t batch = 1;
2043 std::vector<size_t> input_strides;
2044 std::vector<size_t> output_strides;
2045 size_t input_distance = 0;
2046 size_t output_distance = 0;
2047 layout::buffer_layout_t in_layout = layout::complex_interleaved;
2048 layout::buffer_layout_t out_layout = layout::complex_interleaved;
2049 placeness::placeness_t placeness = placeness::in_place;
2050 direction::direction_t direction = direction::forward;
2051
2052 data_pattern pattern = sawtooth;
2053 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2054 }
2055
TEST_F(accuracy_test_pow2_single,normal_2D_forward_in_place_complex_interleaved_to_complex_interleaved)2056 TEST_F(accuracy_test_pow2_single, normal_2D_forward_in_place_complex_interleaved_to_complex_interleaved)
2057 {
2058 try { normal_2D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
2059 catch( const std::exception& err ) { handle_exception(err); }
2060 }
2061
TEST_F(accuracy_test_pow2_double,normal_2D_forward_in_place_complex_interleaved_to_complex_interleaved)2062 TEST_F(accuracy_test_pow2_double, normal_2D_forward_in_place_complex_interleaved_to_complex_interleaved)
2063 {
2064 try { normal_2D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
2065 catch( const std::exception& err ) { handle_exception(err); }
2066 }
2067
2068 // *****************************************************
2069 // *****************************************************
2070 template< class T, class cl_T, class fftw_T >
normal_2D_backward_in_place_complex_interleaved_to_complex_interleaved()2071 void normal_2D_backward_in_place_complex_interleaved_to_complex_interleaved()
2072 {
2073 std::vector<size_t> lengths;
2074 lengths.push_back( normal2 );
2075 lengths.push_back( normal2 );
2076 size_t batch = 1;
2077 std::vector<size_t> input_strides;
2078 std::vector<size_t> output_strides;
2079 size_t input_distance = 0;
2080 size_t output_distance = 0;
2081 layout::buffer_layout_t in_layout = layout::complex_interleaved;
2082 layout::buffer_layout_t out_layout = layout::complex_interleaved;
2083 placeness::placeness_t placeness = placeness::in_place;
2084 direction::direction_t direction = direction::backward;
2085
2086 data_pattern pattern = sawtooth;
2087 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2088 }
2089
TEST_F(accuracy_test_pow2_single,normal_2D_backward_in_place_complex_interleaved_to_complex_interleaved)2090 TEST_F(accuracy_test_pow2_single, normal_2D_backward_in_place_complex_interleaved_to_complex_interleaved)
2091 {
2092 try { normal_2D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
2093 catch( const std::exception& err ) { handle_exception(err); }
2094 }
2095
TEST_F(accuracy_test_pow2_double,normal_2D_backward_in_place_complex_interleaved_to_complex_interleaved)2096 TEST_F(accuracy_test_pow2_double, normal_2D_backward_in_place_complex_interleaved_to_complex_interleaved)
2097 {
2098 try { normal_2D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
2099 catch( const std::exception& err ) { handle_exception(err); }
2100 }
2101
2102 // *****************************************************
2103 // *****************************************************
2104 template< class T, class cl_T, class fftw_T >
normal_2D_forward_out_of_place_complex_planar_to_complex_planar()2105 void normal_2D_forward_out_of_place_complex_planar_to_complex_planar()
2106 {
2107 std::vector<size_t> lengths;
2108 lengths.push_back( normal2 );
2109 lengths.push_back( normal2 );
2110 size_t batch = 1;
2111 std::vector<size_t> input_strides;
2112 std::vector<size_t> output_strides;
2113 size_t input_distance = 0;
2114 size_t output_distance = 0;
2115 layout::buffer_layout_t in_layout = layout::complex_planar;
2116 layout::buffer_layout_t out_layout = layout::complex_planar;
2117 placeness::placeness_t placeness = placeness::out_of_place;
2118 direction::direction_t direction = direction::forward;
2119
2120 data_pattern pattern = sawtooth;
2121 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2122 }
2123
TEST_F(accuracy_test_pow2_single,normal_2D_forward_out_of_place_complex_planar_to_complex_planar)2124 TEST_F(accuracy_test_pow2_single, normal_2D_forward_out_of_place_complex_planar_to_complex_planar)
2125 {
2126 try { normal_2D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
2127 catch( const std::exception& err ) { handle_exception(err); }
2128 }
2129
TEST_F(accuracy_test_pow2_double,normal_2D_forward_out_of_place_complex_planar_to_complex_planar)2130 TEST_F(accuracy_test_pow2_double, normal_2D_forward_out_of_place_complex_planar_to_complex_planar)
2131 {
2132 try { normal_2D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
2133 catch( const std::exception& err ) { handle_exception(err); }
2134 }
2135
2136 // *****************************************************
2137 // *****************************************************
2138 template< class T, class cl_T, class fftw_T >
normal_2D_backward_out_of_place_complex_planar_to_complex_planar()2139 void normal_2D_backward_out_of_place_complex_planar_to_complex_planar()
2140 {
2141 std::vector<size_t> lengths;
2142 lengths.push_back( normal2 );
2143 lengths.push_back( normal2 );
2144 size_t batch = 1;
2145 std::vector<size_t> input_strides;
2146 std::vector<size_t> output_strides;
2147 size_t input_distance = 0;
2148 size_t output_distance = 0;
2149 layout::buffer_layout_t in_layout = layout::complex_planar;
2150 layout::buffer_layout_t out_layout = layout::complex_planar;
2151 placeness::placeness_t placeness = placeness::out_of_place;
2152 direction::direction_t direction = direction::backward;
2153
2154 data_pattern pattern = sawtooth;
2155 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2156 }
2157
TEST_F(accuracy_test_pow2_single,normal_2D_backward_out_of_place_complex_planar_to_complex_planar)2158 TEST_F(accuracy_test_pow2_single, normal_2D_backward_out_of_place_complex_planar_to_complex_planar)
2159 {
2160 try { normal_2D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
2161 catch( const std::exception& err ) { handle_exception(err); }
2162 }
2163
TEST_F(accuracy_test_pow2_double,normal_2D_backward_out_of_place_complex_planar_to_complex_planar)2164 TEST_F(accuracy_test_pow2_double, normal_2D_backward_out_of_place_complex_planar_to_complex_planar)
2165 {
2166 try { normal_2D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
2167 catch( const std::exception& err ) { handle_exception(err); }
2168 }
2169
2170 // *****************************************************
2171 // *****************************************************
2172 template< class T, class cl_T, class fftw_T >
normal_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved()2173 void normal_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
2174 {
2175 std::vector<size_t> lengths;
2176 lengths.push_back( normal2 );
2177 lengths.push_back( normal2 );
2178 size_t batch = 1;
2179 std::vector<size_t> input_strides;
2180 std::vector<size_t> output_strides;
2181 size_t input_distance = 0;
2182 size_t output_distance = 0;
2183 layout::buffer_layout_t in_layout = layout::complex_interleaved;
2184 layout::buffer_layout_t out_layout = layout::complex_interleaved;
2185 placeness::placeness_t placeness = placeness::out_of_place;
2186 direction::direction_t direction = direction::forward;
2187
2188 data_pattern pattern = sawtooth;
2189 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2190 }
2191
TEST_F(accuracy_test_pow2_single,normal_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)2192 TEST_F(accuracy_test_pow2_single, normal_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
2193 {
2194 try { normal_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
2195 catch( const std::exception& err ) { handle_exception(err); }
2196 }
2197
TEST_F(accuracy_test_pow2_double,normal_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)2198 TEST_F(accuracy_test_pow2_double, normal_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
2199 {
2200 try { normal_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
2201 catch( const std::exception& err ) { handle_exception(err); }
2202 }
2203
2204 // *****************************************************
2205 // *****************************************************
2206 template< class T, class cl_T, class fftw_T >
normal_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved()2207 void normal_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
2208 {
2209 std::vector<size_t> lengths;
2210 lengths.push_back( normal2 );
2211 lengths.push_back( normal2 );
2212 size_t batch = 1;
2213 std::vector<size_t> input_strides;
2214 std::vector<size_t> output_strides;
2215 size_t input_distance = 0;
2216 size_t output_distance = 0;
2217 layout::buffer_layout_t in_layout = layout::complex_interleaved;
2218 layout::buffer_layout_t out_layout = layout::complex_interleaved;
2219 placeness::placeness_t placeness = placeness::out_of_place;
2220 direction::direction_t direction = direction::backward;
2221
2222 data_pattern pattern = sawtooth;
2223 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2224 }
2225
TEST_F(accuracy_test_pow2_single,normal_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)2226 TEST_F(accuracy_test_pow2_single, normal_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
2227 {
2228 try { normal_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
2229 catch( const std::exception& err ) { handle_exception(err); }
2230 }
2231
TEST_F(accuracy_test_pow2_double,normal_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)2232 TEST_F(accuracy_test_pow2_double, normal_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
2233 {
2234 try { normal_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
2235 catch( const std::exception& err ) { handle_exception(err); }
2236 }
2237
2238 // *****************************************************
2239 // *****************************************************
2240 template< class T, class cl_T, class fftw_T >
normal_2D_forward_out_of_place_complex_planar_to_complex_interleaved()2241 void normal_2D_forward_out_of_place_complex_planar_to_complex_interleaved()
2242 {
2243 std::vector<size_t> lengths;
2244 lengths.push_back( normal2 );
2245 lengths.push_back( normal2 );
2246 size_t batch = 1;
2247 std::vector<size_t> input_strides;
2248 std::vector<size_t> output_strides;
2249 size_t input_distance = 0;
2250 size_t output_distance = 0;
2251 layout::buffer_layout_t in_layout = layout::complex_planar;
2252 layout::buffer_layout_t out_layout = layout::complex_interleaved;
2253 placeness::placeness_t placeness = placeness::out_of_place;
2254 direction::direction_t direction = direction::forward;
2255
2256 data_pattern pattern = sawtooth;
2257 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2258 }
2259
TEST_F(accuracy_test_pow2_single,normal_2D_forward_out_of_place_complex_planar_to_complex_interleaved)2260 TEST_F(accuracy_test_pow2_single, normal_2D_forward_out_of_place_complex_planar_to_complex_interleaved)
2261 {
2262 try { normal_2D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
2263 catch( const std::exception& err ) { handle_exception(err); }
2264 }
2265
TEST_F(accuracy_test_pow2_double,normal_2D_forward_out_of_place_complex_planar_to_complex_interleaved)2266 TEST_F(accuracy_test_pow2_double, normal_2D_forward_out_of_place_complex_planar_to_complex_interleaved)
2267 {
2268 try { normal_2D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
2269 catch( const std::exception& err ) { handle_exception(err); }
2270 }
2271
2272 // *****************************************************
2273 // *****************************************************
2274 template< class T, class cl_T, class fftw_T >
normal_2D_backward_out_of_place_complex_planar_to_complex_interleaved()2275 void normal_2D_backward_out_of_place_complex_planar_to_complex_interleaved()
2276 {
2277 std::vector<size_t> lengths;
2278 lengths.push_back( normal2 );
2279 lengths.push_back( normal2 );
2280 size_t batch = 1;
2281 std::vector<size_t> input_strides;
2282 std::vector<size_t> output_strides;
2283 size_t input_distance = 0;
2284 size_t output_distance = 0;
2285 layout::buffer_layout_t in_layout = layout::complex_planar;
2286 layout::buffer_layout_t out_layout = layout::complex_interleaved;
2287 placeness::placeness_t placeness = placeness::out_of_place;
2288 direction::direction_t direction = direction::backward;
2289
2290 data_pattern pattern = sawtooth;
2291 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2292 }
2293
TEST_F(accuracy_test_pow2_single,normal_2D_backward_out_of_place_complex_planar_to_complex_interleaved)2294 TEST_F(accuracy_test_pow2_single, normal_2D_backward_out_of_place_complex_planar_to_complex_interleaved)
2295 {
2296 try { normal_2D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
2297 catch( const std::exception& err ) { handle_exception(err); }
2298 }
2299
TEST_F(accuracy_test_pow2_double,normal_2D_backward_out_of_place_complex_planar_to_complex_interleaved)2300 TEST_F(accuracy_test_pow2_double, normal_2D_backward_out_of_place_complex_planar_to_complex_interleaved)
2301 {
2302 try { normal_2D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
2303 catch( const std::exception& err ) { handle_exception(err); }
2304 }
2305
2306 // *****************************************************
2307 // *****************************************************
2308 template< class T, class cl_T, class fftw_T >
normal_2D_forward_out_of_place_complex_interleaved_to_complex_planar()2309 void normal_2D_forward_out_of_place_complex_interleaved_to_complex_planar()
2310 {
2311 std::vector<size_t> lengths;
2312 lengths.push_back( normal2 );
2313 lengths.push_back( normal2 );
2314 size_t batch = 1;
2315 std::vector<size_t> input_strides;
2316 std::vector<size_t> output_strides;
2317 size_t input_distance = 0;
2318 size_t output_distance = 0;
2319 layout::buffer_layout_t in_layout = layout::complex_interleaved;
2320 layout::buffer_layout_t out_layout = layout::complex_planar;
2321 placeness::placeness_t placeness = placeness::out_of_place;
2322 direction::direction_t direction = direction::forward;
2323
2324 data_pattern pattern = sawtooth;
2325 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2326 }
2327
TEST_F(accuracy_test_pow2_single,normal_2D_forward_out_of_place_complex_interleaved_to_complex_planar)2328 TEST_F(accuracy_test_pow2_single, normal_2D_forward_out_of_place_complex_interleaved_to_complex_planar)
2329 {
2330 try { normal_2D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
2331 catch( const std::exception& err ) { handle_exception(err); }
2332 }
2333
TEST_F(accuracy_test_pow2_double,normal_2D_forward_out_of_place_complex_interleaved_to_complex_planar)2334 TEST_F(accuracy_test_pow2_double, normal_2D_forward_out_of_place_complex_interleaved_to_complex_planar)
2335 {
2336 try { normal_2D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
2337 catch( const std::exception& err ) { handle_exception(err); }
2338 }
2339
2340 // *****************************************************
2341 // *****************************************************
2342 template< class T, class cl_T, class fftw_T >
normal_2D_backward_out_of_place_complex_interleaved_to_complex_planar()2343 void normal_2D_backward_out_of_place_complex_interleaved_to_complex_planar()
2344 {
2345 std::vector<size_t> lengths;
2346 lengths.push_back( normal2 );
2347 lengths.push_back( normal2 );
2348 size_t batch = 1;
2349 std::vector<size_t> input_strides;
2350 std::vector<size_t> output_strides;
2351 size_t input_distance = 0;
2352 size_t output_distance = 0;
2353 layout::buffer_layout_t in_layout = layout::complex_interleaved;
2354 layout::buffer_layout_t out_layout = layout::complex_planar;
2355 placeness::placeness_t placeness = placeness::out_of_place;
2356 direction::direction_t direction = direction::backward;
2357
2358 data_pattern pattern = sawtooth;
2359 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2360 }
2361
TEST_F(accuracy_test_pow2_single,normal_2D_backward_out_of_place_complex_interleaved_to_complex_planar)2362 TEST_F(accuracy_test_pow2_single, normal_2D_backward_out_of_place_complex_interleaved_to_complex_planar)
2363 {
2364 try { normal_2D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
2365 catch( const std::exception& err ) { handle_exception(err); }
2366 }
2367
TEST_F(accuracy_test_pow2_double,normal_2D_backward_out_of_place_complex_interleaved_to_complex_planar)2368 TEST_F(accuracy_test_pow2_double, normal_2D_backward_out_of_place_complex_interleaved_to_complex_planar)
2369 {
2370 try { normal_2D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
2371 catch( const std::exception& err ) { handle_exception(err); }
2372 }
2373
2374 // *****************************************************
2375 // *****************************************************
2376 template< class T, class cl_T, class fftw_T >
normal_2D_in_place_real_to_hermitian_interleaved()2377 void normal_2D_in_place_real_to_hermitian_interleaved()
2378 {
2379 std::vector<size_t> lengths;
2380 lengths.push_back( normal2 );
2381 lengths.push_back( normal2 );
2382 size_t batch = 1;
2383 std::vector<size_t> input_strides;
2384 std::vector<size_t> output_strides;
2385 size_t input_distance = 0;
2386 size_t output_distance = 0;
2387 layout::buffer_layout_t layout = layout::hermitian_interleaved;
2388 placeness::placeness_t placeness = placeness::in_place;
2389
2390 data_pattern pattern = sawtooth;
2391 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
2392 }
2393
TEST_F(accuracy_test_pow2_single,normal_2D_in_place_real_to_hermitian_interleaved)2394 TEST_F(accuracy_test_pow2_single, normal_2D_in_place_real_to_hermitian_interleaved)
2395 {
2396 try { normal_2D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
2397 catch( const std::exception& err ) { handle_exception(err); }
2398 }
2399
TEST_F(accuracy_test_pow2_double,normal_2D_in_place_real_to_hermitian_interleaved)2400 TEST_F(accuracy_test_pow2_double, normal_2D_in_place_real_to_hermitian_interleaved)
2401 {
2402 try { normal_2D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
2403 catch( const std::exception& err ) { handle_exception(err); }
2404 }
2405
2406 // *****************************************************
2407 // *****************************************************
2408 template< class T, class cl_T, class fftw_T >
normal_2D_in_place_hermitian_interleaved_to_real()2409 void normal_2D_in_place_hermitian_interleaved_to_real()
2410 {
2411 std::vector<size_t> lengths;
2412 lengths.push_back( normal2 );
2413 lengths.push_back( normal2 );
2414 size_t batch = 1;
2415 std::vector<size_t> input_strides;
2416 std::vector<size_t> output_strides;
2417 size_t input_distance = 0;
2418 size_t output_distance = 0;
2419 layout::buffer_layout_t layout = layout::hermitian_interleaved;
2420 placeness::placeness_t placeness = placeness::in_place;
2421
2422 data_pattern pattern = sawtooth;
2423 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
2424 }
2425
TEST_F(accuracy_test_pow2_single,normal_2D_in_place_hermitian_interleaved_to_real)2426 TEST_F(accuracy_test_pow2_single, normal_2D_in_place_hermitian_interleaved_to_real)
2427 {
2428 try { normal_2D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
2429 catch( const std::exception& err ) { handle_exception(err); }
2430 }
2431
TEST_F(accuracy_test_pow2_double,normal_2D_in_place_hermitian_interleaved_to_real)2432 TEST_F(accuracy_test_pow2_double, normal_2D_in_place_hermitian_interleaved_to_real)
2433 {
2434 try { normal_2D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
2435 catch( const std::exception& err ) { handle_exception(err); }
2436 }
2437
2438 // *****************************************************
2439 // *****************************************************
2440 template< class T, class cl_T, class fftw_T >
normal_2D_out_of_place_real_to_hermitian_interleaved()2441 void normal_2D_out_of_place_real_to_hermitian_interleaved()
2442 {
2443 std::vector<size_t> lengths;
2444 lengths.push_back( normal2 );
2445 lengths.push_back( normal2 );
2446 size_t batch = 1;
2447 std::vector<size_t> input_strides;
2448 std::vector<size_t> output_strides;
2449 size_t input_distance = 0;
2450 size_t output_distance = 0;
2451 layout::buffer_layout_t layout = layout::hermitian_interleaved;
2452 placeness::placeness_t placeness = placeness::out_of_place;
2453
2454 data_pattern pattern = sawtooth;
2455 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
2456 }
2457
TEST_F(accuracy_test_pow2_single,normal_2D_out_of_place_real_to_hermitian_interleaved)2458 TEST_F(accuracy_test_pow2_single, normal_2D_out_of_place_real_to_hermitian_interleaved)
2459 {
2460 try { normal_2D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
2461 catch( const std::exception& err ) { handle_exception(err); }
2462 }
2463
TEST_F(accuracy_test_pow2_double,normal_2D_out_of_place_real_to_hermitian_interleaved)2464 TEST_F(accuracy_test_pow2_double, normal_2D_out_of_place_real_to_hermitian_interleaved)
2465 {
2466 try { normal_2D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
2467 catch( const std::exception& err ) { handle_exception(err); }
2468 }
2469
2470 // *****************************************************
2471 // *****************************************************
2472 template< class T, class cl_T, class fftw_T >
normal_2D_out_of_place_hermitian_interleaved_to_real()2473 void normal_2D_out_of_place_hermitian_interleaved_to_real()
2474 {
2475 std::vector<size_t> lengths;
2476 lengths.push_back( normal2 );
2477 lengths.push_back( normal2 );
2478 size_t batch = 1;
2479 std::vector<size_t> input_strides;
2480 std::vector<size_t> output_strides;
2481 size_t input_distance = 0;
2482 size_t output_distance = 0;
2483 layout::buffer_layout_t layout = layout::hermitian_interleaved;
2484 placeness::placeness_t placeness = placeness::out_of_place;
2485
2486 data_pattern pattern = sawtooth;
2487 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
2488 }
2489
TEST_F(accuracy_test_pow2_single,normal_2D_out_of_place_hermitian_interleaved_to_real)2490 TEST_F(accuracy_test_pow2_single, normal_2D_out_of_place_hermitian_interleaved_to_real)
2491 {
2492 try { normal_2D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
2493 catch( const std::exception& err ) { handle_exception(err); }
2494 }
2495
TEST_F(accuracy_test_pow2_double,normal_2D_out_of_place_hermitian_interleaved_to_real)2496 TEST_F(accuracy_test_pow2_double, normal_2D_out_of_place_hermitian_interleaved_to_real)
2497 {
2498 try { normal_2D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
2499 catch( const std::exception& err ) { handle_exception(err); }
2500 }
2501
2502 // *****************************************************
2503 // *****************************************************
2504 template< class T, class cl_T, class fftw_T >
normal_2D_out_of_place_real_to_hermitian_planar()2505 void normal_2D_out_of_place_real_to_hermitian_planar()
2506 {
2507 std::vector<size_t> lengths;
2508 lengths.push_back( normal2 );
2509 lengths.push_back( normal2 );
2510 size_t batch = 1;
2511 std::vector<size_t> input_strides;
2512 std::vector<size_t> output_strides;
2513 size_t input_distance = 0;
2514 size_t output_distance = 0;
2515 layout::buffer_layout_t layout = layout::hermitian_planar;
2516 placeness::placeness_t placeness = placeness::out_of_place;
2517
2518 data_pattern pattern = sawtooth;
2519 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
2520 }
2521
TEST_F(accuracy_test_pow2_single,normal_2D_out_of_place_real_to_hermitian_planar)2522 TEST_F(accuracy_test_pow2_single, normal_2D_out_of_place_real_to_hermitian_planar)
2523 {
2524 try { normal_2D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
2525 catch( const std::exception& err ) { handle_exception(err); }
2526 }
2527
TEST_F(accuracy_test_pow2_double,normal_2D_out_of_place_real_to_hermitian_planar)2528 TEST_F(accuracy_test_pow2_double, normal_2D_out_of_place_real_to_hermitian_planar)
2529 {
2530 try { normal_2D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
2531 catch( const std::exception& err ) { handle_exception(err); }
2532 }
2533
2534 // *****************************************************
2535 // *****************************************************
2536 template< class T, class cl_T, class fftw_T >
normal_2D_out_of_place_hermitian_planar_to_real()2537 void normal_2D_out_of_place_hermitian_planar_to_real()
2538 {
2539 std::vector<size_t> lengths;
2540 lengths.push_back( normal2 );
2541 lengths.push_back( normal2 );
2542 size_t batch = 1;
2543 std::vector<size_t> input_strides;
2544 std::vector<size_t> output_strides;
2545 size_t input_distance = 0;
2546 size_t output_distance = 0;
2547 layout::buffer_layout_t layout = layout::hermitian_planar;
2548 placeness::placeness_t placeness = placeness::out_of_place;
2549
2550 data_pattern pattern = sawtooth;
2551 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
2552 }
2553
TEST_F(accuracy_test_pow2_single,normal_2D_out_of_place_hermitian_planar_to_real)2554 TEST_F(accuracy_test_pow2_single, normal_2D_out_of_place_hermitian_planar_to_real)
2555 {
2556 try { normal_2D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
2557 catch( const std::exception& err ) { handle_exception(err); }
2558 }
2559
TEST_F(accuracy_test_pow2_double,normal_2D_out_of_place_hermitian_planar_to_real)2560 TEST_F(accuracy_test_pow2_double, normal_2D_out_of_place_hermitian_planar_to_real)
2561 {
2562 try { normal_2D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
2563 catch( const std::exception& err ) { handle_exception(err); }
2564 }
2565
2566 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
2567 // ^^^^^^^^^^^^^^^^^^^^^^^ small 2D ^^^^^^^^^^^^^^^^^^^^^^^ //
2568 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
2569
2570 // *****************************************************
2571 // *****************************************************
2572 template< class T, class cl_T, class fftw_T >
small_2D_forward_in_place_complex_planar_to_complex_planar()2573 void small_2D_forward_in_place_complex_planar_to_complex_planar()
2574 {
2575 std::vector<size_t> lengths;
2576 lengths.push_back( small2 );
2577 lengths.push_back( small2 );
2578 size_t batch = 1;
2579 std::vector<size_t> input_strides;
2580 std::vector<size_t> output_strides;
2581 size_t input_distance = 0;
2582 size_t output_distance = 0;
2583 layout::buffer_layout_t in_layout = layout::complex_planar;
2584 layout::buffer_layout_t out_layout = layout::complex_planar;
2585 placeness::placeness_t placeness = placeness::in_place;
2586 direction::direction_t direction = direction::forward;
2587
2588 data_pattern pattern = sawtooth;
2589 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2590 }
2591
TEST_F(accuracy_test_pow2_single,small_2D_forward_in_place_complex_planar_to_complex_planar)2592 TEST_F(accuracy_test_pow2_single, small_2D_forward_in_place_complex_planar_to_complex_planar)
2593 {
2594 try { small_2D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
2595 catch( const std::exception& err ) { handle_exception(err); }
2596 }
2597
TEST_F(accuracy_test_pow2_double,small_2D_forward_in_place_complex_planar_to_complex_planar)2598 TEST_F(accuracy_test_pow2_double, small_2D_forward_in_place_complex_planar_to_complex_planar)
2599 {
2600 try { small_2D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
2601 catch( const std::exception& err ) { handle_exception(err); }
2602 }
2603
2604 // *****************************************************
2605 // *****************************************************
2606 template< class T, class cl_T, class fftw_T >
small_2D_backward_in_place_complex_planar_to_complex_planar()2607 void small_2D_backward_in_place_complex_planar_to_complex_planar()
2608 {
2609 std::vector<size_t> lengths;
2610 lengths.push_back( small2 );
2611 lengths.push_back( small2 );
2612 size_t batch = 1;
2613 std::vector<size_t> input_strides;
2614 std::vector<size_t> output_strides;
2615 size_t input_distance = 0;
2616 size_t output_distance = 0;
2617 layout::buffer_layout_t in_layout = layout::complex_planar;
2618 layout::buffer_layout_t out_layout = layout::complex_planar;
2619 placeness::placeness_t placeness = placeness::in_place;
2620 direction::direction_t direction = direction::backward;
2621
2622 data_pattern pattern = sawtooth;
2623 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2624 }
2625
TEST_F(accuracy_test_pow2_single,small_2D_backward_in_place_complex_planar_to_complex_planar)2626 TEST_F(accuracy_test_pow2_single, small_2D_backward_in_place_complex_planar_to_complex_planar)
2627 {
2628 try { small_2D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
2629 catch( const std::exception& err ) { handle_exception(err); }
2630 }
2631
TEST_F(accuracy_test_pow2_double,small_2D_backward_in_place_complex_planar_to_complex_planar)2632 TEST_F(accuracy_test_pow2_double, small_2D_backward_in_place_complex_planar_to_complex_planar)
2633 {
2634 try { small_2D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
2635 catch( const std::exception& err ) { handle_exception(err); }
2636 }
2637
2638 // *****************************************************
2639 // *****************************************************
2640 template< class T, class cl_T, class fftw_T >
small_2D_forward_in_place_complex_interleaved_to_complex_interleaved()2641 void small_2D_forward_in_place_complex_interleaved_to_complex_interleaved()
2642 {
2643 std::vector<size_t> lengths;
2644 lengths.push_back( small2 );
2645 lengths.push_back( small2 );
2646 size_t batch = 1;
2647 std::vector<size_t> input_strides;
2648 std::vector<size_t> output_strides;
2649 size_t input_distance = 0;
2650 size_t output_distance = 0;
2651 layout::buffer_layout_t in_layout = layout::complex_interleaved;
2652 layout::buffer_layout_t out_layout = layout::complex_interleaved;
2653 placeness::placeness_t placeness = placeness::in_place;
2654 direction::direction_t direction = direction::forward;
2655
2656 data_pattern pattern = sawtooth;
2657 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2658 }
2659
TEST_F(accuracy_test_pow2_single,small_2D_forward_in_place_complex_interleaved_to_complex_interleaved)2660 TEST_F(accuracy_test_pow2_single, small_2D_forward_in_place_complex_interleaved_to_complex_interleaved)
2661 {
2662 try { small_2D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
2663 catch( const std::exception& err ) { handle_exception(err); }
2664 }
2665
TEST_F(accuracy_test_pow2_double,small_2D_forward_in_place_complex_interleaved_to_complex_interleaved)2666 TEST_F(accuracy_test_pow2_double, small_2D_forward_in_place_complex_interleaved_to_complex_interleaved)
2667 {
2668 try { small_2D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
2669 catch( const std::exception& err ) { handle_exception(err); }
2670 }
2671
2672 // *****************************************************
2673 // *****************************************************
2674 template< class T, class cl_T, class fftw_T >
small_2D_backward_in_place_complex_interleaved_to_complex_interleaved()2675 void small_2D_backward_in_place_complex_interleaved_to_complex_interleaved()
2676 {
2677 std::vector<size_t> lengths;
2678 lengths.push_back( small2 );
2679 lengths.push_back( small2 );
2680 size_t batch = 1;
2681 std::vector<size_t> input_strides;
2682 std::vector<size_t> output_strides;
2683 size_t input_distance = 0;
2684 size_t output_distance = 0;
2685 layout::buffer_layout_t in_layout = layout::complex_interleaved;
2686 layout::buffer_layout_t out_layout = layout::complex_interleaved;
2687 placeness::placeness_t placeness = placeness::in_place;
2688 direction::direction_t direction = direction::backward;
2689
2690 data_pattern pattern = sawtooth;
2691 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2692 }
2693
TEST_F(accuracy_test_pow2_single,small_2D_backward_in_place_complex_interleaved_to_complex_interleaved)2694 TEST_F(accuracy_test_pow2_single, small_2D_backward_in_place_complex_interleaved_to_complex_interleaved)
2695 {
2696 try { small_2D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
2697 catch( const std::exception& err ) { handle_exception(err); }
2698 }
2699
TEST_F(accuracy_test_pow2_double,small_2D_backward_in_place_complex_interleaved_to_complex_interleaved)2700 TEST_F(accuracy_test_pow2_double, small_2D_backward_in_place_complex_interleaved_to_complex_interleaved)
2701 {
2702 try { small_2D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
2703 catch( const std::exception& err ) { handle_exception(err); }
2704 }
2705
2706 // *****************************************************
2707 // *****************************************************
2708 template< class T, class cl_T, class fftw_T >
small_2D_forward_out_of_place_complex_planar_to_complex_planar()2709 void small_2D_forward_out_of_place_complex_planar_to_complex_planar()
2710 {
2711 std::vector<size_t> lengths;
2712 lengths.push_back( small2 );
2713 lengths.push_back( small2 );
2714 size_t batch = 1;
2715 std::vector<size_t> input_strides;
2716 std::vector<size_t> output_strides;
2717 size_t input_distance = 0;
2718 size_t output_distance = 0;
2719 layout::buffer_layout_t in_layout = layout::complex_planar;
2720 layout::buffer_layout_t out_layout = layout::complex_planar;
2721 placeness::placeness_t placeness = placeness::out_of_place;
2722 direction::direction_t direction = direction::forward;
2723
2724 data_pattern pattern = sawtooth;
2725 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2726 }
2727
TEST_F(accuracy_test_pow2_single,small_2D_forward_out_of_place_complex_planar_to_complex_planar)2728 TEST_F(accuracy_test_pow2_single, small_2D_forward_out_of_place_complex_planar_to_complex_planar)
2729 {
2730 try { small_2D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
2731 catch( const std::exception& err ) { handle_exception(err); }
2732 }
2733
TEST_F(accuracy_test_pow2_double,small_2D_forward_out_of_place_complex_planar_to_complex_planar)2734 TEST_F(accuracy_test_pow2_double, small_2D_forward_out_of_place_complex_planar_to_complex_planar)
2735 {
2736 try { small_2D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
2737 catch( const std::exception& err ) { handle_exception(err); }
2738 }
2739
2740 // *****************************************************
2741 // *****************************************************
2742 template< class T, class cl_T, class fftw_T >
small_2D_backward_out_of_place_complex_planar_to_complex_planar()2743 void small_2D_backward_out_of_place_complex_planar_to_complex_planar()
2744 {
2745 std::vector<size_t> lengths;
2746 lengths.push_back( small2 );
2747 lengths.push_back( small2 );
2748 size_t batch = 1;
2749 std::vector<size_t> input_strides;
2750 std::vector<size_t> output_strides;
2751 size_t input_distance = 0;
2752 size_t output_distance = 0;
2753 layout::buffer_layout_t in_layout = layout::complex_planar;
2754 layout::buffer_layout_t out_layout = layout::complex_planar;
2755 placeness::placeness_t placeness = placeness::out_of_place;
2756 direction::direction_t direction = direction::backward;
2757
2758 data_pattern pattern = sawtooth;
2759 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2760 }
2761
TEST_F(accuracy_test_pow2_single,small_2D_backward_out_of_place_complex_planar_to_complex_planar)2762 TEST_F(accuracy_test_pow2_single, small_2D_backward_out_of_place_complex_planar_to_complex_planar)
2763 {
2764 try { small_2D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
2765 catch( const std::exception& err ) { handle_exception(err); }
2766 }
2767
TEST_F(accuracy_test_pow2_double,small_2D_backward_out_of_place_complex_planar_to_complex_planar)2768 TEST_F(accuracy_test_pow2_double, small_2D_backward_out_of_place_complex_planar_to_complex_planar)
2769 {
2770 try { small_2D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
2771 catch( const std::exception& err ) { handle_exception(err); }
2772 }
2773
2774 // *****************************************************
2775 // *****************************************************
2776 template< class T, class cl_T, class fftw_T >
small_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved()2777 void small_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
2778 {
2779 std::vector<size_t> lengths;
2780 lengths.push_back( small2 );
2781 lengths.push_back( small2 );
2782 size_t batch = 1;
2783 std::vector<size_t> input_strides;
2784 std::vector<size_t> output_strides;
2785 size_t input_distance = 0;
2786 size_t output_distance = 0;
2787 layout::buffer_layout_t in_layout = layout::complex_interleaved;
2788 layout::buffer_layout_t out_layout = layout::complex_interleaved;
2789 placeness::placeness_t placeness = placeness::out_of_place;
2790 direction::direction_t direction = direction::forward;
2791
2792 data_pattern pattern = sawtooth;
2793 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2794 }
2795
TEST_F(accuracy_test_pow2_single,small_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)2796 TEST_F(accuracy_test_pow2_single, small_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
2797 {
2798 try { small_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
2799 catch( const std::exception& err ) { handle_exception(err); }
2800 }
2801
TEST_F(accuracy_test_pow2_double,small_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)2802 TEST_F(accuracy_test_pow2_double, small_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
2803 {
2804 try { small_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
2805 catch( const std::exception& err ) { handle_exception(err); }
2806 }
2807
2808 // *****************************************************
2809 // *****************************************************
2810 template< class T, class cl_T, class fftw_T >
small_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved()2811 void small_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
2812 {
2813 std::vector<size_t> lengths;
2814 lengths.push_back( small2 );
2815 lengths.push_back( small2 );
2816 size_t batch = 1;
2817 std::vector<size_t> input_strides;
2818 std::vector<size_t> output_strides;
2819 size_t input_distance = 0;
2820 size_t output_distance = 0;
2821 layout::buffer_layout_t in_layout = layout::complex_interleaved;
2822 layout::buffer_layout_t out_layout = layout::complex_interleaved;
2823 placeness::placeness_t placeness = placeness::out_of_place;
2824 direction::direction_t direction = direction::backward;
2825
2826 data_pattern pattern = sawtooth;
2827 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2828 }
2829
TEST_F(accuracy_test_pow2_single,small_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)2830 TEST_F(accuracy_test_pow2_single, small_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
2831 {
2832 try { small_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
2833 catch( const std::exception& err ) { handle_exception(err); }
2834 }
2835
TEST_F(accuracy_test_pow2_double,small_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)2836 TEST_F(accuracy_test_pow2_double, small_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
2837 {
2838 try { small_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
2839 catch( const std::exception& err ) { handle_exception(err); }
2840 }
2841
2842 // *****************************************************
2843 // *****************************************************
2844 template< class T, class cl_T, class fftw_T >
small_2D_forward_out_of_place_complex_planar_to_complex_interleaved()2845 void small_2D_forward_out_of_place_complex_planar_to_complex_interleaved()
2846 {
2847 std::vector<size_t> lengths;
2848 lengths.push_back( small2 );
2849 lengths.push_back( small2 );
2850 size_t batch = 1;
2851 std::vector<size_t> input_strides;
2852 std::vector<size_t> output_strides;
2853 size_t input_distance = 0;
2854 size_t output_distance = 0;
2855 layout::buffer_layout_t in_layout = layout::complex_planar;
2856 layout::buffer_layout_t out_layout = layout::complex_interleaved;
2857 placeness::placeness_t placeness = placeness::out_of_place;
2858 direction::direction_t direction = direction::forward;
2859
2860 data_pattern pattern = sawtooth;
2861 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2862 }
2863
TEST_F(accuracy_test_pow2_single,small_2D_forward_out_of_place_complex_planar_to_complex_interleaved)2864 TEST_F(accuracy_test_pow2_single, small_2D_forward_out_of_place_complex_planar_to_complex_interleaved)
2865 {
2866 try { small_2D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
2867 catch( const std::exception& err ) { handle_exception(err); }
2868 }
2869
TEST_F(accuracy_test_pow2_double,small_2D_forward_out_of_place_complex_planar_to_complex_interleaved)2870 TEST_F(accuracy_test_pow2_double, small_2D_forward_out_of_place_complex_planar_to_complex_interleaved)
2871 {
2872 try { small_2D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
2873 catch( const std::exception& err ) { handle_exception(err); }
2874 }
2875
2876 // *****************************************************
2877 // *****************************************************
2878 template< class T, class cl_T, class fftw_T >
small_2D_backward_out_of_place_complex_planar_to_complex_interleaved()2879 void small_2D_backward_out_of_place_complex_planar_to_complex_interleaved()
2880 {
2881 std::vector<size_t> lengths;
2882 lengths.push_back( small2 );
2883 lengths.push_back( small2 );
2884 size_t batch = 1;
2885 std::vector<size_t> input_strides;
2886 std::vector<size_t> output_strides;
2887 size_t input_distance = 0;
2888 size_t output_distance = 0;
2889 layout::buffer_layout_t in_layout = layout::complex_planar;
2890 layout::buffer_layout_t out_layout = layout::complex_interleaved;
2891 placeness::placeness_t placeness = placeness::out_of_place;
2892 direction::direction_t direction = direction::backward;
2893
2894 data_pattern pattern = sawtooth;
2895 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2896 }
2897
TEST_F(accuracy_test_pow2_single,small_2D_backward_out_of_place_complex_planar_to_complex_interleaved)2898 TEST_F(accuracy_test_pow2_single, small_2D_backward_out_of_place_complex_planar_to_complex_interleaved)
2899 {
2900 try { small_2D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
2901 catch( const std::exception& err ) { handle_exception(err); }
2902 }
2903
TEST_F(accuracy_test_pow2_double,small_2D_backward_out_of_place_complex_planar_to_complex_interleaved)2904 TEST_F(accuracy_test_pow2_double, small_2D_backward_out_of_place_complex_planar_to_complex_interleaved)
2905 {
2906 try { small_2D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
2907 catch( const std::exception& err ) { handle_exception(err); }
2908 }
2909
2910 // *****************************************************
2911 // *****************************************************
2912 template< class T, class cl_T, class fftw_T >
small_2D_forward_out_of_place_complex_interleaved_to_complex_planar()2913 void small_2D_forward_out_of_place_complex_interleaved_to_complex_planar()
2914 {
2915 std::vector<size_t> lengths;
2916 lengths.push_back( small2 );
2917 lengths.push_back( small2 );
2918 size_t batch = 1;
2919 std::vector<size_t> input_strides;
2920 std::vector<size_t> output_strides;
2921 size_t input_distance = 0;
2922 size_t output_distance = 0;
2923 layout::buffer_layout_t in_layout = layout::complex_interleaved;
2924 layout::buffer_layout_t out_layout = layout::complex_planar;
2925 placeness::placeness_t placeness = placeness::out_of_place;
2926 direction::direction_t direction = direction::forward;
2927
2928 data_pattern pattern = sawtooth;
2929 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2930 }
2931
TEST_F(accuracy_test_pow2_single,small_2D_forward_out_of_place_complex_interleaved_to_complex_planar)2932 TEST_F(accuracy_test_pow2_single, small_2D_forward_out_of_place_complex_interleaved_to_complex_planar)
2933 {
2934 try { small_2D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
2935 catch( const std::exception& err ) { handle_exception(err); }
2936 }
2937
TEST_F(accuracy_test_pow2_double,small_2D_forward_out_of_place_complex_interleaved_to_complex_planar)2938 TEST_F(accuracy_test_pow2_double, small_2D_forward_out_of_place_complex_interleaved_to_complex_planar)
2939 {
2940 try { small_2D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
2941 catch( const std::exception& err ) { handle_exception(err); }
2942 }
2943
2944 // *****************************************************
2945 // *****************************************************
2946 template< class T, class cl_T, class fftw_T >
small_2D_backward_out_of_place_complex_interleaved_to_complex_planar()2947 void small_2D_backward_out_of_place_complex_interleaved_to_complex_planar()
2948 {
2949 std::vector<size_t> lengths;
2950 lengths.push_back( small2 );
2951 lengths.push_back( small2 );
2952 size_t batch = 1;
2953 std::vector<size_t> input_strides;
2954 std::vector<size_t> output_strides;
2955 size_t input_distance = 0;
2956 size_t output_distance = 0;
2957 layout::buffer_layout_t in_layout = layout::complex_interleaved;
2958 layout::buffer_layout_t out_layout = layout::complex_planar;
2959 placeness::placeness_t placeness = placeness::out_of_place;
2960 direction::direction_t direction = direction::backward;
2961
2962 data_pattern pattern = sawtooth;
2963 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
2964 }
2965
TEST_F(accuracy_test_pow2_single,small_2D_backward_out_of_place_complex_interleaved_to_complex_planar)2966 TEST_F(accuracy_test_pow2_single, small_2D_backward_out_of_place_complex_interleaved_to_complex_planar)
2967 {
2968 try { small_2D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
2969 catch( const std::exception& err ) { handle_exception(err); }
2970 }
2971
TEST_F(accuracy_test_pow2_double,small_2D_backward_out_of_place_complex_interleaved_to_complex_planar)2972 TEST_F(accuracy_test_pow2_double, small_2D_backward_out_of_place_complex_interleaved_to_complex_planar)
2973 {
2974 try { small_2D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
2975 catch( const std::exception& err ) { handle_exception(err); }
2976 }
2977
2978 // *****************************************************
2979 // *****************************************************
2980 template< class T, class cl_T, class fftw_T >
small_2D_in_place_real_to_hermitian_interleaved()2981 void small_2D_in_place_real_to_hermitian_interleaved()
2982 {
2983 std::vector<size_t> lengths;
2984 lengths.push_back( small2 );
2985 lengths.push_back( small2 );
2986 size_t batch = 1;
2987 std::vector<size_t> input_strides;
2988 std::vector<size_t> output_strides;
2989 size_t input_distance = 0;
2990 size_t output_distance = 0;
2991 layout::buffer_layout_t layout = layout::hermitian_interleaved;
2992 placeness::placeness_t placeness = placeness::in_place;
2993
2994 data_pattern pattern = sawtooth;
2995 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
2996 }
2997
TEST_F(accuracy_test_pow2_single,small_2D_in_place_real_to_hermitian_interleaved)2998 TEST_F(accuracy_test_pow2_single, small_2D_in_place_real_to_hermitian_interleaved)
2999 {
3000 try { small_2D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
3001 catch( const std::exception& err ) { handle_exception(err); }
3002 }
3003
TEST_F(accuracy_test_pow2_double,small_2D_in_place_real_to_hermitian_interleaved)3004 TEST_F(accuracy_test_pow2_double, small_2D_in_place_real_to_hermitian_interleaved)
3005 {
3006 try { small_2D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
3007 catch( const std::exception& err ) { handle_exception(err); }
3008 }
3009
3010 // *****************************************************
3011 // *****************************************************
3012 template< class T, class cl_T, class fftw_T >
small_2D_in_place_hermitian_interleaved_to_real()3013 void small_2D_in_place_hermitian_interleaved_to_real()
3014 {
3015 std::vector<size_t> lengths;
3016 lengths.push_back( small2 );
3017 lengths.push_back( small2 );
3018 size_t batch = 1;
3019 std::vector<size_t> input_strides;
3020 std::vector<size_t> output_strides;
3021 size_t input_distance = 0;
3022 size_t output_distance = 0;
3023 layout::buffer_layout_t layout = layout::hermitian_interleaved;
3024 placeness::placeness_t placeness = placeness::in_place;
3025
3026 data_pattern pattern = sawtooth;
3027 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
3028 }
3029
TEST_F(accuracy_test_pow2_single,small_2D_in_place_hermitian_interleaved_to_real)3030 TEST_F(accuracy_test_pow2_single, small_2D_in_place_hermitian_interleaved_to_real)
3031 {
3032 try { small_2D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
3033 catch( const std::exception& err ) { handle_exception(err); }
3034 }
3035
TEST_F(accuracy_test_pow2_double,small_2D_in_place_hermitian_interleaved_to_real)3036 TEST_F(accuracy_test_pow2_double, small_2D_in_place_hermitian_interleaved_to_real)
3037 {
3038 try { small_2D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
3039 catch( const std::exception& err ) { handle_exception(err); }
3040 }
3041
3042 // *****************************************************
3043 // *****************************************************
3044 template< class T, class cl_T, class fftw_T >
small_2D_out_of_place_real_to_hermitian_interleaved()3045 void small_2D_out_of_place_real_to_hermitian_interleaved()
3046 {
3047 std::vector<size_t> lengths;
3048 lengths.push_back( small2 );
3049 lengths.push_back( small2 );
3050 size_t batch = 1;
3051 std::vector<size_t> input_strides;
3052 std::vector<size_t> output_strides;
3053 size_t input_distance = 0;
3054 size_t output_distance = 0;
3055 layout::buffer_layout_t layout = layout::hermitian_interleaved;
3056 placeness::placeness_t placeness = placeness::out_of_place;
3057
3058 data_pattern pattern = sawtooth;
3059 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
3060 }
3061
TEST_F(accuracy_test_pow2_single,small_2D_out_of_place_real_to_hermitian_interleaved)3062 TEST_F(accuracy_test_pow2_single, small_2D_out_of_place_real_to_hermitian_interleaved)
3063 {
3064 try { small_2D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
3065 catch( const std::exception& err ) { handle_exception(err); }
3066 }
3067
TEST_F(accuracy_test_pow2_double,small_2D_out_of_place_real_to_hermitian_interleaved)3068 TEST_F(accuracy_test_pow2_double, small_2D_out_of_place_real_to_hermitian_interleaved)
3069 {
3070 try { small_2D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
3071 catch( const std::exception& err ) { handle_exception(err); }
3072 }
3073
3074 // *****************************************************
3075 // *****************************************************
3076 template< class T, class cl_T, class fftw_T >
small_2D_out_of_place_hermitian_interleaved_to_real()3077 void small_2D_out_of_place_hermitian_interleaved_to_real()
3078 {
3079 std::vector<size_t> lengths;
3080 lengths.push_back( small2 );
3081 lengths.push_back( small2 );
3082 size_t batch = 1;
3083 std::vector<size_t> input_strides;
3084 std::vector<size_t> output_strides;
3085 size_t input_distance = 0;
3086 size_t output_distance = 0;
3087 layout::buffer_layout_t layout = layout::hermitian_interleaved;
3088 placeness::placeness_t placeness = placeness::out_of_place;
3089
3090 data_pattern pattern = sawtooth;
3091 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
3092 }
3093
TEST_F(accuracy_test_pow2_single,small_2D_out_of_place_hermitian_interleaved_to_real)3094 TEST_F(accuracy_test_pow2_single, small_2D_out_of_place_hermitian_interleaved_to_real)
3095 {
3096 try { small_2D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
3097 catch( const std::exception& err ) { handle_exception(err); }
3098 }
3099
TEST_F(accuracy_test_pow2_double,small_2D_out_of_place_hermitian_interleaved_to_real)3100 TEST_F(accuracy_test_pow2_double, small_2D_out_of_place_hermitian_interleaved_to_real)
3101 {
3102 try { small_2D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
3103 catch( const std::exception& err ) { handle_exception(err); }
3104 }
3105
3106 // *****************************************************
3107 // *****************************************************
3108 template< class T, class cl_T, class fftw_T >
small_2D_out_of_place_real_to_hermitian_planar()3109 void small_2D_out_of_place_real_to_hermitian_planar()
3110 {
3111 std::vector<size_t> lengths;
3112 lengths.push_back( small2 );
3113 lengths.push_back( small2 );
3114 size_t batch = 1;
3115 std::vector<size_t> input_strides;
3116 std::vector<size_t> output_strides;
3117 size_t input_distance = 0;
3118 size_t output_distance = 0;
3119 layout::buffer_layout_t layout = layout::hermitian_planar;
3120 placeness::placeness_t placeness = placeness::out_of_place;
3121
3122 data_pattern pattern = sawtooth;
3123 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
3124 }
3125
TEST_F(accuracy_test_pow2_single,small_2D_out_of_place_real_to_hermitian_planar)3126 TEST_F(accuracy_test_pow2_single, small_2D_out_of_place_real_to_hermitian_planar)
3127 {
3128 try { small_2D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
3129 catch( const std::exception& err ) { handle_exception(err); }
3130 }
3131
TEST_F(accuracy_test_pow2_double,small_2D_out_of_place_real_to_hermitian_planar)3132 TEST_F(accuracy_test_pow2_double, small_2D_out_of_place_real_to_hermitian_planar)
3133 {
3134 try { small_2D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
3135 catch( const std::exception& err ) { handle_exception(err); }
3136 }
3137
3138 // *****************************************************
3139 // *****************************************************
3140 template< class T, class cl_T, class fftw_T >
small_2D_out_of_place_hermitian_planar_to_real()3141 void small_2D_out_of_place_hermitian_planar_to_real()
3142 {
3143 std::vector<size_t> lengths;
3144 lengths.push_back( small2 );
3145 lengths.push_back( small2 );
3146 size_t batch = 1;
3147 std::vector<size_t> input_strides;
3148 std::vector<size_t> output_strides;
3149 size_t input_distance = 0;
3150 size_t output_distance = 0;
3151 layout::buffer_layout_t layout = layout::hermitian_planar;
3152 placeness::placeness_t placeness = placeness::out_of_place;
3153
3154 data_pattern pattern = sawtooth;
3155 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
3156 }
3157
TEST_F(accuracy_test_pow2_single,small_2D_out_of_place_hermitian_planar_to_real)3158 TEST_F(accuracy_test_pow2_single, small_2D_out_of_place_hermitian_planar_to_real)
3159 {
3160 try { small_2D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
3161 catch( const std::exception& err ) { handle_exception(err); }
3162 }
3163
TEST_F(accuracy_test_pow2_double,small_2D_out_of_place_hermitian_planar_to_real)3164 TEST_F(accuracy_test_pow2_double, small_2D_out_of_place_hermitian_planar_to_real)
3165 {
3166 try { small_2D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
3167 catch( const std::exception& err ) { handle_exception(err); }
3168 }
3169
3170 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
3171 // ^^^^^^^^^^^^^^^^^^^^^^^ large 2D ^^^^^^^^^^^^^^^^^^^^^^^ //
3172 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
3173
3174 // *****************************************************
3175 // *****************************************************
3176 template< class T, class cl_T, class fftw_T >
large_2D_forward_in_place_complex_planar_to_complex_planar()3177 void large_2D_forward_in_place_complex_planar_to_complex_planar()
3178 {
3179 std::vector<size_t> lengths;
3180 lengths.push_back( MaxLength2D<T>(2) );
3181 lengths.push_back( normal2 );
3182 size_t batch = 1;
3183 std::vector<size_t> input_strides;
3184 std::vector<size_t> output_strides;
3185 size_t input_distance = 0;
3186 size_t output_distance = 0;
3187 layout::buffer_layout_t in_layout = layout::complex_planar;
3188 layout::buffer_layout_t out_layout = layout::complex_planar;
3189 placeness::placeness_t placeness = placeness::in_place;
3190 direction::direction_t direction = direction::forward;
3191
3192 data_pattern pattern = sawtooth;
3193 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3194 }
3195
TEST_F(accuracy_test_pow2_single,large_2D_forward_in_place_complex_planar_to_complex_planar)3196 TEST_F(accuracy_test_pow2_single, large_2D_forward_in_place_complex_planar_to_complex_planar)
3197 {
3198 try { large_2D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
3199 catch( const std::exception& err ) { handle_exception(err); }
3200 }
3201
TEST_F(accuracy_test_pow2_double,large_2D_forward_in_place_complex_planar_to_complex_planar)3202 TEST_F(accuracy_test_pow2_double, large_2D_forward_in_place_complex_planar_to_complex_planar)
3203 {
3204 try { large_2D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
3205 catch( const std::exception& err ) { handle_exception(err); }
3206 }
3207
3208 // *****************************************************
3209 // *****************************************************
3210 template< class T, class cl_T, class fftw_T >
large_2D_backward_in_place_complex_planar_to_complex_planar()3211 void large_2D_backward_in_place_complex_planar_to_complex_planar()
3212 {
3213 std::vector<size_t> lengths;
3214 lengths.push_back( MaxLength2D<T>(2) );
3215 lengths.push_back( normal2 );
3216 size_t batch = 1;
3217 std::vector<size_t> input_strides;
3218 std::vector<size_t> output_strides;
3219 size_t input_distance = 0;
3220 size_t output_distance = 0;
3221 layout::buffer_layout_t in_layout = layout::complex_planar;
3222 layout::buffer_layout_t out_layout = layout::complex_planar;
3223 placeness::placeness_t placeness = placeness::in_place;
3224 direction::direction_t direction = direction::backward;
3225
3226 data_pattern pattern = sawtooth;
3227 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3228 }
3229
TEST_F(accuracy_test_pow2_single,large_2D_backward_in_place_complex_planar_to_complex_planar)3230 TEST_F(accuracy_test_pow2_single, large_2D_backward_in_place_complex_planar_to_complex_planar)
3231 {
3232 try { large_2D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
3233 catch( const std::exception& err ) { handle_exception(err); }
3234 }
3235
TEST_F(accuracy_test_pow2_double,large_2D_backward_in_place_complex_planar_to_complex_planar)3236 TEST_F(accuracy_test_pow2_double, large_2D_backward_in_place_complex_planar_to_complex_planar)
3237 {
3238 try { large_2D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
3239 catch( const std::exception& err ) { handle_exception(err); }
3240 }
3241
3242 // *****************************************************
3243 // *****************************************************
3244 template< class T, class cl_T, class fftw_T >
large_2D_forward_in_place_complex_interleaved_to_complex_interleaved()3245 void large_2D_forward_in_place_complex_interleaved_to_complex_interleaved()
3246 {
3247 std::vector<size_t> lengths;
3248 lengths.push_back( MaxLength2D<T>(2) );
3249 lengths.push_back( normal2 );
3250 size_t batch = 1;
3251 std::vector<size_t> input_strides;
3252 std::vector<size_t> output_strides;
3253 size_t input_distance = 0;
3254 size_t output_distance = 0;
3255 layout::buffer_layout_t in_layout = layout::complex_interleaved;
3256 layout::buffer_layout_t out_layout = layout::complex_interleaved;
3257 placeness::placeness_t placeness = placeness::in_place;
3258 direction::direction_t direction = direction::forward;
3259
3260 data_pattern pattern = sawtooth;
3261 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3262 }
3263
TEST_F(accuracy_test_pow2_single,large_2D_forward_in_place_complex_interleaved_to_complex_interleaved)3264 TEST_F(accuracy_test_pow2_single, large_2D_forward_in_place_complex_interleaved_to_complex_interleaved)
3265 {
3266 try { large_2D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
3267 catch( const std::exception& err ) { handle_exception(err); }
3268 }
3269
TEST_F(accuracy_test_pow2_double,large_2D_forward_in_place_complex_interleaved_to_complex_interleaved)3270 TEST_F(accuracy_test_pow2_double, large_2D_forward_in_place_complex_interleaved_to_complex_interleaved)
3271 {
3272 try { large_2D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
3273 catch( const std::exception& err ) { handle_exception(err); }
3274 }
3275
3276 // *****************************************************
3277 // *****************************************************
3278 template< class T, class cl_T, class fftw_T >
large_2D_backward_in_place_complex_interleaved_to_complex_interleaved()3279 void large_2D_backward_in_place_complex_interleaved_to_complex_interleaved()
3280 {
3281 std::vector<size_t> lengths;
3282 lengths.push_back( MaxLength2D<T>(2) );
3283 lengths.push_back( normal2 );
3284 size_t batch = 1;
3285 std::vector<size_t> input_strides;
3286 std::vector<size_t> output_strides;
3287 size_t input_distance = 0;
3288 size_t output_distance = 0;
3289 layout::buffer_layout_t in_layout = layout::complex_interleaved;
3290 layout::buffer_layout_t out_layout = layout::complex_interleaved;
3291 placeness::placeness_t placeness = placeness::in_place;
3292 direction::direction_t direction = direction::backward;
3293
3294 data_pattern pattern = sawtooth;
3295 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3296 }
3297
TEST_F(accuracy_test_pow2_single,large_2D_backward_in_place_complex_interleaved_to_complex_interleaved)3298 TEST_F(accuracy_test_pow2_single, large_2D_backward_in_place_complex_interleaved_to_complex_interleaved)
3299 {
3300 try { large_2D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
3301 catch( const std::exception& err ) { handle_exception(err); }
3302 }
3303
TEST_F(accuracy_test_pow2_double,large_2D_backward_in_place_complex_interleaved_to_complex_interleaved)3304 TEST_F(accuracy_test_pow2_double, large_2D_backward_in_place_complex_interleaved_to_complex_interleaved)
3305 {
3306 try { large_2D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
3307 catch( const std::exception& err ) { handle_exception(err); }
3308 }
3309
3310 // *****************************************************
3311 // *****************************************************
3312 template< class T, class cl_T, class fftw_T >
large_2D_forward_out_of_place_complex_planar_to_complex_planar()3313 void large_2D_forward_out_of_place_complex_planar_to_complex_planar()
3314 {
3315 std::vector<size_t> lengths;
3316 lengths.push_back( MaxLength2D<T>(2) );
3317 lengths.push_back( normal2 );
3318 size_t batch = 1;
3319 std::vector<size_t> input_strides;
3320 std::vector<size_t> output_strides;
3321 size_t input_distance = 0;
3322 size_t output_distance = 0;
3323 layout::buffer_layout_t in_layout = layout::complex_planar;
3324 layout::buffer_layout_t out_layout = layout::complex_planar;
3325 placeness::placeness_t placeness = placeness::out_of_place;
3326 direction::direction_t direction = direction::forward;
3327
3328 data_pattern pattern = sawtooth;
3329 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3330 }
3331
TEST_F(accuracy_test_pow2_single,large_2D_forward_out_of_place_complex_planar_to_complex_planar)3332 TEST_F(accuracy_test_pow2_single, large_2D_forward_out_of_place_complex_planar_to_complex_planar)
3333 {
3334 try { large_2D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
3335 catch( const std::exception& err ) { handle_exception(err); }
3336 }
3337
TEST_F(accuracy_test_pow2_double,large_2D_forward_out_of_place_complex_planar_to_complex_planar)3338 TEST_F(accuracy_test_pow2_double, large_2D_forward_out_of_place_complex_planar_to_complex_planar)
3339 {
3340 try { large_2D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
3341 catch( const std::exception& err ) { handle_exception(err); }
3342 }
3343
3344 // *****************************************************
3345 // *****************************************************
3346 template< class T, class cl_T, class fftw_T >
large_2D_backward_out_of_place_complex_planar_to_complex_planar()3347 void large_2D_backward_out_of_place_complex_planar_to_complex_planar()
3348 {
3349 std::vector<size_t> lengths;
3350 lengths.push_back( MaxLength2D<T>(2) );
3351 lengths.push_back( normal2 );
3352 size_t batch = 1;
3353 std::vector<size_t> input_strides;
3354 std::vector<size_t> output_strides;
3355 size_t input_distance = 0;
3356 size_t output_distance = 0;
3357 layout::buffer_layout_t in_layout = layout::complex_planar;
3358 layout::buffer_layout_t out_layout = layout::complex_planar;
3359 placeness::placeness_t placeness = placeness::out_of_place;
3360 direction::direction_t direction = direction::backward;
3361
3362 data_pattern pattern = sawtooth;
3363 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3364 }
3365
TEST_F(accuracy_test_pow2_single,large_2D_backward_out_of_place_complex_planar_to_complex_planar)3366 TEST_F(accuracy_test_pow2_single, large_2D_backward_out_of_place_complex_planar_to_complex_planar)
3367 {
3368 try { large_2D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
3369 catch( const std::exception& err ) { handle_exception(err); }
3370 }
3371
TEST_F(accuracy_test_pow2_double,large_2D_backward_out_of_place_complex_planar_to_complex_planar)3372 TEST_F(accuracy_test_pow2_double, large_2D_backward_out_of_place_complex_planar_to_complex_planar)
3373 {
3374 try { large_2D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
3375 catch( const std::exception& err ) { handle_exception(err); }
3376 }
3377
3378 // *****************************************************
3379 // *****************************************************
3380 template< class T, class cl_T, class fftw_T >
large_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved()3381 void large_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
3382 {
3383 std::vector<size_t> lengths;
3384 lengths.push_back( MaxLength2D<T>(2) );
3385 lengths.push_back( normal2 );
3386 size_t batch = 1;
3387 std::vector<size_t> input_strides;
3388 std::vector<size_t> output_strides;
3389 size_t input_distance = 0;
3390 size_t output_distance = 0;
3391 layout::buffer_layout_t in_layout = layout::complex_interleaved;
3392 layout::buffer_layout_t out_layout = layout::complex_interleaved;
3393 placeness::placeness_t placeness = placeness::out_of_place;
3394 direction::direction_t direction = direction::forward;
3395
3396 data_pattern pattern = sawtooth;
3397 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3398 }
3399
TEST_F(accuracy_test_pow2_single,large_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)3400 TEST_F(accuracy_test_pow2_single, large_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
3401 {
3402 try { large_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
3403 catch( const std::exception& err ) { handle_exception(err); }
3404 }
3405
TEST_F(accuracy_test_pow2_double,large_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)3406 TEST_F(accuracy_test_pow2_double, large_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
3407 {
3408 try { large_2D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
3409 catch( const std::exception& err ) { handle_exception(err); }
3410 }
3411
3412 // *****************************************************
3413 // *****************************************************
3414 template< class T, class cl_T, class fftw_T >
large_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved()3415 void large_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
3416 {
3417 std::vector<size_t> lengths;
3418 lengths.push_back( MaxLength2D<T>(2) );
3419 lengths.push_back( normal2 );
3420 size_t batch = 1;
3421 std::vector<size_t> input_strides;
3422 std::vector<size_t> output_strides;
3423 size_t input_distance = 0;
3424 size_t output_distance = 0;
3425 layout::buffer_layout_t in_layout = layout::complex_interleaved;
3426 layout::buffer_layout_t out_layout = layout::complex_interleaved;
3427 placeness::placeness_t placeness = placeness::out_of_place;
3428 direction::direction_t direction = direction::backward;
3429
3430 data_pattern pattern = sawtooth;
3431 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3432 }
3433
TEST_F(accuracy_test_pow2_single,large_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)3434 TEST_F(accuracy_test_pow2_single, large_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
3435 {
3436 try { large_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
3437 catch( const std::exception& err ) { handle_exception(err); }
3438 }
3439
TEST_F(accuracy_test_pow2_double,large_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)3440 TEST_F(accuracy_test_pow2_double, large_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
3441 {
3442 try { large_2D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
3443 catch( const std::exception& err ) { handle_exception(err); }
3444 }
3445
3446 // *****************************************************
3447 // *****************************************************
3448 template< class T, class cl_T, class fftw_T >
large_2D_forward_out_of_place_complex_planar_to_complex_interleaved()3449 void large_2D_forward_out_of_place_complex_planar_to_complex_interleaved()
3450 {
3451 std::vector<size_t> lengths;
3452 lengths.push_back( MaxLength2D<T>(2) );
3453 lengths.push_back( normal2 );
3454 size_t batch = 1;
3455 std::vector<size_t> input_strides;
3456 std::vector<size_t> output_strides;
3457 size_t input_distance = 0;
3458 size_t output_distance = 0;
3459 layout::buffer_layout_t in_layout = layout::complex_planar;
3460 layout::buffer_layout_t out_layout = layout::complex_interleaved;
3461 placeness::placeness_t placeness = placeness::out_of_place;
3462 direction::direction_t direction = direction::forward;
3463
3464 data_pattern pattern = sawtooth;
3465 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3466 }
3467
TEST_F(accuracy_test_pow2_single,large_2D_forward_out_of_place_complex_planar_to_complex_interleaved)3468 TEST_F(accuracy_test_pow2_single, large_2D_forward_out_of_place_complex_planar_to_complex_interleaved)
3469 {
3470 try { large_2D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
3471 catch( const std::exception& err ) { handle_exception(err); }
3472 }
3473
TEST_F(accuracy_test_pow2_double,large_2D_forward_out_of_place_complex_planar_to_complex_interleaved)3474 TEST_F(accuracy_test_pow2_double, large_2D_forward_out_of_place_complex_planar_to_complex_interleaved)
3475 {
3476 try { large_2D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
3477 catch( const std::exception& err ) { handle_exception(err); }
3478 }
3479
3480 // *****************************************************
3481 // *****************************************************
3482 template< class T, class cl_T, class fftw_T >
large_2D_backward_out_of_place_complex_planar_to_complex_interleaved()3483 void large_2D_backward_out_of_place_complex_planar_to_complex_interleaved()
3484 {
3485 std::vector<size_t> lengths;
3486 lengths.push_back( MaxLength2D<T>(2) );
3487 lengths.push_back( normal2 );
3488 size_t batch = 1;
3489 std::vector<size_t> input_strides;
3490 std::vector<size_t> output_strides;
3491 size_t input_distance = 0;
3492 size_t output_distance = 0;
3493 layout::buffer_layout_t in_layout = layout::complex_planar;
3494 layout::buffer_layout_t out_layout = layout::complex_interleaved;
3495 placeness::placeness_t placeness = placeness::out_of_place;
3496 direction::direction_t direction = direction::backward;
3497
3498 data_pattern pattern = sawtooth;
3499 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3500 }
3501
TEST_F(accuracy_test_pow2_single,large_2D_backward_out_of_place_complex_planar_to_complex_interleaved)3502 TEST_F(accuracy_test_pow2_single, large_2D_backward_out_of_place_complex_planar_to_complex_interleaved)
3503 {
3504 try { large_2D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
3505 catch( const std::exception& err ) { handle_exception(err); }
3506 }
3507
TEST_F(accuracy_test_pow2_double,large_2D_backward_out_of_place_complex_planar_to_complex_interleaved)3508 TEST_F(accuracy_test_pow2_double, large_2D_backward_out_of_place_complex_planar_to_complex_interleaved)
3509 {
3510 try { large_2D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
3511 catch( const std::exception& err ) { handle_exception(err); }
3512 }
3513
3514 // *****************************************************
3515 // *****************************************************
3516 template< class T, class cl_T, class fftw_T >
large_2D_forward_out_of_place_complex_interleaved_to_complex_planar()3517 void large_2D_forward_out_of_place_complex_interleaved_to_complex_planar()
3518 {
3519 std::vector<size_t> lengths;
3520 lengths.push_back( MaxLength2D<T>(2) );
3521 lengths.push_back( normal2 );
3522 size_t batch = 1;
3523 std::vector<size_t> input_strides;
3524 std::vector<size_t> output_strides;
3525 size_t input_distance = 0;
3526 size_t output_distance = 0;
3527 layout::buffer_layout_t in_layout = layout::complex_interleaved;
3528 layout::buffer_layout_t out_layout = layout::complex_planar;
3529 placeness::placeness_t placeness = placeness::out_of_place;
3530 direction::direction_t direction = direction::forward;
3531
3532 data_pattern pattern = sawtooth;
3533 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3534 }
3535
TEST_F(accuracy_test_pow2_single,large_2D_forward_out_of_place_complex_interleaved_to_complex_planar)3536 TEST_F(accuracy_test_pow2_single, large_2D_forward_out_of_place_complex_interleaved_to_complex_planar)
3537 {
3538 try { large_2D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
3539 catch( const std::exception& err ) { handle_exception(err); }
3540 }
3541
TEST_F(accuracy_test_pow2_double,large_2D_forward_out_of_place_complex_interleaved_to_complex_planar)3542 TEST_F(accuracy_test_pow2_double, large_2D_forward_out_of_place_complex_interleaved_to_complex_planar)
3543 {
3544 try { large_2D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
3545 catch( const std::exception& err ) { handle_exception(err); }
3546 }
3547
3548 // *****************************************************
3549 // *****************************************************
3550 template< class T, class cl_T, class fftw_T >
large_2D_backward_out_of_place_complex_interleaved_to_complex_planar()3551 void large_2D_backward_out_of_place_complex_interleaved_to_complex_planar()
3552 {
3553 std::vector<size_t> lengths;
3554 lengths.push_back( MaxLength2D<T>(2) );
3555 lengths.push_back( normal2 );
3556 size_t batch = 1;
3557 std::vector<size_t> input_strides;
3558 std::vector<size_t> output_strides;
3559 size_t input_distance = 0;
3560 size_t output_distance = 0;
3561 layout::buffer_layout_t in_layout = layout::complex_interleaved;
3562 layout::buffer_layout_t out_layout = layout::complex_planar;
3563 placeness::placeness_t placeness = placeness::out_of_place;
3564 direction::direction_t direction = direction::backward;
3565
3566 data_pattern pattern = sawtooth;
3567 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3568 }
3569
TEST_F(accuracy_test_pow2_single,large_2D_backward_out_of_place_complex_interleaved_to_complex_planar)3570 TEST_F(accuracy_test_pow2_single, large_2D_backward_out_of_place_complex_interleaved_to_complex_planar)
3571 {
3572 try { large_2D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
3573 catch( const std::exception& err ) { handle_exception(err); }
3574 }
3575
TEST_F(accuracy_test_pow2_double,large_2D_backward_out_of_place_complex_interleaved_to_complex_planar)3576 TEST_F(accuracy_test_pow2_double, large_2D_backward_out_of_place_complex_interleaved_to_complex_planar)
3577 {
3578 try { large_2D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
3579 catch( const std::exception& err ) { handle_exception(err); }
3580 }
3581
3582 // *****************************************************
3583 // *****************************************************
3584 template< class T, class cl_T, class fftw_T >
large_2D_in_place_real_to_hermitian_interleaved()3585 void large_2D_in_place_real_to_hermitian_interleaved()
3586 {
3587 std::vector<size_t> lengths;
3588 lengths.push_back( MaxLength2D<T>(2) );
3589 lengths.push_back( normal2 );
3590 size_t batch = 1;
3591 std::vector<size_t> input_strides;
3592 std::vector<size_t> output_strides;
3593 size_t input_distance = 0;
3594 size_t output_distance = 0;
3595 layout::buffer_layout_t layout = layout::hermitian_interleaved;
3596 placeness::placeness_t placeness = placeness::in_place;
3597
3598 data_pattern pattern = sawtooth;
3599 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
3600 }
3601
TEST_F(accuracy_test_pow2_single,large_2D_in_place_real_to_hermitian_interleaved)3602 TEST_F(accuracy_test_pow2_single, large_2D_in_place_real_to_hermitian_interleaved)
3603 {
3604 try { large_2D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
3605 catch( const std::exception& err ) { handle_exception(err); }
3606 }
3607
TEST_F(accuracy_test_pow2_double,large_2D_in_place_real_to_hermitian_interleaved)3608 TEST_F(accuracy_test_pow2_double, large_2D_in_place_real_to_hermitian_interleaved)
3609 {
3610 try { large_2D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
3611 catch( const std::exception& err ) { handle_exception(err); }
3612 }
3613
3614 // *****************************************************
3615 // *****************************************************
3616 template< class T, class cl_T, class fftw_T >
large_2D_in_place_hermitian_interleaved_to_real()3617 void large_2D_in_place_hermitian_interleaved_to_real()
3618 {
3619 std::vector<size_t> lengths;
3620 lengths.push_back( MaxLength2D<T>(2) );
3621 lengths.push_back( normal2 );
3622 size_t batch = 1;
3623 std::vector<size_t> input_strides;
3624 std::vector<size_t> output_strides;
3625 size_t input_distance = 0;
3626 size_t output_distance = 0;
3627 layout::buffer_layout_t layout = layout::hermitian_interleaved;
3628 placeness::placeness_t placeness = placeness::in_place;
3629
3630 data_pattern pattern = sawtooth;
3631 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
3632 }
3633
TEST_F(accuracy_test_pow2_single,large_2D_in_place_hermitian_interleaved_to_real)3634 TEST_F(accuracy_test_pow2_single, large_2D_in_place_hermitian_interleaved_to_real)
3635 {
3636 try { large_2D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
3637 catch( const std::exception& err ) { handle_exception(err); }
3638 }
3639
TEST_F(accuracy_test_pow2_double,large_2D_in_place_hermitian_interleaved_to_real)3640 TEST_F(accuracy_test_pow2_double, large_2D_in_place_hermitian_interleaved_to_real)
3641 {
3642 try { large_2D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
3643 catch( const std::exception& err ) { handle_exception(err); }
3644 }
3645
3646 // *****************************************************
3647 // *****************************************************
3648 template< class T, class cl_T, class fftw_T >
large_2D_out_of_place_real_to_hermitian_interleaved()3649 void large_2D_out_of_place_real_to_hermitian_interleaved()
3650 {
3651 std::vector<size_t> lengths;
3652 lengths.push_back( MaxLength2D<T>(2) );
3653 lengths.push_back( normal2 );
3654 size_t batch = 1;
3655 std::vector<size_t> input_strides;
3656 std::vector<size_t> output_strides;
3657 size_t input_distance = 0;
3658 size_t output_distance = 0;
3659 layout::buffer_layout_t layout = layout::hermitian_interleaved;
3660 placeness::placeness_t placeness = placeness::out_of_place;
3661
3662 data_pattern pattern = sawtooth;
3663 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
3664 }
3665
TEST_F(accuracy_test_pow2_single,large_2D_out_of_place_real_to_hermitian_interleaved)3666 TEST_F(accuracy_test_pow2_single, large_2D_out_of_place_real_to_hermitian_interleaved)
3667 {
3668 try { large_2D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
3669 catch( const std::exception& err ) { handle_exception(err); }
3670 }
3671
TEST_F(accuracy_test_pow2_double,large_2D_out_of_place_real_to_hermitian_interleaved)3672 TEST_F(accuracy_test_pow2_double, large_2D_out_of_place_real_to_hermitian_interleaved)
3673 {
3674 try { large_2D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
3675 catch( const std::exception& err ) { handle_exception(err); }
3676 }
3677
3678 // *****************************************************
3679 // *****************************************************
3680 template< class T, class cl_T, class fftw_T >
large_2D_out_of_place_hermitian_interleaved_to_real()3681 void large_2D_out_of_place_hermitian_interleaved_to_real()
3682 {
3683 std::vector<size_t> lengths;
3684 lengths.push_back( MaxLength2D<T>(2) );
3685 lengths.push_back( normal2 );
3686 size_t batch = 1;
3687 std::vector<size_t> input_strides;
3688 std::vector<size_t> output_strides;
3689 size_t input_distance = 0;
3690 size_t output_distance = 0;
3691 layout::buffer_layout_t layout = layout::hermitian_interleaved;
3692 placeness::placeness_t placeness = placeness::out_of_place;
3693
3694 data_pattern pattern = sawtooth;
3695 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
3696 }
3697
TEST_F(accuracy_test_pow2_single,large_2D_out_of_place_hermitian_interleaved_to_real)3698 TEST_F(accuracy_test_pow2_single, large_2D_out_of_place_hermitian_interleaved_to_real)
3699 {
3700 try { large_2D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
3701 catch( const std::exception& err ) { handle_exception(err); }
3702 }
3703
TEST_F(accuracy_test_pow2_double,large_2D_out_of_place_hermitian_interleaved_to_real)3704 TEST_F(accuracy_test_pow2_double, large_2D_out_of_place_hermitian_interleaved_to_real)
3705 {
3706 try { large_2D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
3707 catch( const std::exception& err ) { handle_exception(err); }
3708 }
3709
3710 // *****************************************************
3711 // *****************************************************
3712 template< class T, class cl_T, class fftw_T >
large_2D_out_of_place_real_to_hermitian_planar()3713 void large_2D_out_of_place_real_to_hermitian_planar()
3714 {
3715 std::vector<size_t> lengths;
3716 lengths.push_back( MaxLength2D<T>(2) );
3717 lengths.push_back( normal2 );
3718 size_t batch = 1;
3719 std::vector<size_t> input_strides;
3720 std::vector<size_t> output_strides;
3721 size_t input_distance = 0;
3722 size_t output_distance = 0;
3723 layout::buffer_layout_t layout = layout::hermitian_planar;
3724 placeness::placeness_t placeness = placeness::out_of_place;
3725
3726 data_pattern pattern = sawtooth;
3727 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
3728 }
3729
TEST_F(accuracy_test_pow2_single,large_2D_out_of_place_real_to_hermitian_planar)3730 TEST_F(accuracy_test_pow2_single, large_2D_out_of_place_real_to_hermitian_planar)
3731 {
3732 try { large_2D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
3733 catch( const std::exception& err ) { handle_exception(err); }
3734 }
3735
TEST_F(accuracy_test_pow2_double,large_2D_out_of_place_real_to_hermitian_planar)3736 TEST_F(accuracy_test_pow2_double, large_2D_out_of_place_real_to_hermitian_planar)
3737 {
3738 try { large_2D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
3739 catch( const std::exception& err ) { handle_exception(err); }
3740 }
3741
3742 // *****************************************************
3743 // *****************************************************
3744 template< class T, class cl_T, class fftw_T >
large_2D_out_of_place_hermitian_planar_to_real()3745 void large_2D_out_of_place_hermitian_planar_to_real()
3746 {
3747 std::vector<size_t> lengths;
3748 lengths.push_back( MaxLength2D<T>(2) );
3749 lengths.push_back( normal2 );
3750 size_t batch = 1;
3751 std::vector<size_t> input_strides;
3752 std::vector<size_t> output_strides;
3753 size_t input_distance = 0;
3754 size_t output_distance = 0;
3755 layout::buffer_layout_t layout = layout::hermitian_planar;
3756 placeness::placeness_t placeness = placeness::out_of_place;
3757
3758 data_pattern pattern = sawtooth;
3759 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
3760 }
3761
TEST_F(accuracy_test_pow2_single,large_2D_out_of_place_hermitian_planar_to_real)3762 TEST_F(accuracy_test_pow2_single, large_2D_out_of_place_hermitian_planar_to_real)
3763 {
3764 try { large_2D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
3765 catch( const std::exception& err ) { handle_exception(err); }
3766 }
3767
TEST_F(accuracy_test_pow2_double,large_2D_out_of_place_hermitian_planar_to_real)3768 TEST_F(accuracy_test_pow2_double, large_2D_out_of_place_hermitian_planar_to_real)
3769 {
3770 try { large_2D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
3771 catch( const std::exception& err ) { handle_exception(err); }
3772 }
3773
3774 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
3775 // ^^^^^^^^^^^^^^^^^^^^^^^ normal 3D ^^^^^^^^^^^^^^^^^^^^^^ //
3776 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
3777
3778 // *****************************************************
3779 // *****************************************************
3780 template< class T, class cl_T, class fftw_T >
normal_3D_forward_in_place_complex_planar_to_complex_planar()3781 void normal_3D_forward_in_place_complex_planar_to_complex_planar()
3782 {
3783 std::vector<size_t> lengths;
3784 lengths.push_back( normal2 );
3785 lengths.push_back( small2 );
3786 lengths.push_back( small2 );
3787 size_t batch = 1;
3788 std::vector<size_t> input_strides;
3789 std::vector<size_t> output_strides;
3790 size_t input_distance = 0;
3791 size_t output_distance = 0;
3792 layout::buffer_layout_t in_layout = layout::complex_planar;
3793 layout::buffer_layout_t out_layout = layout::complex_planar;
3794 placeness::placeness_t placeness = placeness::in_place;
3795 direction::direction_t direction = direction::forward;
3796
3797 data_pattern pattern = sawtooth;
3798 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3799 }
3800
TEST_F(accuracy_test_pow2_single,normal_3D_forward_in_place_complex_planar_to_complex_planar)3801 TEST_F(accuracy_test_pow2_single, normal_3D_forward_in_place_complex_planar_to_complex_planar)
3802 {
3803 try { normal_3D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
3804 catch( const std::exception& err ) { handle_exception(err); }
3805 }
3806
TEST_F(accuracy_test_pow2_double,normal_3D_forward_in_place_complex_planar_to_complex_planar)3807 TEST_F(accuracy_test_pow2_double, normal_3D_forward_in_place_complex_planar_to_complex_planar)
3808 {
3809 try { normal_3D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
3810 catch( const std::exception& err ) { handle_exception(err); }
3811 }
3812
3813 // *****************************************************
3814 // *****************************************************
3815 template< class T, class cl_T, class fftw_T >
normal_3D_backward_in_place_complex_planar_to_complex_planar()3816 void normal_3D_backward_in_place_complex_planar_to_complex_planar()
3817 {
3818 std::vector<size_t> lengths;
3819 lengths.push_back( normal2 );
3820 lengths.push_back( small2 );
3821 lengths.push_back( small2 );
3822 size_t batch = 1;
3823 std::vector<size_t> input_strides;
3824 std::vector<size_t> output_strides;
3825 size_t input_distance = 0;
3826 size_t output_distance = 0;
3827 layout::buffer_layout_t in_layout = layout::complex_planar;
3828 layout::buffer_layout_t out_layout = layout::complex_planar;
3829 placeness::placeness_t placeness = placeness::in_place;
3830 direction::direction_t direction = direction::backward;
3831
3832 data_pattern pattern = sawtooth;
3833 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3834 }
3835
TEST_F(accuracy_test_pow2_single,normal_3D_backward_in_place_complex_planar_to_complex_planar)3836 TEST_F(accuracy_test_pow2_single, normal_3D_backward_in_place_complex_planar_to_complex_planar)
3837 {
3838 try { normal_3D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
3839 catch( const std::exception& err ) { handle_exception(err); }
3840 }
3841
TEST_F(accuracy_test_pow2_double,normal_3D_backward_in_place_complex_planar_to_complex_planar)3842 TEST_F(accuracy_test_pow2_double, normal_3D_backward_in_place_complex_planar_to_complex_planar)
3843 {
3844 try { normal_3D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
3845 catch( const std::exception& err ) { handle_exception(err); }
3846 }
3847
3848 // *****************************************************
3849 // *****************************************************
3850 template< class T, class cl_T, class fftw_T >
normal_3D_forward_in_place_complex_interleaved_to_complex_interleaved()3851 void normal_3D_forward_in_place_complex_interleaved_to_complex_interleaved()
3852 {
3853 std::vector<size_t> lengths;
3854 lengths.push_back( normal2 );
3855 lengths.push_back( small2 );
3856 lengths.push_back( small2 );
3857 size_t batch = 1;
3858 std::vector<size_t> input_strides;
3859 std::vector<size_t> output_strides;
3860 size_t input_distance = 0;
3861 size_t output_distance = 0;
3862 layout::buffer_layout_t in_layout = layout::complex_interleaved;
3863 layout::buffer_layout_t out_layout = layout::complex_interleaved;
3864 placeness::placeness_t placeness = placeness::in_place;
3865 direction::direction_t direction = direction::forward;
3866
3867 data_pattern pattern = sawtooth;
3868 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3869 }
3870
TEST_F(accuracy_test_pow2_single,normal_3D_forward_in_place_complex_interleaved_to_complex_interleaved)3871 TEST_F(accuracy_test_pow2_single, normal_3D_forward_in_place_complex_interleaved_to_complex_interleaved)
3872 {
3873 try { normal_3D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
3874 catch( const std::exception& err ) { handle_exception(err); }
3875 }
3876
TEST_F(accuracy_test_pow2_double,normal_3D_forward_in_place_complex_interleaved_to_complex_interleaved)3877 TEST_F(accuracy_test_pow2_double, normal_3D_forward_in_place_complex_interleaved_to_complex_interleaved)
3878 {
3879 try { normal_3D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
3880 catch( const std::exception& err ) { handle_exception(err); }
3881 }
3882
3883 // *****************************************************
3884 // *****************************************************
3885 template< class T, class cl_T, class fftw_T >
normal_3D_backward_in_place_complex_interleaved_to_complex_interleaved()3886 void normal_3D_backward_in_place_complex_interleaved_to_complex_interleaved()
3887 {
3888 std::vector<size_t> lengths;
3889 lengths.push_back( normal2 );
3890 lengths.push_back( small2 );
3891 lengths.push_back( small2 );
3892 size_t batch = 1;
3893 std::vector<size_t> input_strides;
3894 std::vector<size_t> output_strides;
3895 size_t input_distance = 0;
3896 size_t output_distance = 0;
3897 layout::buffer_layout_t in_layout = layout::complex_interleaved;
3898 layout::buffer_layout_t out_layout = layout::complex_interleaved;
3899 placeness::placeness_t placeness = placeness::in_place;
3900 direction::direction_t direction = direction::backward;
3901
3902 data_pattern pattern = sawtooth;
3903 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3904 }
3905
TEST_F(accuracy_test_pow2_single,normal_3D_backward_in_place_complex_interleaved_to_complex_interleaved)3906 TEST_F(accuracy_test_pow2_single, normal_3D_backward_in_place_complex_interleaved_to_complex_interleaved)
3907 {
3908 try { normal_3D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
3909 catch( const std::exception& err ) { handle_exception(err); }
3910 }
3911
TEST_F(accuracy_test_pow2_double,normal_3D_backward_in_place_complex_interleaved_to_complex_interleaved)3912 TEST_F(accuracy_test_pow2_double, normal_3D_backward_in_place_complex_interleaved_to_complex_interleaved)
3913 {
3914 try { normal_3D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
3915 catch( const std::exception& err ) { handle_exception(err); }
3916 }
3917
3918 // *****************************************************
3919 // *****************************************************
3920 template< class T, class cl_T, class fftw_T >
normal_3D_forward_out_of_place_complex_planar_to_complex_planar()3921 void normal_3D_forward_out_of_place_complex_planar_to_complex_planar()
3922 {
3923 std::vector<size_t> lengths;
3924 lengths.push_back( normal2 );
3925 lengths.push_back( small2 );
3926 lengths.push_back( small2 );
3927 size_t batch = 1;
3928 std::vector<size_t> input_strides;
3929 std::vector<size_t> output_strides;
3930 size_t input_distance = 0;
3931 size_t output_distance = 0;
3932 layout::buffer_layout_t in_layout = layout::complex_planar;
3933 layout::buffer_layout_t out_layout = layout::complex_planar;
3934 placeness::placeness_t placeness = placeness::out_of_place;
3935 direction::direction_t direction = direction::forward;
3936
3937 data_pattern pattern = sawtooth;
3938 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3939 }
3940
TEST_F(accuracy_test_pow2_single,normal_3D_forward_out_of_place_complex_planar_to_complex_planar)3941 TEST_F(accuracy_test_pow2_single, normal_3D_forward_out_of_place_complex_planar_to_complex_planar)
3942 {
3943 try { normal_3D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
3944 catch( const std::exception& err ) { handle_exception(err); }
3945 }
3946
TEST_F(accuracy_test_pow2_double,normal_3D_forward_out_of_place_complex_planar_to_complex_planar)3947 TEST_F(accuracy_test_pow2_double, normal_3D_forward_out_of_place_complex_planar_to_complex_planar)
3948 {
3949 try { normal_3D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
3950 catch( const std::exception& err ) { handle_exception(err); }
3951 }
3952
3953 // *****************************************************
3954 // *****************************************************
3955 template< class T, class cl_T, class fftw_T >
normal_3D_backward_out_of_place_complex_planar_to_complex_planar()3956 void normal_3D_backward_out_of_place_complex_planar_to_complex_planar()
3957 {
3958 std::vector<size_t> lengths;
3959 lengths.push_back( normal2 );
3960 lengths.push_back( small2 );
3961 lengths.push_back( small2 );
3962 size_t batch = 1;
3963 std::vector<size_t> input_strides;
3964 std::vector<size_t> output_strides;
3965 size_t input_distance = 0;
3966 size_t output_distance = 0;
3967 layout::buffer_layout_t in_layout = layout::complex_planar;
3968 layout::buffer_layout_t out_layout = layout::complex_planar;
3969 placeness::placeness_t placeness = placeness::out_of_place;
3970 direction::direction_t direction = direction::backward;
3971
3972 data_pattern pattern = sawtooth;
3973 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
3974 }
3975
TEST_F(accuracy_test_pow2_single,normal_3D_backward_out_of_place_complex_planar_to_complex_planar)3976 TEST_F(accuracy_test_pow2_single, normal_3D_backward_out_of_place_complex_planar_to_complex_planar)
3977 {
3978 try { normal_3D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
3979 catch( const std::exception& err ) { handle_exception(err); }
3980 }
3981
TEST_F(accuracy_test_pow2_double,normal_3D_backward_out_of_place_complex_planar_to_complex_planar)3982 TEST_F(accuracy_test_pow2_double, normal_3D_backward_out_of_place_complex_planar_to_complex_planar)
3983 {
3984 try { normal_3D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
3985 catch( const std::exception& err ) { handle_exception(err); }
3986 }
3987
3988 // *****************************************************
3989 // *****************************************************
3990 template< class T, class cl_T, class fftw_T >
normal_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved()3991 void normal_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
3992 {
3993 std::vector<size_t> lengths;
3994 lengths.push_back( normal2 );
3995 lengths.push_back( small2 );
3996 lengths.push_back( small2 );
3997 size_t batch = 1;
3998 std::vector<size_t> input_strides;
3999 std::vector<size_t> output_strides;
4000 size_t input_distance = 0;
4001 size_t output_distance = 0;
4002 layout::buffer_layout_t in_layout = layout::complex_interleaved;
4003 layout::buffer_layout_t out_layout = layout::complex_interleaved;
4004 placeness::placeness_t placeness = placeness::out_of_place;
4005 direction::direction_t direction = direction::forward;
4006
4007 data_pattern pattern = sawtooth;
4008 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4009 }
4010
TEST_F(accuracy_test_pow2_single,normal_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)4011 TEST_F(accuracy_test_pow2_single, normal_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
4012 {
4013 try { normal_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
4014 catch( const std::exception& err ) { handle_exception(err); }
4015 }
4016
TEST_F(accuracy_test_pow2_double,normal_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)4017 TEST_F(accuracy_test_pow2_double, normal_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
4018 {
4019 try { normal_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
4020 catch( const std::exception& err ) { handle_exception(err); }
4021 }
4022
4023 // *****************************************************
4024 // *****************************************************
4025 template< class T, class cl_T, class fftw_T >
normal_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved()4026 void normal_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
4027 {
4028 std::vector<size_t> lengths;
4029 lengths.push_back( normal2 );
4030 lengths.push_back( small2 );
4031 lengths.push_back( small2 );
4032 size_t batch = 1;
4033 std::vector<size_t> input_strides;
4034 std::vector<size_t> output_strides;
4035 size_t input_distance = 0;
4036 size_t output_distance = 0;
4037 layout::buffer_layout_t in_layout = layout::complex_interleaved;
4038 layout::buffer_layout_t out_layout = layout::complex_interleaved;
4039 placeness::placeness_t placeness = placeness::out_of_place;
4040 direction::direction_t direction = direction::backward;
4041
4042 data_pattern pattern = sawtooth;
4043 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4044 }
4045
TEST_F(accuracy_test_pow2_single,normal_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)4046 TEST_F(accuracy_test_pow2_single, normal_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
4047 {
4048 try { normal_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
4049 catch( const std::exception& err ) { handle_exception(err); }
4050 }
4051
TEST_F(accuracy_test_pow2_double,normal_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)4052 TEST_F(accuracy_test_pow2_double, normal_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
4053 {
4054 try { normal_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
4055 catch( const std::exception& err ) { handle_exception(err); }
4056 }
4057
4058 // *****************************************************
4059 // *****************************************************
4060 template< class T, class cl_T, class fftw_T >
normal_3D_forward_out_of_place_complex_planar_to_complex_interleaved()4061 void normal_3D_forward_out_of_place_complex_planar_to_complex_interleaved()
4062 {
4063 std::vector<size_t> lengths;
4064 lengths.push_back( normal2 );
4065 lengths.push_back( small2 );
4066 lengths.push_back( small2 );
4067 size_t batch = 1;
4068 std::vector<size_t> input_strides;
4069 std::vector<size_t> output_strides;
4070 size_t input_distance = 0;
4071 size_t output_distance = 0;
4072 layout::buffer_layout_t in_layout = layout::complex_planar;
4073 layout::buffer_layout_t out_layout = layout::complex_interleaved;
4074 placeness::placeness_t placeness = placeness::out_of_place;
4075 direction::direction_t direction = direction::forward;
4076
4077 data_pattern pattern = sawtooth;
4078 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4079 }
4080
TEST_F(accuracy_test_pow2_single,normal_3D_forward_out_of_place_complex_planar_to_complex_interleaved)4081 TEST_F(accuracy_test_pow2_single, normal_3D_forward_out_of_place_complex_planar_to_complex_interleaved)
4082 {
4083 try { normal_3D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
4084 catch( const std::exception& err ) { handle_exception(err); }
4085 }
4086
TEST_F(accuracy_test_pow2_double,normal_3D_forward_out_of_place_complex_planar_to_complex_interleaved)4087 TEST_F(accuracy_test_pow2_double, normal_3D_forward_out_of_place_complex_planar_to_complex_interleaved)
4088 {
4089 try { normal_3D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
4090 catch( const std::exception& err ) { handle_exception(err); }
4091 }
4092
4093 // *****************************************************
4094 // *****************************************************
4095 template< class T, class cl_T, class fftw_T >
normal_3D_backward_out_of_place_complex_planar_to_complex_interleaved()4096 void normal_3D_backward_out_of_place_complex_planar_to_complex_interleaved()
4097 {
4098 std::vector<size_t> lengths;
4099 lengths.push_back( normal2 );
4100 lengths.push_back( small2 );
4101 lengths.push_back( small2 );
4102 size_t batch = 1;
4103 std::vector<size_t> input_strides;
4104 std::vector<size_t> output_strides;
4105 size_t input_distance = 0;
4106 size_t output_distance = 0;
4107 layout::buffer_layout_t in_layout = layout::complex_planar;
4108 layout::buffer_layout_t out_layout = layout::complex_interleaved;
4109 placeness::placeness_t placeness = placeness::out_of_place;
4110 direction::direction_t direction = direction::backward;
4111
4112 data_pattern pattern = sawtooth;
4113 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4114 }
4115
TEST_F(accuracy_test_pow2_single,normal_3D_backward_out_of_place_complex_planar_to_complex_interleaved)4116 TEST_F(accuracy_test_pow2_single, normal_3D_backward_out_of_place_complex_planar_to_complex_interleaved)
4117 {
4118 try { normal_3D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
4119 catch( const std::exception& err ) { handle_exception(err); }
4120 }
4121
TEST_F(accuracy_test_pow2_double,normal_3D_backward_out_of_place_complex_planar_to_complex_interleaved)4122 TEST_F(accuracy_test_pow2_double, normal_3D_backward_out_of_place_complex_planar_to_complex_interleaved)
4123 {
4124 try { normal_3D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
4125 catch( const std::exception& err ) { handle_exception(err); }
4126 }
4127
4128 // *****************************************************
4129 // *****************************************************
4130 template< class T, class cl_T, class fftw_T >
normal_3D_forward_out_of_place_complex_interleaved_to_complex_planar()4131 void normal_3D_forward_out_of_place_complex_interleaved_to_complex_planar()
4132 {
4133 std::vector<size_t> lengths;
4134 lengths.push_back( normal2 );
4135 lengths.push_back( small2 );
4136 lengths.push_back( small2 );
4137 size_t batch = 1;
4138 std::vector<size_t> input_strides;
4139 std::vector<size_t> output_strides;
4140 size_t input_distance = 0;
4141 size_t output_distance = 0;
4142 layout::buffer_layout_t in_layout = layout::complex_interleaved;
4143 layout::buffer_layout_t out_layout = layout::complex_planar;
4144 placeness::placeness_t placeness = placeness::out_of_place;
4145 direction::direction_t direction = direction::forward;
4146
4147 data_pattern pattern = sawtooth;
4148 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4149 }
4150
TEST_F(accuracy_test_pow2_single,normal_3D_forward_out_of_place_complex_interleaved_to_complex_planar)4151 TEST_F(accuracy_test_pow2_single, normal_3D_forward_out_of_place_complex_interleaved_to_complex_planar)
4152 {
4153 try { normal_3D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
4154 catch( const std::exception& err ) { handle_exception(err); }
4155 }
4156
TEST_F(accuracy_test_pow2_double,normal_3D_forward_out_of_place_complex_interleaved_to_complex_planar)4157 TEST_F(accuracy_test_pow2_double, normal_3D_forward_out_of_place_complex_interleaved_to_complex_planar)
4158 {
4159 try { normal_3D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
4160 catch( const std::exception& err ) { handle_exception(err); }
4161 }
4162
4163 // *****************************************************
4164 // *****************************************************
4165 template< class T, class cl_T, class fftw_T >
normal_3D_backward_out_of_place_complex_interleaved_to_complex_planar()4166 void normal_3D_backward_out_of_place_complex_interleaved_to_complex_planar()
4167 {
4168 std::vector<size_t> lengths;
4169 lengths.push_back( normal2 );
4170 lengths.push_back( small2 );
4171 lengths.push_back( small2 );
4172 size_t batch = 1;
4173 std::vector<size_t> input_strides;
4174 std::vector<size_t> output_strides;
4175 size_t input_distance = 0;
4176 size_t output_distance = 0;
4177 layout::buffer_layout_t in_layout = layout::complex_interleaved;
4178 layout::buffer_layout_t out_layout = layout::complex_planar;
4179 placeness::placeness_t placeness = placeness::out_of_place;
4180 direction::direction_t direction = direction::backward;
4181
4182 data_pattern pattern = sawtooth;
4183 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4184 }
4185
TEST_F(accuracy_test_pow2_single,normal_3D_backward_out_of_place_complex_interleaved_to_complex_planar)4186 TEST_F(accuracy_test_pow2_single, normal_3D_backward_out_of_place_complex_interleaved_to_complex_planar)
4187 {
4188 try { normal_3D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
4189 catch( const std::exception& err ) { handle_exception(err); }
4190 }
4191
TEST_F(accuracy_test_pow2_double,normal_3D_backward_out_of_place_complex_interleaved_to_complex_planar)4192 TEST_F(accuracy_test_pow2_double, normal_3D_backward_out_of_place_complex_interleaved_to_complex_planar)
4193 {
4194 try { normal_3D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
4195 catch( const std::exception& err ) { handle_exception(err); }
4196 }
4197
4198 // *****************************************************
4199 // *****************************************************
4200 template< class T, class cl_T, class fftw_T >
normal_3D_in_place_real_to_hermitian_interleaved()4201 void normal_3D_in_place_real_to_hermitian_interleaved()
4202 {
4203 std::vector<size_t> lengths;
4204 lengths.push_back( small2 );
4205 lengths.push_back( normal2 );
4206 lengths.push_back( small2 );
4207 size_t batch = 1;
4208 std::vector<size_t> input_strides;
4209 std::vector<size_t> output_strides;
4210 size_t input_distance = 0;
4211 size_t output_distance = 0;
4212 layout::buffer_layout_t layout = layout::hermitian_interleaved;
4213 placeness::placeness_t placeness = placeness::in_place;
4214
4215 data_pattern pattern = sawtooth;
4216 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
4217 }
4218
TEST_F(accuracy_test_pow2_single,normal_3D_in_place_real_to_hermitian_interleaved)4219 TEST_F(accuracy_test_pow2_single, normal_3D_in_place_real_to_hermitian_interleaved)
4220 {
4221 try { normal_3D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
4222 catch( const std::exception& err ) { handle_exception(err); }
4223 }
4224
TEST_F(accuracy_test_pow2_double,normal_3D_in_place_real_to_hermitian_interleaved)4225 TEST_F(accuracy_test_pow2_double, normal_3D_in_place_real_to_hermitian_interleaved)
4226 {
4227 try { normal_3D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
4228 catch( const std::exception& err ) { handle_exception(err); }
4229 }
4230
4231 // *****************************************************
4232 // *****************************************************
4233 template< class T, class cl_T, class fftw_T >
normal_3D_in_place_hermitian_interleaved_to_real()4234 void normal_3D_in_place_hermitian_interleaved_to_real()
4235 {
4236 std::vector<size_t> lengths;
4237 lengths.push_back( normal2 );
4238 lengths.push_back( small2 );
4239 lengths.push_back( small2 );
4240 size_t batch = 1;
4241 std::vector<size_t> input_strides;
4242 std::vector<size_t> output_strides;
4243 size_t input_distance = 0;
4244 size_t output_distance = 0;
4245 layout::buffer_layout_t layout = layout::hermitian_interleaved;
4246 placeness::placeness_t placeness = placeness::in_place;
4247
4248 data_pattern pattern = sawtooth;
4249 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
4250 }
4251
TEST_F(accuracy_test_pow2_single,normal_3D_in_place_hermitian_interleaved_to_real)4252 TEST_F(accuracy_test_pow2_single, normal_3D_in_place_hermitian_interleaved_to_real)
4253 {
4254 try { normal_3D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
4255 catch( const std::exception& err ) { handle_exception(err); }
4256 }
4257
TEST_F(accuracy_test_pow2_double,normal_3D_in_place_hermitian_interleaved_to_real)4258 TEST_F(accuracy_test_pow2_double, normal_3D_in_place_hermitian_interleaved_to_real)
4259 {
4260 try { normal_3D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
4261 catch( const std::exception& err ) { handle_exception(err); }
4262 }
4263
4264 // *****************************************************
4265 // *****************************************************
4266 template< class T, class cl_T, class fftw_T >
normal_3D_out_of_place_real_to_hermitian_interleaved()4267 void normal_3D_out_of_place_real_to_hermitian_interleaved()
4268 {
4269 std::vector<size_t> lengths;
4270 lengths.push_back( small2 );
4271 lengths.push_back( small2 );
4272 lengths.push_back( normal2 );
4273 size_t batch = 1;
4274 std::vector<size_t> input_strides;
4275 std::vector<size_t> output_strides;
4276 size_t input_distance = 0;
4277 size_t output_distance = 0;
4278 layout::buffer_layout_t layout = layout::hermitian_interleaved;
4279 placeness::placeness_t placeness = placeness::out_of_place;
4280
4281 data_pattern pattern = sawtooth;
4282 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
4283 }
4284
TEST_F(accuracy_test_pow2_single,normal_3D_out_of_place_real_to_hermitian_interleaved)4285 TEST_F(accuracy_test_pow2_single, normal_3D_out_of_place_real_to_hermitian_interleaved)
4286 {
4287 try { normal_3D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
4288 catch( const std::exception& err ) { handle_exception(err); }
4289 }
4290
TEST_F(accuracy_test_pow2_double,normal_3D_out_of_place_real_to_hermitian_interleaved)4291 TEST_F(accuracy_test_pow2_double, normal_3D_out_of_place_real_to_hermitian_interleaved)
4292 {
4293 try { normal_3D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
4294 catch( const std::exception& err ) { handle_exception(err); }
4295 }
4296
4297 // *****************************************************
4298 // *****************************************************
4299 template< class T, class cl_T, class fftw_T >
normal_3D_out_of_place_hermitian_interleaved_to_real()4300 void normal_3D_out_of_place_hermitian_interleaved_to_real()
4301 {
4302 std::vector<size_t> lengths;
4303 lengths.push_back( normal2 );
4304 lengths.push_back( small2 );
4305 lengths.push_back( small2 );
4306 size_t batch = 1;
4307 std::vector<size_t> input_strides;
4308 std::vector<size_t> output_strides;
4309 size_t input_distance = 0;
4310 size_t output_distance = 0;
4311 layout::buffer_layout_t layout = layout::hermitian_interleaved;
4312 placeness::placeness_t placeness = placeness::out_of_place;
4313
4314 data_pattern pattern = sawtooth;
4315 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
4316 }
4317
TEST_F(accuracy_test_pow2_single,normal_3D_out_of_place_hermitian_interleaved_to_real)4318 TEST_F(accuracy_test_pow2_single, normal_3D_out_of_place_hermitian_interleaved_to_real)
4319 {
4320 try { normal_3D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
4321 catch( const std::exception& err ) { handle_exception(err); }
4322 }
4323
TEST_F(accuracy_test_pow2_double,normal_3D_out_of_place_hermitian_interleaved_to_real)4324 TEST_F(accuracy_test_pow2_double, normal_3D_out_of_place_hermitian_interleaved_to_real)
4325 {
4326 try { normal_3D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
4327 catch( const std::exception& err ) { handle_exception(err); }
4328 }
4329
4330 // *****************************************************
4331 // *****************************************************
4332 template< class T, class cl_T, class fftw_T >
normal_3D_out_of_place_real_to_hermitian_planar()4333 void normal_3D_out_of_place_real_to_hermitian_planar()
4334 {
4335 std::vector<size_t> lengths;
4336 lengths.push_back( normal2 );
4337 lengths.push_back( small2 );
4338 lengths.push_back( small2 );
4339 size_t batch = 1;
4340 std::vector<size_t> input_strides;
4341 std::vector<size_t> output_strides;
4342 size_t input_distance = 0;
4343 size_t output_distance = 0;
4344 layout::buffer_layout_t layout = layout::hermitian_planar;
4345 placeness::placeness_t placeness = placeness::out_of_place;
4346
4347 data_pattern pattern = sawtooth;
4348 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
4349 }
4350
TEST_F(accuracy_test_pow2_single,normal_3D_out_of_place_real_to_hermitian_planar)4351 TEST_F(accuracy_test_pow2_single, normal_3D_out_of_place_real_to_hermitian_planar)
4352 {
4353 try { normal_3D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
4354 catch( const std::exception& err ) { handle_exception(err); }
4355 }
4356
TEST_F(accuracy_test_pow2_double,normal_3D_out_of_place_real_to_hermitian_planar)4357 TEST_F(accuracy_test_pow2_double, normal_3D_out_of_place_real_to_hermitian_planar)
4358 {
4359 try { normal_3D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
4360 catch( const std::exception& err ) { handle_exception(err); }
4361 }
4362
4363 // *****************************************************
4364 // *****************************************************
4365 template< class T, class cl_T, class fftw_T >
normal_3D_out_of_place_hermitian_planar_to_real()4366 void normal_3D_out_of_place_hermitian_planar_to_real()
4367 {
4368 std::vector<size_t> lengths;
4369 lengths.push_back( small2 );
4370 lengths.push_back( normal2 );
4371 lengths.push_back( small2 );
4372 size_t batch = 1;
4373 std::vector<size_t> input_strides;
4374 std::vector<size_t> output_strides;
4375 size_t input_distance = 0;
4376 size_t output_distance = 0;
4377 layout::buffer_layout_t layout = layout::hermitian_planar;
4378 placeness::placeness_t placeness = placeness::out_of_place;
4379
4380 data_pattern pattern = sawtooth;
4381 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
4382 }
4383
TEST_F(accuracy_test_pow2_single,normal_3D_out_of_place_hermitian_planar_to_real)4384 TEST_F(accuracy_test_pow2_single, normal_3D_out_of_place_hermitian_planar_to_real)
4385 {
4386 try { normal_3D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
4387 catch( const std::exception& err ) { handle_exception(err); }
4388 }
4389
TEST_F(accuracy_test_pow2_double,normal_3D_out_of_place_hermitian_planar_to_real)4390 TEST_F(accuracy_test_pow2_double, normal_3D_out_of_place_hermitian_planar_to_real)
4391 {
4392 try { normal_3D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
4393 catch( const std::exception& err ) { handle_exception(err); }
4394 }
4395
4396 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
4397 // ^^^^^^^^^^^^^^^^^^^^^^^ small 3D ^^^^^^^^^^^^^^^^^^^^^^^ //
4398 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
4399
4400 // *****************************************************
4401 // *****************************************************
4402 template< class T, class cl_T, class fftw_T >
small_3D_forward_in_place_complex_planar_to_complex_planar()4403 void small_3D_forward_in_place_complex_planar_to_complex_planar()
4404 {
4405 std::vector<size_t> lengths;
4406 lengths.push_back( small2 );
4407 lengths.push_back( small2 );
4408 lengths.push_back( small2 );
4409 size_t batch = 1;
4410 std::vector<size_t> input_strides;
4411 std::vector<size_t> output_strides;
4412 size_t input_distance = 0;
4413 size_t output_distance = 0;
4414 layout::buffer_layout_t in_layout = layout::complex_planar;
4415 layout::buffer_layout_t out_layout = layout::complex_planar;
4416 placeness::placeness_t placeness = placeness::in_place;
4417 direction::direction_t direction = direction::forward;
4418
4419 data_pattern pattern = sawtooth;
4420 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4421 }
4422
TEST_F(accuracy_test_pow2_single,small_3D_forward_in_place_complex_planar_to_complex_planar)4423 TEST_F(accuracy_test_pow2_single, small_3D_forward_in_place_complex_planar_to_complex_planar)
4424 {
4425 try { small_3D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
4426 catch( const std::exception& err ) { handle_exception(err); }
4427 }
4428
TEST_F(accuracy_test_pow2_double,small_3D_forward_in_place_complex_planar_to_complex_planar)4429 TEST_F(accuracy_test_pow2_double, small_3D_forward_in_place_complex_planar_to_complex_planar)
4430 {
4431 try { small_3D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
4432 catch( const std::exception& err ) { handle_exception(err); }
4433 }
4434
4435 // *****************************************************
4436 // *****************************************************
4437 template< class T, class cl_T, class fftw_T >
small_3D_backward_in_place_complex_planar_to_complex_planar()4438 void small_3D_backward_in_place_complex_planar_to_complex_planar()
4439 {
4440 std::vector<size_t> lengths;
4441 lengths.push_back( small2 );
4442 lengths.push_back( small2 );
4443 lengths.push_back( small2 );
4444 size_t batch = 1;
4445 std::vector<size_t> input_strides;
4446 std::vector<size_t> output_strides;
4447 size_t input_distance = 0;
4448 size_t output_distance = 0;
4449 layout::buffer_layout_t in_layout = layout::complex_planar;
4450 layout::buffer_layout_t out_layout = layout::complex_planar;
4451 placeness::placeness_t placeness = placeness::in_place;
4452 direction::direction_t direction = direction::backward;
4453
4454 data_pattern pattern = sawtooth;
4455 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4456 }
4457
TEST_F(accuracy_test_pow2_single,small_3D_backward_in_place_complex_planar_to_complex_planar)4458 TEST_F(accuracy_test_pow2_single, small_3D_backward_in_place_complex_planar_to_complex_planar)
4459 {
4460 try { small_3D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
4461 catch( const std::exception& err ) { handle_exception(err); }
4462 }
4463
TEST_F(accuracy_test_pow2_double,small_3D_backward_in_place_complex_planar_to_complex_planar)4464 TEST_F(accuracy_test_pow2_double, small_3D_backward_in_place_complex_planar_to_complex_planar)
4465 {
4466 try { small_3D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
4467 catch( const std::exception& err ) { handle_exception(err); }
4468 }
4469
4470 // *****************************************************
4471 // *****************************************************
4472 template< class T, class cl_T, class fftw_T >
small_3D_forward_in_place_complex_interleaved_to_complex_interleaved()4473 void small_3D_forward_in_place_complex_interleaved_to_complex_interleaved()
4474 {
4475 std::vector<size_t> lengths;
4476 lengths.push_back( small2 );
4477 lengths.push_back( small2 );
4478 lengths.push_back( small2 );
4479 size_t batch = 1;
4480 std::vector<size_t> input_strides;
4481 std::vector<size_t> output_strides;
4482 size_t input_distance = 0;
4483 size_t output_distance = 0;
4484 layout::buffer_layout_t in_layout = layout::complex_interleaved;
4485 layout::buffer_layout_t out_layout = layout::complex_interleaved;
4486 placeness::placeness_t placeness = placeness::in_place;
4487 direction::direction_t direction = direction::forward;
4488
4489 data_pattern pattern = sawtooth;
4490 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4491 }
4492
TEST_F(accuracy_test_pow2_single,small_3D_forward_in_place_complex_interleaved_to_complex_interleaved)4493 TEST_F(accuracy_test_pow2_single, small_3D_forward_in_place_complex_interleaved_to_complex_interleaved)
4494 {
4495 try { small_3D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
4496 catch( const std::exception& err ) { handle_exception(err); }
4497 }
4498
TEST_F(accuracy_test_pow2_double,small_3D_forward_in_place_complex_interleaved_to_complex_interleaved)4499 TEST_F(accuracy_test_pow2_double, small_3D_forward_in_place_complex_interleaved_to_complex_interleaved)
4500 {
4501 try { small_3D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
4502 catch( const std::exception& err ) { handle_exception(err); }
4503 }
4504
4505 // *****************************************************
4506 // *****************************************************
4507 template< class T, class cl_T, class fftw_T >
small_3D_backward_in_place_complex_interleaved_to_complex_interleaved()4508 void small_3D_backward_in_place_complex_interleaved_to_complex_interleaved()
4509 {
4510 std::vector<size_t> lengths;
4511 lengths.push_back( small2 );
4512 lengths.push_back( small2 );
4513 lengths.push_back( small2 );
4514 size_t batch = 1;
4515 std::vector<size_t> input_strides;
4516 std::vector<size_t> output_strides;
4517 size_t input_distance = 0;
4518 size_t output_distance = 0;
4519 layout::buffer_layout_t in_layout = layout::complex_interleaved;
4520 layout::buffer_layout_t out_layout = layout::complex_interleaved;
4521 placeness::placeness_t placeness = placeness::in_place;
4522 direction::direction_t direction = direction::backward;
4523
4524 data_pattern pattern = sawtooth;
4525 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4526 }
4527
TEST_F(accuracy_test_pow2_single,small_3D_backward_in_place_complex_interleaved_to_complex_interleaved)4528 TEST_F(accuracy_test_pow2_single, small_3D_backward_in_place_complex_interleaved_to_complex_interleaved)
4529 {
4530 try { small_3D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
4531 catch( const std::exception& err ) { handle_exception(err); }
4532 }
4533
TEST_F(accuracy_test_pow2_double,small_3D_backward_in_place_complex_interleaved_to_complex_interleaved)4534 TEST_F(accuracy_test_pow2_double, small_3D_backward_in_place_complex_interleaved_to_complex_interleaved)
4535 {
4536 try { small_3D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
4537 catch( const std::exception& err ) { handle_exception(err); }
4538 }
4539
4540 // *****************************************************
4541 // *****************************************************
4542 template< class T, class cl_T, class fftw_T >
small_3D_forward_out_of_place_complex_planar_to_complex_planar()4543 void small_3D_forward_out_of_place_complex_planar_to_complex_planar()
4544 {
4545 std::vector<size_t> lengths;
4546 lengths.push_back( small2 );
4547 lengths.push_back( small2 );
4548 lengths.push_back( small2 );
4549 size_t batch = 1;
4550 std::vector<size_t> input_strides;
4551 std::vector<size_t> output_strides;
4552 size_t input_distance = 0;
4553 size_t output_distance = 0;
4554 layout::buffer_layout_t in_layout = layout::complex_planar;
4555 layout::buffer_layout_t out_layout = layout::complex_planar;
4556 placeness::placeness_t placeness = placeness::out_of_place;
4557 direction::direction_t direction = direction::forward;
4558
4559 data_pattern pattern = sawtooth;
4560 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4561 }
4562
TEST_F(accuracy_test_pow2_single,small_3D_forward_out_of_place_complex_planar_to_complex_planar)4563 TEST_F(accuracy_test_pow2_single, small_3D_forward_out_of_place_complex_planar_to_complex_planar)
4564 {
4565 try { small_3D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
4566 catch( const std::exception& err ) { handle_exception(err); }
4567 }
4568
TEST_F(accuracy_test_pow2_double,small_3D_forward_out_of_place_complex_planar_to_complex_planar)4569 TEST_F(accuracy_test_pow2_double, small_3D_forward_out_of_place_complex_planar_to_complex_planar)
4570 {
4571 try { small_3D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
4572 catch( const std::exception& err ) { handle_exception(err); }
4573 }
4574
4575 // *****************************************************
4576 // *****************************************************
4577 template< class T, class cl_T, class fftw_T >
small_3D_backward_out_of_place_complex_planar_to_complex_planar()4578 void small_3D_backward_out_of_place_complex_planar_to_complex_planar()
4579 {
4580 std::vector<size_t> lengths;
4581 lengths.push_back( small2 );
4582 lengths.push_back( small2 );
4583 lengths.push_back( small2 );
4584 size_t batch = 1;
4585 std::vector<size_t> input_strides;
4586 std::vector<size_t> output_strides;
4587 size_t input_distance = 0;
4588 size_t output_distance = 0;
4589 layout::buffer_layout_t in_layout = layout::complex_planar;
4590 layout::buffer_layout_t out_layout = layout::complex_planar;
4591 placeness::placeness_t placeness = placeness::out_of_place;
4592 direction::direction_t direction = direction::backward;
4593
4594 data_pattern pattern = sawtooth;
4595 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4596 }
4597
TEST_F(accuracy_test_pow2_single,small_3D_backward_out_of_place_complex_planar_to_complex_planar)4598 TEST_F(accuracy_test_pow2_single, small_3D_backward_out_of_place_complex_planar_to_complex_planar)
4599 {
4600 try { small_3D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
4601 catch( const std::exception& err ) { handle_exception(err); }
4602 }
4603
TEST_F(accuracy_test_pow2_double,small_3D_backward_out_of_place_complex_planar_to_complex_planar)4604 TEST_F(accuracy_test_pow2_double, small_3D_backward_out_of_place_complex_planar_to_complex_planar)
4605 {
4606 try { small_3D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
4607 catch( const std::exception& err ) { handle_exception(err); }
4608 }
4609
4610 // *****************************************************
4611 // *****************************************************
4612 template< class T, class cl_T, class fftw_T >
small_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved()4613 void small_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
4614 {
4615 std::vector<size_t> lengths;
4616 lengths.push_back( small2 );
4617 lengths.push_back( small2 );
4618 lengths.push_back( small2 );
4619 size_t batch = 1;
4620 std::vector<size_t> input_strides;
4621 std::vector<size_t> output_strides;
4622 size_t input_distance = 0;
4623 size_t output_distance = 0;
4624 layout::buffer_layout_t in_layout = layout::complex_interleaved;
4625 layout::buffer_layout_t out_layout = layout::complex_interleaved;
4626 placeness::placeness_t placeness = placeness::out_of_place;
4627 direction::direction_t direction = direction::forward;
4628
4629 data_pattern pattern = sawtooth;
4630 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4631 }
4632
TEST_F(accuracy_test_pow2_single,small_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)4633 TEST_F(accuracy_test_pow2_single, small_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
4634 {
4635 try { small_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
4636 catch( const std::exception& err ) { handle_exception(err); }
4637 }
4638
TEST_F(accuracy_test_pow2_double,small_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)4639 TEST_F(accuracy_test_pow2_double, small_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
4640 {
4641 try { small_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
4642 catch( const std::exception& err ) { handle_exception(err); }
4643 }
4644
4645 // *****************************************************
4646 // *****************************************************
4647 template< class T, class cl_T, class fftw_T >
small_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved()4648 void small_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
4649 {
4650 std::vector<size_t> lengths;
4651 lengths.push_back( small2 );
4652 lengths.push_back( small2 );
4653 lengths.push_back( small2 );
4654 size_t batch = 1;
4655 std::vector<size_t> input_strides;
4656 std::vector<size_t> output_strides;
4657 size_t input_distance = 0;
4658 size_t output_distance = 0;
4659 layout::buffer_layout_t in_layout = layout::complex_interleaved;
4660 layout::buffer_layout_t out_layout = layout::complex_interleaved;
4661 placeness::placeness_t placeness = placeness::out_of_place;
4662 direction::direction_t direction = direction::backward;
4663
4664 data_pattern pattern = sawtooth;
4665 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4666 }
4667
TEST_F(accuracy_test_pow2_single,small_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)4668 TEST_F(accuracy_test_pow2_single, small_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
4669 {
4670 try { small_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
4671 catch( const std::exception& err ) { handle_exception(err); }
4672 }
4673
TEST_F(accuracy_test_pow2_double,small_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)4674 TEST_F(accuracy_test_pow2_double, small_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
4675 {
4676 try { small_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
4677 catch( const std::exception& err ) { handle_exception(err); }
4678 }
4679
4680 // *****************************************************
4681 // *****************************************************
4682 template< class T, class cl_T, class fftw_T >
small_3D_forward_out_of_place_complex_planar_to_complex_interleaved()4683 void small_3D_forward_out_of_place_complex_planar_to_complex_interleaved()
4684 {
4685 std::vector<size_t> lengths;
4686 lengths.push_back( small2 );
4687 lengths.push_back( small2 );
4688 lengths.push_back( small2 );
4689 size_t batch = 1;
4690 std::vector<size_t> input_strides;
4691 std::vector<size_t> output_strides;
4692 size_t input_distance = 0;
4693 size_t output_distance = 0;
4694 layout::buffer_layout_t in_layout = layout::complex_planar;
4695 layout::buffer_layout_t out_layout = layout::complex_interleaved;
4696 placeness::placeness_t placeness = placeness::out_of_place;
4697 direction::direction_t direction = direction::forward;
4698
4699 data_pattern pattern = sawtooth;
4700 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4701 }
4702
TEST_F(accuracy_test_pow2_single,small_3D_forward_out_of_place_complex_planar_to_complex_interleaved)4703 TEST_F(accuracy_test_pow2_single, small_3D_forward_out_of_place_complex_planar_to_complex_interleaved)
4704 {
4705 try { small_3D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
4706 catch( const std::exception& err ) { handle_exception(err); }
4707 }
4708
TEST_F(accuracy_test_pow2_double,small_3D_forward_out_of_place_complex_planar_to_complex_interleaved)4709 TEST_F(accuracy_test_pow2_double, small_3D_forward_out_of_place_complex_planar_to_complex_interleaved)
4710 {
4711 try { small_3D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
4712 catch( const std::exception& err ) { handle_exception(err); }
4713 }
4714
4715 // *****************************************************
4716 // *****************************************************
4717 template< class T, class cl_T, class fftw_T >
small_3D_backward_out_of_place_complex_planar_to_complex_interleaved()4718 void small_3D_backward_out_of_place_complex_planar_to_complex_interleaved()
4719 {
4720 std::vector<size_t> lengths;
4721 lengths.push_back( small2 );
4722 lengths.push_back( small2 );
4723 lengths.push_back( small2 );
4724 size_t batch = 1;
4725 std::vector<size_t> input_strides;
4726 std::vector<size_t> output_strides;
4727 size_t input_distance = 0;
4728 size_t output_distance = 0;
4729 layout::buffer_layout_t in_layout = layout::complex_planar;
4730 layout::buffer_layout_t out_layout = layout::complex_interleaved;
4731 placeness::placeness_t placeness = placeness::out_of_place;
4732 direction::direction_t direction = direction::backward;
4733
4734 data_pattern pattern = sawtooth;
4735 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4736 }
4737
TEST_F(accuracy_test_pow2_single,small_3D_backward_out_of_place_complex_planar_to_complex_interleaved)4738 TEST_F(accuracy_test_pow2_single, small_3D_backward_out_of_place_complex_planar_to_complex_interleaved)
4739 {
4740 try { small_3D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
4741 catch( const std::exception& err ) { handle_exception(err); }
4742 }
4743
TEST_F(accuracy_test_pow2_double,small_3D_backward_out_of_place_complex_planar_to_complex_interleaved)4744 TEST_F(accuracy_test_pow2_double, small_3D_backward_out_of_place_complex_planar_to_complex_interleaved)
4745 {
4746 try { small_3D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
4747 catch( const std::exception& err ) { handle_exception(err); }
4748 }
4749
4750 // *****************************************************
4751 // *****************************************************
4752 template< class T, class cl_T, class fftw_T >
small_3D_forward_out_of_place_complex_interleaved_to_complex_planar()4753 void small_3D_forward_out_of_place_complex_interleaved_to_complex_planar()
4754 {
4755 std::vector<size_t> lengths;
4756 lengths.push_back( small2 );
4757 lengths.push_back( small2 );
4758 lengths.push_back( small2 );
4759 size_t batch = 1;
4760 std::vector<size_t> input_strides;
4761 std::vector<size_t> output_strides;
4762 size_t input_distance = 0;
4763 size_t output_distance = 0;
4764 layout::buffer_layout_t in_layout = layout::complex_interleaved;
4765 layout::buffer_layout_t out_layout = layout::complex_planar;
4766 placeness::placeness_t placeness = placeness::out_of_place;
4767 direction::direction_t direction = direction::forward;
4768
4769 data_pattern pattern = sawtooth;
4770 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4771 }
4772
TEST_F(accuracy_test_pow2_single,small_3D_forward_out_of_place_complex_interleaved_to_complex_planar)4773 TEST_F(accuracy_test_pow2_single, small_3D_forward_out_of_place_complex_interleaved_to_complex_planar)
4774 {
4775 try { small_3D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
4776 catch( const std::exception& err ) { handle_exception(err); }
4777 }
4778
TEST_F(accuracy_test_pow2_double,small_3D_forward_out_of_place_complex_interleaved_to_complex_planar)4779 TEST_F(accuracy_test_pow2_double, small_3D_forward_out_of_place_complex_interleaved_to_complex_planar)
4780 {
4781 try { small_3D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
4782 catch( const std::exception& err ) { handle_exception(err); }
4783 }
4784
4785 // *****************************************************
4786 // *****************************************************
4787 template< class T, class cl_T, class fftw_T >
small_3D_backward_out_of_place_complex_interleaved_to_complex_planar()4788 void small_3D_backward_out_of_place_complex_interleaved_to_complex_planar()
4789 {
4790 std::vector<size_t> lengths;
4791 lengths.push_back( small2 );
4792 lengths.push_back( small2 );
4793 lengths.push_back( small2 );
4794 size_t batch = 1;
4795 std::vector<size_t> input_strides;
4796 std::vector<size_t> output_strides;
4797 size_t input_distance = 0;
4798 size_t output_distance = 0;
4799 layout::buffer_layout_t in_layout = layout::complex_interleaved;
4800 layout::buffer_layout_t out_layout = layout::complex_planar;
4801 placeness::placeness_t placeness = placeness::out_of_place;
4802 direction::direction_t direction = direction::backward;
4803
4804 data_pattern pattern = sawtooth;
4805 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
4806 }
4807
TEST_F(accuracy_test_pow2_single,small_3D_backward_out_of_place_complex_interleaved_to_complex_planar)4808 TEST_F(accuracy_test_pow2_single, small_3D_backward_out_of_place_complex_interleaved_to_complex_planar)
4809 {
4810 try { small_3D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
4811 catch( const std::exception& err ) { handle_exception(err); }
4812 }
4813
TEST_F(accuracy_test_pow2_double,small_3D_backward_out_of_place_complex_interleaved_to_complex_planar)4814 TEST_F(accuracy_test_pow2_double, small_3D_backward_out_of_place_complex_interleaved_to_complex_planar)
4815 {
4816 try { small_3D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
4817 catch( const std::exception& err ) { handle_exception(err); }
4818 }
4819
4820 // *****************************************************
4821 // *****************************************************
4822 template< class T, class cl_T, class fftw_T >
small_3D_in_place_real_to_hermitian_interleaved()4823 void small_3D_in_place_real_to_hermitian_interleaved()
4824 {
4825 std::vector<size_t> lengths;
4826 lengths.push_back( small2 );
4827 lengths.push_back( small2 );
4828 lengths.push_back( small2 );
4829 size_t batch = 1;
4830 std::vector<size_t> input_strides;
4831 std::vector<size_t> output_strides;
4832 size_t input_distance = 0;
4833 size_t output_distance = 0;
4834 layout::buffer_layout_t layout = layout::hermitian_interleaved;
4835 placeness::placeness_t placeness = placeness::in_place;
4836
4837 data_pattern pattern = sawtooth;
4838 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
4839 }
4840
TEST_F(accuracy_test_pow2_single,_small_3D_in_place_real_to_hermitian_interleaved)4841 TEST_F(accuracy_test_pow2_single, _small_3D_in_place_real_to_hermitian_interleaved)
4842 {
4843 try { small_3D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
4844 catch( const std::exception& err ) { handle_exception(err); }
4845 }
4846
TEST_F(accuracy_test_pow2_double,_small_3D_in_place_real_to_hermitian_interleaved)4847 TEST_F(accuracy_test_pow2_double, _small_3D_in_place_real_to_hermitian_interleaved)
4848 {
4849 try { small_3D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
4850 catch( const std::exception& err ) { handle_exception(err); }
4851 }
4852
4853 // *****************************************************
4854 // *****************************************************
4855 template< class T, class cl_T, class fftw_T >
small_3D_in_place_hermitian_interleaved_to_real()4856 void small_3D_in_place_hermitian_interleaved_to_real()
4857 {
4858 std::vector<size_t> lengths;
4859 lengths.push_back( small2 );
4860 lengths.push_back( small2 );
4861 lengths.push_back( small2 );
4862 size_t batch = 1;
4863 std::vector<size_t> input_strides;
4864 std::vector<size_t> output_strides;
4865 size_t input_distance = 0;
4866 size_t output_distance = 0;
4867 layout::buffer_layout_t layout = layout::hermitian_interleaved;
4868 placeness::placeness_t placeness = placeness::in_place;
4869
4870 data_pattern pattern = sawtooth;
4871 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
4872 }
4873
TEST_F(accuracy_test_pow2_single,_small_3D_in_place_hermitian_interleaved_to_real)4874 TEST_F(accuracy_test_pow2_single, _small_3D_in_place_hermitian_interleaved_to_real)
4875 {
4876 try { small_3D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
4877 catch( const std::exception& err ) { handle_exception(err); }
4878 }
4879
TEST_F(accuracy_test_pow2_double,_small_3D_in_place_hermitian_interleaved_to_real)4880 TEST_F(accuracy_test_pow2_double, _small_3D_in_place_hermitian_interleaved_to_real)
4881 {
4882 try { small_3D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
4883 catch( const std::exception& err ) { handle_exception(err); }
4884 }
4885
4886 // *****************************************************
4887 // *****************************************************
4888 template< class T, class cl_T, class fftw_T >
small_3D_out_of_place_real_to_hermitian_interleaved()4889 void small_3D_out_of_place_real_to_hermitian_interleaved()
4890 {
4891 std::vector<size_t> lengths;
4892 lengths.push_back( small2 );
4893 lengths.push_back( small2 );
4894 lengths.push_back( small2 );
4895 size_t batch = 1;
4896 std::vector<size_t> input_strides;
4897 std::vector<size_t> output_strides;
4898 size_t input_distance = 0;
4899 size_t output_distance = 0;
4900 layout::buffer_layout_t layout = layout::hermitian_interleaved;
4901 placeness::placeness_t placeness = placeness::out_of_place;
4902
4903 data_pattern pattern = sawtooth;
4904 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
4905 }
4906
TEST_F(accuracy_test_pow2_single,_small_3D_out_of_place_real_to_hermitian_interleaved)4907 TEST_F(accuracy_test_pow2_single, _small_3D_out_of_place_real_to_hermitian_interleaved)
4908 {
4909 try { small_3D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
4910 catch( const std::exception& err ) { handle_exception(err); }
4911 }
4912
TEST_F(accuracy_test_pow2_double,_small_3D_out_of_place_real_to_hermitian_interleaved)4913 TEST_F(accuracy_test_pow2_double, _small_3D_out_of_place_real_to_hermitian_interleaved)
4914 {
4915 try { small_3D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
4916 catch( const std::exception& err ) { handle_exception(err); }
4917 }
4918
4919 // *****************************************************
4920 // *****************************************************
4921 template< class T, class cl_T, class fftw_T >
small_3D_out_of_place_hermitian_interleaved_to_real()4922 void small_3D_out_of_place_hermitian_interleaved_to_real()
4923 {
4924 std::vector<size_t> lengths;
4925 lengths.push_back( small2 );
4926 lengths.push_back( small2 );
4927 lengths.push_back( small2 );
4928 size_t batch = 1;
4929 std::vector<size_t> input_strides;
4930 std::vector<size_t> output_strides;
4931 size_t input_distance = 0;
4932 size_t output_distance = 0;
4933 layout::buffer_layout_t layout = layout::hermitian_interleaved;
4934 placeness::placeness_t placeness = placeness::out_of_place;
4935
4936 data_pattern pattern = sawtooth;
4937 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
4938 }
4939
TEST_F(accuracy_test_pow2_single,_small_3D_out_of_place_hermitian_interleaved_to_real)4940 TEST_F(accuracy_test_pow2_single, _small_3D_out_of_place_hermitian_interleaved_to_real)
4941 {
4942 try { small_3D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
4943 catch( const std::exception& err ) { handle_exception(err); }
4944 }
4945
TEST_F(accuracy_test_pow2_double,_small_3D_out_of_place_hermitian_interleaved_to_real)4946 TEST_F(accuracy_test_pow2_double, _small_3D_out_of_place_hermitian_interleaved_to_real)
4947 {
4948 try { small_3D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
4949 catch( const std::exception& err ) { handle_exception(err); }
4950 }
4951
4952 // *****************************************************
4953 // *****************************************************
4954 template< class T, class cl_T, class fftw_T >
small_3D_out_of_place_real_to_hermitian_planar()4955 void small_3D_out_of_place_real_to_hermitian_planar()
4956 {
4957 std::vector<size_t> lengths;
4958 lengths.push_back( small2 );
4959 lengths.push_back( small2 );
4960 lengths.push_back( small2 );
4961 size_t batch = 1;
4962 std::vector<size_t> input_strides;
4963 std::vector<size_t> output_strides;
4964 size_t input_distance = 0;
4965 size_t output_distance = 0;
4966 layout::buffer_layout_t layout = layout::hermitian_planar;
4967 placeness::placeness_t placeness = placeness::out_of_place;
4968
4969 data_pattern pattern = sawtooth;
4970 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
4971 }
4972
TEST_F(accuracy_test_pow2_single,_small_3D_out_of_place_real_to_hermitian_planar)4973 TEST_F(accuracy_test_pow2_single, _small_3D_out_of_place_real_to_hermitian_planar)
4974 {
4975 try { small_3D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
4976 catch( const std::exception& err ) { handle_exception(err); }
4977 }
4978
TEST_F(accuracy_test_pow2_double,_small_3D_out_of_place_real_to_hermitian_planar)4979 TEST_F(accuracy_test_pow2_double, _small_3D_out_of_place_real_to_hermitian_planar)
4980 {
4981 try { small_3D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
4982 catch( const std::exception& err ) { handle_exception(err); }
4983 }
4984
4985 // *****************************************************
4986 // *****************************************************
4987 template< class T, class cl_T, class fftw_T >
small_3D_out_of_place_hermitian_planar_to_real()4988 void small_3D_out_of_place_hermitian_planar_to_real()
4989 {
4990 std::vector<size_t> lengths;
4991 lengths.push_back( small2 );
4992 lengths.push_back( small2 );
4993 lengths.push_back( small2 );
4994 size_t batch = 1;
4995 std::vector<size_t> input_strides;
4996 std::vector<size_t> output_strides;
4997 size_t input_distance = 0;
4998 size_t output_distance = 0;
4999 layout::buffer_layout_t layout = layout::hermitian_planar;
5000 placeness::placeness_t placeness = placeness::out_of_place;
5001
5002 data_pattern pattern = sawtooth;
5003 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5004 }
5005
TEST_F(accuracy_test_pow2_single,_small_3D_out_of_place_hermitian_planar_to_real)5006 TEST_F(accuracy_test_pow2_single, _small_3D_out_of_place_hermitian_planar_to_real)
5007 {
5008 try { small_3D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
5009 catch( const std::exception& err ) { handle_exception(err); }
5010 }
5011
TEST_F(accuracy_test_pow2_double,_small_3D_out_of_place_hermitian_planar_to_real)5012 TEST_F(accuracy_test_pow2_double, _small_3D_out_of_place_hermitian_planar_to_real)
5013 {
5014 try { small_3D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
5015 catch( const std::exception& err ) { handle_exception(err); }
5016 }
5017
5018 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
5019 // ^^^^^^^^^^^^^^^^^^^^^^^ large 3D ^^^^^^^^^^^^^^^^^^^^^^^ //
5020 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
5021
5022 // *****************************************************
5023 // *****************************************************
5024 template< class T, class cl_T, class fftw_T >
large_3D_forward_in_place_complex_planar_to_complex_planar()5025 void large_3D_forward_in_place_complex_planar_to_complex_planar()
5026 {
5027 std::vector<size_t> lengths;
5028 lengths.push_back( large2 );
5029 lengths.push_back( 2 );
5030 lengths.push_back( 2 );
5031 size_t batch = 1;
5032 std::vector<size_t> input_strides;
5033 std::vector<size_t> output_strides;
5034 size_t input_distance = 0;
5035 size_t output_distance = 0;
5036 layout::buffer_layout_t in_layout = layout::complex_planar;
5037 layout::buffer_layout_t out_layout = layout::complex_planar;
5038 placeness::placeness_t placeness = placeness::in_place;
5039 direction::direction_t direction = direction::forward;
5040
5041 data_pattern pattern = sawtooth;
5042 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5043 }
5044
TEST_F(accuracy_test_pow2_single,large_3D_forward_in_place_complex_planar_to_complex_planar)5045 TEST_F(accuracy_test_pow2_single, large_3D_forward_in_place_complex_planar_to_complex_planar)
5046 {
5047 try { large_3D_forward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
5048 catch( const std::exception& err ) { handle_exception(err); }
5049 }
5050
TEST_F(accuracy_test_pow2_double,large_3D_forward_in_place_complex_planar_to_complex_planar)5051 TEST_F(accuracy_test_pow2_double, large_3D_forward_in_place_complex_planar_to_complex_planar)
5052 {
5053 try { large_3D_forward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
5054 catch( const std::exception& err ) { handle_exception(err); }
5055 }
5056
5057 // *****************************************************
5058 // *****************************************************
5059 template< class T, class cl_T, class fftw_T >
large_3D_backward_in_place_complex_planar_to_complex_planar()5060 void large_3D_backward_in_place_complex_planar_to_complex_planar()
5061 {
5062 std::vector<size_t> lengths;
5063 lengths.push_back( large2 );
5064 lengths.push_back( 2 );
5065 lengths.push_back( 2 );
5066 size_t batch = 1;
5067 std::vector<size_t> input_strides;
5068 std::vector<size_t> output_strides;
5069 size_t input_distance = 0;
5070 size_t output_distance = 0;
5071 layout::buffer_layout_t in_layout = layout::complex_planar;
5072 layout::buffer_layout_t out_layout = layout::complex_planar;
5073 placeness::placeness_t placeness = placeness::in_place;
5074 direction::direction_t direction = direction::backward;
5075
5076 data_pattern pattern = sawtooth;
5077 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5078 }
5079
TEST_F(accuracy_test_pow2_single,large_3D_backward_in_place_complex_planar_to_complex_planar)5080 TEST_F(accuracy_test_pow2_single, large_3D_backward_in_place_complex_planar_to_complex_planar)
5081 {
5082 try { large_3D_backward_in_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
5083 catch( const std::exception& err ) { handle_exception(err); }
5084 }
5085
TEST_F(accuracy_test_pow2_double,large_3D_backward_in_place_complex_planar_to_complex_planar)5086 TEST_F(accuracy_test_pow2_double, large_3D_backward_in_place_complex_planar_to_complex_planar)
5087 {
5088 try { large_3D_backward_in_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
5089 catch( const std::exception& err ) { handle_exception(err); }
5090 }
5091
5092 // *****************************************************
5093 // *****************************************************
5094 template< class T, class cl_T, class fftw_T >
large_3D_forward_in_place_complex_interleaved_to_complex_interleaved()5095 void large_3D_forward_in_place_complex_interleaved_to_complex_interleaved()
5096 {
5097 std::vector<size_t> lengths;
5098 lengths.push_back( large2 );
5099 lengths.push_back( 2 );
5100 lengths.push_back( 2 );
5101 size_t batch = 1;
5102 std::vector<size_t> input_strides;
5103 std::vector<size_t> output_strides;
5104 size_t input_distance = 0;
5105 size_t output_distance = 0;
5106 layout::buffer_layout_t in_layout = layout::complex_interleaved;
5107 layout::buffer_layout_t out_layout = layout::complex_interleaved;
5108 placeness::placeness_t placeness = placeness::in_place;
5109 direction::direction_t direction = direction::forward;
5110
5111 data_pattern pattern = sawtooth;
5112 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5113 }
5114
TEST_F(accuracy_test_pow2_single,large_3D_forward_in_place_complex_interleaved_to_complex_interleaved)5115 TEST_F(accuracy_test_pow2_single, large_3D_forward_in_place_complex_interleaved_to_complex_interleaved)
5116 {
5117 try { large_3D_forward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
5118 catch( const std::exception& err ) { handle_exception(err); }
5119 }
5120
TEST_F(accuracy_test_pow2_double,large_3D_forward_in_place_complex_interleaved_to_complex_interleaved)5121 TEST_F(accuracy_test_pow2_double, large_3D_forward_in_place_complex_interleaved_to_complex_interleaved)
5122 {
5123 try { large_3D_forward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
5124 catch( const std::exception& err ) { handle_exception(err); }
5125 }
5126
5127 // *****************************************************
5128 // *****************************************************
5129 template< class T, class cl_T, class fftw_T >
large_3D_backward_in_place_complex_interleaved_to_complex_interleaved()5130 void large_3D_backward_in_place_complex_interleaved_to_complex_interleaved()
5131 {
5132 std::vector<size_t> lengths;
5133 lengths.push_back( large2 );
5134 lengths.push_back( 2 );
5135 lengths.push_back( 2 );
5136 size_t batch = 1;
5137 std::vector<size_t> input_strides;
5138 std::vector<size_t> output_strides;
5139 size_t input_distance = 0;
5140 size_t output_distance = 0;
5141 layout::buffer_layout_t in_layout = layout::complex_interleaved;
5142 layout::buffer_layout_t out_layout = layout::complex_interleaved;
5143 placeness::placeness_t placeness = placeness::in_place;
5144 direction::direction_t direction = direction::backward;
5145
5146 data_pattern pattern = sawtooth;
5147 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5148 }
5149
TEST_F(accuracy_test_pow2_single,large_3D_backward_in_place_complex_interleaved_to_complex_interleaved)5150 TEST_F(accuracy_test_pow2_single, large_3D_backward_in_place_complex_interleaved_to_complex_interleaved)
5151 {
5152 try { large_3D_backward_in_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
5153 catch( const std::exception& err ) { handle_exception(err); }
5154 }
5155
TEST_F(accuracy_test_pow2_double,large_3D_backward_in_place_complex_interleaved_to_complex_interleaved)5156 TEST_F(accuracy_test_pow2_double, large_3D_backward_in_place_complex_interleaved_to_complex_interleaved)
5157 {
5158 try { large_3D_backward_in_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
5159 catch( const std::exception& err ) { handle_exception(err); }
5160 }
5161
5162 // *****************************************************
5163 // *****************************************************
5164 template< class T, class cl_T, class fftw_T >
large_3D_forward_out_of_place_complex_planar_to_complex_planar()5165 void large_3D_forward_out_of_place_complex_planar_to_complex_planar()
5166 {
5167 std::vector<size_t> lengths;
5168 lengths.push_back( large2 );
5169 lengths.push_back( 2 );
5170 lengths.push_back( 2 );
5171 size_t batch = 1;
5172 std::vector<size_t> input_strides;
5173 std::vector<size_t> output_strides;
5174 size_t input_distance = 0;
5175 size_t output_distance = 0;
5176 layout::buffer_layout_t in_layout = layout::complex_planar;
5177 layout::buffer_layout_t out_layout = layout::complex_planar;
5178 placeness::placeness_t placeness = placeness::out_of_place;
5179 direction::direction_t direction = direction::forward;
5180
5181 data_pattern pattern = sawtooth;
5182 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5183 }
5184
TEST_F(accuracy_test_pow2_single,large_3D_forward_out_of_place_complex_planar_to_complex_planar)5185 TEST_F(accuracy_test_pow2_single, large_3D_forward_out_of_place_complex_planar_to_complex_planar)
5186 {
5187 try { large_3D_forward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
5188 catch( const std::exception& err ) { handle_exception(err); }
5189 }
5190
TEST_F(accuracy_test_pow2_double,large_3D_forward_out_of_place_complex_planar_to_complex_planar)5191 TEST_F(accuracy_test_pow2_double, large_3D_forward_out_of_place_complex_planar_to_complex_planar)
5192 {
5193 try { large_3D_forward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
5194 catch( const std::exception& err ) { handle_exception(err); }
5195 }
5196
5197 // *****************************************************
5198 // *****************************************************
5199 template< class T, class cl_T, class fftw_T >
large_3D_backward_out_of_place_complex_planar_to_complex_planar()5200 void large_3D_backward_out_of_place_complex_planar_to_complex_planar()
5201 {
5202 std::vector<size_t> lengths;
5203 lengths.push_back( large2 );
5204 lengths.push_back( 2 );
5205 lengths.push_back( 2 );
5206 size_t batch = 1;
5207 std::vector<size_t> input_strides;
5208 std::vector<size_t> output_strides;
5209 size_t input_distance = 0;
5210 size_t output_distance = 0;
5211 layout::buffer_layout_t in_layout = layout::complex_planar;
5212 layout::buffer_layout_t out_layout = layout::complex_planar;
5213 placeness::placeness_t placeness = placeness::out_of_place;
5214 direction::direction_t direction = direction::backward;
5215
5216 data_pattern pattern = sawtooth;
5217 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5218 }
5219
TEST_F(accuracy_test_pow2_single,large_3D_backward_out_of_place_complex_planar_to_complex_planar)5220 TEST_F(accuracy_test_pow2_single, large_3D_backward_out_of_place_complex_planar_to_complex_planar)
5221 {
5222 try { large_3D_backward_out_of_place_complex_planar_to_complex_planar< float, cl_float, fftwf_complex >(); }
5223 catch( const std::exception& err ) { handle_exception(err); }
5224 }
5225
TEST_F(accuracy_test_pow2_double,large_3D_backward_out_of_place_complex_planar_to_complex_planar)5226 TEST_F(accuracy_test_pow2_double, large_3D_backward_out_of_place_complex_planar_to_complex_planar)
5227 {
5228 try { large_3D_backward_out_of_place_complex_planar_to_complex_planar< double, cl_double, fftw_complex >(); }
5229 catch( const std::exception& err ) { handle_exception(err); }
5230 }
5231
5232 // *****************************************************
5233 // *****************************************************
5234 template< class T, class cl_T, class fftw_T >
large_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved()5235 void large_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved()
5236 {
5237 std::vector<size_t> lengths;
5238 lengths.push_back( large2 );
5239 lengths.push_back( 2 );
5240 lengths.push_back( 2 );
5241 size_t batch = 1;
5242 std::vector<size_t> input_strides;
5243 std::vector<size_t> output_strides;
5244 size_t input_distance = 0;
5245 size_t output_distance = 0;
5246 layout::buffer_layout_t in_layout = layout::complex_interleaved;
5247 layout::buffer_layout_t out_layout = layout::complex_interleaved;
5248 placeness::placeness_t placeness = placeness::out_of_place;
5249 direction::direction_t direction = direction::forward;
5250
5251 data_pattern pattern = sawtooth;
5252 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5253 }
5254
TEST_F(accuracy_test_pow2_single,large_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)5255 TEST_F(accuracy_test_pow2_single, large_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
5256 {
5257 try { large_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
5258 catch( const std::exception& err ) { handle_exception(err); }
5259 }
5260
TEST_F(accuracy_test_pow2_double,large_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)5261 TEST_F(accuracy_test_pow2_double, large_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved)
5262 {
5263 try { large_3D_forward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
5264 catch( const std::exception& err ) { handle_exception(err); }
5265 }
5266
5267 // *****************************************************
5268 // *****************************************************
5269 template< class T, class cl_T, class fftw_T >
large_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved()5270 void large_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved()
5271 {
5272 std::vector<size_t> lengths;
5273 lengths.push_back( large2 );
5274 lengths.push_back( 2 );
5275 lengths.push_back( 2 );
5276 size_t batch = 1;
5277 std::vector<size_t> input_strides;
5278 std::vector<size_t> output_strides;
5279 size_t input_distance = 0;
5280 size_t output_distance = 0;
5281 layout::buffer_layout_t in_layout = layout::complex_interleaved;
5282 layout::buffer_layout_t out_layout = layout::complex_interleaved;
5283 placeness::placeness_t placeness = placeness::out_of_place;
5284 direction::direction_t direction = direction::backward;
5285
5286 data_pattern pattern = sawtooth;
5287 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5288 }
5289
TEST_F(accuracy_test_pow2_single,large_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)5290 TEST_F(accuracy_test_pow2_single, large_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
5291 {
5292 try { large_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
5293 catch( const std::exception& err ) { handle_exception(err); }
5294 }
5295
TEST_F(accuracy_test_pow2_double,large_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)5296 TEST_F(accuracy_test_pow2_double, large_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved)
5297 {
5298 try { large_3D_backward_out_of_place_complex_interleaved_to_complex_interleaved< double, cl_double, fftw_complex >(); }
5299 catch( const std::exception& err ) { handle_exception(err); }
5300 }
5301
5302 // *****************************************************
5303 // *****************************************************
5304 template< class T, class cl_T, class fftw_T >
large_3D_forward_out_of_place_complex_planar_to_complex_interleaved()5305 void large_3D_forward_out_of_place_complex_planar_to_complex_interleaved()
5306 {
5307 std::vector<size_t> lengths;
5308 lengths.push_back( large2 );
5309 lengths.push_back( 2 );
5310 lengths.push_back( 2 );
5311 size_t batch = 1;
5312 std::vector<size_t> input_strides;
5313 std::vector<size_t> output_strides;
5314 size_t input_distance = 0;
5315 size_t output_distance = 0;
5316 layout::buffer_layout_t in_layout = layout::complex_planar;
5317 layout::buffer_layout_t out_layout = layout::complex_interleaved;
5318 placeness::placeness_t placeness = placeness::out_of_place;
5319 direction::direction_t direction = direction::forward;
5320
5321 data_pattern pattern = sawtooth;
5322 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5323 }
5324
TEST_F(accuracy_test_pow2_single,large_3D_forward_out_of_place_complex_planar_to_complex_interleaved)5325 TEST_F(accuracy_test_pow2_single, large_3D_forward_out_of_place_complex_planar_to_complex_interleaved)
5326 {
5327 try { large_3D_forward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
5328 catch( const std::exception& err ) { handle_exception(err); }
5329 }
5330
TEST_F(accuracy_test_pow2_double,large_3D_forward_out_of_place_complex_planar_to_complex_interleaved)5331 TEST_F(accuracy_test_pow2_double, large_3D_forward_out_of_place_complex_planar_to_complex_interleaved)
5332 {
5333 try { large_3D_forward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
5334 catch( const std::exception& err ) { handle_exception(err); }
5335 }
5336
5337 // *****************************************************
5338 // *****************************************************
5339 template< class T, class cl_T, class fftw_T >
large_3D_backward_out_of_place_complex_planar_to_complex_interleaved()5340 void large_3D_backward_out_of_place_complex_planar_to_complex_interleaved()
5341 {
5342 std::vector<size_t> lengths;
5343 lengths.push_back( 2 );
5344 lengths.push_back( 2 );
5345 lengths.push_back( large2 );
5346 size_t batch = 1;
5347 std::vector<size_t> input_strides;
5348 std::vector<size_t> output_strides;
5349 size_t input_distance = 0;
5350 size_t output_distance = 0;
5351 layout::buffer_layout_t in_layout = layout::complex_planar;
5352 layout::buffer_layout_t out_layout = layout::complex_interleaved;
5353 placeness::placeness_t placeness = placeness::out_of_place;
5354 direction::direction_t direction = direction::backward;
5355
5356 data_pattern pattern = sawtooth;
5357 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5358 }
5359
TEST_F(accuracy_test_pow2_single,large_3D_backward_out_of_place_complex_planar_to_complex_interleaved)5360 TEST_F(accuracy_test_pow2_single, large_3D_backward_out_of_place_complex_planar_to_complex_interleaved)
5361 {
5362 try { large_3D_backward_out_of_place_complex_planar_to_complex_interleaved< float, cl_float, fftwf_complex >(); }
5363 catch( const std::exception& err ) { handle_exception(err); }
5364 }
5365
TEST_F(accuracy_test_pow2_double,large_3D_backward_out_of_place_complex_planar_to_complex_interleaved)5366 TEST_F(accuracy_test_pow2_double, large_3D_backward_out_of_place_complex_planar_to_complex_interleaved)
5367 {
5368 try { large_3D_backward_out_of_place_complex_planar_to_complex_interleaved< double, cl_double, fftw_complex >(); }
5369 catch( const std::exception& err ) { handle_exception(err); }
5370 }
5371
5372 // *****************************************************
5373 // *****************************************************
5374 template< class T, class cl_T, class fftw_T >
large_3D_forward_out_of_place_complex_interleaved_to_complex_planar()5375 void large_3D_forward_out_of_place_complex_interleaved_to_complex_planar()
5376 {
5377 std::vector<size_t> lengths;
5378 lengths.push_back( 2 );
5379 lengths.push_back( large2 );
5380 lengths.push_back( 2 );
5381 size_t batch = 1;
5382 std::vector<size_t> input_strides;
5383 std::vector<size_t> output_strides;
5384 size_t input_distance = 0;
5385 size_t output_distance = 0;
5386 layout::buffer_layout_t in_layout = layout::complex_interleaved;
5387 layout::buffer_layout_t out_layout = layout::complex_planar;
5388 placeness::placeness_t placeness = placeness::out_of_place;
5389 direction::direction_t direction = direction::forward;
5390
5391 data_pattern pattern = sawtooth;
5392 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5393 }
5394
TEST_F(accuracy_test_pow2_single,large_3D_forward_out_of_place_complex_interleaved_to_complex_planar)5395 TEST_F(accuracy_test_pow2_single, large_3D_forward_out_of_place_complex_interleaved_to_complex_planar)
5396 {
5397 try { large_3D_forward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
5398 catch( const std::exception& err ) { handle_exception(err); }
5399 }
5400
TEST_F(accuracy_test_pow2_double,large_3D_forward_out_of_place_complex_interleaved_to_complex_planar)5401 TEST_F(accuracy_test_pow2_double, large_3D_forward_out_of_place_complex_interleaved_to_complex_planar)
5402 {
5403 try { large_3D_forward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
5404 catch( const std::exception& err ) { handle_exception(err); }
5405 }
5406
5407 // *****************************************************
5408 // *****************************************************
5409 template< class T, class cl_T, class fftw_T >
large_3D_backward_out_of_place_complex_interleaved_to_complex_planar()5410 void large_3D_backward_out_of_place_complex_interleaved_to_complex_planar()
5411 {
5412 std::vector<size_t> lengths;
5413 lengths.push_back( large2 );
5414 lengths.push_back( 2 );
5415 lengths.push_back( 2 );
5416 size_t batch = 1;
5417 std::vector<size_t> input_strides;
5418 std::vector<size_t> output_strides;
5419 size_t input_distance = 0;
5420 size_t output_distance = 0;
5421 layout::buffer_layout_t in_layout = layout::complex_interleaved;
5422 layout::buffer_layout_t out_layout = layout::complex_planar;
5423 placeness::placeness_t placeness = placeness::out_of_place;
5424 direction::direction_t direction = direction::backward;
5425
5426 data_pattern pattern = sawtooth;
5427 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5428 }
5429
TEST_F(accuracy_test_pow2_single,large_3D_backward_out_of_place_complex_interleaved_to_complex_planar)5430 TEST_F(accuracy_test_pow2_single, large_3D_backward_out_of_place_complex_interleaved_to_complex_planar)
5431 {
5432 try { large_3D_backward_out_of_place_complex_interleaved_to_complex_planar< float, cl_float, fftwf_complex >(); }
5433 catch( const std::exception& err ) { handle_exception(err); }
5434 }
5435
TEST_F(accuracy_test_pow2_double,large_3D_backward_out_of_place_complex_interleaved_to_complex_planar)5436 TEST_F(accuracy_test_pow2_double, large_3D_backward_out_of_place_complex_interleaved_to_complex_planar)
5437 {
5438 try { large_3D_backward_out_of_place_complex_interleaved_to_complex_planar< double, cl_double, fftw_complex >(); }
5439 catch( const std::exception& err ) { handle_exception(err); }
5440 }
5441
5442 // *****************************************************
5443 // *****************************************************
5444 template< class T, class cl_T, class fftw_T >
large_3D_in_place_real_to_hermitian_interleaved()5445 void large_3D_in_place_real_to_hermitian_interleaved()
5446 {
5447 std::vector<size_t> lengths;
5448 lengths.push_back( 2 );
5449 lengths.push_back( 2 );
5450 lengths.push_back( large2 );
5451 size_t batch = 1;
5452 std::vector<size_t> input_strides;
5453 std::vector<size_t> output_strides;
5454 size_t input_distance = 0;
5455 size_t output_distance = 0;
5456 layout::buffer_layout_t layout = layout::hermitian_interleaved;
5457 placeness::placeness_t placeness = placeness::in_place;
5458
5459 data_pattern pattern = sawtooth;
5460 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5461 }
5462
TEST_F(accuracy_test_pow2_single,large_3D_in_place_real_to_hermitian_interleaved)5463 TEST_F(accuracy_test_pow2_single, large_3D_in_place_real_to_hermitian_interleaved)
5464 {
5465 try { large_3D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
5466 catch( const std::exception& err ) { handle_exception(err); }
5467 }
5468
TEST_F(accuracy_test_pow2_double,large_3D_in_place_real_to_hermitian_interleaved)5469 TEST_F(accuracy_test_pow2_double, large_3D_in_place_real_to_hermitian_interleaved)
5470 {
5471 try { large_3D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
5472 catch( const std::exception& err ) { handle_exception(err); }
5473 }
5474
5475 // *****************************************************
5476 // *****************************************************
5477 template< class T, class cl_T, class fftw_T >
large_3D_in_place_hermitian_interleaved_to_real()5478 void large_3D_in_place_hermitian_interleaved_to_real()
5479 {
5480 std::vector<size_t> lengths;
5481 lengths.push_back( large2 );
5482 lengths.push_back( 2 );
5483 lengths.push_back( 2 );
5484 size_t batch = 1;
5485 std::vector<size_t> input_strides;
5486 std::vector<size_t> output_strides;
5487 size_t input_distance = 0;
5488 size_t output_distance = 0;
5489 layout::buffer_layout_t layout = layout::hermitian_interleaved;
5490 placeness::placeness_t placeness = placeness::in_place;
5491
5492 data_pattern pattern = sawtooth;
5493 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5494 }
5495
TEST_F(accuracy_test_pow2_single,large_3D_in_place_hermitian_interleaved_to_real)5496 TEST_F(accuracy_test_pow2_single, large_3D_in_place_hermitian_interleaved_to_real)
5497 {
5498 try { large_3D_in_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
5499 catch( const std::exception& err ) { handle_exception(err); }
5500 }
5501
TEST_F(accuracy_test_pow2_double,large_3D_in_place_hermitian_interleaved_to_real)5502 TEST_F(accuracy_test_pow2_double, large_3D_in_place_hermitian_interleaved_to_real)
5503 {
5504 try { large_3D_in_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
5505 catch( const std::exception& err ) { handle_exception(err); }
5506 }
5507
5508 // *****************************************************
5509 // *****************************************************
5510 template< class T, class cl_T, class fftw_T >
large_3D_out_of_place_real_to_hermitian_interleaved()5511 void large_3D_out_of_place_real_to_hermitian_interleaved()
5512 {
5513 std::vector<size_t> lengths;
5514 lengths.push_back( large2 );
5515 lengths.push_back( 2 );
5516 lengths.push_back( 2 );
5517 size_t batch = 1;
5518 std::vector<size_t> input_strides;
5519 std::vector<size_t> output_strides;
5520 size_t input_distance = 0;
5521 size_t output_distance = 0;
5522 layout::buffer_layout_t layout = layout::hermitian_interleaved;
5523 placeness::placeness_t placeness = placeness::out_of_place;
5524
5525 data_pattern pattern = sawtooth;
5526 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5527 }
5528
TEST_F(accuracy_test_pow2_single,large_3D_out_of_place_real_to_hermitian_interleaved)5529 TEST_F(accuracy_test_pow2_single, large_3D_out_of_place_real_to_hermitian_interleaved)
5530 {
5531 try { large_3D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
5532 catch( const std::exception& err ) { handle_exception(err); }
5533 }
5534
TEST_F(accuracy_test_pow2_double,large_3D_out_of_place_real_to_hermitian_interleaved)5535 TEST_F(accuracy_test_pow2_double, large_3D_out_of_place_real_to_hermitian_interleaved)
5536 {
5537 try { large_3D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
5538 catch( const std::exception& err ) { handle_exception(err); }
5539 }
5540
5541 // *****************************************************
5542 // *****************************************************
5543 template< class T, class cl_T, class fftw_T >
large_3D_out_of_place_hermitian_interleaved_to_real()5544 void large_3D_out_of_place_hermitian_interleaved_to_real()
5545 {
5546 std::vector<size_t> lengths;
5547 lengths.push_back( large2 );
5548 lengths.push_back( 2 );
5549 lengths.push_back( 2 );
5550 size_t batch = 1;
5551 std::vector<size_t> input_strides;
5552 std::vector<size_t> output_strides;
5553 size_t input_distance = 0;
5554 size_t output_distance = 0;
5555 layout::buffer_layout_t layout = layout::hermitian_interleaved;
5556 placeness::placeness_t placeness = placeness::out_of_place;
5557
5558 data_pattern pattern = sawtooth;
5559 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5560 }
5561
TEST_F(accuracy_test_pow2_single,large_3D_out_of_place_hermitian_interleaved_to_real)5562 TEST_F(accuracy_test_pow2_single, large_3D_out_of_place_hermitian_interleaved_to_real)
5563 {
5564 try { large_3D_out_of_place_hermitian_interleaved_to_real< float, cl_float, fftwf_complex >(); }
5565 catch( const std::exception& err ) { handle_exception(err); }
5566 }
5567
TEST_F(accuracy_test_pow2_double,large_3D_out_of_place_hermitian_interleaved_to_real)5568 TEST_F(accuracy_test_pow2_double, large_3D_out_of_place_hermitian_interleaved_to_real)
5569 {
5570 try { large_3D_out_of_place_hermitian_interleaved_to_real< double, cl_double, fftw_complex >(); }
5571 catch( const std::exception& err ) { handle_exception(err); }
5572 }
5573
5574 // *****************************************************
5575 // *****************************************************
5576 template< class T, class cl_T, class fftw_T >
large_3D_out_of_place_real_to_hermitian_planar()5577 void large_3D_out_of_place_real_to_hermitian_planar()
5578 {
5579 std::vector<size_t> lengths;
5580 lengths.push_back( large2 );
5581 lengths.push_back( 2 );
5582 lengths.push_back( 2 );
5583 size_t batch = 1;
5584 std::vector<size_t> input_strides;
5585 std::vector<size_t> output_strides;
5586 size_t input_distance = 0;
5587 size_t output_distance = 0;
5588 layout::buffer_layout_t layout = layout::hermitian_planar;
5589 placeness::placeness_t placeness = placeness::out_of_place;
5590
5591 data_pattern pattern = sawtooth;
5592 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5593 }
5594
TEST_F(accuracy_test_pow2_single,large_3D_out_of_place_real_to_hermitian_planar)5595 TEST_F(accuracy_test_pow2_single, large_3D_out_of_place_real_to_hermitian_planar)
5596 {
5597 try { large_3D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
5598 catch( const std::exception& err ) { handle_exception(err); }
5599 }
5600
TEST_F(accuracy_test_pow2_double,large_3D_out_of_place_real_to_hermitian_planar)5601 TEST_F(accuracy_test_pow2_double, large_3D_out_of_place_real_to_hermitian_planar)
5602 {
5603 try { large_3D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
5604 catch( const std::exception& err ) { handle_exception(err); }
5605 }
5606
5607 // *****************************************************
5608 // *****************************************************
5609 template< class T, class cl_T, class fftw_T >
large_3D_out_of_place_hermitian_planar_to_real()5610 void large_3D_out_of_place_hermitian_planar_to_real()
5611 {
5612 std::vector<size_t> lengths;
5613 lengths.push_back( 2 );
5614 lengths.push_back( large2 );
5615 lengths.push_back( 2 );
5616 size_t batch = 1;
5617 std::vector<size_t> input_strides;
5618 std::vector<size_t> output_strides;
5619 size_t input_distance = 0;
5620 size_t output_distance = 0;
5621 layout::buffer_layout_t layout = layout::hermitian_planar;
5622 placeness::placeness_t placeness = placeness::out_of_place;
5623
5624 data_pattern pattern = sawtooth;
5625 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5626 }
5627
TEST_F(accuracy_test_pow2_single,large_3D_out_of_place_hermitian_planar_to_real)5628 TEST_F(accuracy_test_pow2_single, large_3D_out_of_place_hermitian_planar_to_real)
5629 {
5630 try { large_3D_out_of_place_hermitian_planar_to_real< float, cl_float, fftwf_complex >(); }
5631 catch( const std::exception& err ) { handle_exception(err); }
5632 }
5633
TEST_F(accuracy_test_pow2_double,large_3D_out_of_place_hermitian_planar_to_real)5634 TEST_F(accuracy_test_pow2_double, large_3D_out_of_place_hermitian_planar_to_real)
5635 {
5636 try { large_3D_out_of_place_hermitian_planar_to_real< double, cl_double, fftw_complex >(); }
5637 catch( const std::exception& err ) { handle_exception(err); }
5638 }
5639
5640 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
5641 // ^^^^^^^^^^^^^^^^^^^^^^^ special ^^^^^^^^^^^^^^^^^^^^^^^^ //
5642 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
5643
5644 // *****************************************************
5645 // *****************************************************
5646 template< class T, class cl_T, class fftw_T >
normal_1D_array_complex_to_complex()5647 void normal_1D_array_complex_to_complex()
5648 {
5649 std::vector<size_t> lengths;
5650 lengths.push_back( normal2 );
5651 size_t batch = 8;
5652 std::vector<size_t> input_strides;
5653 std::vector<size_t> output_strides;
5654 size_t input_distance = 0;
5655 size_t output_distance = 0;
5656 layout::buffer_layout_t in_layout = layout::complex_interleaved;
5657 layout::buffer_layout_t out_layout = layout::complex_interleaved;
5658 placeness::placeness_t placeness = placeness::in_place;
5659 direction::direction_t direction = direction::forward;
5660
5661 data_pattern pattern = sawtooth;
5662 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5663 }
5664
TEST_F(accuracy_test_pow2_single,normal_1D_array_complex_to_complex)5665 TEST_F(accuracy_test_pow2_single, normal_1D_array_complex_to_complex)
5666 {
5667 try { normal_1D_array_complex_to_complex< float, cl_float, fftwf_complex >(); }
5668 catch( const std::exception& err ) { handle_exception(err); }
5669 }
5670
TEST_F(accuracy_test_pow2_double,normal_1D_array_complex_to_complex)5671 TEST_F(accuracy_test_pow2_double, normal_1D_array_complex_to_complex)
5672 {
5673 try { normal_1D_array_complex_to_complex< double, cl_double, fftw_complex >(); }
5674 catch( const std::exception& err ) { handle_exception(err); }
5675 }
5676
5677 // *****************************************************
5678 // *****************************************************
5679 template< class T, class cl_T, class fftw_T >
normal_1D_array_complex_to_complex_with_odd_batch_size()5680 void normal_1D_array_complex_to_complex_with_odd_batch_size()
5681 {
5682 std::vector<size_t> lengths;
5683 lengths.push_back( normal2 );
5684 size_t batch = 5;
5685 std::vector<size_t> input_strides;
5686 std::vector<size_t> output_strides;
5687 size_t input_distance = 0;
5688 size_t output_distance = 0;
5689 layout::buffer_layout_t in_layout = layout::complex_interleaved;
5690 layout::buffer_layout_t out_layout = layout::complex_interleaved;
5691 placeness::placeness_t placeness = placeness::in_place;
5692 direction::direction_t direction = direction::forward;
5693
5694 data_pattern pattern = sawtooth;
5695 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5696 }
5697
TEST_F(accuracy_test_pow2_single,normal_1D_array_complex_to_complex_with_odd_batch_size)5698 TEST_F(accuracy_test_pow2_single, normal_1D_array_complex_to_complex_with_odd_batch_size)
5699 {
5700 try { normal_1D_array_complex_to_complex_with_odd_batch_size< float, cl_float, fftwf_complex >(); }
5701 catch( const std::exception& err ) { handle_exception(err); }
5702 }
5703
TEST_F(accuracy_test_pow2_double,normal_1D_array_complex_to_complex_with_odd_batch_size)5704 TEST_F(accuracy_test_pow2_double, normal_1D_array_complex_to_complex_with_odd_batch_size)
5705 {
5706 try { normal_1D_array_complex_to_complex_with_odd_batch_size< double, cl_double, fftw_complex >(); }
5707 catch( const std::exception& err ) { handle_exception(err); }
5708 }
5709
5710 // *****************************************************
5711 // *****************************************************
5712 template< class T, class cl_T, class fftw_T >
normal_1D_array_real_to_hermitian()5713 void normal_1D_array_real_to_hermitian()
5714 {
5715 std::vector<size_t> lengths;
5716 lengths.push_back( normal2 );
5717 size_t batch = 8;
5718 std::vector<size_t> input_strides;
5719 std::vector<size_t> output_strides;
5720 size_t input_distance = 0;
5721 size_t output_distance = 0;
5722 layout::buffer_layout_t layout = layout::hermitian_interleaved;
5723 placeness::placeness_t placeness = placeness::in_place;
5724
5725 data_pattern pattern = sawtooth;
5726 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5727 }
5728
TEST_F(accuracy_test_pow2_single,normal_1D_array_real_to_hermitian)5729 TEST_F(accuracy_test_pow2_single, normal_1D_array_real_to_hermitian)
5730 {
5731 try { normal_1D_array_real_to_hermitian< float, cl_float, fftwf_complex >(); }
5732 catch( const std::exception& err ) { handle_exception(err); }
5733 }
5734
TEST_F(accuracy_test_pow2_double,normal_1D_array_real_to_hermitian)5735 TEST_F(accuracy_test_pow2_double, normal_1D_array_real_to_hermitian)
5736 {
5737 try { normal_1D_array_real_to_hermitian< double, cl_double, fftw_complex >(); }
5738 catch( const std::exception& err ) { handle_exception(err); }
5739 }
5740
5741 // *****************************************************
5742 // *****************************************************
5743 template< class T, class cl_T, class fftw_T >
normal_1D_array_real_to_hermitian_with_odd_batch_size()5744 void normal_1D_array_real_to_hermitian_with_odd_batch_size()
5745 {
5746 std::vector<size_t> lengths;
5747 lengths.push_back( normal2 );
5748 size_t batch = 5;
5749 std::vector<size_t> input_strides;
5750 std::vector<size_t> output_strides;
5751 size_t input_distance = 0;
5752 size_t output_distance = 0;
5753 layout::buffer_layout_t layout = layout::hermitian_interleaved;
5754 placeness::placeness_t placeness = placeness::in_place;
5755
5756 data_pattern pattern = sawtooth;
5757 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5758 }
5759
TEST_F(accuracy_test_pow2_single,normal_1D_array_real_to_hermitian_with_odd_batch_size)5760 TEST_F(accuracy_test_pow2_single, normal_1D_array_real_to_hermitian_with_odd_batch_size)
5761 {
5762 try { normal_1D_array_real_to_hermitian_with_odd_batch_size< float, cl_float, fftwf_complex >(); }
5763 catch( const std::exception& err ) { handle_exception(err); }
5764 }
5765
TEST_F(accuracy_test_pow2_double,normal_1D_array_real_to_hermitian_with_odd_batch_size)5766 TEST_F(accuracy_test_pow2_double, normal_1D_array_real_to_hermitian_with_odd_batch_size)
5767 {
5768 try { normal_1D_array_real_to_hermitian_with_odd_batch_size< double, cl_double, fftw_complex >(); }
5769 catch( const std::exception& err ) { handle_exception(err); }
5770 }
5771
5772 // *****************************************************
5773 // *****************************************************
5774 template< class T, class cl_T, class fftw_T >
normal_1D_array_hermitian_to_real()5775 void normal_1D_array_hermitian_to_real()
5776 {
5777 std::vector<size_t> lengths;
5778 lengths.push_back( normal2 );
5779 size_t batch = 8;
5780 std::vector<size_t> input_strides;
5781 std::vector<size_t> output_strides;
5782 size_t input_distance = 0;
5783 size_t output_distance = 0;
5784 layout::buffer_layout_t layout = layout::hermitian_interleaved;
5785 placeness::placeness_t placeness = placeness::in_place;
5786
5787 data_pattern pattern = sawtooth;
5788 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5789 }
5790
TEST_F(accuracy_test_pow2_single,normal_1D_array_hermitian_to_real)5791 TEST_F(accuracy_test_pow2_single, normal_1D_array_hermitian_to_real)
5792 {
5793 try { normal_1D_array_hermitian_to_real< float, cl_float, fftwf_complex >(); }
5794 catch( const std::exception& err ) { handle_exception(err); }
5795 }
5796
TEST_F(accuracy_test_pow2_double,normal_1D_array_hermitian_to_real)5797 TEST_F(accuracy_test_pow2_double, normal_1D_array_hermitian_to_real)
5798 {
5799 try { normal_1D_array_hermitian_to_real< double, cl_double, fftw_complex >(); }
5800 catch( const std::exception& err ) { handle_exception(err); }
5801 }
5802
5803 // *****************************************************
5804 // *****************************************************
5805 template< class T, class cl_T, class fftw_T >
normal_1D_array_hermitian_to_real_with_odd_batch_size()5806 void normal_1D_array_hermitian_to_real_with_odd_batch_size()
5807 {
5808 std::vector<size_t> lengths;
5809 lengths.push_back( normal2 );
5810 size_t batch = 5;
5811 std::vector<size_t> input_strides;
5812 std::vector<size_t> output_strides;
5813 size_t input_distance = 0;
5814 size_t output_distance = 0;
5815 layout::buffer_layout_t layout = layout::hermitian_planar;
5816 placeness::placeness_t placeness = placeness::out_of_place;
5817
5818 data_pattern pattern = sawtooth;
5819 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5820 }
5821
TEST_F(accuracy_test_pow2_single,normal_1D_array_hermitian_to_real_with_odd_batch_size)5822 TEST_F(accuracy_test_pow2_single, normal_1D_array_hermitian_to_real_with_odd_batch_size)
5823 {
5824 try { normal_1D_array_hermitian_to_real_with_odd_batch_size< float, cl_float, fftwf_complex >(); }
5825 catch( const std::exception& err ) { handle_exception(err); }
5826 }
5827
TEST_F(accuracy_test_pow2_double,normal_1D_array_hermitian_to_real_with_odd_batch_size)5828 TEST_F(accuracy_test_pow2_double, normal_1D_array_hermitian_to_real_with_odd_batch_size)
5829 {
5830 try { normal_1D_array_hermitian_to_real_with_odd_batch_size< double, cl_double, fftw_complex >(); }
5831 catch( const std::exception& err ) { handle_exception(err); }
5832 }
5833
5834 // *****************************************************
5835 // *****************************************************
5836 template< class T, class cl_T, class fftw_T >
small_2D_array_real_to_hermitian()5837 void small_2D_array_real_to_hermitian()
5838 {
5839 std::vector<size_t> lengths;
5840 lengths.push_back( small2 );
5841 lengths.push_back( small2 );
5842 size_t batch = 8;
5843 std::vector<size_t> input_strides;
5844 std::vector<size_t> output_strides;
5845 size_t input_distance = 0;
5846 size_t output_distance = 0;
5847 layout::buffer_layout_t layout = layout::hermitian_interleaved;
5848 placeness::placeness_t placeness = placeness::in_place;
5849
5850 data_pattern pattern = sawtooth;
5851 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5852 }
5853
TEST_F(accuracy_test_pow2_single,small_2D_array_real_to_hermitian)5854 TEST_F(accuracy_test_pow2_single, small_2D_array_real_to_hermitian)
5855 {
5856 try { small_2D_array_real_to_hermitian< float, cl_float, fftwf_complex >(); }
5857 catch( const std::exception& err ) { handle_exception(err); }
5858 }
5859
TEST_F(accuracy_test_pow2_double,small_2D_array_real_to_hermitian)5860 TEST_F(accuracy_test_pow2_double, small_2D_array_real_to_hermitian)
5861 {
5862 try { small_2D_array_real_to_hermitian< double, cl_double, fftw_complex >(); }
5863 catch( const std::exception& err ) { handle_exception(err); }
5864 }
5865
5866 // *****************************************************
5867 // *****************************************************
5868 template< class T, class cl_T, class fftw_T >
small_2D_array_real_to_hermitian_with_odd_batch_size()5869 void small_2D_array_real_to_hermitian_with_odd_batch_size()
5870 {
5871 std::vector<size_t> lengths;
5872 lengths.push_back( small2 );
5873 lengths.push_back( small2 );
5874 size_t batch = 5;
5875 std::vector<size_t> input_strides;
5876 std::vector<size_t> output_strides;
5877 size_t input_distance = 0;
5878 size_t output_distance = 0;
5879 layout::buffer_layout_t layout = layout::hermitian_interleaved;
5880 placeness::placeness_t placeness = placeness::in_place;
5881
5882 data_pattern pattern = sawtooth;
5883 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5884 }
5885
TEST_F(accuracy_test_pow2_single,small_2D_array_real_to_hermitian_with_odd_batch_size)5886 TEST_F(accuracy_test_pow2_single, small_2D_array_real_to_hermitian_with_odd_batch_size)
5887 {
5888 try { small_2D_array_real_to_hermitian_with_odd_batch_size< float, cl_float, fftwf_complex >(); }
5889 catch( const std::exception& err ) { handle_exception(err); }
5890 }
5891
TEST_F(accuracy_test_pow2_double,small_2D_array_real_to_hermitian_with_odd_batch_size)5892 TEST_F(accuracy_test_pow2_double, small_2D_array_real_to_hermitian_with_odd_batch_size)
5893 {
5894 try { small_2D_array_real_to_hermitian_with_odd_batch_size< double, cl_double, fftw_complex >(); }
5895 catch( const std::exception& err ) { handle_exception(err); }
5896 }
5897
5898 // *****************************************************
5899 // *****************************************************
5900 template< class T, class cl_T, class fftw_T >
small_2D_array_hermitian_to_real()5901 void small_2D_array_hermitian_to_real()
5902 {
5903 std::vector<size_t> lengths;
5904 lengths.push_back( small2 );
5905 lengths.push_back( small2 );
5906 size_t batch = 8;
5907 std::vector<size_t> input_strides;
5908 std::vector<size_t> output_strides;
5909 size_t input_distance = 0;
5910 size_t output_distance = 0;
5911 layout::buffer_layout_t layout = layout::hermitian_interleaved;
5912 placeness::placeness_t placeness = placeness::in_place;
5913
5914 data_pattern pattern = sawtooth;
5915 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5916 }
5917
TEST_F(accuracy_test_pow2_single,small_2D_array_hermitian_to_real)5918 TEST_F(accuracy_test_pow2_single, small_2D_array_hermitian_to_real)
5919 {
5920 try { small_2D_array_hermitian_to_real< float, cl_float, fftwf_complex >(); }
5921 catch( const std::exception& err ) { handle_exception(err); }
5922 }
5923
TEST_F(accuracy_test_pow2_double,small_2D_array_hermitian_to_real)5924 TEST_F(accuracy_test_pow2_double, small_2D_array_hermitian_to_real)
5925 {
5926 try { small_2D_array_hermitian_to_real< double, cl_double, fftw_complex >(); }
5927 catch( const std::exception& err ) { handle_exception(err); }
5928 }
5929
5930 // *****************************************************
5931 // *****************************************************
5932 template< class T, class cl_T, class fftw_T >
small_2D_array_hermitian_to_real_with_odd_batch_size()5933 void small_2D_array_hermitian_to_real_with_odd_batch_size()
5934 {
5935 std::vector<size_t> lengths;
5936 lengths.push_back( small2 );
5937 lengths.push_back( small2 );
5938 size_t batch = 5;
5939 std::vector<size_t> input_strides;
5940 std::vector<size_t> output_strides;
5941 size_t input_distance = 0;
5942 size_t output_distance = 0;
5943 layout::buffer_layout_t layout = layout::hermitian_planar;
5944 placeness::placeness_t placeness = placeness::out_of_place;
5945
5946 data_pattern pattern = sawtooth;
5947 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
5948 }
5949
TEST_F(accuracy_test_pow2_single,small_2D_array_hermitian_to_real_with_odd_batch_size)5950 TEST_F(accuracy_test_pow2_single, small_2D_array_hermitian_to_real_with_odd_batch_size)
5951 {
5952 try { small_2D_array_hermitian_to_real_with_odd_batch_size< float, cl_float, fftwf_complex >(); }
5953 catch( const std::exception& err ) { handle_exception(err); }
5954 }
5955
TEST_F(accuracy_test_pow2_double,small_2D_array_hermitian_to_real_with_odd_batch_size)5956 TEST_F(accuracy_test_pow2_double, small_2D_array_hermitian_to_real_with_odd_batch_size)
5957 {
5958 try { small_2D_array_hermitian_to_real_with_odd_batch_size< double, cl_double, fftw_complex >(); }
5959 catch( const std::exception& err ) { handle_exception(err); }
5960 }
5961
5962 // *****************************************************
5963 // *****************************************************
5964 template< class T, class cl_T, class fftw_T >
large_1D_array_complex_to_complex()5965 void large_1D_array_complex_to_complex()
5966 {
5967 std::vector<size_t> lengths;
5968 lengths.push_back( large2 );
5969 size_t batch = 2;
5970 std::vector<size_t> input_strides;
5971 std::vector<size_t> output_strides;
5972 size_t input_distance = 0;
5973 size_t output_distance = 0;
5974 layout::buffer_layout_t in_layout = layout::complex_interleaved;
5975 layout::buffer_layout_t out_layout = layout::complex_interleaved;
5976 placeness::placeness_t placeness = placeness::in_place;
5977 direction::direction_t direction = direction::forward;
5978
5979 data_pattern pattern = sawtooth;
5980 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
5981 }
5982
TEST_F(accuracy_test_pow2_single,large_1D_array_complex_to_complex)5983 TEST_F(accuracy_test_pow2_single, large_1D_array_complex_to_complex)
5984 {
5985 try { large_1D_array_complex_to_complex< float, cl_float, fftwf_complex >(); }
5986 catch( const std::exception& err ) { handle_exception(err); }
5987 }
5988
TEST_F(accuracy_test_pow2_double,large_1D_array_complex_to_complex)5989 TEST_F(accuracy_test_pow2_double, large_1D_array_complex_to_complex)
5990 {
5991 try { large_1D_array_complex_to_complex< double, cl_double, fftw_complex >(); }
5992 catch( const std::exception& err ) { handle_exception(err); }
5993 }
5994
5995 // *****************************************************
5996 // *****************************************************
5997 template< class T, class cl_T, class fftw_T >
astoundingly_large_1D_complex_to_complex()5998 void astoundingly_large_1D_complex_to_complex()
5999 {
6000 std::vector<size_t> lengths;
6001 lengths.push_back( 1024 );
6002 size_t batch = 65536;
6003 std::vector<size_t> input_strides;
6004 std::vector<size_t> output_strides;
6005 size_t input_distance = 0;
6006 size_t output_distance = 0;
6007 layout::buffer_layout_t in_layout = layout::complex_interleaved;
6008 layout::buffer_layout_t out_layout = layout::complex_interleaved;
6009 placeness::placeness_t placeness = placeness::in_place;
6010 direction::direction_t direction = direction::forward;
6011
6012 data_pattern pattern = sawtooth;
6013 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
6014 }
6015
TEST_F(accuracy_test_pow2_single,DISABLED_astoundingly_large_1D_complex_to_complex)6016 TEST_F(accuracy_test_pow2_single, DISABLED_astoundingly_large_1D_complex_to_complex)
6017 {
6018 try { astoundingly_large_1D_complex_to_complex< float, cl_float, fftwf_complex >(); }
6019 catch( const std::exception& err ) { handle_exception(err); }
6020 }
6021
TEST_F(accuracy_test_pow2_double,DISABLED_astoundingly_large_1D_complex_to_complex)6022 TEST_F(accuracy_test_pow2_double, DISABLED_astoundingly_large_1D_complex_to_complex)
6023 {
6024 try { astoundingly_large_1D_complex_to_complex< double, cl_double, fftw_complex >(); }
6025 catch( const std::exception& err ) { handle_exception(err); }
6026 }
6027
6028 // *****************************************************
6029 // *****************************************************
6030 template< class T, class cl_T, class fftw_T >
very_small_1D_non_unit_stride_complex_to_complex()6031 void very_small_1D_non_unit_stride_complex_to_complex()
6032 {
6033 std::vector<size_t> lengths;
6034 lengths.push_back( 4 );
6035 size_t batch = 1;
6036 std::vector<size_t> input_strides;
6037 std::vector<size_t> output_strides;
6038 input_strides.push_back( 3 );
6039 output_strides.push_back( 3 );
6040 size_t input_distance = 0;
6041 size_t output_distance = 0;
6042 layout::buffer_layout_t in_layout = layout::complex_planar;
6043 layout::buffer_layout_t out_layout = layout::complex_interleaved;
6044 placeness::placeness_t placeness = placeness::out_of_place;
6045 direction::direction_t direction = direction::forward;
6046
6047 data_pattern pattern = sawtooth;
6048 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
6049 }
6050
TEST_F(accuracy_test_pow2_single,very_small_1D_non_unit_stride_complex_to_complex)6051 TEST_F(accuracy_test_pow2_single, very_small_1D_non_unit_stride_complex_to_complex)
6052 {
6053 try { very_small_1D_non_unit_stride_complex_to_complex< float, cl_float, fftwf_complex >(); }
6054 catch( const std::exception& err ) { handle_exception(err); }
6055 }
6056
TEST_F(accuracy_test_pow2_double,very_small_1D_non_unit_stride_complex_to_complex)6057 TEST_F(accuracy_test_pow2_double, very_small_1D_non_unit_stride_complex_to_complex)
6058 {
6059 try { very_small_1D_non_unit_stride_complex_to_complex< double, cl_double, fftw_complex >(); }
6060 catch( const std::exception& err ) { handle_exception(err); }
6061 }
6062
6063 // *****************************************************
6064 // *****************************************************
6065 template< class T, class cl_T, class fftw_T >
small_1D_non_unit_stride_real_to_hermitian()6066 void small_1D_non_unit_stride_real_to_hermitian()
6067 {
6068 std::vector<size_t> lengths;
6069 lengths.push_back( small2 );
6070 size_t batch = 1;
6071 std::vector<size_t> input_strides;
6072 std::vector<size_t> output_strides;
6073 input_strides.push_back( 3 );
6074 output_strides.push_back( 3 );
6075 size_t input_distance = 0;
6076 size_t output_distance = 0;
6077 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6078 placeness::placeness_t placeness = placeness::out_of_place;
6079
6080 data_pattern pattern = sawtooth;
6081 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6082 }
6083
TEST_F(accuracy_test_pow2_single,small_1D_non_unit_stride_real_to_hermitian)6084 TEST_F(accuracy_test_pow2_single, small_1D_non_unit_stride_real_to_hermitian)
6085 {
6086 try {small_1D_non_unit_stride_real_to_hermitian< float, cl_float, fftwf_complex >(); }
6087 catch( const std::exception& err ) { handle_exception(err); }
6088 }
6089
TEST_F(accuracy_test_pow2_double,small_1D_non_unit_stride_real_to_hermitian)6090 TEST_F(accuracy_test_pow2_double, small_1D_non_unit_stride_real_to_hermitian)
6091 {
6092 try { small_1D_non_unit_stride_real_to_hermitian< double, cl_double, fftw_complex >(); }
6093 catch( const std::exception& err ) { handle_exception(err); }
6094 }
6095
6096 // *****************************************************
6097 // *****************************************************
6098 template< class T, class cl_T, class fftw_T >
small_1D_non_unit_stride_hermitian_to_real()6099 void small_1D_non_unit_stride_hermitian_to_real()
6100 {
6101 std::vector<size_t> lengths;
6102 lengths.push_back( small2 );
6103 size_t batch = 1;
6104 std::vector<size_t> input_strides;
6105 std::vector<size_t> output_strides;
6106 input_strides.push_back( 3 );
6107 output_strides.push_back( 3 );
6108 size_t input_distance = 0;
6109 size_t output_distance = 0;
6110 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6111 placeness::placeness_t placeness = placeness::out_of_place;
6112
6113 data_pattern pattern = sawtooth;
6114 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6115 }
6116
TEST_F(accuracy_test_pow2_single,small_1D_non_unit_stride_hermitian_to_real)6117 TEST_F(accuracy_test_pow2_single, small_1D_non_unit_stride_hermitian_to_real)
6118 {
6119 try { small_1D_non_unit_stride_hermitian_to_real< float, cl_float, fftwf_complex >(); }
6120 catch( const std::exception& err ) { handle_exception(err); }
6121 }
6122
TEST_F(accuracy_test_pow2_double,small_1D_non_unit_stride_hermitian_to_real)6123 TEST_F(accuracy_test_pow2_double, small_1D_non_unit_stride_hermitian_to_real)
6124 {
6125 try { small_1D_non_unit_stride_hermitian_to_real< double, cl_double, fftw_complex >(); }
6126 catch( const std::exception& err ) { handle_exception(err); }
6127 }
6128
6129 // *****************************************************
6130 // *****************************************************
6131 template< class T, class cl_T, class fftw_T >
very_small_1D_non_unit_stride_real_to_hermitian()6132 void very_small_1D_non_unit_stride_real_to_hermitian()
6133 {
6134 std::vector<size_t> lengths;
6135 lengths.push_back( 8 );
6136 size_t batch = 1;
6137 std::vector<size_t> input_strides;
6138 std::vector<size_t> output_strides;
6139 input_strides.push_back( 3 );
6140 output_strides.push_back( 3 );
6141 size_t input_distance = 0;
6142 size_t output_distance = 0;
6143 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6144 placeness::placeness_t placeness = placeness::out_of_place;
6145
6146 data_pattern pattern = sawtooth;
6147 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6148 }
6149
TEST_F(accuracy_test_pow2_single,very_small_1D_non_unit_stride_real_to_hermitian)6150 TEST_F(accuracy_test_pow2_single, very_small_1D_non_unit_stride_real_to_hermitian)
6151 {
6152 try {very_small_1D_non_unit_stride_real_to_hermitian< float, cl_float, fftwf_complex >(); }
6153 catch( const std::exception& err ) { handle_exception(err); }
6154 }
6155
TEST_F(accuracy_test_pow2_double,very_small_1D_non_unit_stride_real_to_hermitian)6156 TEST_F(accuracy_test_pow2_double, very_small_1D_non_unit_stride_real_to_hermitian)
6157 {
6158 try { very_small_1D_non_unit_stride_real_to_hermitian< double, cl_double, fftw_complex >(); }
6159 catch( const std::exception& err ) { handle_exception(err); }
6160 }
6161
6162 // *****************************************************
6163 // *****************************************************
6164 template< class T, class cl_T, class fftw_T >
very_small_1D_non_unit_stride_hermitian_to_real()6165 void very_small_1D_non_unit_stride_hermitian_to_real()
6166 {
6167 std::vector<size_t> lengths;
6168 lengths.push_back( 8 );
6169 size_t batch = 1;
6170 std::vector<size_t> input_strides;
6171 std::vector<size_t> output_strides;
6172 input_strides.push_back( 3 );
6173 output_strides.push_back( 3 );
6174 size_t input_distance = 0;
6175 size_t output_distance = 0;
6176 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6177 placeness::placeness_t placeness = placeness::out_of_place;
6178
6179 data_pattern pattern = sawtooth;
6180 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6181 }
6182
TEST_F(accuracy_test_pow2_single,very_small_1D_non_unit_stride_hermitian_to_real)6183 TEST_F(accuracy_test_pow2_single, very_small_1D_non_unit_stride_hermitian_to_real)
6184 {
6185 try { very_small_1D_non_unit_stride_hermitian_to_real< float, cl_float, fftwf_complex >(); }
6186 catch( const std::exception& err ) { handle_exception(err); }
6187 }
6188
TEST_F(accuracy_test_pow2_double,very_small_1D_non_unit_stride_hermitian_to_real)6189 TEST_F(accuracy_test_pow2_double, very_small_1D_non_unit_stride_hermitian_to_real)
6190 {
6191 try { very_small_1D_non_unit_stride_hermitian_to_real< double, cl_double, fftw_complex >(); }
6192 catch( const std::exception& err ) { handle_exception(err); }
6193 }
6194
6195 // *****************************************************
6196 // *****************************************************
6197 template< class T, class cl_T, class fftw_T >
very_very_small_1D_non_unit_stride_real_to_hermitian()6198 void very_very_small_1D_non_unit_stride_real_to_hermitian()
6199 {
6200 std::vector<size_t> lengths;
6201 lengths.push_back( 4 );
6202 size_t batch = 1;
6203 std::vector<size_t> input_strides;
6204 std::vector<size_t> output_strides;
6205 input_strides.push_back( 3 );
6206 output_strides.push_back( 3 );
6207 size_t input_distance = 0;
6208 size_t output_distance = 0;
6209 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6210 placeness::placeness_t placeness = placeness::out_of_place;
6211
6212 data_pattern pattern = impulse;
6213 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6214 }
6215
TEST_F(accuracy_test_pow2_single,very_very_small_1D_non_unit_stride_real_to_hermitian)6216 TEST_F(accuracy_test_pow2_single, very_very_small_1D_non_unit_stride_real_to_hermitian)
6217 {
6218 try {very_very_small_1D_non_unit_stride_real_to_hermitian< float, cl_float, fftwf_complex >(); }
6219 catch( const std::exception& err ) { handle_exception(err); }
6220 }
6221
TEST_F(accuracy_test_pow2_double,very_very_small_1D_non_unit_stride_real_to_hermitian)6222 TEST_F(accuracy_test_pow2_double, very_very_small_1D_non_unit_stride_real_to_hermitian)
6223 {
6224 try { very_very_small_1D_non_unit_stride_real_to_hermitian< double, cl_double, fftw_complex >(); }
6225 catch( const std::exception& err ) { handle_exception(err); }
6226 }
6227
6228 // *****************************************************
6229 // *****************************************************
6230 template< class T, class cl_T, class fftw_T >
very_very_small_1D_non_unit_stride_hermitian_to_real()6231 void very_very_small_1D_non_unit_stride_hermitian_to_real()
6232 {
6233 std::vector<size_t> lengths;
6234 lengths.push_back( 4 );
6235 size_t batch = 1;
6236 std::vector<size_t> input_strides;
6237 std::vector<size_t> output_strides;
6238 input_strides.push_back( 3 );
6239 output_strides.push_back( 3 );
6240 size_t input_distance = 0;
6241 size_t output_distance = 0;
6242 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6243 placeness::placeness_t placeness = placeness::out_of_place;
6244
6245 data_pattern pattern = impulse;
6246 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6247 }
6248
TEST_F(accuracy_test_pow2_single,very_very_small_1D_non_unit_stride_hermitian_to_real)6249 TEST_F(accuracy_test_pow2_single, very_very_small_1D_non_unit_stride_hermitian_to_real)
6250 {
6251 try { very_very_small_1D_non_unit_stride_hermitian_to_real< float, cl_float, fftwf_complex >(); }
6252 catch( const std::exception& err ) { handle_exception(err); }
6253 }
6254
TEST_F(accuracy_test_pow2_double,very_very_small_1D_non_unit_stride_hermitian_to_real)6255 TEST_F(accuracy_test_pow2_double, very_very_small_1D_non_unit_stride_hermitian_to_real)
6256 {
6257 try { very_very_small_1D_non_unit_stride_hermitian_to_real< double, cl_double, fftw_complex >(); }
6258 catch( const std::exception& err ) { handle_exception(err); }
6259 }
6260
6261 // *****************************************************
6262 // *****************************************************
6263 template< class T, class cl_T, class fftw_T >
normal_1D_non_unit_stride_and_distance_complex_to_complex()6264 void normal_1D_non_unit_stride_and_distance_complex_to_complex()
6265 {
6266 std::vector<size_t> lengths;
6267 lengths.push_back( normal2 );
6268 size_t batch = 2;
6269 std::vector<size_t> input_strides;
6270 std::vector<size_t> output_strides;
6271 input_strides.push_back( 42 );
6272 output_strides.push_back( 42 );
6273 size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 14;
6274 size_t output_distance = lengths[lengths.size()-1] * output_strides[output_strides.size()-1] + 14;
6275 layout::buffer_layout_t in_layout = layout::complex_planar;
6276 layout::buffer_layout_t out_layout = layout::complex_interleaved;
6277 placeness::placeness_t placeness = placeness::out_of_place;
6278 direction::direction_t direction = direction::forward;
6279
6280 data_pattern pattern = sawtooth;
6281 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
6282 }
6283
TEST_F(accuracy_test_pow2_single,normal_1D_non_unit_stride_and_distance_complex_to_complex)6284 TEST_F(accuracy_test_pow2_single, normal_1D_non_unit_stride_and_distance_complex_to_complex)
6285 {
6286 try { normal_1D_non_unit_stride_and_distance_complex_to_complex< float, cl_float, fftwf_complex >(); }
6287 catch( const std::exception& err ) { handle_exception(err); }
6288 }
6289
TEST_F(accuracy_test_pow2_double,normal_1D_non_unit_stride_and_distance_complex_to_complex)6290 TEST_F(accuracy_test_pow2_double, normal_1D_non_unit_stride_and_distance_complex_to_complex)
6291 {
6292 try { normal_1D_non_unit_stride_and_distance_complex_to_complex< double, cl_double, fftw_complex >(); }
6293 catch( const std::exception& err ) { handle_exception(err); }
6294 }
6295
6296 // *****************************************************
6297 // *****************************************************
6298 template< class T, class cl_T, class fftw_T >
very_small_1D_non_unit_stride_and_distance_real_to_complex()6299 void very_small_1D_non_unit_stride_and_distance_real_to_complex()
6300 {
6301 std::vector<size_t> lengths;
6302 lengths.push_back( 4 );
6303 size_t batch = 2;
6304
6305 std::vector<size_t> input_strides;
6306 input_strides.push_back( 2 );
6307
6308 size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 2;
6309
6310 std::vector<size_t> output_strides( input_strides );
6311 size_t output_distance = input_distance;
6312
6313 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6314 placeness::placeness_t placeness = placeness::out_of_place;
6315
6316 data_pattern pattern = impulse;
6317 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6318 }
6319
TEST_F(accuracy_test_pow2_single,very_small_1D_non_unit_stride_and_distance_real_to_complex)6320 TEST_F(accuracy_test_pow2_single, very_small_1D_non_unit_stride_and_distance_real_to_complex)
6321 {
6322 try { very_small_1D_non_unit_stride_and_distance_real_to_complex< float, cl_float, fftwf_complex >(); }
6323 catch( const std::exception& err ) { handle_exception(err); }
6324 }
6325
TEST_F(accuracy_test_pow2_double,very_small_1D_non_unit_stride_and_distance_real_to_complex)6326 TEST_F(accuracy_test_pow2_double, very_small_1D_non_unit_stride_and_distance_real_to_complex)
6327 {
6328 try { very_small_1D_non_unit_stride_and_distance_real_to_complex< double, cl_double, fftw_complex >(); }
6329 catch( const std::exception& err ) { handle_exception(err); }
6330 }
6331
6332 // *****************************************************
6333 // *****************************************************
6334 template< class T, class cl_T, class fftw_T >
very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex()6335 void very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex()
6336 {
6337 std::vector<size_t> lengths;
6338 lengths.push_back( 4 );
6339 size_t batch = 2;
6340
6341 std::vector<size_t> input_strides;
6342 input_strides.push_back( 16 );
6343
6344 size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 128;
6345
6346 std::vector<size_t> output_strides;
6347 output_strides.push_back( 2 );
6348
6349 size_t output_distance = lengths[lengths.size()-1] * output_strides[output_strides.size()-1] + 2;
6350
6351 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6352 placeness::placeness_t placeness = placeness::out_of_place;
6353
6354 data_pattern pattern = impulse;
6355 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6356 }
6357
TEST_F(accuracy_test_pow2_single,very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex)6358 TEST_F(accuracy_test_pow2_single, very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
6359 {
6360 try { very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex< float, cl_float, fftwf_complex >(); }
6361 catch( const std::exception& err ) { handle_exception(err); }
6362 }
6363
TEST_F(accuracy_test_pow2_double,very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex)6364 TEST_F(accuracy_test_pow2_double, very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
6365 {
6366 try { very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex< double, cl_double, fftw_complex >(); }
6367 catch( const std::exception& err ) { handle_exception(err); }
6368 }
6369
6370 // *****************************************************
6371 // *****************************************************
6372 template< class T, class cl_T, class fftw_T >
very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex()6373 void very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex()
6374 {
6375 std::vector<size_t> lengths;
6376 lengths.push_back( 4 );
6377 size_t batch = 2;
6378
6379 std::vector<size_t> input_strides;
6380 input_strides.push_back( 16 );
6381
6382 size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 128;
6383
6384 std::vector<size_t> output_strides;
6385 output_strides.push_back( 2 );
6386
6387 size_t output_distance = lengths[lengths.size()-1] * output_strides[output_strides.size()-1] + 2;
6388
6389 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6390 placeness::placeness_t placeness = placeness::in_place;
6391
6392 data_pattern pattern = impulse;
6393 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6394 }
6395
TEST_F(accuracy_test_pow2_single,very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex)6396 TEST_F(accuracy_test_pow2_single, very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
6397 {
6398 try { very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex< float, cl_float, fftwf_complex >(); }
6399 catch( const std::exception& err ) { handle_exception(err); }
6400 }
6401
TEST_F(accuracy_test_pow2_double,very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex)6402 TEST_F(accuracy_test_pow2_double, very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
6403 {
6404 try { very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex< double, cl_double, fftw_complex >(); }
6405 catch( const std::exception& err ) { handle_exception(err); }
6406 }
6407
6408 // *****************************************************
6409 // *****************************************************
6410 template< class T, class cl_T, class fftw_T >
normal_1D_forward_user_defined_scale_complex_to_complex()6411 void normal_1D_forward_user_defined_scale_complex_to_complex()
6412 {
6413 std::vector<size_t> lengths;
6414 lengths.push_back( normal2 );
6415 size_t batch = 1;
6416 std::vector<size_t> input_strides;
6417 std::vector<size_t> output_strides;
6418 size_t input_distance = 0;
6419 size_t output_distance = 0;
6420 layout::buffer_layout_t in_layout = layout::complex_planar;
6421 layout::buffer_layout_t out_layout = layout::complex_interleaved;
6422 placeness::placeness_t placeness = placeness::out_of_place;
6423 direction::direction_t direction = direction::forward;
6424
6425 data_pattern pattern = sawtooth;
6426 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 42.0f );
6427 }
6428
TEST_F(accuracy_test_pow2_single,normal_1D_forward_user_defined_scale_complex_to_complex)6429 TEST_F(accuracy_test_pow2_single, normal_1D_forward_user_defined_scale_complex_to_complex)
6430 {
6431 try { normal_1D_forward_user_defined_scale_complex_to_complex< float, cl_float, fftwf_complex >(); }
6432 catch( const std::exception& err ) { handle_exception(err); }
6433 }
6434
TEST_F(accuracy_test_pow2_double,normal_1D_forward_user_defined_scale_complex_to_complex)6435 TEST_F(accuracy_test_pow2_double, normal_1D_forward_user_defined_scale_complex_to_complex)
6436 {
6437 try { normal_1D_forward_user_defined_scale_complex_to_complex< double, cl_double, fftw_complex >(); }
6438 catch( const std::exception& err ) { handle_exception(err); }
6439 }
6440
6441 // *****************************************************
6442 // *****************************************************
6443 template< class T, class cl_T, class fftw_T >
normal_1D_backward_user_defined_scale_complex_to_complex()6444 void normal_1D_backward_user_defined_scale_complex_to_complex()
6445 {
6446 std::vector<size_t> lengths;
6447 lengths.push_back( normal2 );
6448 size_t batch = 1;
6449 std::vector<size_t> input_strides;
6450 std::vector<size_t> output_strides;
6451 size_t input_distance = 0;
6452 size_t output_distance = 0;
6453 layout::buffer_layout_t in_layout = layout::complex_planar;
6454 layout::buffer_layout_t out_layout = layout::complex_interleaved;
6455 placeness::placeness_t placeness = placeness::out_of_place;
6456 direction::direction_t direction = direction::backward;
6457
6458 data_pattern pattern = sawtooth;
6459 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 42.5f );
6460 }
6461
TEST_F(accuracy_test_pow2_single,normal_1D_backward_user_defined_scale_complex_to_complex)6462 TEST_F(accuracy_test_pow2_single, normal_1D_backward_user_defined_scale_complex_to_complex)
6463 {
6464 try { normal_1D_backward_user_defined_scale_complex_to_complex< float, cl_float, fftwf_complex >(); }
6465 catch( const std::exception& err ) { handle_exception(err); }
6466 }
6467
TEST_F(accuracy_test_pow2_double,normal_1D_backward_user_defined_scale_complex_to_complex)6468 TEST_F(accuracy_test_pow2_double, normal_1D_backward_user_defined_scale_complex_to_complex)
6469 {
6470 try { normal_1D_backward_user_defined_scale_complex_to_complex< double, cl_double, fftw_complex >(); }
6471 catch( const std::exception& err ) { handle_exception(err); }
6472 }
6473
6474 // *****************************************************
6475 // *****************************************************
6476 template< class T, class cl_T, class fftw_T >
normal_1D_non_unit_stride_and_distance_real_to_hermitian()6477 void normal_1D_non_unit_stride_and_distance_real_to_hermitian()
6478 {
6479 std::vector<size_t> lengths;
6480 lengths.push_back( normal2 );
6481 size_t batch = 2;
6482 std::vector<size_t> input_strides;
6483 std::vector<size_t> output_strides;
6484 input_strides.push_back( 42 );
6485 output_strides.push_back( 42 );
6486 size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 14;
6487 size_t output_distance = lengths[lengths.size()-1] * output_strides[output_strides.size()-1] + 14;
6488 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6489 placeness::placeness_t placeness = placeness::out_of_place;
6490
6491 data_pattern pattern = sawtooth;
6492 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6493 }
6494
TEST_F(accuracy_test_pow2_single,normal_1D_non_unit_stride_and_distance_real_to_hermitian)6495 TEST_F(accuracy_test_pow2_single, normal_1D_non_unit_stride_and_distance_real_to_hermitian)
6496 {
6497 try { normal_1D_non_unit_stride_and_distance_real_to_hermitian< float, cl_float, fftwf_complex >(); }
6498 catch( const std::exception& err ) { handle_exception(err); }
6499 }
6500
TEST_F(accuracy_test_pow2_double,normal_1D_non_unit_stride_and_distance_real_to_hermitian)6501 TEST_F(accuracy_test_pow2_double, normal_1D_non_unit_stride_and_distance_real_to_hermitian)
6502 {
6503 try { normal_1D_non_unit_stride_and_distance_real_to_hermitian< double, cl_double, fftw_complex >(); }
6504 catch( const std::exception& err ) { handle_exception(err); }
6505 }
6506
6507 // *****************************************************
6508 // *****************************************************
6509 template< class T, class cl_T, class fftw_T >
normal_1D_user_defined_scale_real_to_hermitian()6510 void normal_1D_user_defined_scale_real_to_hermitian()
6511 {
6512 std::vector<size_t> lengths;
6513 lengths.push_back( normal2 );
6514 size_t batch = 1;
6515 std::vector<size_t> input_strides;
6516 std::vector<size_t> output_strides;
6517 size_t input_distance = 0;
6518 size_t output_distance = 0;
6519 layout::buffer_layout_t layout = layout::hermitian_planar;
6520 placeness::placeness_t placeness = placeness::out_of_place;
6521
6522 data_pattern pattern = impulse;
6523 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness, 42.0f );
6524 }
6525
TEST_F(accuracy_test_pow2_single,normal_1D_user_defined_scale_real_to_hermitian)6526 TEST_F(accuracy_test_pow2_single, normal_1D_user_defined_scale_real_to_hermitian)
6527 {
6528 try { normal_1D_user_defined_scale_real_to_hermitian< float, cl_float, fftwf_complex >(); }
6529 catch( const std::exception& err ) { handle_exception(err); }
6530 }
6531
TEST_F(accuracy_test_pow2_double,normal_1D_user_defined_scale_real_to_hermitian)6532 TEST_F(accuracy_test_pow2_double, normal_1D_user_defined_scale_real_to_hermitian)
6533 {
6534 try { normal_1D_user_defined_scale_real_to_hermitian< double, cl_double, fftw_complex >(); }
6535 catch( const std::exception& err ) { handle_exception(err); }
6536 }
6537
6538 // *****************************************************
6539 // *****************************************************
6540 template< class T, class cl_T, class fftw_T >
normal_1D_non_unit_stride_and_distance_hermitian_to_real()6541 void normal_1D_non_unit_stride_and_distance_hermitian_to_real()
6542 {
6543 std::vector<size_t> lengths;
6544 lengths.push_back( normal2 );
6545 size_t batch = 2;
6546 std::vector<size_t> input_strides;
6547 std::vector<size_t> output_strides;
6548 input_strides.push_back( 42 );
6549 output_strides.push_back( 42 );
6550 size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 14;
6551 size_t output_distance = lengths[lengths.size()-1] * output_strides[output_strides.size()-1] + 14;
6552 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6553 placeness::placeness_t placeness = placeness::out_of_place;
6554
6555 data_pattern pattern = sawtooth;
6556 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6557 }
6558
TEST_F(accuracy_test_pow2_single,normal_1D_non_unit_stride_and_distance_hermitian_to_real)6559 TEST_F(accuracy_test_pow2_single, normal_1D_non_unit_stride_and_distance_hermitian_to_real)
6560 {
6561 try { normal_1D_non_unit_stride_and_distance_hermitian_to_real< float, cl_float, fftwf_complex >(); }
6562 catch( const std::exception& err ) { handle_exception(err); }
6563 }
6564
TEST_F(accuracy_test_pow2_double,normal_1D_non_unit_stride_and_distance_hermitian_to_real)6565 TEST_F(accuracy_test_pow2_double, normal_1D_non_unit_stride_and_distance_hermitian_to_real)
6566 {
6567 try { normal_1D_non_unit_stride_and_distance_hermitian_to_real< double, cl_double, fftw_complex >(); }
6568 catch( const std::exception& err ) { handle_exception(err); }
6569 }
6570
6571 // *****************************************************
6572 // *****************************************************
6573 template< class T, class cl_T, class fftw_T >
small_2D_non_unit_stride_real_to_hermitian()6574 void small_2D_non_unit_stride_real_to_hermitian()
6575 {
6576 std::vector<size_t> lengths;
6577 lengths.push_back( 4 );
6578 lengths.push_back( 4 );
6579 size_t batch = 2;
6580
6581 std::vector<size_t> input_strides;
6582 input_strides.push_back( 5 );
6583 input_strides.push_back( lengths[0] * input_strides[0] + 1 );
6584
6585 std::vector<size_t> output_strides;
6586 output_strides.push_back( 2 );
6587 output_strides.push_back( lengths[0] * output_strides[0] + 2 );
6588
6589 size_t input_distance = 0;
6590 size_t output_distance = 0;
6591
6592 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6593 placeness::placeness_t placeness = placeness::out_of_place;
6594
6595 data_pattern pattern = sawtooth;
6596 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6597 }
6598
TEST_F(accuracy_test_pow2_single,small_2D_non_unit_stride_real_to_hermitian)6599 TEST_F(accuracy_test_pow2_single, small_2D_non_unit_stride_real_to_hermitian)
6600 {
6601 try { small_2D_non_unit_stride_real_to_hermitian< float, cl_float, fftwf_complex >(); }
6602 catch( const std::exception& err ) { handle_exception(err); }
6603 }
6604
TEST_F(accuracy_test_pow2_double,small_2D_non_unit_stride_real_to_hermitian)6605 TEST_F(accuracy_test_pow2_double, small_2D_non_unit_stride_real_to_hermitian)
6606 {
6607 try { small_2D_non_unit_stride_real_to_hermitian< double, cl_double, fftw_complex >(); }
6608 catch( const std::exception& err ) { handle_exception(err); }
6609 }
6610
6611 // *****************************************************
6612 // *****************************************************
6613 template< class T, class cl_T, class fftw_T >
small_2D_non_unit_distance_real_to_hermitian()6614 void small_2D_non_unit_distance_real_to_hermitian()
6615 {
6616 std::vector<size_t> lengths;
6617 lengths.push_back( 4 );
6618 lengths.push_back( 4 );
6619 size_t batch = 2;
6620
6621 std::vector<size_t> input_strides;
6622 std::vector<size_t> output_strides;
6623
6624 size_t input_distance = lengths[0] * lengths[1] + 4;
6625 size_t output_distance = lengths[0] * lengths[1] + 5;
6626
6627 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6628 placeness::placeness_t placeness = placeness::out_of_place;
6629
6630 data_pattern pattern = sawtooth;
6631 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6632 }
6633
TEST_F(accuracy_test_pow2_single,small_2D_non_unit_distance_real_to_hermitian)6634 TEST_F(accuracy_test_pow2_single, small_2D_non_unit_distance_real_to_hermitian)
6635 {
6636 try { small_2D_non_unit_distance_real_to_hermitian< float, cl_float, fftwf_complex >(); }
6637 catch( const std::exception& err ) { handle_exception(err); }
6638 }
6639
TEST_F(accuracy_test_pow2_double,small_2D_non_unit_distance_real_to_hermitian)6640 TEST_F(accuracy_test_pow2_double, small_2D_non_unit_distance_real_to_hermitian)
6641 {
6642 try { small_2D_non_unit_distance_real_to_hermitian< double, cl_double, fftw_complex >(); }
6643 catch( const std::exception& err ) { handle_exception(err); }
6644 }
6645
6646 // *****************************************************
6647 // *****************************************************
6648 template< class T, class cl_T, class fftw_T >
small_2D_non_unit_stride_and_distance_real_to_hermitian()6649 void small_2D_non_unit_stride_and_distance_real_to_hermitian()
6650 {
6651 std::vector<size_t> lengths;
6652 lengths.push_back( 4 );
6653 lengths.push_back( 4 );
6654 size_t batch = 2;
6655
6656 std::vector<size_t> input_strides;
6657 input_strides.push_back( 5 );
6658 input_strides.push_back( lengths[0] * input_strides[0] + 1 );
6659
6660 std::vector<size_t> output_strides;
6661 output_strides.push_back( 2 );
6662 output_strides.push_back( lengths[0] * output_strides[0] + 2 );
6663
6664 size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 30;
6665 size_t output_distance = lengths[lengths.size()-1] * output_strides[output_strides.size()-1] + 42;
6666
6667 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6668 placeness::placeness_t placeness = placeness::out_of_place;
6669
6670 data_pattern pattern = sawtooth;
6671 real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6672 }
6673
TEST_F(accuracy_test_pow2_single,small_2D_non_unit_stride_and_distance_real_to_hermitian)6674 TEST_F(accuracy_test_pow2_single, small_2D_non_unit_stride_and_distance_real_to_hermitian)
6675 {
6676 try { small_2D_non_unit_stride_and_distance_real_to_hermitian< float, cl_float, fftwf_complex >(); }
6677 catch( const std::exception& err ) { handle_exception(err); }
6678 }
6679
TEST_F(accuracy_test_pow2_double,small_2D_non_unit_stride_and_distance_real_to_hermitian)6680 TEST_F(accuracy_test_pow2_double, small_2D_non_unit_stride_and_distance_real_to_hermitian)
6681 {
6682 try { small_2D_non_unit_stride_and_distance_real_to_hermitian< double, cl_double, fftw_complex >(); }
6683 catch( const std::exception& err ) { handle_exception(err); }
6684 }
6685
6686 // *****************************************************
6687 // *****************************************************
6688 template< class T, class cl_T, class fftw_T >
small_2D_non_unit_stride_and_distance_hermitian_to_real()6689 void small_2D_non_unit_stride_and_distance_hermitian_to_real()
6690 {
6691 std::vector<size_t> lengths;
6692 lengths.push_back( 4 );
6693 lengths.push_back( 4 );
6694 size_t batch = 2;
6695
6696 std::vector<size_t> input_strides;
6697 input_strides.push_back( 12 );
6698 input_strides.push_back( lengths[0] * input_strides[0] + 9 );
6699
6700 std::vector<size_t> output_strides;
6701 output_strides.push_back( 7 );
6702 output_strides.push_back( lengths[0] * output_strides[0] + 32 );
6703
6704 size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 50;
6705 size_t output_distance = lengths[lengths.size()-1] * output_strides[output_strides.size()-1] + 60;
6706
6707 layout::buffer_layout_t layout = layout::hermitian_interleaved;
6708 placeness::placeness_t placeness = placeness::out_of_place;
6709
6710 data_pattern pattern = sawtooth;
6711 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
6712 }
6713
TEST_F(accuracy_test_pow2_single,small_2D_non_unit_stride_and_distance_hermitian_to_real)6714 TEST_F(accuracy_test_pow2_single, small_2D_non_unit_stride_and_distance_hermitian_to_real)
6715 {
6716 try { small_2D_non_unit_stride_and_distance_hermitian_to_real< float, cl_float, fftwf_complex >(); }
6717 catch( const std::exception& err ) { handle_exception(err); }
6718 }
6719
TEST_F(accuracy_test_pow2_double,small_2D_non_unit_stride_and_distance_hermitian_to_real)6720 TEST_F(accuracy_test_pow2_double, small_2D_non_unit_stride_and_distance_hermitian_to_real)
6721 {
6722 try { small_2D_non_unit_stride_and_distance_hermitian_to_real< double, cl_double, fftw_complex >(); }
6723 catch( const std::exception& err ) { handle_exception(err); }
6724 }
6725
6726 // *****************************************************
6727 // *****************************************************
6728 template< class T, class cl_T, class fftw_T >
normal_1D_user_defined_scale_hermitian_to_real()6729 void normal_1D_user_defined_scale_hermitian_to_real()
6730 {
6731 std::vector<size_t> lengths;
6732 lengths.push_back( normal2 );
6733 size_t batch = 1;
6734 std::vector<size_t> input_strides;
6735 std::vector<size_t> output_strides;
6736 size_t input_distance = 0;
6737 size_t output_distance = 0;
6738 layout::buffer_layout_t layout = layout::hermitian_planar;
6739 placeness::placeness_t placeness = placeness::out_of_place;
6740
6741 data_pattern pattern = sawtooth;
6742 complex_to_real<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness, 42.0f );
6743 }
6744
TEST_F(accuracy_test_pow2_single,normal_1D_user_defined_scale_hermitian_to_real)6745 TEST_F(accuracy_test_pow2_single, normal_1D_user_defined_scale_hermitian_to_real)
6746 {
6747 try { normal_1D_user_defined_scale_hermitian_to_real< float, cl_float, fftwf_complex >(); }
6748 catch( const std::exception& err ) { handle_exception(err); }
6749 }
6750
TEST_F(accuracy_test_pow2_double,normal_1D_user_defined_scale_hermitian_to_real)6751 TEST_F(accuracy_test_pow2_double, normal_1D_user_defined_scale_hermitian_to_real)
6752 {
6753 try { normal_1D_user_defined_scale_hermitian_to_real< double, cl_double, fftw_complex >(); }
6754 catch( const std::exception& err ) { handle_exception(err); }
6755 }
6756
6757 // *****************************************************
6758 // *****************************************************
6759 template< class T, class cl_T, class fftw_T >
single_point_1D_forward_complex_to_complex()6760 void single_point_1D_forward_complex_to_complex()
6761 {
6762 std::vector<size_t> lengths;
6763 lengths.push_back( 1 );
6764 size_t batch = 1;
6765 std::vector<size_t> input_strides;
6766 std::vector<size_t> output_strides;
6767 size_t input_distance = 0;
6768 size_t output_distance = 0;
6769 layout::buffer_layout_t in_layout = layout::complex_planar;
6770 layout::buffer_layout_t out_layout = layout::complex_interleaved;
6771 placeness::placeness_t placeness = placeness::out_of_place;
6772 direction::direction_t direction = direction::forward;
6773
6774 data_pattern pattern = impulse;
6775 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 0.42f );
6776 }
6777
TEST_F(accuracy_test_pow2_single,single_point_1D_forward_complex_to_complex)6778 TEST_F(accuracy_test_pow2_single, single_point_1D_forward_complex_to_complex)
6779 {
6780 try { single_point_1D_forward_complex_to_complex< float, cl_float, fftwf_complex >(); }
6781 catch( const std::exception& err ) { handle_exception(err); }
6782 }
6783
TEST_F(accuracy_test_pow2_double,single_point_1D_forward_complex_to_complex)6784 TEST_F(accuracy_test_pow2_double, single_point_1D_forward_complex_to_complex)
6785 {
6786 try { single_point_1D_forward_complex_to_complex< double, cl_double, fftw_complex >(); }
6787 catch( const std::exception& err ) { handle_exception(err); }
6788 }
6789
6790 // *****************************************************
6791 // *****************************************************
6792 template< class T, class cl_T, class fftw_T >
single_point_1D_backward_complex_to_complex()6793 void single_point_1D_backward_complex_to_complex()
6794 {
6795 std::vector<size_t> lengths;
6796 lengths.push_back( 1 );
6797 size_t batch = 1;
6798 std::vector<size_t> input_strides;
6799 std::vector<size_t> output_strides;
6800 size_t input_distance = 0;
6801 size_t output_distance = 0;
6802 layout::buffer_layout_t in_layout = layout::complex_interleaved;
6803 layout::buffer_layout_t out_layout = layout::complex_planar;
6804 placeness::placeness_t placeness = placeness::out_of_place;
6805 direction::direction_t direction = direction::backward;
6806
6807 data_pattern pattern = impulse;
6808 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 0.42f );
6809 }
6810
TEST_F(accuracy_test_pow2_single,single_point_1D_backward_complex_to_complex)6811 TEST_F(accuracy_test_pow2_single, single_point_1D_backward_complex_to_complex)
6812 {
6813 try { single_point_1D_backward_complex_to_complex< float, cl_float, fftwf_complex >(); }
6814 catch( const std::exception& err ) { handle_exception(err); }
6815 }
6816
TEST_F(accuracy_test_pow2_double,single_point_1D_backward_complex_to_complex)6817 TEST_F(accuracy_test_pow2_double, single_point_1D_backward_complex_to_complex)
6818 {
6819 try { single_point_1D_backward_complex_to_complex< double, cl_double, fftw_complex >(); }
6820 catch( const std::exception& err ) { handle_exception(err); }
6821 }
6822
6823 // *****************************************************
6824 // *****************************************************
6825 template< class T, class cl_T, class fftw_T >
small_2D_non_unit_stride_complex_to_complex()6826 void small_2D_non_unit_stride_complex_to_complex()
6827 {
6828 std::vector<size_t> lengths;
6829 lengths.push_back( small2 );
6830 lengths.push_back( small2 );
6831 size_t batch = 1;
6832 std::vector<size_t> input_strides;
6833 std::vector<size_t> output_strides;
6834 input_strides.push_back( 3 );
6835 output_strides.push_back( 3 );
6836 input_strides.push_back( lengths[0] * input_strides[0] + 20 );
6837 output_strides.push_back( lengths[0] * output_strides[0] + 20 );
6838 size_t input_distance = 0;
6839 size_t output_distance = 0;
6840 layout::buffer_layout_t in_layout = layout::complex_planar;
6841 layout::buffer_layout_t out_layout = layout::complex_interleaved;
6842 placeness::placeness_t placeness = placeness::out_of_place;
6843 direction::direction_t direction = direction::forward;
6844
6845 data_pattern pattern = sawtooth;
6846 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
6847 }
6848
TEST_F(accuracy_test_pow2_single,small_2D_non_unit_stride_complex_to_complex)6849 TEST_F(accuracy_test_pow2_single, small_2D_non_unit_stride_complex_to_complex)
6850 {
6851 try { small_2D_non_unit_stride_complex_to_complex< float, cl_float, fftwf_complex >(); }
6852 catch( const std::exception& err ) { handle_exception(err); }
6853 }
6854
TEST_F(accuracy_test_pow2_double,small_2D_non_unit_stride_complex_to_complex)6855 TEST_F(accuracy_test_pow2_double, small_2D_non_unit_stride_complex_to_complex)
6856 {
6857 try { small_2D_non_unit_stride_complex_to_complex< double, cl_double, fftw_complex >(); }
6858 catch( const std::exception& err ) { handle_exception(err); }
6859 }
6860
6861 // *****************************************************
6862 // *****************************************************
6863 template< class T, class cl_T, class fftw_T >
small_2D_non_unit_stride_and_distance_complex_to_complex()6864 void small_2D_non_unit_stride_and_distance_complex_to_complex()
6865 {
6866 std::vector<size_t> lengths;
6867 lengths.push_back( small2 );
6868 lengths.push_back( small2 );
6869 size_t batch = 2;
6870 std::vector<size_t> input_strides;
6871 std::vector<size_t> output_strides;
6872 input_strides.push_back( 42 );
6873 output_strides.push_back( 42 );
6874 input_strides.push_back( lengths[0] * input_strides[0] + 19 );
6875 output_strides.push_back( lengths[0] * output_strides[0] + 19 );
6876 size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 14;
6877 size_t output_distance = lengths[lengths.size()-1] * output_strides[output_strides.size()-1] + 14;
6878 layout::buffer_layout_t in_layout = layout::complex_interleaved;
6879 layout::buffer_layout_t out_layout = layout::complex_planar;
6880 placeness::placeness_t placeness = placeness::out_of_place;
6881 direction::direction_t direction = direction::forward;
6882
6883 data_pattern pattern = sawtooth;
6884 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
6885 }
6886
TEST_F(accuracy_test_pow2_single,small_2D_non_unit_stride_and_distance_complex_to_complex)6887 TEST_F(accuracy_test_pow2_single, small_2D_non_unit_stride_and_distance_complex_to_complex)
6888 {
6889 try { small_2D_non_unit_stride_and_distance_complex_to_complex< float, cl_float, fftwf_complex >(); }
6890 catch( const std::exception& err ) { handle_exception(err); }
6891 }
6892
TEST_F(accuracy_test_pow2_double,small_2D_non_unit_stride_and_distance_complex_to_complex)6893 TEST_F(accuracy_test_pow2_double, small_2D_non_unit_stride_and_distance_complex_to_complex)
6894 {
6895 try { small_2D_non_unit_stride_and_distance_complex_to_complex< double, cl_double, fftw_complex >(); }
6896 catch( const std::exception& err ) { handle_exception(err); }
6897 }
6898
6899 // *****************************************************
6900 // *****************************************************
6901 template< class T, class cl_T, class fftw_T >
normal_2D_forward_user_defined_scale_complex_to_complex()6902 void normal_2D_forward_user_defined_scale_complex_to_complex()
6903 {
6904 std::vector<size_t> lengths;
6905 lengths.push_back( normal2 );
6906 lengths.push_back( normal2 );
6907 size_t batch = 1;
6908 std::vector<size_t> input_strides;
6909 std::vector<size_t> output_strides;
6910 size_t input_distance = 0;
6911 size_t output_distance = 0;
6912 layout::buffer_layout_t in_layout = layout::complex_planar;
6913 layout::buffer_layout_t out_layout = layout::complex_interleaved;
6914 placeness::placeness_t placeness = placeness::out_of_place;
6915 direction::direction_t direction = direction::forward;
6916
6917 data_pattern pattern = sawtooth;
6918 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 42.0f );
6919 }
6920
TEST_F(accuracy_test_pow2_single,normal_2D_forward_user_defined_scale_complex_to_complex)6921 TEST_F(accuracy_test_pow2_single, normal_2D_forward_user_defined_scale_complex_to_complex)
6922 {
6923 try { normal_2D_forward_user_defined_scale_complex_to_complex< float, cl_float, fftwf_complex >(); }
6924 catch( const std::exception& err ) { handle_exception(err); }
6925 }
6926
TEST_F(accuracy_test_pow2_double,normal_2D_forward_user_defined_scale_complex_to_complex)6927 TEST_F(accuracy_test_pow2_double, normal_2D_forward_user_defined_scale_complex_to_complex)
6928 {
6929 try { normal_2D_forward_user_defined_scale_complex_to_complex< double, cl_double, fftw_complex >(); }
6930 catch( const std::exception& err ) { handle_exception(err); }
6931 }
6932
6933 // *****************************************************
6934 // *****************************************************
6935 template< class T, class cl_T, class fftw_T >
normal_2D_backward_user_defined_scale_complex_to_complex()6936 void normal_2D_backward_user_defined_scale_complex_to_complex()
6937 {
6938 std::vector<size_t> lengths;
6939 lengths.push_back( normal2 );
6940 lengths.push_back( normal2 );
6941 size_t batch = 1;
6942 std::vector<size_t> input_strides;
6943 std::vector<size_t> output_strides;
6944 size_t input_distance = 0;
6945 size_t output_distance = 0;
6946 layout::buffer_layout_t in_layout = layout::complex_planar;
6947 layout::buffer_layout_t out_layout = layout::complex_interleaved;
6948 placeness::placeness_t placeness = placeness::out_of_place;
6949 direction::direction_t direction = direction::backward;
6950
6951 data_pattern pattern = sawtooth;
6952 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 42.5f );
6953 }
6954
TEST_F(accuracy_test_pow2_single,normal_2D_backward_user_defined_scale_complex_to_complex)6955 TEST_F(accuracy_test_pow2_single, normal_2D_backward_user_defined_scale_complex_to_complex)
6956 {
6957 try { normal_2D_backward_user_defined_scale_complex_to_complex< float, cl_float, fftwf_complex >(); }
6958 catch( const std::exception& err ) { handle_exception(err); }
6959 }
6960
TEST_F(accuracy_test_pow2_double,normal_2D_backward_user_defined_scale_complex_to_complex)6961 TEST_F(accuracy_test_pow2_double, normal_2D_backward_user_defined_scale_complex_to_complex)
6962 {
6963 try { normal_2D_backward_user_defined_scale_complex_to_complex< double, cl_double, fftw_complex >(); }
6964 catch( const std::exception& err ) { handle_exception(err); }
6965 }
6966
6967 // *****************************************************
6968 // *****************************************************
6969 template< class T, class cl_T, class fftw_T >
rectangular_2D_array_complex_to_complex()6970 void rectangular_2D_array_complex_to_complex()
6971 {
6972 std::vector<size_t> lengths;
6973 lengths.push_back( small2 );
6974 lengths.push_back( normal2 );
6975 size_t batch = 8;
6976 std::vector<size_t> input_strides;
6977 std::vector<size_t> output_strides;
6978 size_t input_distance = 0;
6979 size_t output_distance = 0;
6980 layout::buffer_layout_t in_layout = layout::complex_interleaved;
6981 layout::buffer_layout_t out_layout = layout::complex_interleaved;
6982 placeness::placeness_t placeness = placeness::in_place;
6983 direction::direction_t direction = direction::forward;
6984
6985 data_pattern pattern = sawtooth;
6986 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
6987 }
6988
TEST_F(accuracy_test_pow2_single,rectangular_2D_array_complex_to_complex)6989 TEST_F(accuracy_test_pow2_single, rectangular_2D_array_complex_to_complex)
6990 {
6991 try { rectangular_2D_array_complex_to_complex< float, cl_float, fftwf_complex >(); }
6992 catch( const std::exception& err ) { handle_exception(err); }
6993 }
6994
TEST_F(accuracy_test_pow2_double,rectangular_2D_array_complex_to_complex)6995 TEST_F(accuracy_test_pow2_double, rectangular_2D_array_complex_to_complex)
6996 {
6997 try { rectangular_2D_array_complex_to_complex< double, cl_double, fftw_complex >(); }
6998 catch( const std::exception& err ) { handle_exception(err); }
6999 }
7000
7001 // *****************************************************
7002 // *****************************************************
7003 template< class T, class cl_T, class fftw_T >
normal_2D_array_complex_to_complex_with_odd_batch_size()7004 void normal_2D_array_complex_to_complex_with_odd_batch_size()
7005 {
7006 std::vector<size_t> lengths;
7007 lengths.push_back( normal2 );
7008 lengths.push_back( small2 );
7009 size_t batch = 5;
7010 std::vector<size_t> input_strides;
7011 std::vector<size_t> output_strides;
7012 size_t input_distance = 0;
7013 size_t output_distance = 0;
7014 layout::buffer_layout_t in_layout = layout::complex_planar;
7015 layout::buffer_layout_t out_layout = layout::complex_planar;
7016 placeness::placeness_t placeness = placeness::in_place;
7017 direction::direction_t direction = direction::forward;
7018
7019 data_pattern pattern = sawtooth;
7020 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
7021 }
7022
TEST_F(accuracy_test_pow2_single,normal_2D_array_complex_to_complex_with_odd_batch_size)7023 TEST_F(accuracy_test_pow2_single, normal_2D_array_complex_to_complex_with_odd_batch_size)
7024 {
7025 try { normal_2D_array_complex_to_complex_with_odd_batch_size< float, cl_float, fftwf_complex >(); }
7026 catch( const std::exception& err ) { handle_exception(err); }
7027 }
7028
TEST_F(accuracy_test_pow2_double,normal_2D_array_complex_to_complex_with_odd_batch_size)7029 TEST_F(accuracy_test_pow2_double, normal_2D_array_complex_to_complex_with_odd_batch_size)
7030 {
7031 try { normal_2D_array_complex_to_complex_with_odd_batch_size< double, cl_double, fftw_complex >(); }
7032 catch( const std::exception& err ) { handle_exception(err); }
7033 }
7034
7035 // *****************************************************
7036 // *****************************************************
7037 template< class T, class cl_T, class fftw_T >
large_2D_array_forward_complex_to_complex()7038 void large_2D_array_forward_complex_to_complex()
7039 {
7040 std::vector<size_t> lengths;
7041 lengths.push_back( small2 );
7042 lengths.push_back( large2 );
7043 size_t batch = 8;
7044 std::vector<size_t> input_strides;
7045 std::vector<size_t> output_strides;
7046 size_t input_distance = 0;
7047 size_t output_distance = 0;
7048 layout::buffer_layout_t in_layout = layout::complex_interleaved;
7049 layout::buffer_layout_t out_layout = layout::complex_interleaved;
7050 placeness::placeness_t placeness = placeness::in_place;
7051 direction::direction_t direction = direction::forward;
7052
7053 data_pattern pattern = sawtooth;
7054 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
7055 }
7056
TEST_F(accuracy_test_pow2_single,large_2D_array_forward_complex_to_complex)7057 TEST_F(accuracy_test_pow2_single, large_2D_array_forward_complex_to_complex)
7058 {
7059 try { large_2D_array_forward_complex_to_complex< float, cl_float, fftwf_complex >(); }
7060 catch( const std::exception& err ) { handle_exception(err); }
7061 }
7062
TEST_F(accuracy_test_pow2_double,large_2D_array_forward_complex_to_complex)7063 TEST_F(accuracy_test_pow2_double, large_2D_array_forward_complex_to_complex)
7064 {
7065 try { large_2D_array_forward_complex_to_complex< double, cl_double, fftw_complex >(); }
7066 catch( const std::exception& err ) { handle_exception(err); }
7067 }
7068
7069 // *****************************************************
7070 // *****************************************************
7071 template< class T, class cl_T, class fftw_T >
large_2D_array_backward_complex_to_complex()7072 void large_2D_array_backward_complex_to_complex()
7073 {
7074 std::vector<size_t> lengths;
7075 lengths.push_back( small2 );
7076 lengths.push_back( large2 );
7077 size_t batch = 8;
7078 std::vector<size_t> input_strides;
7079 std::vector<size_t> output_strides;
7080 size_t input_distance = 0;
7081 size_t output_distance = 0;
7082 layout::buffer_layout_t in_layout = layout::complex_interleaved;
7083 layout::buffer_layout_t out_layout = layout::complex_interleaved;
7084 placeness::placeness_t placeness = placeness::in_place;
7085 direction::direction_t direction = direction::backward;
7086
7087 data_pattern pattern = sawtooth;
7088 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
7089 }
7090
TEST_F(accuracy_test_pow2_single,large_2D_array_backward_complex_to_complex)7091 TEST_F(accuracy_test_pow2_single, large_2D_array_backward_complex_to_complex)
7092 {
7093 try { large_2D_array_backward_complex_to_complex< float, cl_float, fftwf_complex >(); }
7094 catch( const std::exception& err ) { handle_exception(err); }
7095 }
7096
TEST_F(accuracy_test_pow2_double,large_2D_array_backward_complex_to_complex)7097 TEST_F(accuracy_test_pow2_double, large_2D_array_backward_complex_to_complex)
7098 {
7099 try { large_2D_array_backward_complex_to_complex< double, cl_double, fftw_complex >(); }
7100 catch( const std::exception& err ) { handle_exception(err); }
7101 }
7102
7103 // *****************************************************
7104 // *****************************************************
7105 template< class T, class cl_T, class fftw_T >
single_point_2D_forward_complex_to_complex()7106 void single_point_2D_forward_complex_to_complex()
7107 {
7108 std::vector<size_t> lengths;
7109 lengths.push_back( 1 );
7110 lengths.push_back( 1 );
7111 size_t batch = 1;
7112 std::vector<size_t> input_strides;
7113 std::vector<size_t> output_strides;
7114 size_t input_distance = 0;
7115 size_t output_distance = 0;
7116 layout::buffer_layout_t in_layout = layout::complex_planar;
7117 layout::buffer_layout_t out_layout = layout::complex_interleaved;
7118 placeness::placeness_t placeness = placeness::out_of_place;
7119 direction::direction_t direction = direction::forward;
7120
7121 data_pattern pattern = impulse;
7122 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 0.42f );
7123 }
7124
TEST_F(accuracy_test_pow2_single,single_point_2D_forward_complex_to_complex)7125 TEST_F(accuracy_test_pow2_single, single_point_2D_forward_complex_to_complex)
7126 {
7127 try { single_point_2D_forward_complex_to_complex< float, cl_float, fftwf_complex >(); }
7128 catch( const std::exception& err ) { handle_exception(err); }
7129 }
7130
TEST_F(accuracy_test_pow2_double,single_point_2D_forward_complex_to_complex)7131 TEST_F(accuracy_test_pow2_double, single_point_2D_forward_complex_to_complex)
7132 {
7133 try { single_point_2D_forward_complex_to_complex< double, cl_double, fftw_complex >(); }
7134 catch( const std::exception& err ) { handle_exception(err); }
7135 }
7136
7137 // *****************************************************
7138 // *****************************************************
7139 template< class T, class cl_T, class fftw_T >
single_point_2D_backward_complex_to_complex()7140 void single_point_2D_backward_complex_to_complex()
7141 {
7142 std::vector<size_t> lengths;
7143 lengths.push_back( 1 );
7144 lengths.push_back( 1 );
7145 size_t batch = 1;
7146 std::vector<size_t> input_strides;
7147 std::vector<size_t> output_strides;
7148 size_t input_distance = 0;
7149 size_t output_distance = 0;
7150 layout::buffer_layout_t in_layout = layout::complex_interleaved;
7151 layout::buffer_layout_t out_layout = layout::complex_planar;
7152 placeness::placeness_t placeness = placeness::out_of_place;
7153 direction::direction_t direction = direction::backward;
7154
7155 data_pattern pattern = impulse;
7156 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 0.42f );
7157 }
7158
TEST_F(accuracy_test_pow2_single,single_point_2D_backward_complex_to_complex)7159 TEST_F(accuracy_test_pow2_single, single_point_2D_backward_complex_to_complex)
7160 {
7161 try { single_point_2D_backward_complex_to_complex< float, cl_float, fftwf_complex >(); }
7162 catch( const std::exception& err ) { handle_exception(err); }
7163 }
7164
TEST_F(accuracy_test_pow2_double,single_point_2D_backward_complex_to_complex)7165 TEST_F(accuracy_test_pow2_double, single_point_2D_backward_complex_to_complex)
7166 {
7167 try { single_point_2D_backward_complex_to_complex< double, cl_double, fftw_complex >(); }
7168 catch( const std::exception& err ) { handle_exception(err); }
7169 }
7170
7171 // *****************************************************
7172 // *****************************************************
7173 template< class T, class cl_T, class fftw_T >
single_point_3D_forward_complex_to_complex()7174 void single_point_3D_forward_complex_to_complex()
7175 {
7176 std::vector<size_t> lengths;
7177 lengths.push_back( 1 );
7178 lengths.push_back( 1 );
7179 lengths.push_back( 1 );
7180 size_t batch = 1;
7181 std::vector<size_t> input_strides;
7182 std::vector<size_t> output_strides;
7183 size_t input_distance = 0;
7184 size_t output_distance = 0;
7185 layout::buffer_layout_t in_layout = layout::complex_planar;
7186 layout::buffer_layout_t out_layout = layout::complex_interleaved;
7187 placeness::placeness_t placeness = placeness::out_of_place;
7188 direction::direction_t direction = direction::forward;
7189
7190 data_pattern pattern = impulse;
7191 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 0.42f );
7192 }
7193
TEST_F(accuracy_test_pow2_single,single_point_3D_forward_complex_to_complex)7194 TEST_F(accuracy_test_pow2_single, single_point_3D_forward_complex_to_complex)
7195 {
7196 try { single_point_3D_forward_complex_to_complex< float, cl_float, fftwf_complex >(); }
7197 catch( const std::exception& err ) { handle_exception(err); }
7198 }
7199
TEST_F(accuracy_test_pow2_double,single_point_3D_forward_complex_to_complex)7200 TEST_F(accuracy_test_pow2_double, single_point_3D_forward_complex_to_complex)
7201 {
7202 try { single_point_3D_forward_complex_to_complex< double, cl_double, fftw_complex >(); }
7203 catch( const std::exception& err ) { handle_exception(err); }
7204 }
7205
7206 // *****************************************************
7207 // *****************************************************
7208 template< class T, class cl_T, class fftw_T >
single_point_3D_backward_complex_to_complex()7209 void single_point_3D_backward_complex_to_complex()
7210 {
7211 std::vector<size_t> lengths;
7212 lengths.push_back( 1 );
7213 lengths.push_back( 1 );
7214 lengths.push_back( 1 );
7215 size_t batch = 1;
7216 std::vector<size_t> input_strides;
7217 std::vector<size_t> output_strides;
7218 size_t input_distance = 0;
7219 size_t output_distance = 0;
7220 layout::buffer_layout_t in_layout = layout::complex_interleaved;
7221 layout::buffer_layout_t out_layout = layout::complex_planar;
7222 placeness::placeness_t placeness = placeness::out_of_place;
7223 direction::direction_t direction = direction::backward;
7224
7225 data_pattern pattern = impulse;
7226 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness, 0.42f );
7227 }
7228
TEST_F(accuracy_test_pow2_single,single_point_3D_backward_complex_to_complex)7229 TEST_F(accuracy_test_pow2_single, single_point_3D_backward_complex_to_complex)
7230 {
7231 try { single_point_3D_backward_complex_to_complex< float, cl_float, fftwf_complex >(); }
7232 catch( const std::exception& err ) { handle_exception(err); }
7233 }
7234
TEST_F(accuracy_test_pow2_double,single_point_3D_backward_complex_to_complex)7235 TEST_F(accuracy_test_pow2_double, single_point_3D_backward_complex_to_complex)
7236 {
7237 try { single_point_3D_backward_complex_to_complex< double, cl_double, fftw_complex >(); }
7238 catch( const std::exception& err ) { handle_exception(err); }
7239 }
7240
7241 // *****************************************************
7242 // *****************************************************
7243 template< class T, class cl_T, class fftw_T >
small_3D_non_unit_stride_complex_to_complex()7244 void small_3D_non_unit_stride_complex_to_complex()
7245 {
7246 std::vector<size_t> lengths;
7247 lengths.push_back( small2 );
7248 lengths.push_back( small2 );
7249 lengths.push_back( small2 );
7250 size_t batch = 1;
7251 std::vector<size_t> input_strides;
7252 input_strides.push_back( 2 );
7253 input_strides.push_back( lengths[0] * input_strides[0] + 20 );
7254 input_strides.push_back( lengths[1] * input_strides[1] + 17 );
7255
7256 std::vector<size_t> output_strides( input_strides );
7257
7258 size_t input_distance = 0;
7259 size_t output_distance = input_distance;
7260
7261 layout::buffer_layout_t in_layout = layout::complex_planar;
7262 layout::buffer_layout_t out_layout = layout::complex_interleaved;
7263 placeness::placeness_t placeness = placeness::out_of_place;
7264 direction::direction_t direction = direction::forward;
7265
7266 data_pattern pattern = sawtooth;
7267 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
7268 }
7269
TEST_F(accuracy_test_pow2_single,small_3D_non_unit_stride_complex_to_complex)7270 TEST_F(accuracy_test_pow2_single, small_3D_non_unit_stride_complex_to_complex)
7271 {
7272 try { small_3D_non_unit_stride_complex_to_complex< float, cl_float, fftwf_complex >(); }
7273 catch( const std::exception& err ) { handle_exception(err); }
7274 }
7275
TEST_F(accuracy_test_pow2_double,small_3D_non_unit_stride_complex_to_complex)7276 TEST_F(accuracy_test_pow2_double, small_3D_non_unit_stride_complex_to_complex)
7277 {
7278 try { small_3D_non_unit_stride_complex_to_complex< double, cl_double, fftw_complex >(); }
7279 catch( const std::exception& err ) { handle_exception(err); }
7280 }
7281
7282 // *****************************************************
7283 // *****************************************************
7284 template< class T, class cl_T, class fftw_T >
small_3D_non_unit_stride_and_distance_complex_to_complex()7285 void small_3D_non_unit_stride_and_distance_complex_to_complex()
7286 {
7287 std::vector<size_t> lengths;
7288 lengths.push_back( small2 );
7289 lengths.push_back( small2 );
7290 lengths.push_back( small2 );
7291 size_t batch = 2;
7292 std::vector<size_t> input_strides;
7293 input_strides.push_back( 2 );
7294 input_strides.push_back( lengths[0] * input_strides[0] + 19 );
7295 input_strides.push_back( lengths[1] * input_strides[1] + 3 );
7296
7297 size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 14;
7298
7299 std::vector<size_t> output_strides( input_strides );
7300 size_t output_distance = input_distance;
7301
7302 layout::buffer_layout_t in_layout = layout::complex_interleaved;
7303 layout::buffer_layout_t out_layout = layout::complex_planar;
7304 placeness::placeness_t placeness = placeness::out_of_place;
7305 direction::direction_t direction = direction::forward;
7306
7307 data_pattern pattern = sawtooth;
7308 complex_to_complex<T, cl_T, fftw_T>( pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness );
7309 }
7310
TEST_F(accuracy_test_pow2_single,small_3D_non_unit_stride_and_distance_complex_to_complex)7311 TEST_F(accuracy_test_pow2_single, small_3D_non_unit_stride_and_distance_complex_to_complex)
7312 {
7313 try { small_3D_non_unit_stride_and_distance_complex_to_complex< float, cl_float, fftwf_complex >(); }
7314 catch( const std::exception& err ) { handle_exception(err); }
7315 }
7316
TEST_F(accuracy_test_pow2_double,small_3D_non_unit_stride_and_distance_complex_to_complex)7317 TEST_F(accuracy_test_pow2_double, small_3D_non_unit_stride_and_distance_complex_to_complex)
7318 {
7319 try { small_3D_non_unit_stride_and_distance_complex_to_complex< double, cl_double, fftw_complex >(); }
7320 catch( const std::exception& err ) { handle_exception(err); }
7321 }
7322
7323 // *****************************************************
7324 // *****************************************************
7325 template< class T, class cl_T, class fftw_T >
normal_1D_round_trip_complex_to_complex()7326 void normal_1D_round_trip_complex_to_complex()
7327 {
7328 std::vector<size_t> lengths;
7329 lengths.push_back( normal2 );
7330 size_t batch = 1;
7331 layout::buffer_layout_t layout = layout::complex_interleaved;
7332
7333 data_pattern pattern = sawtooth;
7334 complex_to_complex_round_trip<T, cl_T, fftw_T>( pattern, lengths, batch, layout );
7335 }
7336
TEST_F(accuracy_test_pow2_single,normal_1D_round_trip_complex_to_complex)7337 TEST_F(accuracy_test_pow2_single, normal_1D_round_trip_complex_to_complex)
7338 {
7339 try { normal_1D_round_trip_complex_to_complex< float, cl_float, fftwf_complex >(); }
7340 catch( const std::exception& err ) { handle_exception(err); }
7341 }
7342
TEST_F(accuracy_test_pow2_double,normal_1D_round_trip_complex_to_complex)7343 TEST_F(accuracy_test_pow2_double, normal_1D_round_trip_complex_to_complex)
7344 {
7345 try { normal_1D_round_trip_complex_to_complex< double, cl_double, fftw_complex >(); }
7346 catch( const std::exception& err ) { handle_exception(err); }
7347 }
7348
7349 // *****************************************************
7350 // *****************************************************
7351 template< class T, class cl_T, class fftw_T >
normal_2D_round_trip_complex_to_complex()7352 void normal_2D_round_trip_complex_to_complex()
7353 {
7354 std::vector<size_t> lengths;
7355 lengths.push_back( normal2 );
7356 lengths.push_back( normal2 );
7357 size_t batch = 1;
7358 layout::buffer_layout_t layout = layout::complex_planar;
7359
7360 data_pattern pattern = sawtooth;
7361 complex_to_complex_round_trip<T, cl_T, fftw_T>( pattern, lengths, batch, layout );
7362 }
7363
7364 template< class T, class cl_T, class fftw_T >
testcase_2D_round_trip_complex_to_complex(size_t l0,size_t l1)7365 void testcase_2D_round_trip_complex_to_complex(size_t l0, size_t l1)
7366 {
7367 std::vector<size_t> lengths;
7368 lengths.push_back( l0 );
7369 lengths.push_back( l1 );
7370 size_t batch = 1;
7371 layout::buffer_layout_t layout = layout::complex_planar;
7372
7373 data_pattern pattern = sawtooth;
7374 complex_to_complex_round_trip<T, cl_T, fftw_T>( pattern, lengths, batch, layout );
7375 }
7376
7377 // added this regression test to catch failures seen in transposes
TEST_F(accuracy_test_pow2_single,testcase1_2D_round_trip_complex_to_complex)7378 TEST_F(accuracy_test_pow2_single, testcase1_2D_round_trip_complex_to_complex)
7379 {
7380 try { testcase_2D_round_trip_complex_to_complex< float, cl_float, fftwf_complex >(1024, 16); }
7381 catch( const std::exception& err ) { handle_exception(err); }
7382 }
7383
TEST_F(accuracy_test_pow2_single,normal_2D_round_trip_complex_to_complex)7384 TEST_F(accuracy_test_pow2_single, normal_2D_round_trip_complex_to_complex)
7385 {
7386 try { normal_2D_round_trip_complex_to_complex< float, cl_float, fftwf_complex >(); }
7387 catch( const std::exception& err ) { handle_exception(err); }
7388 }
7389
TEST_F(accuracy_test_pow2_double,normal_2D_round_trip_complex_to_complex)7390 TEST_F(accuracy_test_pow2_double, normal_2D_round_trip_complex_to_complex)
7391 {
7392 try { normal_2D_round_trip_complex_to_complex< double, cl_double, fftw_complex >(); }
7393 catch( const std::exception& err ) { handle_exception(err); }
7394 }
7395
7396 // *****************************************************
7397 // *****************************************************
7398 template< class T, class cl_T, class fftw_T >
small_3D_round_trip_complex_to_complex()7399 void small_3D_round_trip_complex_to_complex()
7400 {
7401 std::vector<size_t> lengths;
7402 lengths.push_back( small2 );
7403 lengths.push_back( small2 );
7404 lengths.push_back( small2 );
7405 size_t batch = 1;
7406 layout::buffer_layout_t layout = layout::complex_planar;
7407
7408 data_pattern pattern = sawtooth;
7409 complex_to_complex_round_trip<T, cl_T, fftw_T>( pattern, lengths, batch, layout );
7410 }
7411
TEST_F(accuracy_test_pow2_single,small_3D_round_trip_complex_to_complex)7412 TEST_F(accuracy_test_pow2_single, small_3D_round_trip_complex_to_complex)
7413 {
7414 try { small_3D_round_trip_complex_to_complex< float, cl_float, fftwf_complex >(); }
7415 catch( const std::exception& err ) { handle_exception(err); }
7416 }
7417
TEST_F(accuracy_test_pow2_double,small_3D_round_trip_complex_to_complex)7418 TEST_F(accuracy_test_pow2_double, small_3D_round_trip_complex_to_complex)
7419 {
7420 try { small_3D_round_trip_complex_to_complex< double, cl_double, fftw_complex >(); }
7421 catch( const std::exception& err ) { handle_exception(err); }
7422 }
7423
7424 // *****************************************************
7425 // *****************************************************
7426 template< class T, class cl_T, class fftw_T >
normal_1D_round_trip_real_to_complex()7427 void normal_1D_round_trip_real_to_complex()
7428 {
7429 std::vector<size_t> lengths;
7430 lengths.push_back( normal2 );
7431 size_t batch = 1;
7432
7433 data_pattern pattern = impulse;
7434 real_to_complex_round_trip<T, cl_T, fftw_T>( pattern, lengths, batch );
7435 }
7436
TEST_F(accuracy_test_pow2_single,normal_1D_round_trip_real_to_complex)7437 TEST_F(accuracy_test_pow2_single, normal_1D_round_trip_real_to_complex)
7438 {
7439 try { normal_1D_round_trip_real_to_complex< float, cl_float, fftwf_complex >(); }
7440 catch( const std::exception& err ) { handle_exception(err); }
7441 }
7442
TEST_F(accuracy_test_pow2_double,normal_1D_round_trip_real_to_complex)7443 TEST_F(accuracy_test_pow2_double, normal_1D_round_trip_real_to_complex)
7444 {
7445 try { normal_1D_round_trip_real_to_complex< double, cl_double, fftw_complex >(); }
7446 catch( const std::exception& err ) { handle_exception(err); }
7447 }
7448
7449 // *****************************************************
7450 // *****************************************************
7451 template< class T, class cl_T, class fftw_T >
large_1D_round_trip_real_to_complex()7452 void large_1D_round_trip_real_to_complex()
7453 {
7454 std::vector<size_t> lengths;
7455 lengths.push_back( large2 );
7456 size_t batch = 1;
7457
7458 data_pattern pattern = impulse;
7459 real_to_complex_round_trip<T, cl_T, fftw_T>( pattern, lengths, batch );
7460 }
7461
TEST_F(accuracy_test_pow2_single,large_1D_round_trip_real_to_complex)7462 TEST_F(accuracy_test_pow2_single, large_1D_round_trip_real_to_complex)
7463 {
7464 try { large_1D_round_trip_real_to_complex< float, cl_float, fftwf_complex >(); }
7465 catch( const std::exception& err ) { handle_exception(err); }
7466 }
7467
TEST_F(accuracy_test_pow2_double,large_1D_round_trip_real_to_complex)7468 TEST_F(accuracy_test_pow2_double, large_1D_round_trip_real_to_complex)
7469 {
7470 try { large_1D_round_trip_real_to_complex< double, cl_double, fftw_complex >(); }
7471 catch( const std::exception& err ) { handle_exception(err); }
7472 }
7473
7474 // *****************************************************
7475 // *****************************************************
7476 template< class T, class cl_T, class fftw_T >
normal_2D_round_trip_real_to_complex()7477 void normal_2D_round_trip_real_to_complex()
7478 {
7479 std::vector<size_t> lengths;
7480 lengths.push_back( normal2 );
7481 lengths.push_back( normal2 );
7482 size_t batch = 1;
7483
7484 data_pattern pattern = impulse;
7485 real_to_complex_round_trip<T, cl_T, fftw_T>( pattern, lengths, batch );
7486 }
7487
TEST_F(accuracy_test_pow2_single,normal_2D_round_trip_real_to_complex)7488 TEST_F(accuracy_test_pow2_single, normal_2D_round_trip_real_to_complex)
7489 {
7490 try { normal_2D_round_trip_real_to_complex< float, cl_float, fftwf_complex >(); }
7491 catch( const std::exception& err ) { handle_exception(err); }
7492 }
7493
TEST_F(accuracy_test_pow2_double,normal_2D_round_trip_real_to_complex)7494 TEST_F(accuracy_test_pow2_double, normal_2D_round_trip_real_to_complex)
7495 {
7496 try { normal_2D_round_trip_real_to_complex< double, cl_double, fftw_complex >(); }
7497 catch( const std::exception& err ) { handle_exception(err); }
7498 }
7499
7500 // *****************************************************
7501 // *****************************************************
7502 template< class T, class cl_T, class fftw_T >
small_3D_round_trip_real_to_complex()7503 void small_3D_round_trip_real_to_complex()
7504 {
7505 std::vector<size_t> lengths;
7506 lengths.push_back( small2 );
7507 lengths.push_back( small2 );
7508 lengths.push_back( small2 );
7509 size_t batch = 1;
7510
7511 data_pattern pattern = impulse;
7512 real_to_complex_round_trip<T, cl_T, fftw_T>( pattern, lengths, batch );
7513 }
7514
TEST_F(accuracy_test_pow2_single,small_3D_round_trip_real_to_complex)7515 TEST_F(accuracy_test_pow2_single, small_3D_round_trip_real_to_complex)
7516 {
7517 try { small_3D_round_trip_real_to_complex< float, cl_float, fftwf_complex >(); }
7518 catch( const std::exception& err ) { handle_exception(err); }
7519 }
7520
TEST_F(accuracy_test_pow2_double,small_3D_round_trip_real_to_complex)7521 TEST_F(accuracy_test_pow2_double, small_3D_round_trip_real_to_complex)
7522 {
7523 try { small_3D_round_trip_real_to_complex< double, cl_double, fftw_complex >(); }
7524 catch( const std::exception& err ) { handle_exception(err); }
7525 }
7526
7527 } //namespace
7528