59 #ifndef INCLUDED_volk_32f_s32f_calc_spectral_noise_floor_32f_a_H 60 #define INCLUDED_volk_32f_s32f_calc_spectral_noise_floor_32f_a_H 67 #include <immintrin.h> 71 const float* realDataPoints,
72 const float spectralExclusionValue,
73 const unsigned int num_points)
75 unsigned int number = 0;
76 const unsigned int eighthPoints = num_points / 8;
78 const float* dataPointsPtr = realDataPoints;
82 __m256 avgPointsVal = _mm256_setzero_ps();
84 for(; number < eighthPoints; number++){
86 dataPointsVal = _mm256_load_ps(dataPointsPtr);
90 avgPointsVal = _mm256_add_ps(avgPointsVal, dataPointsVal);
93 _mm256_store_ps(avgPointsVector, avgPointsVal);
96 sumMean += avgPointsVector[0];
97 sumMean += avgPointsVector[1];
98 sumMean += avgPointsVector[2];
99 sumMean += avgPointsVector[3];
100 sumMean += avgPointsVector[4];
101 sumMean += avgPointsVector[5];
102 sumMean += avgPointsVector[6];
103 sumMean += avgPointsVector[7];
105 number = eighthPoints * 8;
106 for(;number < num_points; number++){
107 sumMean += realDataPoints[number];
113 const float meanAmplitude = (sumMean / ((float)num_points)) + spectralExclusionValue;
115 dataPointsPtr = realDataPoints;
116 __m256 vMeanAmplitudeVector = _mm256_set1_ps(meanAmplitude);
117 __m256 vOnesVector = _mm256_set1_ps(1.0);
118 __m256 vValidBinCount = _mm256_setzero_ps();
119 avgPointsVal = _mm256_setzero_ps();
123 for(; number < eighthPoints; number++){
125 dataPointsVal = _mm256_load_ps(dataPointsPtr);
130 compareMask = _mm256_cmp_ps(dataPointsVal, vMeanAmplitudeVector, 18);
133 avgPointsVal = _mm256_add_ps(avgPointsVal, _mm256_and_ps(compareMask, dataPointsVal));
136 vValidBinCount = _mm256_add_ps(vValidBinCount, _mm256_and_ps(compareMask, vOnesVector));
140 _mm256_store_ps(avgPointsVector, avgPointsVal);
143 sumMean += avgPointsVector[0];
144 sumMean += avgPointsVector[1];
145 sumMean += avgPointsVector[2];
146 sumMean += avgPointsVector[3];
147 sumMean += avgPointsVector[4];
148 sumMean += avgPointsVector[5];
149 sumMean += avgPointsVector[6];
150 sumMean += avgPointsVector[7];
154 _mm256_store_ps(validBinCountVector, vValidBinCount);
156 float validBinCount = 0;
157 validBinCount += validBinCountVector[0];
158 validBinCount += validBinCountVector[1];
159 validBinCount += validBinCountVector[2];
160 validBinCount += validBinCountVector[3];
161 validBinCount += validBinCountVector[4];
162 validBinCount += validBinCountVector[5];
163 validBinCount += validBinCountVector[6];
164 validBinCount += validBinCountVector[7];
166 number = eighthPoints * 8;
167 for(;number < num_points; number++){
168 if(realDataPoints[number] <= meanAmplitude){
169 sumMean += realDataPoints[number];
170 validBinCount += 1.0;
174 float localNoiseFloorAmplitude = 0;
175 if(validBinCount > 0.0){
176 localNoiseFloorAmplitude = sumMean / validBinCount;
179 localNoiseFloorAmplitude = meanAmplitude;
182 *noiseFloorAmplitude = localNoiseFloorAmplitude;
187 #include <xmmintrin.h> 191 const float* realDataPoints,
192 const float spectralExclusionValue,
193 const unsigned int num_points)
195 unsigned int number = 0;
196 const unsigned int quarterPoints = num_points / 4;
198 const float* dataPointsPtr = realDataPoints;
201 __m128 dataPointsVal;
202 __m128 avgPointsVal = _mm_setzero_ps();
204 for(; number < quarterPoints; number++){
206 dataPointsVal = _mm_load_ps(dataPointsPtr);
210 avgPointsVal = _mm_add_ps(avgPointsVal, dataPointsVal);
213 _mm_store_ps(avgPointsVector, avgPointsVal);
216 sumMean += avgPointsVector[0];
217 sumMean += avgPointsVector[1];
218 sumMean += avgPointsVector[2];
219 sumMean += avgPointsVector[3];
221 number = quarterPoints * 4;
222 for(;number < num_points; number++){
223 sumMean += realDataPoints[number];
229 const float meanAmplitude = (sumMean / ((float)num_points)) + spectralExclusionValue;
231 dataPointsPtr = realDataPoints;
232 __m128 vMeanAmplitudeVector = _mm_set_ps1(meanAmplitude);
233 __m128 vOnesVector = _mm_set_ps1(1.0);
234 __m128 vValidBinCount = _mm_setzero_ps();
235 avgPointsVal = _mm_setzero_ps();
239 for(; number < quarterPoints; number++){
241 dataPointsVal = _mm_load_ps(dataPointsPtr);
246 compareMask = _mm_cmple_ps(dataPointsVal, vMeanAmplitudeVector);
249 avgPointsVal = _mm_add_ps(avgPointsVal, _mm_and_ps(compareMask, dataPointsVal));
252 vValidBinCount = _mm_add_ps(vValidBinCount, _mm_and_ps(compareMask, vOnesVector));
256 _mm_store_ps(avgPointsVector, avgPointsVal);
259 sumMean += avgPointsVector[0];
260 sumMean += avgPointsVector[1];
261 sumMean += avgPointsVector[2];
262 sumMean += avgPointsVector[3];
266 _mm_store_ps(validBinCountVector, vValidBinCount);
268 float validBinCount = 0;
269 validBinCount += validBinCountVector[0];
270 validBinCount += validBinCountVector[1];
271 validBinCount += validBinCountVector[2];
272 validBinCount += validBinCountVector[3];
274 number = quarterPoints * 4;
275 for(;number < num_points; number++){
276 if(realDataPoints[number] <= meanAmplitude){
277 sumMean += realDataPoints[number];
278 validBinCount += 1.0;
282 float localNoiseFloorAmplitude = 0;
283 if(validBinCount > 0.0){
284 localNoiseFloorAmplitude = sumMean / validBinCount;
287 localNoiseFloorAmplitude = meanAmplitude;
290 *noiseFloorAmplitude = localNoiseFloorAmplitude;
295 #ifdef LV_HAVE_GENERIC 299 const float* realDataPoints,
300 const float spectralExclusionValue,
301 const unsigned int num_points)
306 for(number = 0; number < num_points; number++){
308 sumMean += realDataPoints[number];
314 const float meanAmplitude = (sumMean / num_points) + spectralExclusionValue;
318 unsigned int newNumDataPoints = num_points;
319 for(number = 0; number < num_points; number++){
320 if (realDataPoints[number] <= meanAmplitude)
321 sumMean += realDataPoints[number];
326 float localNoiseFloorAmplitude = 0.0;
327 if (newNumDataPoints == 0)
328 localNoiseFloorAmplitude = meanAmplitude;
330 localNoiseFloorAmplitude = sumMean / ((float)newNumDataPoints);
332 *noiseFloorAmplitude = localNoiseFloorAmplitude;
339 #ifndef INCLUDED_volk_32f_s32f_calc_spectral_noise_floor_32f_u_H 340 #define INCLUDED_volk_32f_s32f_calc_spectral_noise_floor_32f_u_H 343 #include <inttypes.h> 347 #include <immintrin.h> 351 const float* realDataPoints,
352 const float spectralExclusionValue,
353 const unsigned int num_points)
355 unsigned int number = 0;
356 const unsigned int eighthPoints = num_points / 8;
358 const float* dataPointsPtr = realDataPoints;
361 __m256 dataPointsVal;
362 __m256 avgPointsVal = _mm256_setzero_ps();
364 for(; number < eighthPoints; number++){
366 dataPointsVal = _mm256_loadu_ps(dataPointsPtr);
370 avgPointsVal = _mm256_add_ps(avgPointsVal, dataPointsVal);
373 _mm256_storeu_ps(avgPointsVector, avgPointsVal);
376 sumMean += avgPointsVector[0];
377 sumMean += avgPointsVector[1];
378 sumMean += avgPointsVector[2];
379 sumMean += avgPointsVector[3];
380 sumMean += avgPointsVector[4];
381 sumMean += avgPointsVector[5];
382 sumMean += avgPointsVector[6];
383 sumMean += avgPointsVector[7];
385 number = eighthPoints * 8;
386 for(;number < num_points; number++){
387 sumMean += realDataPoints[number];
393 const float meanAmplitude = (sumMean / ((float)num_points)) + spectralExclusionValue;
395 dataPointsPtr = realDataPoints;
396 __m256 vMeanAmplitudeVector = _mm256_set1_ps(meanAmplitude);
397 __m256 vOnesVector = _mm256_set1_ps(1.0);
398 __m256 vValidBinCount = _mm256_setzero_ps();
399 avgPointsVal = _mm256_setzero_ps();
403 for(; number < eighthPoints; number++){
405 dataPointsVal = _mm256_loadu_ps(dataPointsPtr);
410 compareMask = _mm256_cmp_ps(dataPointsVal, vMeanAmplitudeVector, 18);
413 avgPointsVal = _mm256_add_ps(avgPointsVal, _mm256_and_ps(compareMask, dataPointsVal));
416 vValidBinCount = _mm256_add_ps(vValidBinCount, _mm256_and_ps(compareMask, vOnesVector));
420 _mm256_storeu_ps(avgPointsVector, avgPointsVal);
423 sumMean += avgPointsVector[0];
424 sumMean += avgPointsVector[1];
425 sumMean += avgPointsVector[2];
426 sumMean += avgPointsVector[3];
427 sumMean += avgPointsVector[4];
428 sumMean += avgPointsVector[5];
429 sumMean += avgPointsVector[6];
430 sumMean += avgPointsVector[7];
434 _mm256_storeu_ps(validBinCountVector, vValidBinCount);
436 float validBinCount = 0;
437 validBinCount += validBinCountVector[0];
438 validBinCount += validBinCountVector[1];
439 validBinCount += validBinCountVector[2];
440 validBinCount += validBinCountVector[3];
441 validBinCount += validBinCountVector[4];
442 validBinCount += validBinCountVector[5];
443 validBinCount += validBinCountVector[6];
444 validBinCount += validBinCountVector[7];
446 number = eighthPoints * 8;
447 for(;number < num_points; number++){
448 if(realDataPoints[number] <= meanAmplitude){
449 sumMean += realDataPoints[number];
450 validBinCount += 1.0;
454 float localNoiseFloorAmplitude = 0;
455 if(validBinCount > 0.0){
456 localNoiseFloorAmplitude = sumMean / validBinCount;
459 localNoiseFloorAmplitude = meanAmplitude;
462 *noiseFloorAmplitude = localNoiseFloorAmplitude;
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:298
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:190
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:350
#define __VOLK_ATTR_ALIGNED(x)
Definition: volk_common.h:33
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:70