61#ifndef INCLUDED_volk_32f_s32f_calc_spectral_noise_floor_32f_a_H
62#define INCLUDED_volk_32f_s32f_calc_spectral_noise_floor_32f_a_H
73 const float* realDataPoints,
74 const float spectralExclusionValue,
75 const unsigned int num_points)
77 unsigned int number = 0;
78 const unsigned int eighthPoints = num_points / 8;
80 const float* dataPointsPtr = realDataPoints;
84 __m256 avgPointsVal = _mm256_setzero_ps();
86 for (; number < eighthPoints; number++) {
88 dataPointsVal = _mm256_load_ps(dataPointsPtr);
92 avgPointsVal = _mm256_add_ps(avgPointsVal, dataPointsVal);
95 _mm256_store_ps(avgPointsVector, avgPointsVal);
98 sumMean += avgPointsVector[0];
99 sumMean += avgPointsVector[1];
100 sumMean += avgPointsVector[2];
101 sumMean += avgPointsVector[3];
102 sumMean += avgPointsVector[4];
103 sumMean += avgPointsVector[5];
104 sumMean += avgPointsVector[6];
105 sumMean += avgPointsVector[7];
107 number = eighthPoints * 8;
108 for (; number < num_points; number++) {
109 sumMean += realDataPoints[number];
115 const float meanAmplitude = (sumMean / ((float)num_points)) + spectralExclusionValue;
117 dataPointsPtr = realDataPoints;
118 __m256 vMeanAmplitudeVector = _mm256_set1_ps(meanAmplitude);
119 __m256 vOnesVector = _mm256_set1_ps(1.0);
120 __m256 vValidBinCount = _mm256_setzero_ps();
121 avgPointsVal = _mm256_setzero_ps();
125 for (; number < eighthPoints; number++) {
127 dataPointsVal = _mm256_load_ps(dataPointsPtr);
132 compareMask = _mm256_cmp_ps(dataPointsVal, vMeanAmplitudeVector, _CMP_LE_OQ);
137 _mm256_add_ps(avgPointsVal, _mm256_and_ps(compareMask, dataPointsVal));
141 _mm256_add_ps(vValidBinCount, _mm256_and_ps(compareMask, vOnesVector));
145 _mm256_store_ps(avgPointsVector, avgPointsVal);
148 sumMean += avgPointsVector[0];
149 sumMean += avgPointsVector[1];
150 sumMean += avgPointsVector[2];
151 sumMean += avgPointsVector[3];
152 sumMean += avgPointsVector[4];
153 sumMean += avgPointsVector[5];
154 sumMean += avgPointsVector[6];
155 sumMean += avgPointsVector[7];
159 _mm256_store_ps(validBinCountVector, vValidBinCount);
161 float validBinCount = 0;
162 validBinCount += validBinCountVector[0];
163 validBinCount += validBinCountVector[1];
164 validBinCount += validBinCountVector[2];
165 validBinCount += validBinCountVector[3];
166 validBinCount += validBinCountVector[4];
167 validBinCount += validBinCountVector[5];
168 validBinCount += validBinCountVector[6];
169 validBinCount += validBinCountVector[7];
171 number = eighthPoints * 8;
172 for (; number < num_points; number++) {
173 if (realDataPoints[number] <= meanAmplitude) {
174 sumMean += realDataPoints[number];
175 validBinCount += 1.0;
179 float localNoiseFloorAmplitude = 0;
180 if (validBinCount > 0.0) {
181 localNoiseFloorAmplitude = sumMean / validBinCount;
183 localNoiseFloorAmplitude =
187 *noiseFloorAmplitude = localNoiseFloorAmplitude;
192#include <xmmintrin.h>
196 const float* realDataPoints,
197 const float spectralExclusionValue,
198 const unsigned int num_points)
200 unsigned int number = 0;
201 const unsigned int quarterPoints = num_points / 4;
203 const float* dataPointsPtr = realDataPoints;
206 __m128 dataPointsVal;
207 __m128 avgPointsVal = _mm_setzero_ps();
209 for (; number < quarterPoints; number++) {
211 dataPointsVal = _mm_load_ps(dataPointsPtr);
215 avgPointsVal = _mm_add_ps(avgPointsVal, dataPointsVal);
218 _mm_store_ps(avgPointsVector, avgPointsVal);
221 sumMean += avgPointsVector[0];
222 sumMean += avgPointsVector[1];
223 sumMean += avgPointsVector[2];
224 sumMean += avgPointsVector[3];
226 number = quarterPoints * 4;
227 for (; number < num_points; number++) {
228 sumMean += realDataPoints[number];
234 const float meanAmplitude = (sumMean / ((float)num_points)) + spectralExclusionValue;
236 dataPointsPtr = realDataPoints;
237 __m128 vMeanAmplitudeVector = _mm_set_ps1(meanAmplitude);
238 __m128 vOnesVector = _mm_set_ps1(1.0);
239 __m128 vValidBinCount = _mm_setzero_ps();
240 avgPointsVal = _mm_setzero_ps();
244 for (; number < quarterPoints; number++) {
246 dataPointsVal = _mm_load_ps(dataPointsPtr);
251 compareMask = _mm_cmple_ps(dataPointsVal, vMeanAmplitudeVector);
255 avgPointsVal = _mm_add_ps(avgPointsVal, _mm_and_ps(compareMask, dataPointsVal));
258 vValidBinCount = _mm_add_ps(vValidBinCount, _mm_and_ps(compareMask, vOnesVector));
262 _mm_store_ps(avgPointsVector, avgPointsVal);
265 sumMean += avgPointsVector[0];
266 sumMean += avgPointsVector[1];
267 sumMean += avgPointsVector[2];
268 sumMean += avgPointsVector[3];
272 _mm_store_ps(validBinCountVector, vValidBinCount);
274 float validBinCount = 0;
275 validBinCount += validBinCountVector[0];
276 validBinCount += validBinCountVector[1];
277 validBinCount += validBinCountVector[2];
278 validBinCount += validBinCountVector[3];
280 number = quarterPoints * 4;
281 for (; number < num_points; number++) {
282 if (realDataPoints[number] <= meanAmplitude) {
283 sumMean += realDataPoints[number];
284 validBinCount += 1.0;
288 float localNoiseFloorAmplitude = 0;
289 if (validBinCount > 0.0) {
290 localNoiseFloorAmplitude = sumMean / validBinCount;
292 localNoiseFloorAmplitude =
296 *noiseFloorAmplitude = localNoiseFloorAmplitude;
301#ifdef LV_HAVE_GENERIC
305 const float* realDataPoints,
306 const float spectralExclusionValue,
307 const unsigned int num_points)
312 for (number = 0; number < num_points; number++) {
314 sumMean += realDataPoints[number];
320 const float meanAmplitude = (sumMean / num_points) + spectralExclusionValue;
324 unsigned int newNumDataPoints = num_points;
325 for (number = 0; number < num_points; number++) {
326 if (realDataPoints[number] <= meanAmplitude)
327 sumMean += realDataPoints[number];
332 float localNoiseFloorAmplitude = 0.0;
333 if (newNumDataPoints == 0)
334 localNoiseFloorAmplitude = meanAmplitude;
336 localNoiseFloorAmplitude = sumMean / ((float)newNumDataPoints);
338 *noiseFloorAmplitude = localNoiseFloorAmplitude;
345#ifndef INCLUDED_volk_32f_s32f_calc_spectral_noise_floor_32f_u_H
346#define INCLUDED_volk_32f_s32f_calc_spectral_noise_floor_32f_u_H
353#include <immintrin.h>
357 const float* realDataPoints,
358 const float spectralExclusionValue,
359 const unsigned int num_points)
361 unsigned int number = 0;
362 const unsigned int eighthPoints = num_points / 8;
364 const float* dataPointsPtr = realDataPoints;
367 __m256 dataPointsVal;
368 __m256 avgPointsVal = _mm256_setzero_ps();
370 for (; number < eighthPoints; number++) {
372 dataPointsVal = _mm256_loadu_ps(dataPointsPtr);
376 avgPointsVal = _mm256_add_ps(avgPointsVal, dataPointsVal);
379 _mm256_storeu_ps(avgPointsVector, avgPointsVal);
382 sumMean += avgPointsVector[0];
383 sumMean += avgPointsVector[1];
384 sumMean += avgPointsVector[2];
385 sumMean += avgPointsVector[3];
386 sumMean += avgPointsVector[4];
387 sumMean += avgPointsVector[5];
388 sumMean += avgPointsVector[6];
389 sumMean += avgPointsVector[7];
391 number = eighthPoints * 8;
392 for (; number < num_points; number++) {
393 sumMean += realDataPoints[number];
399 const float meanAmplitude = (sumMean / ((float)num_points)) + spectralExclusionValue;
401 dataPointsPtr = realDataPoints;
402 __m256 vMeanAmplitudeVector = _mm256_set1_ps(meanAmplitude);
403 __m256 vOnesVector = _mm256_set1_ps(1.0);
404 __m256 vValidBinCount = _mm256_setzero_ps();
405 avgPointsVal = _mm256_setzero_ps();
409 for (; number < eighthPoints; number++) {
411 dataPointsVal = _mm256_loadu_ps(dataPointsPtr);
416 compareMask = _mm256_cmp_ps(dataPointsVal, vMeanAmplitudeVector, _CMP_LE_OQ);
421 _mm256_add_ps(avgPointsVal, _mm256_and_ps(compareMask, dataPointsVal));
425 _mm256_add_ps(vValidBinCount, _mm256_and_ps(compareMask, vOnesVector));
429 _mm256_storeu_ps(avgPointsVector, avgPointsVal);
432 sumMean += avgPointsVector[0];
433 sumMean += avgPointsVector[1];
434 sumMean += avgPointsVector[2];
435 sumMean += avgPointsVector[3];
436 sumMean += avgPointsVector[4];
437 sumMean += avgPointsVector[5];
438 sumMean += avgPointsVector[6];
439 sumMean += avgPointsVector[7];
443 _mm256_storeu_ps(validBinCountVector, vValidBinCount);
445 float validBinCount = 0;
446 validBinCount += validBinCountVector[0];
447 validBinCount += validBinCountVector[1];
448 validBinCount += validBinCountVector[2];
449 validBinCount += validBinCountVector[3];
450 validBinCount += validBinCountVector[4];
451 validBinCount += validBinCountVector[5];
452 validBinCount += validBinCountVector[6];
453 validBinCount += validBinCountVector[7];
455 number = eighthPoints * 8;
456 for (; number < num_points; number++) {
457 if (realDataPoints[number] <= meanAmplitude) {
458 sumMean += realDataPoints[number];
459 validBinCount += 1.0;
463 float localNoiseFloorAmplitude = 0;
464 if (validBinCount > 0.0) {
465 localNoiseFloorAmplitude = sumMean / validBinCount;
467 localNoiseFloorAmplitude =
471 *noiseFloorAmplitude = localNoiseFloorAmplitude;
static void volk_32f_s32f_calc_spectral_noise_floor_32f_u_avx(float *noiseFloorAmplitude, const float *realDataPoints, const float spectralExclusionValue, const unsigned int num_points)
Definition: volk_32f_s32f_calc_spectral_noise_floor_32f.h:356
static void volk_32f_s32f_calc_spectral_noise_floor_32f_generic(float *noiseFloorAmplitude, const float *realDataPoints, const float spectralExclusionValue, const unsigned int num_points)
Definition: volk_32f_s32f_calc_spectral_noise_floor_32f.h:304
static void volk_32f_s32f_calc_spectral_noise_floor_32f_a_sse(float *noiseFloorAmplitude, const float *realDataPoints, const float spectralExclusionValue, const unsigned int num_points)
Definition: volk_32f_s32f_calc_spectral_noise_floor_32f.h:195
static void volk_32f_s32f_calc_spectral_noise_floor_32f_a_avx(float *noiseFloorAmplitude, const float *realDataPoints, const float spectralExclusionValue, const unsigned int num_points)
Definition: volk_32f_s32f_calc_spectral_noise_floor_32f.h:72
#define __VOLK_ATTR_ALIGNED(x)
Definition: volk_common.h:56