68#ifndef INCLUDED_volk_32fc_s32fc_rotator2_32fc_a_H
69#define INCLUDED_volk_32fc_s32fc_rotator2_32fc_a_H
76#define ROTATOR_RELOAD 512
77#define ROTATOR_RELOAD_2 (ROTATOR_RELOAD / 2)
78#define ROTATOR_RELOAD_4 (ROTATOR_RELOAD / 4)
87 unsigned int num_points)
93 *outVector++ = *inVector++ * (*phase);
94 (*phase) *= *phase_inc;
100 *outVector++ = *inVector++ * (*phase);
101 (*phase) *= *phase_inc;
120 unsigned int num_points)
124 const lv_32fc_t* inputVectorPtr = inVector;
126 lv_32fc_t phasePtr[4] = { (*phase), (*phase), (*phase), (*phase) };
127 float32x4x2_t input_vec;
128 float32x4x2_t output_vec;
130 unsigned int i = 0, j = 0;
133 for (
i = 0;
i < 4; ++
i) {
135 incr *= (*phase_inc);
139 const lv_32fc_t incrPtr[4] = { incr, incr, incr, incr };
140 const float32x4x2_t incr_vec = vld2q_f32((
float*)incrPtr);
141 float32x4x2_t phase_vec = vld2q_f32((
float*)phasePtr);
145 input_vec = vld2q_f32((
float*)inputVectorPtr);
153 vst2q_f32((
float*)outputVectorPtr, output_vec);
155 outputVectorPtr += 4;
163 phase_vec.val[0] = vmulq_f32(phase_vec.val[0], inv_mag);
164 phase_vec.val[1] = vmulq_f32(phase_vec.val[1], inv_mag);
168 input_vec = vld2q_f32((
float*)inputVectorPtr);
176 vst2q_f32((
float*)outputVectorPtr, output_vec);
178 outputVectorPtr += 4;
188 phase_vec.val[0] = vmulq_f32(phase_vec.val[0], inv_mag);
189 phase_vec.val[1] = vmulq_f32(phase_vec.val[1], inv_mag);
192 vst2q_f32((
float*)phasePtr, phase_vec);
195 for (
i = 0;
i < num_points % 4;
i++) {
196 *outputVectorPtr++ = *inputVectorPtr++ * phasePtr[0];
197 phasePtr[0] *= (*phase_inc);
201 (*phase) = phasePtr[0];
208#include <smmintrin.h>
210static inline void volk_32fc_s32fc_x2_rotator2_32fc_a_sse4_1(
lv_32fc_t* outVector,
214 unsigned int num_points)
219 lv_32fc_t phase_Ptr[2] = { (*phase), (*phase) };
221 unsigned int i, j = 0;
223 for (
i = 0;
i < 2; ++
i) {
224 phase_Ptr[
i] *= incr;
225 incr *= (*phase_inc);
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);
236 aVal = _mm_load_ps((
float*)aPtr);
238 yl = _mm_moveldup_ps(phase_Val);
239 yh = _mm_movehdup_ps(phase_Val);
240 ylp = _mm_moveldup_ps(inc_Val);
241 yhp = _mm_movehdup_ps(inc_Val);
243 tmp1 = _mm_mul_ps(aVal, yl);
244 tmp1p = _mm_mul_ps(phase_Val, ylp);
246 aVal = _mm_shuffle_ps(aVal, aVal, 0xB1);
247 phase_Val = _mm_shuffle_ps(phase_Val, phase_Val, 0xB1);
248 tmp2 = _mm_mul_ps(aVal, yh);
249 tmp2p = _mm_mul_ps(phase_Val, yhp);
251 z = _mm_addsub_ps(tmp1, tmp2);
252 phase_Val = _mm_addsub_ps(tmp1p, tmp2p);
254 _mm_store_ps((
float*)cPtr, z);
259 tmp1 = _mm_mul_ps(phase_Val, phase_Val);
260 tmp2 = _mm_hadd_ps(tmp1, tmp1);
261 tmp1 = _mm_shuffle_ps(tmp2, tmp2, 0xD8);
262 tmp2 = _mm_sqrt_ps(tmp1);
263 phase_Val = _mm_div_ps(phase_Val, tmp2);
266 aVal = _mm_load_ps((
float*)aPtr);
268 yl = _mm_moveldup_ps(phase_Val);
269 yh = _mm_movehdup_ps(phase_Val);
270 ylp = _mm_moveldup_ps(inc_Val);
271 yhp = _mm_movehdup_ps(inc_Val);
273 tmp1 = _mm_mul_ps(aVal, yl);
275 tmp1p = _mm_mul_ps(phase_Val, ylp);
277 aVal = _mm_shuffle_ps(aVal, aVal, 0xB1);
278 phase_Val = _mm_shuffle_ps(phase_Val, phase_Val, 0xB1);
279 tmp2 = _mm_mul_ps(aVal, yh);
280 tmp2p = _mm_mul_ps(phase_Val, yhp);
282 z = _mm_addsub_ps(tmp1, tmp2);
283 phase_Val = _mm_addsub_ps(tmp1p, tmp2p);
285 _mm_store_ps((
float*)cPtr, z);
291 tmp1 = _mm_mul_ps(phase_Val, phase_Val);
292 tmp2 = _mm_hadd_ps(tmp1, tmp1);
293 tmp1 = _mm_shuffle_ps(tmp2, tmp2, 0xD8);
294 tmp2 = _mm_sqrt_ps(tmp1);
295 phase_Val = _mm_div_ps(phase_Val, tmp2);
298 _mm_storeu_ps((
float*)phase_Ptr, phase_Val);
299 if (num_points & 1) {
300 *cPtr++ = *aPtr++ * phase_Ptr[0];
301 phase_Ptr[0] *= (*phase_inc);
304 (*phase) = phase_Ptr[0];
311#include <smmintrin.h>
313static inline void volk_32fc_s32fc_x2_rotator2_32fc_u_sse4_1(
lv_32fc_t* outVector,
317 unsigned int num_points)
322 lv_32fc_t phase_Ptr[2] = { (*phase), (*phase) };
324 unsigned int i, j = 0;
326 for (
i = 0;
i < 2; ++
i) {
327 phase_Ptr[
i] *= incr;
328 incr *= (*phase_inc);
334 __m128 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
336 phase_Val = _mm_loadu_ps((
float*)phase_Ptr);
342 aVal = _mm_loadu_ps((
float*)aPtr);
344 yl = _mm_moveldup_ps(phase_Val);
345 yh = _mm_movehdup_ps(phase_Val);
346 ylp = _mm_moveldup_ps(inc_Val);
347 yhp = _mm_movehdup_ps(inc_Val);
349 tmp1 = _mm_mul_ps(aVal, yl);
350 tmp1p = _mm_mul_ps(phase_Val, ylp);
352 aVal = _mm_shuffle_ps(aVal, aVal, 0xB1);
353 phase_Val = _mm_shuffle_ps(phase_Val, phase_Val, 0xB1);
354 tmp2 = _mm_mul_ps(aVal, yh);
355 tmp2p = _mm_mul_ps(phase_Val, yhp);
357 z = _mm_addsub_ps(tmp1, tmp2);
358 phase_Val = _mm_addsub_ps(tmp1p, tmp2p);
360 _mm_storeu_ps((
float*)cPtr, z);
365 tmp1 = _mm_mul_ps(phase_Val, phase_Val);
366 tmp2 = _mm_hadd_ps(tmp1, tmp1);
367 tmp1 = _mm_shuffle_ps(tmp2, tmp2, 0xD8);
368 tmp2 = _mm_sqrt_ps(tmp1);
369 phase_Val = _mm_div_ps(phase_Val, tmp2);
372 aVal = _mm_loadu_ps((
float*)aPtr);
374 yl = _mm_moveldup_ps(phase_Val);
375 yh = _mm_movehdup_ps(phase_Val);
376 ylp = _mm_moveldup_ps(inc_Val);
377 yhp = _mm_movehdup_ps(inc_Val);
379 tmp1 = _mm_mul_ps(aVal, yl);
381 tmp1p = _mm_mul_ps(phase_Val, ylp);
383 aVal = _mm_shuffle_ps(aVal, aVal, 0xB1);
384 phase_Val = _mm_shuffle_ps(phase_Val, phase_Val, 0xB1);
385 tmp2 = _mm_mul_ps(aVal, yh);
386 tmp2p = _mm_mul_ps(phase_Val, yhp);
388 z = _mm_addsub_ps(tmp1, tmp2);
389 phase_Val = _mm_addsub_ps(tmp1p, tmp2p);
391 _mm_storeu_ps((
float*)cPtr, z);
397 tmp1 = _mm_mul_ps(phase_Val, phase_Val);
398 tmp2 = _mm_hadd_ps(tmp1, tmp1);
399 tmp1 = _mm_shuffle_ps(tmp2, tmp2, 0xD8);
400 tmp2 = _mm_sqrt_ps(tmp1);
401 phase_Val = _mm_div_ps(phase_Val, tmp2);
404 _mm_storeu_ps((
float*)phase_Ptr, phase_Val);
405 if (num_points & 1) {
406 *cPtr++ = *aPtr++ * phase_Ptr[0];
407 phase_Ptr[0] *= (*phase_inc);
410 (*phase) = phase_Ptr[0];
417#include <immintrin.h>
424 unsigned int num_points)
429 lv_32fc_t phase_Ptr[4] = { (*phase), (*phase), (*phase), (*phase) };
431 unsigned int i, j = 0;
433 for (
i = 0;
i < 4; ++
i) {
434 phase_Ptr[
i] *= incr;
435 incr *= (*phase_inc);
438 __m256 aVal, phase_Val, z;
440 phase_Val = _mm256_loadu_ps((
float*)phase_Ptr);
442 const __m256 inc_Val = _mm256_set_ps(
lv_cimag(incr),
454 aVal = _mm256_load_ps((
float*)aPtr);
459 _mm256_store_ps((
float*)cPtr, z);
468 aVal = _mm256_load_ps((
float*)aPtr);
473 _mm256_store_ps((
float*)cPtr, z);
482 _mm256_storeu_ps((
float*)phase_Ptr, phase_Val);
483 (*phase) = phase_Ptr[0];
485 cPtr, aPtr, phase_inc, phase, num_points % 4);
492#include <immintrin.h>
499 unsigned int num_points)
504 lv_32fc_t phase_Ptr[4] = { (*phase), (*phase), (*phase), (*phase) };
506 unsigned int i, j = 0;
508 for (
i = 0;
i < 4; ++
i) {
509 phase_Ptr[
i] *= incr;
510 incr *= (*phase_inc);
513 __m256 aVal, phase_Val, z;
515 phase_Val = _mm256_loadu_ps((
float*)phase_Ptr);
517 const __m256 inc_Val = _mm256_set_ps(
lv_cimag(incr),
529 aVal = _mm256_loadu_ps((
float*)aPtr);
534 _mm256_storeu_ps((
float*)cPtr, z);
543 aVal = _mm256_loadu_ps((
float*)aPtr);
548 _mm256_storeu_ps((
float*)cPtr, z);
557 _mm256_storeu_ps((
float*)phase_Ptr, phase_Val);
558 (*phase) = phase_Ptr[0];
560 cPtr, aPtr, phase_inc, phase, num_points % 4);
565#if LV_HAVE_AVX && LV_HAVE_FMA
566#include <immintrin.h>
568static inline void volk_32fc_s32fc_x2_rotator2_32fc_a_avx_fma(
lv_32fc_t* outVector,
572 unsigned int num_points)
578 lv_32fc_t phase_Ptr[4] = { (*phase), (*phase), (*phase), (*phase) };
580 unsigned int i, j = 0;
582 for (
i = 0;
i < 4; ++
i) {
583 phase_Ptr[
i] *= incr;
584 incr *= (*phase_inc);
587 __m256 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
589 phase_Val = _mm256_load_ps((
float*)phase_Ptr);
590 inc_Val = _mm256_set_ps(
lv_cimag(incr),
602 aVal = _mm256_load_ps((
float*)aPtr);
604 yl = _mm256_moveldup_ps(phase_Val);
605 yh = _mm256_movehdup_ps(phase_Val);
606 ylp = _mm256_moveldup_ps(inc_Val);
607 yhp = _mm256_movehdup_ps(inc_Val);
612 aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
613 phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
614 tmp2 = _mm256_mul_ps(aVal, yh);
615 tmp2p = _mm256_mul_ps(phase_Val, yhp);
617 z = _mm256_fmaddsub_ps(tmp1, yl, tmp2);
618 phase_Val = _mm256_fmaddsub_ps(tmp1p, ylp, tmp2p);
620 _mm256_store_ps((
float*)cPtr, z);
625 tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
626 tmp2 = _mm256_hadd_ps(tmp1, tmp1);
627 tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
628 tmp2 = _mm256_sqrt_ps(tmp1);
629 phase_Val = _mm256_div_ps(phase_Val, tmp2);
632 aVal = _mm256_load_ps((
float*)aPtr);
634 yl = _mm256_moveldup_ps(phase_Val);
635 yh = _mm256_movehdup_ps(phase_Val);
636 ylp = _mm256_moveldup_ps(inc_Val);
637 yhp = _mm256_movehdup_ps(inc_Val);
642 aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
643 phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
644 tmp2 = _mm256_mul_ps(aVal, yh);
645 tmp2p = _mm256_mul_ps(phase_Val, yhp);
647 z = _mm256_fmaddsub_ps(tmp1, yl, tmp2);
648 phase_Val = _mm256_fmaddsub_ps(tmp1p, ylp, tmp2p);
650 _mm256_store_ps((
float*)cPtr, z);
656 tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
657 tmp2 = _mm256_hadd_ps(tmp1, tmp1);
658 tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
659 tmp2 = _mm256_sqrt_ps(tmp1);
660 phase_Val = _mm256_div_ps(phase_Val, tmp2);
663 _mm256_store_ps((
float*)phase_Ptr, phase_Val);
664 for (
i = 0;
i < num_points % 4; ++
i) {
665 *cPtr++ = *aPtr++ * phase_Ptr[0];
666 phase_Ptr[0] *= (*phase_inc);
669 (*phase) = phase_Ptr[0];
674#if LV_HAVE_AVX && LV_HAVE_FMA
675#include <immintrin.h>
677static inline void volk_32fc_s32fc_x2_rotator2_32fc_u_avx_fma(
lv_32fc_t* outVector,
681 unsigned int num_points)
686 lv_32fc_t phase_Ptr[4] = { (*phase), (*phase), (*phase), (*phase) };
688 unsigned int i, j = 0;
690 for (
i = 0;
i < 4; ++
i) {
691 phase_Ptr[
i] *= incr;
692 incr *= (*phase_inc);
695 __m256 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
697 phase_Val = _mm256_loadu_ps((
float*)phase_Ptr);
698 inc_Val = _mm256_set_ps(
lv_cimag(incr),
710 aVal = _mm256_loadu_ps((
float*)aPtr);
712 yl = _mm256_moveldup_ps(phase_Val);
713 yh = _mm256_movehdup_ps(phase_Val);
714 ylp = _mm256_moveldup_ps(inc_Val);
715 yhp = _mm256_movehdup_ps(inc_Val);
720 aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
721 phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
722 tmp2 = _mm256_mul_ps(aVal, yh);
723 tmp2p = _mm256_mul_ps(phase_Val, yhp);
725 z = _mm256_fmaddsub_ps(tmp1, yl, tmp2);
726 phase_Val = _mm256_fmaddsub_ps(tmp1p, ylp, tmp2p);
728 _mm256_storeu_ps((
float*)cPtr, z);
733 tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
734 tmp2 = _mm256_hadd_ps(tmp1, tmp1);
735 tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
736 tmp2 = _mm256_sqrt_ps(tmp1);
737 phase_Val = _mm256_div_ps(phase_Val, tmp2);
740 aVal = _mm256_loadu_ps((
float*)aPtr);
742 yl = _mm256_moveldup_ps(phase_Val);
743 yh = _mm256_movehdup_ps(phase_Val);
744 ylp = _mm256_moveldup_ps(inc_Val);
745 yhp = _mm256_movehdup_ps(inc_Val);
750 aVal = _mm256_shuffle_ps(aVal, aVal, 0xB1);
751 phase_Val = _mm256_shuffle_ps(phase_Val, phase_Val, 0xB1);
752 tmp2 = _mm256_mul_ps(aVal, yh);
753 tmp2p = _mm256_mul_ps(phase_Val, yhp);
755 z = _mm256_fmaddsub_ps(tmp1, yl, tmp2);
756 phase_Val = _mm256_fmaddsub_ps(tmp1p, ylp, tmp2p);
758 _mm256_storeu_ps((
float*)cPtr, z);
764 tmp1 = _mm256_mul_ps(phase_Val, phase_Val);
765 tmp2 = _mm256_hadd_ps(tmp1, tmp1);
766 tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
767 tmp2 = _mm256_sqrt_ps(tmp1);
768 phase_Val = _mm256_div_ps(phase_Val, tmp2);
771 _mm256_storeu_ps((
float*)phase_Ptr, phase_Val);
772 for (
i = 0;
i < num_points % 4; ++
i) {
773 *cPtr++ = *aPtr++ * phase_Ptr[0];
774 phase_Ptr[0] *= (*phase_inc);
777 (*phase) = phase_Ptr[0];
788#include <riscv_vector.h>
790static inline void volk_32fc_s32fc_x2_rotator2_32fc_rvv(
lv_32fc_t* outVector,
794 unsigned int num_points)
796 size_t vlmax = __riscv_vsetvlmax_e32m2();
800 vfloat32m2_t phr = __riscv_vfmv_v_f_f32m2(0, vlmax), phi = phr;
801 for (
size_t i = 0;
i < vlmax; ++
i) {
805 phr = __riscv_vfslide1down(phr,
lv_creal(ph), vlmax);
806 phi = __riscv_vfslide1down(phi,
lv_cimag(ph), vlmax);
811 vfloat32m2_t incr = __riscv_vfmv_v_f_f32m2(
lv_creal(inc), vlmax);
812 vfloat32m2_t inci = __riscv_vfmv_v_f_f32m2(
lv_cimag(inc), vlmax);
820 for (; n > 0; n -= vl, inVector += vl, outVector += vl) {
822 vl = __riscv_vsetvl_e32m2(n < vlmax ? n : vlmax);
824 vuint64m4_t va = __riscv_vle64_v_u64m4((
const uint64_t*)inVector, vl);
825 vfloat32m2_t var = __riscv_vreinterpret_f32m2(__riscv_vnsrl(va, 0, vl));
826 vfloat32m2_t vai = __riscv_vreinterpret_f32m2(__riscv_vnsrl(va, 32, vl));
829 __riscv_vfnmsac(__riscv_vfmul(var, phr, vl), vai, phi, vl);
831 __riscv_vfmacc(__riscv_vfmul(var, phi, vl), vai, phr, vl);
833 vuint32m2_t vru = __riscv_vreinterpret_u32m2(vr);
834 vuint32m2_t viu = __riscv_vreinterpret_u32m2(vi);
836 __riscv_vwmaccu(__riscv_vwaddu_vv(vru, viu, vl), 0xFFFFFFFF, viu, vl);
837 __riscv_vse64((uint64_t*)outVector, res, vl);
839 vfloat32m2_t tmp = phr;
840 phr = __riscv_vfnmsac(__riscv_vfmul(tmp, incr, vl), phi, inci, vl);
841 phi = __riscv_vfmacc(__riscv_vfmul(tmp, inci, vl), phi, incr, vl);
849 __riscv_vfmacc(__riscv_vfmul(phr, phr, vl), phi, phi, vl);
850 scale = __riscv_vfsqrt(scale, vl);
851 phr = __riscv_vfdiv(phr, scale, vl);
852 phi = __riscv_vfdiv(phi, scale, vl);
856 for (
size_t i = 0;
i < vlmax - vl; ++
i) {
864#include <riscv_vector.h>
866static inline void volk_32fc_s32fc_x2_rotator2_32fc_rvvseg(
lv_32fc_t* outVector,
870 unsigned int num_points)
872 size_t vlmax = __riscv_vsetvlmax_e32m2();
876 vfloat32m2_t phr = __riscv_vfmv_v_f_f32m2(0, vlmax), phi = phr;
877 for (
size_t i = 0;
i < vlmax; ++
i) {
881 phr = __riscv_vfslide1down(phr,
lv_creal(ph), vlmax);
882 phi = __riscv_vfslide1down(phi,
lv_cimag(ph), vlmax);
887 vfloat32m2_t incr = __riscv_vfmv_v_f_f32m2(
lv_creal(inc), vlmax);
888 vfloat32m2_t inci = __riscv_vfmv_v_f_f32m2(
lv_cimag(inc), vlmax);
896 for (; n > 0; n -= vl, inVector += vl, outVector += vl) {
898 vl = __riscv_vsetvl_e32m2(n < vlmax ? n : vlmax);
901 __riscv_vlseg2e32_v_f32m2x2((
const float*)inVector, vl);
902 vfloat32m2_t var = __riscv_vget_f32m2(va, 0);
903 vfloat32m2_t vai = __riscv_vget_f32m2(va, 1);
906 __riscv_vfnmsac(__riscv_vfmul(var, phr, vl), vai, phi, vl);
908 __riscv_vfmacc(__riscv_vfmul(var, phi, vl), vai, phr, vl);
909 vfloat32m2x2_t vc = __riscv_vcreate_v_f32m2x2(vr, vi);
910 __riscv_vsseg2e32_v_f32m2x2((
float*)outVector, vc, vl);
912 vfloat32m2_t tmp = phr;
913 phr = __riscv_vfnmsac(__riscv_vfmul(tmp, incr, vl), phi, inci, vl);
914 phi = __riscv_vfmacc(__riscv_vfmul(tmp, inci, vl), phi, incr, vl);
922 __riscv_vfmacc(__riscv_vfmul(phr, phr, vl), phi, phi, vl);
923 scale = __riscv_vfsqrt(scale, vl);
924 phr = __riscv_vfdiv(phr, scale, vl);
925 phi = __riscv_vfdiv(phi, scale, vl);
929 for (
size_t i = 0;
i < vlmax - vl; ++
i) {
static void volk_32fc_s32fc_x2_rotator2_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_rotator2_32fc.h:83
static void volk_32fc_s32fc_x2_rotator2_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_rotator2_32fc.h:420
static void volk_32fc_s32fc_x2_rotator2_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_rotator2_32fc.h:495
#define ROTATOR_RELOAD_4
Definition volk_32fc_s32fc_x2_rotator2_32fc.h:78
#define ROTATOR_RELOAD_2
Definition volk_32fc_s32fc_x2_rotator2_32fc.h:77
#define ROTATOR_RELOAD
Definition volk_32fc_s32fc_x2_rotator2_32fc.h:76
static void volk_32fc_s32fc_x2_rotator2_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_rotator2_32fc.h:116
static __m256 _mm256_complexmul_ps(__m256 x, __m256 y)
Definition volk_avx_intrinsics.h:57
static __m256 _mm256_normalize_ps(__m256 val)
Definition volk_avx_intrinsics.h:89
#define __VOLK_PREFETCH(addr)
Definition volk_common.h:68
#define __VOLK_ATTR_ALIGNED(x)
Definition volk_common.h:62
#define lv_cimag(x)
Definition volk_complex.h:98
#define lv_cmake(r, i)
Definition volk_complex.h:77
#define lv_creal(x)
Definition volk_complex.h:96
float complex lv_32fc_t
Definition volk_complex.h:74
for i
Definition volk_config_fixed.tmpl.h:13
static float32x4_t _vinvsqrtq_f32(float32x4_t x)
Definition volk_neon_intrinsics.h:83
static float32x4x2_t _vmultiply_complexq_f32(float32x4x2_t a_val, float32x4x2_t b_val)
Definition volk_neon_intrinsics.h:105
static float32x4_t _vmagnitudesquaredq_f32(float32x4x2_t cmplxValue)
Definition volk_neon_intrinsics.h:73