80 #ifndef INCLUDED_volk_32fc_s32fc_rotator_32fc_a_H 81 #define INCLUDED_volk_32fc_s32fc_rotator_32fc_a_H 88 #define ROTATOR_RELOAD 512 91 #ifdef LV_HAVE_GENERIC 98 *outVector++ = *inVector++ * (*phase);
99 (*phase) *= phase_inc;
102 (*phase) /= std::abs((*phase));
109 *outVector++ = *inVector++ * (*phase);
110 (*phase) *= phase_inc;
119 #include <arm_neon.h> 126 const lv_32fc_t* inputVectorPtr = inVector;
128 lv_32fc_t phasePtr[4] = {(*phase), (*phase), (*phase), (*phase)};
129 float32x4x2_t input_vec;
130 float32x4x2_t output_vec;
132 unsigned int i = 0, j = 0;
133 const unsigned int quarter_points = num_points / 4;
135 for(i = 0; i < 4; ++
i) {
141 const lv_32fc_t incrPtr[4] = {incr, incr, incr, incr};
142 const float32x4x2_t incr_vec = vld2q_f32((
float*) incrPtr);
143 float32x4x2_t phase_vec = vld2q_f32((
float*) phasePtr);
145 for(i = 0; i < (
unsigned int)(quarter_points/
ROTATOR_RELOAD); i++) {
147 input_vec = vld2q_f32((
float*) inputVectorPtr);
155 vst2q_f32((
float*)outputVectorPtr, output_vec);
165 phase_vec.val[0] = vmulq_f32(phase_vec.val[0], inv_mag);
166 phase_vec.val[1] = vmulq_f32(phase_vec.val[1], inv_mag);
170 input_vec = vld2q_f32((
float*) inputVectorPtr);
178 vst2q_f32((
float*)outputVectorPtr, output_vec);
190 phase_vec.val[0] = vmulq_f32(phase_vec.val[0], inv_mag);
191 phase_vec.val[1] = vmulq_f32(phase_vec.val[1], inv_mag);
194 vst2q_f32((
float*)phasePtr, phase_vec);
197 for(i = 0; i < num_points % 4; i++) {
198 *outputVectorPtr++ = *inputVectorPtr++ * phasePtr[0];
199 phasePtr[0] *= (phase_inc);
203 (*phase) = phasePtr[0];
209 #ifdef LV_HAVE_SSE4_1 210 #include <smmintrin.h> 212 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){
216 lv_32fc_t phase_Ptr[2] = {(*phase), (*phase)};
218 unsigned int i, j = 0;
220 for(i = 0; i < 2; ++
i) {
221 phase_Ptr[
i] *= incr;
228 __m128 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
230 phase_Val = _mm_loadu_ps((
float*)phase_Ptr);
233 const unsigned int halfPoints = num_points / 2;
239 aVal = _mm_load_ps((
float*)aPtr);
241 yl = _mm_moveldup_ps(phase_Val);
242 yh = _mm_movehdup_ps(phase_Val);
243 ylp = _mm_moveldup_ps(inc_Val);
244 yhp = _mm_movehdup_ps(inc_Val);
246 tmp1 = _mm_mul_ps(aVal, yl);
247 tmp1p = _mm_mul_ps(phase_Val, ylp);
249 aVal = _mm_shuffle_ps(aVal, aVal, 0xB1);
250 phase_Val = _mm_shuffle_ps(phase_Val, phase_Val, 0xB1);
251 tmp2 = _mm_mul_ps(aVal, yh);
252 tmp2p = _mm_mul_ps(phase_Val, yhp);
254 z = _mm_addsub_ps(tmp1, tmp2);
255 phase_Val = _mm_addsub_ps(tmp1p, tmp2p);
257 _mm_store_ps((
float*)cPtr, z);
262 tmp1 = _mm_mul_ps(phase_Val, phase_Val);
263 tmp2 = _mm_hadd_ps(tmp1, tmp1);
264 tmp1 = _mm_shuffle_ps(tmp2, tmp2, 0xD8);
265 tmp2 = _mm_sqrt_ps(tmp1);
266 phase_Val = _mm_div_ps(phase_Val, tmp2);
269 aVal = _mm_load_ps((
float*)aPtr);
271 yl = _mm_moveldup_ps(phase_Val);
272 yh = _mm_movehdup_ps(phase_Val);
273 ylp = _mm_moveldup_ps(inc_Val);
274 yhp = _mm_movehdup_ps(inc_Val);
276 tmp1 = _mm_mul_ps(aVal, yl);
278 tmp1p = _mm_mul_ps(phase_Val, ylp);
280 aVal = _mm_shuffle_ps(aVal, aVal, 0xB1);
281 phase_Val = _mm_shuffle_ps(phase_Val, phase_Val, 0xB1);
282 tmp2 = _mm_mul_ps(aVal, yh);
283 tmp2p = _mm_mul_ps(phase_Val, yhp);
285 z = _mm_addsub_ps(tmp1, tmp2);
286 phase_Val = _mm_addsub_ps(tmp1p, tmp2p);
288 _mm_store_ps((
float*)cPtr, z);
294 tmp1 = _mm_mul_ps(phase_Val, phase_Val);
295 tmp2 = _mm_hadd_ps(tmp1, tmp1);
296 tmp1 = _mm_shuffle_ps(tmp2, tmp2, 0xD8);
297 tmp2 = _mm_sqrt_ps(tmp1);
298 phase_Val = _mm_div_ps(phase_Val, tmp2);
301 _mm_storeu_ps((
float*)phase_Ptr, phase_Val);
302 for(i = 0; i < num_points%2; ++
i) {
303 *cPtr++ = *aPtr++ * phase_Ptr[0];
304 phase_Ptr[0] *= (phase_inc);
307 (*phase) = phase_Ptr[0];
314 #ifdef LV_HAVE_SSE4_1 315 #include <smmintrin.h> 317 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){
321 lv_32fc_t phase_Ptr[2] = {(*phase), (*phase)};
323 unsigned int i, j = 0;
325 for(i = 0; i < 2; ++
i) {
326 phase_Ptr[
i] *= incr;
333 __m128 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
335 phase_Val = _mm_loadu_ps((
float*)phase_Ptr);
338 const unsigned int halfPoints = num_points / 2;
344 aVal = _mm_loadu_ps((
float*)aPtr);
346 yl = _mm_moveldup_ps(phase_Val);
347 yh = _mm_movehdup_ps(phase_Val);
348 ylp = _mm_moveldup_ps(inc_Val);
349 yhp = _mm_movehdup_ps(inc_Val);
351 tmp1 = _mm_mul_ps(aVal, yl);
352 tmp1p = _mm_mul_ps(phase_Val, ylp);
354 aVal = _mm_shuffle_ps(aVal, aVal, 0xB1);
355 phase_Val = _mm_shuffle_ps(phase_Val, phase_Val, 0xB1);
356 tmp2 = _mm_mul_ps(aVal, yh);
357 tmp2p = _mm_mul_ps(phase_Val, yhp);
359 z = _mm_addsub_ps(tmp1, tmp2);
360 phase_Val = _mm_addsub_ps(tmp1p, tmp2p);
362 _mm_storeu_ps((
float*)cPtr, z);
367 tmp1 = _mm_mul_ps(phase_Val, phase_Val);
368 tmp2 = _mm_hadd_ps(tmp1, tmp1);
369 tmp1 = _mm_shuffle_ps(tmp2, tmp2, 0xD8);
370 tmp2 = _mm_sqrt_ps(tmp1);
371 phase_Val = _mm_div_ps(phase_Val, tmp2);
374 aVal = _mm_loadu_ps((
float*)aPtr);
376 yl = _mm_moveldup_ps(phase_Val);
377 yh = _mm_movehdup_ps(phase_Val);
378 ylp = _mm_moveldup_ps(inc_Val);
379 yhp = _mm_movehdup_ps(inc_Val);
381 tmp1 = _mm_mul_ps(aVal, yl);
383 tmp1p = _mm_mul_ps(phase_Val, ylp);
385 aVal = _mm_shuffle_ps(aVal, aVal, 0xB1);
386 phase_Val = _mm_shuffle_ps(phase_Val, phase_Val, 0xB1);
387 tmp2 = _mm_mul_ps(aVal, yh);
388 tmp2p = _mm_mul_ps(phase_Val, yhp);
390 z = _mm_addsub_ps(tmp1, tmp2);
391 phase_Val = _mm_addsub_ps(tmp1p, tmp2p);
393 _mm_storeu_ps((
float*)cPtr, z);
399 tmp1 = _mm_mul_ps(phase_Val, phase_Val);
400 tmp2 = _mm_hadd_ps(tmp1, tmp1);
401 tmp1 = _mm_shuffle_ps(tmp2, tmp2, 0xD8);
402 tmp2 = _mm_sqrt_ps(tmp1);
403 phase_Val = _mm_div_ps(phase_Val, tmp2);
406 _mm_storeu_ps((
float*)phase_Ptr, phase_Val);
407 for(i = 0; i < num_points%2; ++
i) {
408 *cPtr++ = *aPtr++ * phase_Ptr[0];
409 phase_Ptr[0] *= (phase_inc);
412 (*phase) = phase_Ptr[0];
420 #include <immintrin.h> 426 lv_32fc_t phase_Ptr[4] = {(*phase), (*phase), (*phase), (*phase)};
428 unsigned int i, j = 0;
430 for(i = 0; i < 4; ++
i) {
431 phase_Ptr[
i] *= incr;
440 __m256 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
442 phase_Val = _mm256_loadu_ps((
float*)phase_Ptr);
444 const unsigned int fourthPoints = num_points / 4;
447 for(i = 0; i < (
unsigned int)(fourthPoints/
ROTATOR_RELOAD); i++) {
450 aVal = _mm256_load_ps((
float*)aPtr);
452 yl = _mm256_moveldup_ps(phase_Val);
453 yh = _mm256_movehdup_ps(phase_Val);
454 ylp = _mm256_moveldup_ps(inc_Val);
455 yhp = _mm256_movehdup_ps(inc_Val);
457 tmp1 = _mm256_mul_ps(aVal, yl);
458 tmp1p = _mm256_mul_ps(phase_Val, ylp);
460 aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
461 phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
462 tmp2 = _mm256_mul_ps(aVal, yh);
463 tmp2p = _mm256_mul_ps(phase_Val, yhp);
465 z = _mm256_addsub_ps(tmp1, tmp2);
466 phase_Val = _mm256_addsub_ps(tmp1p, tmp2p);
468 _mm256_store_ps((
float*)cPtr, z);
473 tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
474 tmp2 = _mm256_hadd_ps(tmp1, tmp1);
475 tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
476 tmp2 = _mm256_sqrt_ps(tmp1);
477 phase_Val = _mm256_div_ps(phase_Val, tmp2);
480 aVal = _mm256_load_ps((
float*)aPtr);
482 yl = _mm256_moveldup_ps(phase_Val);
483 yh = _mm256_movehdup_ps(phase_Val);
484 ylp = _mm256_moveldup_ps(inc_Val);
485 yhp = _mm256_movehdup_ps(inc_Val);
487 tmp1 = _mm256_mul_ps(aVal, yl);
489 tmp1p = _mm256_mul_ps(phase_Val, ylp);
491 aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
492 phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
493 tmp2 = _mm256_mul_ps(aVal, yh);
494 tmp2p = _mm256_mul_ps(phase_Val, yhp);
496 z = _mm256_addsub_ps(tmp1, tmp2);
497 phase_Val = _mm256_addsub_ps(tmp1p, tmp2p);
499 _mm256_store_ps((
float*)cPtr, z);
505 tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
506 tmp2 = _mm256_hadd_ps(tmp1, tmp1);
507 tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
508 tmp2 = _mm256_sqrt_ps(tmp1);
509 phase_Val = _mm256_div_ps(phase_Val, tmp2);
512 _mm256_storeu_ps((
float*)phase_Ptr, phase_Val);
513 for(i = 0; i < num_points%4; ++
i) {
514 *cPtr++ = *aPtr++ * phase_Ptr[0];
515 phase_Ptr[0] *= (phase_inc);
518 (*phase) = phase_Ptr[0];
526 #include <immintrin.h> 532 lv_32fc_t phase_Ptr[4] = {(*phase), (*phase), (*phase), (*phase)};
534 unsigned int i, j = 0;
536 for(i = 0; i < 4; ++
i) {
537 phase_Ptr[
i] *= incr;
546 __m256 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
548 phase_Val = _mm256_loadu_ps((
float*)phase_Ptr);
550 const unsigned int fourthPoints = num_points / 4;
553 for(i = 0; i < (
unsigned int)(fourthPoints/
ROTATOR_RELOAD); i++) {
556 aVal = _mm256_loadu_ps((
float*)aPtr);
558 yl = _mm256_moveldup_ps(phase_Val);
559 yh = _mm256_movehdup_ps(phase_Val);
560 ylp = _mm256_moveldup_ps(inc_Val);
561 yhp = _mm256_movehdup_ps(inc_Val);
563 tmp1 = _mm256_mul_ps(aVal, yl);
564 tmp1p = _mm256_mul_ps(phase_Val, ylp);
566 aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
567 phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
568 tmp2 = _mm256_mul_ps(aVal, yh);
569 tmp2p = _mm256_mul_ps(phase_Val, yhp);
571 z = _mm256_addsub_ps(tmp1, tmp2);
572 phase_Val = _mm256_addsub_ps(tmp1p, tmp2p);
574 _mm256_storeu_ps((
float*)cPtr, z);
579 tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
580 tmp2 = _mm256_hadd_ps(tmp1, tmp1);
581 tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
582 tmp2 = _mm256_sqrt_ps(tmp1);
583 phase_Val = _mm256_div_ps(phase_Val, tmp2);
586 aVal = _mm256_loadu_ps((
float*)aPtr);
588 yl = _mm256_moveldup_ps(phase_Val);
589 yh = _mm256_movehdup_ps(phase_Val);
590 ylp = _mm256_moveldup_ps(inc_Val);
591 yhp = _mm256_movehdup_ps(inc_Val);
593 tmp1 = _mm256_mul_ps(aVal, yl);
595 tmp1p = _mm256_mul_ps(phase_Val, ylp);
597 aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
598 phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
599 tmp2 = _mm256_mul_ps(aVal, yh);
600 tmp2p = _mm256_mul_ps(phase_Val, yhp);
602 z = _mm256_addsub_ps(tmp1, tmp2);
603 phase_Val = _mm256_addsub_ps(tmp1p, tmp2p);
605 _mm256_storeu_ps((
float*)cPtr, z);
611 tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
612 tmp2 = _mm256_hadd_ps(tmp1, tmp1);
613 tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
614 tmp2 = _mm256_sqrt_ps(tmp1);
615 phase_Val = _mm256_div_ps(phase_Val, tmp2);
618 _mm256_storeu_ps((
float*)phase_Ptr, phase_Val);
619 for(i = 0; i < num_points%4; ++
i) {
620 *cPtr++ = *aPtr++ * phase_Ptr[0];
621 phase_Ptr[0] *= (phase_inc);
624 (*phase) = phase_Ptr[0];
630 #if LV_HAVE_AVX && LV_HAVE_FMA 631 #include <immintrin.h> 633 static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx_fma(
lv_32fc_t* outVector,
const lv_32fc_t* inVector,
const lv_32fc_t phase_inc,
lv_32fc_t* phase,
unsigned int num_points){
639 unsigned int i, j = 0;
641 for(i = 0; i < 4; ++
i) {
642 phase_Ptr[
i] *= incr;
646 __m256 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
648 phase_Val = _mm256_load_ps((
float*)phase_Ptr);
650 const unsigned int fourthPoints = num_points / 4;
652 for(i = 0; i < (
unsigned int)(fourthPoints/
ROTATOR_RELOAD); i++) {
655 aVal = _mm256_load_ps((
float*)aPtr);
657 yl = _mm256_moveldup_ps(phase_Val);
658 yh = _mm256_movehdup_ps(phase_Val);
659 ylp = _mm256_moveldup_ps(inc_Val);
660 yhp = _mm256_movehdup_ps(inc_Val);
665 aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
666 phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
667 tmp2 = _mm256_mul_ps(aVal, yh);
668 tmp2p = _mm256_mul_ps(phase_Val, yhp);
670 z = _mm256_fmaddsub_ps(tmp1, yl, tmp2);
671 phase_Val = _mm256_fmaddsub_ps(tmp1p, ylp, tmp2p);
673 _mm256_store_ps((
float*)cPtr, z);
678 tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
679 tmp2 = _mm256_hadd_ps(tmp1, tmp1);
680 tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
681 tmp2 = _mm256_sqrt_ps(tmp1);
682 phase_Val = _mm256_div_ps(phase_Val, tmp2);
685 aVal = _mm256_load_ps((
float*)aPtr);
687 yl = _mm256_moveldup_ps(phase_Val);
688 yh = _mm256_movehdup_ps(phase_Val);
689 ylp = _mm256_moveldup_ps(inc_Val);
690 yhp = _mm256_movehdup_ps(inc_Val);
695 aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
696 phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
697 tmp2 = _mm256_mul_ps(aVal, yh);
698 tmp2p = _mm256_mul_ps(phase_Val, yhp);
700 z = _mm256_fmaddsub_ps(tmp1, yl, tmp2);
701 phase_Val = _mm256_fmaddsub_ps(tmp1p, ylp, tmp2p);
703 _mm256_store_ps((
float*)cPtr, z);
709 tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
710 tmp2 = _mm256_hadd_ps(tmp1, tmp1);
711 tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
712 tmp2 = _mm256_sqrt_ps(tmp1);
713 phase_Val = _mm256_div_ps(phase_Val, tmp2);
716 _mm256_store_ps((
float*)phase_Ptr, phase_Val);
717 for(i = 0; i < num_points%4; ++
i) {
718 *cPtr++ = *aPtr++ * phase_Ptr[0];
719 phase_Ptr[0] *= (phase_inc);
722 (*phase) = phase_Ptr[0];
728 #if LV_HAVE_AVX && LV_HAVE_FMA 729 #include <immintrin.h> 731 static inline void volk_32fc_s32fc_x2_rotator_32fc_u_avx_fma(
lv_32fc_t* outVector,
const lv_32fc_t* inVector,
const lv_32fc_t phase_inc,
lv_32fc_t* phase,
unsigned int num_points){
735 lv_32fc_t phase_Ptr[4] = {(*phase), (*phase), (*phase), (*phase)};
737 unsigned int i, j = 0;
739 for(i = 0; i < 4; ++
i) {
740 phase_Ptr[
i] *= incr;
744 __m256 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
746 phase_Val = _mm256_loadu_ps((
float*)phase_Ptr);
748 const unsigned int fourthPoints = num_points / 4;
750 for(i = 0; i < (
unsigned int)(fourthPoints/
ROTATOR_RELOAD); i++) {
753 aVal = _mm256_loadu_ps((
float*)aPtr);
755 yl = _mm256_moveldup_ps(phase_Val);
756 yh = _mm256_movehdup_ps(phase_Val);
757 ylp = _mm256_moveldup_ps(inc_Val);
758 yhp = _mm256_movehdup_ps(inc_Val);
763 aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
764 phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
765 tmp2 = _mm256_mul_ps(aVal, yh);
766 tmp2p = _mm256_mul_ps(phase_Val, yhp);
768 z = _mm256_fmaddsub_ps(tmp1, yl, tmp2);
769 phase_Val = _mm256_fmaddsub_ps(tmp1p, ylp, tmp2p);
771 _mm256_storeu_ps((
float*)cPtr, z);
776 tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
777 tmp2 = _mm256_hadd_ps(tmp1, tmp1);
778 tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
779 tmp2 = _mm256_sqrt_ps(tmp1);
780 phase_Val = _mm256_div_ps(phase_Val, tmp2);
783 aVal = _mm256_loadu_ps((
float*)aPtr);
785 yl = _mm256_moveldup_ps(phase_Val);
786 yh = _mm256_movehdup_ps(phase_Val);
787 ylp = _mm256_moveldup_ps(inc_Val);
788 yhp = _mm256_movehdup_ps(inc_Val);
793 aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
794 phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
795 tmp2 = _mm256_mul_ps(aVal, yh);
796 tmp2p = _mm256_mul_ps(phase_Val, yhp);
798 z = _mm256_fmaddsub_ps(tmp1, yl, tmp2);
799 phase_Val = _mm256_fmaddsub_ps(tmp1p, ylp, tmp2p);
801 _mm256_storeu_ps((
float*)cPtr, z);
807 tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
808 tmp2 = _mm256_hadd_ps(tmp1, tmp1);
809 tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
810 tmp2 = _mm256_sqrt_ps(tmp1);
811 phase_Val = _mm256_div_ps(phase_Val, tmp2);
814 _mm256_storeu_ps((
float*)phase_Ptr, phase_Val);
815 for(i = 0; i < num_points%4; ++
i) {
816 *cPtr++ = *aPtr++ * phase_Ptr[0];
817 phase_Ptr[0] *= (phase_inc);
820 (*phase) = phase_Ptr[0];
static float32x4_t _vinvsqrtq_f32(float32x4_t x)
Definition: volk_neon_intrinsics.h:46
static float32x4x2_t _vmultiply_complexq_f32(float32x4x2_t a_val, float32x4x2_t b_val)
Definition: volk_neon_intrinsics.h:57
static 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)
Definition: volk_32fc_s32fc_x2_rotator_32fc.h:93
static 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)
Definition: volk_32fc_s32fc_x2_rotator_32fc.h:422
static float32x4_t _vmagnitudesquaredq_f32(float32x4x2_t cmplxValue)
Definition: volk_neon_intrinsics.h:36
#define __VOLK_PREFETCH(addr)
Definition: volk_common.h:39
for i
Definition: volk_config_fixed.tmpl.h:25
#define __VOLK_ATTR_ALIGNED(x)
Definition: volk_common.h:33
float complex lv_32fc_t
Definition: volk_complex.h:61
static 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)
Definition: volk_32fc_s32fc_x2_rotator_32fc.h:528
static void volk_32fc_s32fc_x2_rotator_32fc_neon(lv_32fc_t *outVector, const lv_32fc_t *inVector, const lv_32fc_t phase_inc, lv_32fc_t *phase, unsigned int num_points)
Definition: volk_32fc_s32fc_x2_rotator_32fc.h:122
#define lv_creal(x)
Definition: volk_complex.h:83
#define ROTATOR_RELOAD
Definition: volk_32fc_s32fc_x2_rotator_32fc.h:88
#define lv_cimag(x)
Definition: volk_complex.h:85