GNU Radio Manual and C++ API Reference  3.7.7
The Free & Open Software Radio Ecosystem
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
volk_32fc_s32fc_x2_rotator_32fc.h
Go to the documentation of this file.
1 /* -*- c++ -*- */
2 /*
3  * Copyright 2012, 2013, 2014 Free Software Foundation, Inc.
4  *
5  * This file is part of GNU Radio
6  *
7  * GNU Radio is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3, or (at your option)
10  * any later version.
11  *
12  * GNU Radio is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with GNU Radio; see the file COPYING. If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street,
20  * Boston, MA 02110-1301, USA.
21  */
22 
23 /*!
24  * \page volk_32fc_s32fc_x2_rotator_32fc
25  *
26  * \b Overview
27  *
28  * Rotate input vector at fixed rate per sample from initial phase
29  * offset.
30  *
31  * <b>Dispatcher Prototype</b>
32  * \code
33  * void volk_32fc_s32fc_x2_rotator_32fc(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points)
34  * \endcode
35  *
36  * \b Inputs
37  * \li inVector: Vector to be rotated.
38  * \li phase_inc: rotational velocity.
39  * \li phase: initial phase offset.
40  * \li num_points: The number of values in inVector to be rotated and stored into outVector.
41  *
42  * \b Outputs
43  * \li outVector: The vector where the results will be stored.
44  *
45  * \b Example
46  * Generate a tone at f=0.3 (normalized frequency) and use the rotator with
47  * f=0.1 to shift the tone to f=0.4. Change this example to start with a DC
48  * tone (initialize in with lv_cmake(1, 0)) to observe rotator signal generation.
49  * \code
50  * int N = 10;
51  * unsigned int alignment = volk_get_alignment();
52  * lv_32fc_t* in = (lv_32fc_t*)volk_malloc(sizeof(lv_32fc_t)*N, alignment);
53  * lv_32fc_t* out = (lv_32fc_t*)volk_malloc(sizeof(lv_32fc_t)*N, alignment);
54  *
55  * for(unsigned int ii = 0; ii < N; ++ii){
56  * // Generate a tone at f=0.3
57  * float real = std::cos(0.3f * (float)ii);
58  * float imag = std::sin(0.3f * (float)ii);
59  * in[ii] = lv_cmake(real, imag);
60  * }
61  * // The oscillator rotates at f=0.1
62  * float frequency = 0.1f;
63  * lv_32fc_t phase_increment = lv_cmake(std::cos(frequency), std::sin(frequency));
64  * lv_32fc_t phase= lv_cmake(1.f, 0.0f); // start at 1 (0 rad phase)
65  *
66  * // rotate so the output is a tone at f=0.4
67  * volk_32fc_s32fc_x2_rotator_32fc(out, in, phase_increment, &phase, N);
68  *
69  * // print results for inspection
70  * for(unsigned int ii = 0; ii < N; ++ii){
71  * printf("out[%u] = %+1.2f %+1.2fj\n",
72  * ii, lv_creal(out[ii]), lv_cimag(out[ii]));
73  * }
74  *
75  * volk_free(in);
76  * volk_free(out);
77  * \endcode
78  */
79 
80 #ifndef INCLUDED_volk_32fc_s32fc_rotator_32fc_a_H
81 #define INCLUDED_volk_32fc_s32fc_rotator_32fc_a_H
82 
83 
84 #include <volk/volk_complex.h>
85 #include <stdio.h>
86 #include <stdlib.h>
87 #define ROTATOR_RELOAD 512
88 
89 
90 #ifdef LV_HAVE_GENERIC
91 
92 static inline void volk_32fc_s32fc_x2_rotator_32fc_generic(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points){
93  unsigned int i = 0;
94  int j = 0;
95  for(i = 0; i < (unsigned int)(num_points/ROTATOR_RELOAD); ++i) {
96  for(j = 0; j < ROTATOR_RELOAD; ++j) {
97  *outVector++ = *inVector++ * (*phase);
98  (*phase) *= phase_inc;
99  }
100 #ifdef __cplusplus
101  (*phase) /= std::abs((*phase));
102 #else
103  (*phase) /= cabsf((*phase));
104 #endif
105  }
106  for(i = 0; i < num_points%ROTATOR_RELOAD; ++i) {
107  *outVector++ = *inVector++ * (*phase);
108  (*phase) *= phase_inc;
109  }
110 
111 }
112 
113 #endif /* LV_HAVE_GENERIC */
114 
115 
116 #ifdef LV_HAVE_SSE4_1
117 #include <smmintrin.h>
118 
119 static inline void volk_32fc_s32fc_x2_rotator_32fc_a_sse4_1(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points){
120  lv_32fc_t* cPtr = outVector;
121  const lv_32fc_t* aPtr = inVector;
122  lv_32fc_t incr = 1;
123  lv_32fc_t phase_Ptr[2] = {(*phase), (*phase)};
124 
125  unsigned int i, j = 0;
126 
127  for(i = 0; i < 2; ++i) {
128  phase_Ptr[i] *= incr;
129  incr *= (phase_inc);
130  }
131 
132  /*printf("%f, %f\n", lv_creal(phase_Ptr[0]), lv_cimag(phase_Ptr[0]));
133  printf("%f, %f\n", lv_creal(phase_Ptr[1]), lv_cimag(phase_Ptr[1]));
134  printf("incr: %f, %f\n", lv_creal(incr), lv_cimag(incr));*/
135  __m128 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
136 
137  phase_Val = _mm_loadu_ps((float*)phase_Ptr);
138  inc_Val = _mm_set_ps(lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr));
139 
140  const unsigned int halfPoints = num_points / 2;
141 
142 
143  for(i = 0; i < (unsigned int)(halfPoints/ROTATOR_RELOAD); i++) {
144  for(j = 0; j < ROTATOR_RELOAD; ++j) {
145 
146  aVal = _mm_load_ps((float*)aPtr);
147 
148  yl = _mm_moveldup_ps(phase_Val);
149  yh = _mm_movehdup_ps(phase_Val);
150  ylp = _mm_moveldup_ps(inc_Val);
151  yhp = _mm_movehdup_ps(inc_Val);
152 
153  tmp1 = _mm_mul_ps(aVal, yl);
154  tmp1p = _mm_mul_ps(phase_Val, ylp);
155 
156  aVal = _mm_shuffle_ps(aVal, aVal, 0xB1);
157  phase_Val = _mm_shuffle_ps(phase_Val, phase_Val, 0xB1);
158  tmp2 = _mm_mul_ps(aVal, yh);
159  tmp2p = _mm_mul_ps(phase_Val, yhp);
160 
161  z = _mm_addsub_ps(tmp1, tmp2);
162  phase_Val = _mm_addsub_ps(tmp1p, tmp2p);
163 
164  _mm_store_ps((float*)cPtr, z);
165 
166  aPtr += 2;
167  cPtr += 2;
168  }
169  tmp1 = _mm_mul_ps(phase_Val, phase_Val);
170  tmp2 = _mm_hadd_ps(tmp1, tmp1);
171  tmp1 = _mm_shuffle_ps(tmp2, tmp2, 0xD8);
172  tmp2 = _mm_sqrt_ps(tmp1);
173  phase_Val = _mm_div_ps(phase_Val, tmp2);
174  }
175  for(i = 0; i < halfPoints%ROTATOR_RELOAD; ++i) {
176  aVal = _mm_load_ps((float*)aPtr);
177 
178  yl = _mm_moveldup_ps(phase_Val);
179  yh = _mm_movehdup_ps(phase_Val);
180  ylp = _mm_moveldup_ps(inc_Val);
181  yhp = _mm_movehdup_ps(inc_Val);
182 
183  tmp1 = _mm_mul_ps(aVal, yl);
184 
185  tmp1p = _mm_mul_ps(phase_Val, ylp);
186 
187  aVal = _mm_shuffle_ps(aVal, aVal, 0xB1);
188  phase_Val = _mm_shuffle_ps(phase_Val, phase_Val, 0xB1);
189  tmp2 = _mm_mul_ps(aVal, yh);
190  tmp2p = _mm_mul_ps(phase_Val, yhp);
191 
192  z = _mm_addsub_ps(tmp1, tmp2);
193  phase_Val = _mm_addsub_ps(tmp1p, tmp2p);
194 
195  _mm_store_ps((float*)cPtr, z);
196 
197  aPtr += 2;
198  cPtr += 2;
199  }
200 
201  _mm_storeu_ps((float*)phase_Ptr, phase_Val);
202  for(i = 0; i < num_points%2; ++i) {
203  *cPtr++ = *aPtr++ * phase_Ptr[0];
204  phase_Ptr[0] *= (phase_inc);
205  }
206 
207  (*phase) = phase_Ptr[0];
208 
209 }
210 
211 #endif /* LV_HAVE_SSE4_1 for aligned */
212 
213 
214 #ifdef LV_HAVE_SSE4_1
215 #include <smmintrin.h>
216 
217 static inline void volk_32fc_s32fc_x2_rotator_32fc_u_sse4_1(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points){
218  lv_32fc_t* cPtr = outVector;
219  const lv_32fc_t* aPtr = inVector;
220  lv_32fc_t incr = 1;
221  lv_32fc_t phase_Ptr[2] = {(*phase), (*phase)};
222 
223  unsigned int i, j = 0;
224 
225  for(i = 0; i < 2; ++i) {
226  phase_Ptr[i] *= incr;
227  incr *= (phase_inc);
228  }
229 
230  /*printf("%f, %f\n", lv_creal(phase_Ptr[0]), lv_cimag(phase_Ptr[0]));
231  printf("%f, %f\n", lv_creal(phase_Ptr[1]), lv_cimag(phase_Ptr[1]));
232  printf("incr: %f, %f\n", lv_creal(incr), lv_cimag(incr));*/
233  __m128 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
234 
235  phase_Val = _mm_loadu_ps((float*)phase_Ptr);
236  inc_Val = _mm_set_ps(lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr));
237 
238  const unsigned int halfPoints = num_points / 2;
239 
240 
241  for(i = 0; i < (unsigned int)(halfPoints/ROTATOR_RELOAD); i++) {
242  for(j = 0; j < ROTATOR_RELOAD; ++j) {
243 
244  aVal = _mm_loadu_ps((float*)aPtr);
245 
246  yl = _mm_moveldup_ps(phase_Val);
247  yh = _mm_movehdup_ps(phase_Val);
248  ylp = _mm_moveldup_ps(inc_Val);
249  yhp = _mm_movehdup_ps(inc_Val);
250 
251  tmp1 = _mm_mul_ps(aVal, yl);
252  tmp1p = _mm_mul_ps(phase_Val, ylp);
253 
254  aVal = _mm_shuffle_ps(aVal, aVal, 0xB1);
255  phase_Val = _mm_shuffle_ps(phase_Val, phase_Val, 0xB1);
256  tmp2 = _mm_mul_ps(aVal, yh);
257  tmp2p = _mm_mul_ps(phase_Val, yhp);
258 
259  z = _mm_addsub_ps(tmp1, tmp2);
260  phase_Val = _mm_addsub_ps(tmp1p, tmp2p);
261 
262  _mm_storeu_ps((float*)cPtr, z);
263 
264  aPtr += 2;
265  cPtr += 2;
266  }
267  tmp1 = _mm_mul_ps(phase_Val, phase_Val);
268  tmp2 = _mm_hadd_ps(tmp1, tmp1);
269  tmp1 = _mm_shuffle_ps(tmp2, tmp2, 0xD8);
270  tmp2 = _mm_sqrt_ps(tmp1);
271  phase_Val = _mm_div_ps(phase_Val, tmp2);
272  }
273  for(i = 0; i < halfPoints%ROTATOR_RELOAD; ++i) {
274  aVal = _mm_loadu_ps((float*)aPtr);
275 
276  yl = _mm_moveldup_ps(phase_Val);
277  yh = _mm_movehdup_ps(phase_Val);
278  ylp = _mm_moveldup_ps(inc_Val);
279  yhp = _mm_movehdup_ps(inc_Val);
280 
281  tmp1 = _mm_mul_ps(aVal, yl);
282 
283  tmp1p = _mm_mul_ps(phase_Val, ylp);
284 
285  aVal = _mm_shuffle_ps(aVal, aVal, 0xB1);
286  phase_Val = _mm_shuffle_ps(phase_Val, phase_Val, 0xB1);
287  tmp2 = _mm_mul_ps(aVal, yh);
288  tmp2p = _mm_mul_ps(phase_Val, yhp);
289 
290  z = _mm_addsub_ps(tmp1, tmp2);
291  phase_Val = _mm_addsub_ps(tmp1p, tmp2p);
292 
293  _mm_storeu_ps((float*)cPtr, z);
294 
295  aPtr += 2;
296  cPtr += 2;
297  }
298 
299  _mm_storeu_ps((float*)phase_Ptr, phase_Val);
300  for(i = 0; i < num_points%2; ++i) {
301  *cPtr++ = *aPtr++ * phase_Ptr[0];
302  phase_Ptr[0] *= (phase_inc);
303  }
304 
305  (*phase) = phase_Ptr[0];
306 
307 }
308 
309 #endif /* LV_HAVE_SSE4_1 */
310 
311 
312 #ifdef LV_HAVE_AVX
313 #include <immintrin.h>
314 
315 static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points){
316  lv_32fc_t* cPtr = outVector;
317  const lv_32fc_t* aPtr = inVector;
318  lv_32fc_t incr = 1;
319  lv_32fc_t phase_Ptr[4] = {(*phase), (*phase), (*phase), (*phase)};
320 
321  unsigned int i, j = 0;
322 
323  for(i = 0; i < 4; ++i) {
324  phase_Ptr[i] *= incr;
325  incr *= (phase_inc);
326  }
327 
328  /*printf("%f, %f\n", lv_creal(phase_Ptr[0]), lv_cimag(phase_Ptr[0]));
329  printf("%f, %f\n", lv_creal(phase_Ptr[1]), lv_cimag(phase_Ptr[1]));
330  printf("%f, %f\n", lv_creal(phase_Ptr[2]), lv_cimag(phase_Ptr[2]));
331  printf("%f, %f\n", lv_creal(phase_Ptr[3]), lv_cimag(phase_Ptr[3]));
332  printf("incr: %f, %f\n", lv_creal(incr), lv_cimag(incr));*/
333  __m256 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
334 
335  phase_Val = _mm256_loadu_ps((float*)phase_Ptr);
336  inc_Val = _mm256_set_ps(lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr));
337  const unsigned int fourthPoints = num_points / 4;
338 
339 
340  for(i = 0; i < (unsigned int)(fourthPoints/ROTATOR_RELOAD); i++) {
341  for(j = 0; j < ROTATOR_RELOAD; ++j) {
342 
343  aVal = _mm256_load_ps((float*)aPtr);
344 
345  yl = _mm256_moveldup_ps(phase_Val);
346  yh = _mm256_movehdup_ps(phase_Val);
347  ylp = _mm256_moveldup_ps(inc_Val);
348  yhp = _mm256_movehdup_ps(inc_Val);
349 
350  tmp1 = _mm256_mul_ps(aVal, yl);
351  tmp1p = _mm256_mul_ps(phase_Val, ylp);
352 
353  aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
354  phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
355  tmp2 = _mm256_mul_ps(aVal, yh);
356  tmp2p = _mm256_mul_ps(phase_Val, yhp);
357 
358  z = _mm256_addsub_ps(tmp1, tmp2);
359  phase_Val = _mm256_addsub_ps(tmp1p, tmp2p);
360 
361  _mm256_store_ps((float*)cPtr, z);
362 
363  aPtr += 4;
364  cPtr += 4;
365  }
366  tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
367  tmp2 = _mm256_hadd_ps(tmp1, tmp1);
368  tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
369  tmp2 = _mm256_sqrt_ps(tmp1);
370  phase_Val = _mm256_div_ps(phase_Val, tmp2);
371  }
372  for(i = 0; i < fourthPoints%ROTATOR_RELOAD; ++i) {
373  aVal = _mm256_load_ps((float*)aPtr);
374 
375  yl = _mm256_moveldup_ps(phase_Val);
376  yh = _mm256_movehdup_ps(phase_Val);
377  ylp = _mm256_moveldup_ps(inc_Val);
378  yhp = _mm256_movehdup_ps(inc_Val);
379 
380  tmp1 = _mm256_mul_ps(aVal, yl);
381 
382  tmp1p = _mm256_mul_ps(phase_Val, ylp);
383 
384  aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
385  phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
386  tmp2 = _mm256_mul_ps(aVal, yh);
387  tmp2p = _mm256_mul_ps(phase_Val, yhp);
388 
389  z = _mm256_addsub_ps(tmp1, tmp2);
390  phase_Val = _mm256_addsub_ps(tmp1p, tmp2p);
391 
392  _mm256_store_ps((float*)cPtr, z);
393 
394  aPtr += 4;
395  cPtr += 4;
396  }
397 
398  _mm256_storeu_ps((float*)phase_Ptr, phase_Val);
399  for(i = 0; i < num_points%4; ++i) {
400  *cPtr++ = *aPtr++ * phase_Ptr[0];
401  phase_Ptr[0] *= (phase_inc);
402  }
403 
404  (*phase) = phase_Ptr[0];
405 
406 }
407 
408 #endif /* LV_HAVE_AVX for aligned */
409 
410 
411 #ifdef LV_HAVE_AVX
412 #include <immintrin.h>
413 
414 static inline void volk_32fc_s32fc_x2_rotator_32fc_u_avx(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points){
415  lv_32fc_t* cPtr = outVector;
416  const lv_32fc_t* aPtr = inVector;
417  lv_32fc_t incr = 1;
418  lv_32fc_t phase_Ptr[4] = {(*phase), (*phase), (*phase), (*phase)};
419 
420  unsigned int i, j = 0;
421 
422  for(i = 0; i < 4; ++i) {
423  phase_Ptr[i] *= incr;
424  incr *= (phase_inc);
425  }
426 
427  /*printf("%f, %f\n", lv_creal(phase_Ptr[0]), lv_cimag(phase_Ptr[0]));
428  printf("%f, %f\n", lv_creal(phase_Ptr[1]), lv_cimag(phase_Ptr[1]));
429  printf("%f, %f\n", lv_creal(phase_Ptr[2]), lv_cimag(phase_Ptr[2]));
430  printf("%f, %f\n", lv_creal(phase_Ptr[3]), lv_cimag(phase_Ptr[3]));
431  printf("incr: %f, %f\n", lv_creal(incr), lv_cimag(incr));*/
432  __m256 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
433 
434  phase_Val = _mm256_loadu_ps((float*)phase_Ptr);
435  inc_Val = _mm256_set_ps(lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr));
436  const unsigned int fourthPoints = num_points / 4;
437 
438 
439  for(i = 0; i < (unsigned int)(fourthPoints/ROTATOR_RELOAD); i++) {
440  for(j = 0; j < ROTATOR_RELOAD; ++j) {
441 
442  aVal = _mm256_loadu_ps((float*)aPtr);
443 
444  yl = _mm256_moveldup_ps(phase_Val);
445  yh = _mm256_movehdup_ps(phase_Val);
446  ylp = _mm256_moveldup_ps(inc_Val);
447  yhp = _mm256_movehdup_ps(inc_Val);
448 
449  tmp1 = _mm256_mul_ps(aVal, yl);
450  tmp1p = _mm256_mul_ps(phase_Val, ylp);
451 
452  aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
453  phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
454  tmp2 = _mm256_mul_ps(aVal, yh);
455  tmp2p = _mm256_mul_ps(phase_Val, yhp);
456 
457  z = _mm256_addsub_ps(tmp1, tmp2);
458  phase_Val = _mm256_addsub_ps(tmp1p, tmp2p);
459 
460  _mm256_storeu_ps((float*)cPtr, z);
461 
462  aPtr += 4;
463  cPtr += 4;
464  }
465  tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
466  tmp2 = _mm256_hadd_ps(tmp1, tmp1);
467  tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
468  tmp2 = _mm256_sqrt_ps(tmp1);
469  phase_Val = _mm256_div_ps(phase_Val, tmp2);
470  }
471  for(i = 0; i < fourthPoints%ROTATOR_RELOAD; ++i) {
472  aVal = _mm256_loadu_ps((float*)aPtr);
473 
474  yl = _mm256_moveldup_ps(phase_Val);
475  yh = _mm256_movehdup_ps(phase_Val);
476  ylp = _mm256_moveldup_ps(inc_Val);
477  yhp = _mm256_movehdup_ps(inc_Val);
478 
479  tmp1 = _mm256_mul_ps(aVal, yl);
480 
481  tmp1p = _mm256_mul_ps(phase_Val, ylp);
482 
483  aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
484  phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
485  tmp2 = _mm256_mul_ps(aVal, yh);
486  tmp2p = _mm256_mul_ps(phase_Val, yhp);
487 
488  z = _mm256_addsub_ps(tmp1, tmp2);
489  phase_Val = _mm256_addsub_ps(tmp1p, tmp2p);
490 
491  _mm256_storeu_ps((float*)cPtr, z);
492 
493  aPtr += 4;
494  cPtr += 4;
495  }
496 
497  _mm256_storeu_ps((float*)phase_Ptr, phase_Val);
498  for(i = 0; i < num_points%4; ++i) {
499  *cPtr++ = *aPtr++ * phase_Ptr[0];
500  phase_Ptr[0] *= (phase_inc);
501  }
502 
503  (*phase) = phase_Ptr[0];
504 
505 }
506 
507 #endif /* LV_HAVE_AVX */
508 
509 #endif /* INCLUDED_volk_32fc_s32fc_rotator_32fc_a_H */
float complex lv_32fc_t
Definition: volk_complex.h:56
#define lv_creal(x)
Definition: volk_complex.h:76
#define ROTATOR_RELOAD
Definition: volk_32fc_s32fc_x2_rotator_32fc.h:87
#define lv_cimag(x)
Definition: volk_complex.h:78
uint32_t i[4]
Definition: volk_common.h:80