volk_32f_s32f_convert_32i.h

Go to the documentation of this file.

/* -*- c++ -*- */
/*
 * Copyright 2012, 2014 Free Software Foundation, Inc.
 *
 * This file is part of VOLK
 *
 * SPDX-License-Identifier: LGPL-3.0-or-later
 */
 
#ifndef INCLUDED_volk_32f_s32f_convert_32i_u_H
#define INCLUDED_volk_32f_s32f_convert_32i_u_H
 
#include <inttypes.h>
#include <limits.h>
#include <stdio.h>
 
#ifdef LV_HAVE_AVX
#include <immintrin.h>
 
static inline void volk_32f_s32f_convert_32i_u_avx(int32_t* outputVector,
                                                   const float* inputVector,
                                                   const float scalar,
                                                   unsigned int num_points)
{
    unsigned int number = 0;
 
    const unsigned int eighthPoints = num_points / 8;
 
    const float* inputVectorPtr = (const float*)inputVector;
    int32_t* outputVectorPtr = outputVector;
 
    float min_val = INT_MIN;
    float max_val = INT_MAX;
    float r;
 
    __m256 vScalar = _mm256_set1_ps(scalar);
    __m256 inputVal1;
    __m256i intInputVal1;
    __m256 vmin_val = _mm256_set1_ps(min_val);
    __m256 vmax_val = _mm256_set1_ps(max_val);
 
    for (; number < eighthPoints; number++) {
        inputVal1 = _mm256_loadu_ps(inputVectorPtr);
        inputVectorPtr += 8;
 
        inputVal1 = _mm256_max_ps(
            _mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
        intInputVal1 = _mm256_cvtps_epi32(inputVal1);
 
        _mm256_storeu_si256((__m256i*)outputVectorPtr, intInputVal1);
        outputVectorPtr += 8;
    }
 
    number = eighthPoints * 8;
    for (; number < num_points; number++) {
        r = inputVector[number] * scalar;
        if (r > max_val)
            r = max_val;
        else if (r < min_val)
            r = min_val;
        outputVector[number] = (int32_t)rintf(r);
    }
}
 
#endif /* LV_HAVE_AVX */
 
#ifdef LV_HAVE_SSE2
#include <emmintrin.h>
 
static inline void volk_32f_s32f_convert_32i_u_sse2(int32_t* outputVector,
                                                    const float* inputVector,
                                                    const float scalar,
                                                    unsigned int num_points)
{
    unsigned int number = 0;
 
    const unsigned int quarterPoints = num_points / 4;
 
    const float* inputVectorPtr = (const float*)inputVector;
    int32_t* outputVectorPtr = outputVector;
 
    float min_val = INT_MIN;
    float max_val = INT_MAX;
    float r;
 
    __m128 vScalar = _mm_set_ps1(scalar);
    __m128 inputVal1;
    __m128i intInputVal1;
    __m128 vmin_val = _mm_set_ps1(min_val);
    __m128 vmax_val = _mm_set_ps1(max_val);
 
    for (; number < quarterPoints; number++) {
        inputVal1 = _mm_loadu_ps(inputVectorPtr);
        inputVectorPtr += 4;
 
        inputVal1 =
            _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
        intInputVal1 = _mm_cvtps_epi32(inputVal1);
 
        _mm_storeu_si128((__m128i*)outputVectorPtr, intInputVal1);
        outputVectorPtr += 4;
    }
 
    number = quarterPoints * 4;
    for (; number < num_points; number++) {
        r = inputVector[number] * scalar;
        if (r > max_val)
            r = max_val;
        else if (r < min_val)
            r = min_val;
        outputVector[number] = (int32_t)rintf(r);
    }
}
 
#endif /* LV_HAVE_SSE2 */
 
 
#ifdef LV_HAVE_SSE
#include <xmmintrin.h>
 
static inline void volk_32f_s32f_convert_32i_u_sse(int32_t* outputVector,
                                                   const float* inputVector,
                                                   const float scalar,
                                                   unsigned int num_points)
{
    unsigned int number = 0;
 
    const unsigned int quarterPoints = num_points / 4;
 
    const float* inputVectorPtr = (const float*)inputVector;
    int32_t* outputVectorPtr = outputVector;
 
    float min_val = INT_MIN;
    float max_val = INT_MAX;
    float r;
 
    __m128 vScalar = _mm_set_ps1(scalar);
    __m128 ret;
    __m128 vmin_val = _mm_set_ps1(min_val);
    __m128 vmax_val = _mm_set_ps1(max_val);
 
    __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
 
    for (; number < quarterPoints; number++) {
        ret = _mm_loadu_ps(inputVectorPtr);
        inputVectorPtr += 4;
 
        ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
 
        _mm_store_ps(outputFloatBuffer, ret);
        *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[0]);
        *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[1]);
        *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[2]);
        *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[3]);
    }
 
    number = quarterPoints * 4;
    for (; number < num_points; number++) {
        r = inputVector[number] * scalar;
        if (r > max_val)
            r = max_val;
        else if (r < min_val)
            r = min_val;
        outputVector[number] = (int32_t)rintf(r);
    }
}
 
#endif /* LV_HAVE_SSE */
 
 
#ifdef LV_HAVE_GENERIC
 
static inline void volk_32f_s32f_convert_32i_generic(int32_t* outputVector,
                                                     const float* inputVector,
                                                     const float scalar,
                                                     unsigned int num_points)
{
    int32_t* outputVectorPtr = outputVector;
    const float* inputVectorPtr = inputVector;
    const float min_val = (float)INT_MIN;
    const float max_val = (float)INT_MAX;
 
    for (unsigned int number = 0; number < num_points; number++) {
        const float r = *inputVectorPtr++ * scalar;
        int s;
        if (r >= max_val)
            s = INT_MAX;
        else if (r < min_val)
            s = INT_MIN;
        else
            s = (int32_t)rintf(r);
        *outputVectorPtr++ = s;
    }
}
 
#endif /* LV_HAVE_GENERIC */
 
 
#endif /* INCLUDED_volk_32f_s32f_convert_32i_u_H */
#ifndef INCLUDED_volk_32f_s32f_convert_32i_a_H
#define INCLUDED_volk_32f_s32f_convert_32i_a_H
 
#include <inttypes.h>
#include <stdio.h>
#include <volk/volk_common.h>
 
#ifdef LV_HAVE_AVX
#include <immintrin.h>
 
static inline void volk_32f_s32f_convert_32i_a_avx(int32_t* outputVector,
                                                   const float* inputVector,
                                                   const float scalar,
                                                   unsigned int num_points)
{
    unsigned int number = 0;
 
    const unsigned int eighthPoints = num_points / 8;
 
    const float* inputVectorPtr = (const float*)inputVector;
    int32_t* outputVectorPtr = outputVector;
 
    float min_val = INT_MIN;
    float max_val = INT_MAX;
    float r;
 
    __m256 vScalar = _mm256_set1_ps(scalar);
    __m256 inputVal1;
    __m256i intInputVal1;
    __m256 vmin_val = _mm256_set1_ps(min_val);
    __m256 vmax_val = _mm256_set1_ps(max_val);
 
    for (; number < eighthPoints; number++) {
        inputVal1 = _mm256_load_ps(inputVectorPtr);
        inputVectorPtr += 8;
 
        inputVal1 = _mm256_max_ps(
            _mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
        intInputVal1 = _mm256_cvtps_epi32(inputVal1);
 
        _mm256_store_si256((__m256i*)outputVectorPtr, intInputVal1);
        outputVectorPtr += 8;
    }
 
    number = eighthPoints * 8;
    for (; number < num_points; number++) {
        r = inputVector[number] * scalar;
        if (r > max_val)
            r = max_val;
        else if (r < min_val)
            r = min_val;
        outputVector[number] = (int32_t)rintf(r);
    }
}
 
#endif /* LV_HAVE_AVX */
 
 
#ifdef LV_HAVE_SSE2
#include <emmintrin.h>
 
static inline void volk_32f_s32f_convert_32i_a_sse2(int32_t* outputVector,
                                                    const float* inputVector,
                                                    const float scalar,
                                                    unsigned int num_points)
{
    unsigned int number = 0;
 
    const unsigned int quarterPoints = num_points / 4;
 
    const float* inputVectorPtr = (const float*)inputVector;
    int32_t* outputVectorPtr = outputVector;
 
    float min_val = INT_MIN;
    float max_val = INT_MAX;
    float r;
 
    __m128 vScalar = _mm_set_ps1(scalar);
    __m128 inputVal1;
    __m128i intInputVal1;
    __m128 vmin_val = _mm_set_ps1(min_val);
    __m128 vmax_val = _mm_set_ps1(max_val);
 
    for (; number < quarterPoints; number++) {
        inputVal1 = _mm_load_ps(inputVectorPtr);
        inputVectorPtr += 4;
 
        inputVal1 =
            _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
        intInputVal1 = _mm_cvtps_epi32(inputVal1);
 
        _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);
        outputVectorPtr += 4;
    }
 
    number = quarterPoints * 4;
    for (; number < num_points; number++) {
        r = inputVector[number] * scalar;
        if (r > max_val)
            r = max_val;
        else if (r < min_val)
            r = min_val;
        outputVector[number] = (int32_t)rintf(r);
    }
}
 
#endif /* LV_HAVE_SSE2 */
 
 
#ifdef LV_HAVE_SSE
#include <xmmintrin.h>
 
static inline void volk_32f_s32f_convert_32i_a_sse(int32_t* outputVector,
                                                   const float* inputVector,
                                                   const float scalar,
                                                   unsigned int num_points)
{
    unsigned int number = 0;
 
    const unsigned int quarterPoints = num_points / 4;
 
    const float* inputVectorPtr = (const float*)inputVector;
    int32_t* outputVectorPtr = outputVector;
 
    float min_val = INT_MIN;
    float max_val = INT_MAX;
    float r;
 
    __m128 vScalar = _mm_set_ps1(scalar);
    __m128 ret;
    __m128 vmin_val = _mm_set_ps1(min_val);
    __m128 vmax_val = _mm_set_ps1(max_val);
 
    __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
 
    for (; number < quarterPoints; number++) {
        ret = _mm_load_ps(inputVectorPtr);
        inputVectorPtr += 4;
 
        ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
 
        _mm_store_ps(outputFloatBuffer, ret);
        *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[0]);
        *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[1]);
        *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[2]);
        *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[3]);
    }
 
    number = quarterPoints * 4;
    for (; number < num_points; number++) {
        r = inputVector[number] * scalar;
        if (r > max_val)
            r = max_val;
        else if (r < min_val)
            r = min_val;
        outputVector[number] = (int32_t)rintf(r);
    }
}
 
#endif /* LV_HAVE_SSE */
 
 
#ifdef LV_HAVE_GENERIC
 
static inline void volk_32f_s32f_convert_32i_a_generic(int32_t* outputVector,
                                                       const float* inputVector,
                                                       const float scalar,
                                                       unsigned int num_points)
{
    volk_32f_s32f_convert_32i_generic(outputVector, inputVector, scalar, num_points);
}
 
#endif /* LV_HAVE_GENERIC */
 
#endif /* INCLUDED_volk_32f_s32f_convert_32i_a_H */