C++Ipps库-最简单的算法加速(二次封装)

牛顶顶大王

已于 2025-01-14 15:32:22 修改

阅读量1.7k

点赞数 29

文章标签：算法 c++ qt 性能优化机器学习

于 2025-01-14 11:30:32 首次发布

本文链接：https://blog.youkuaiyun.com/u014048039/article/details/145134828

版权

高效计算接口 ComputingInterface 解析

在现代软件开发中，尤其是涉及大量数据处理和信号分析的领域，高效的计算接口至关重要。ComputingInterface 类作为一个功能强大的计算接口，集成了多种高性能计算功能，利用Intel IPP（Integrated Performance Primitives）库实现了高效的向量运算、傅里叶变换（FFT）、滤波等操作。本文将深入解析 ComputingInterface 的核心功能及其优势，帮助开发者更好地理解和应用这一接口。

核心功能概览

向量运算：

排序：LhtSortFloat 和 LhtSortDouble 支持单精度和双精度浮点数的升序或降序排序。
归一化：LhtNormalizeFloat 和 LhtNormalizeDouble 提供向量的归一化操作（尽管部分函数已标记为弃用）。
点乘：LhtDotProductFloat 和 LhtDotProductDouble 实现了向量的点乘运算。
逐元素操作：包括乘法（LhtMulCFloat、LhtMulCDouble）、加法（LhtAddFloat、LhtAddDouble）、减法（LhtSubFloat、LhtSubDouble）等。
统计计算：如向量和 (LhtSumFloat、LhtSumDouble)、无穷范数 (LhtNormInfFloat、LhtNormInfDouble)、最大值和最小值 (LhtMaxFloat、LhtMinFloat、LhtMaxDouble、LhtMinDouble)、均值 (LhtMeanFloat) 等。

傅里叶变换（FFT）与离散傅里叶变换（DFT）：

初始化与析构：LhtFftInitFloat、LhtFftFreeFloat、LhtDftInitFloat、LhtDftFreeFloat 等函数负责FFT和DFT的初始化与资源释放。
计算：LhtFftFloat 和 LhtDftFloat 提供了高效的FFT和DFT计算功能，支持单精度和双精度数据。

滤波与信号处理：

FIR滤波器：包括初始化 (LhtFirInitFloat、LhtFirInitDouble)、析构 (LhtFirFreeFloat、LhtFirFreeDouble) 以及滤波操作 (LhtFirFloat、LhtFirDouble)。
中位数滤波：LhtFilterMedianFloat 实现了中位数滤波功能，用于去除信号中的噪声。
希尔伯特变换与自相关：LhtHilbertFloat、LhtAutocorrelationComplex 等函数提供了高级信号处理能力。
下变频与重采样：LhtdownOrthConversion、LhtResample 等函数支持信号的下变频和重采样操作，适用于通信和音频处理等领域。

小波变换与路径规划：

连续小波变换（CWT）：LhtFCwtInit 和 LhtFCwt 提供了CWT的初始化与计算功能，适用于频率分析和特征提取。
A路径规划：LhtAStar 函数实现了经典的A算法，用于路径规划和图搜索等应用。

实用工具：

数据复制与转换：如 LhtCopyRealAndimag、LhtCopyRealAndimag2Complex 等函数用于快速提取和组合复数的实部与虚部。
极坐标转换：LhtCartToPolar 将笛卡尔坐标转换为极坐标，便于频域分析。

部分头文件

class ComputingInterface : public QObject
{
    Q_OBJECT
public:
    explicit ComputingInterface(QObject *parent = nullptr);

    void init();
    //向量排序  单精度浮点数Ascend  = true 升序   false  降序
    bool LhtSortFloat(float * in1 ,int len,float * result ,bool Ascend = true,bool printResult = false);
    //向量排序  单精度浮点数Ascend  = true 升序   false  降序
    __declspec(deprecated("需要提前找到最大值来做一个除法  才可以将他归一化到0-1."))
    bool LhtNormalizeFloat(float * in1 ,int len,float * result,float  vSub, float vDiv,bool printResult = false);
    //向量点乘运算  单精度浮点数
    bool LhtDotProductFloat(float * in1 , float * in2 ,int len,float * result,bool printResult = false);
    //向量对单个值逐元素乘法  单精度浮点数
    bool LhtMulCFloat(float * in1 , float in2 ,int len,float * result,bool printResult = false);
    //向量逐元素乘法  单精度浮点数
    bool LhtMulFloat(float * in1 , float* in2 ,int len,float * result,bool printResult = false);
    //向量加法  单精度浮点数
    bool LhtAddFloat(float * in1 , float * in2 ,int len,float * result,bool printResult = false);
    //向量减法  单精度浮点数
    bool LhtSubFloat(float * in1 , float * in2 ,int len,float * result,bool printResult = false);
    //向量和  单精度浮点数 ippAlgHintFast 最快    ippAlgHintAccurate  最准确
    bool LhtSumFloat(float * in1 ,int len,float * result, IppHintAlgorithm hint = ippAlgHintFast,bool printResult = false);
    //无穷范数 单精度浮点数  绝对值的最大值
    bool LhtNormInfFloat(float * in1 ,int len,float * result,bool printResult = false);
    //向量最大值 单精度浮点数
    bool LhtMaxFloat(float * in1 ,int len,float * result,bool printResult = false);
    //向量最小值 单精度浮点数
    bool LhtMinFloat(float * in1 ,int len,float * result,bool printResult = false);
    //数组均值 单精度浮点数
    bool LhtMeanFloat(float * in1 ,int len,float * result,bool printResult = false);
    //fft  初始化  比较耗时
    bool LhtFftInitFloat(int len);
    //fft 析构
    void LhtFftFreeFloat();
    //fft计算
    bool LhtFftFloat(float * in1 , float * in2 ,int len,float * result,bool printResult = false);
    //fft计算
    bool LhtFftFloat(Ipp32fc * in1 ,int len,float * result,bool shift = false);
    //dft  初始化  比较耗时
    bool LhtDftInitFloat(int len);
    //dft 析构
    void LhtDftFreeFloat();
    //dft
    bool LhtDftFloat(float * in1 , float * in2 ,int len,float * result1,float * result2,bool printResult = false);
    //V1 和  𝑉2的单个元素的平方和的平方根 单精度浮点数  ippsMagnitude_32fc
    bool LhtCalculateRootOfSumOfSquaresFloat(const Ipp32f* v1, const Ipp32f* v2, int len, Ipp32f* result,bool printResult = false);
    //复数元素的平方和的平方根 单精度浮点数
    bool LhtCalculateRootOfSumOfSquaresFloat2(const Ipp32fc* v1,int len, Ipp32f* result,bool printResult = false);
    //数组平方和的平方根 单精度浮点数
    bool LhtNormL2Float(float * in1 ,int len,float * result,bool printResult = false);
    //计算功率谱ippsPowerSpectr_32f
    bool LhtPowerSpectrFloat(float * in1 ,float * in2 ,int len,float * result,bool printResult = false);
    //生成单音 magn 强度设置   freq  频点
    bool LhtCreateTone(Ipp32fc * result ,int len,float magn,int freq ,bool printResult = false);
    //----------------------------------希尔伯特变换-----------------------------------------------
    bool LhtHilbertFloat(float * in,int len ,  Ipp32fc* out,bool printResult = false);
    //----------------------------------自相关-----------------------------------------------
    bool LhtAutocorrelationComplex(Ipp32fc * in,int len ,  Ipp32fc* out,int outLen,bool printResult = false);

    //-------------------------------2024/7/19数字下变频-------------------------------------------
    bool LhtdownOrthConversion( Ipp32f* v1,  Ipp32f* v2, int len, int freq ,int sampleRate, Ipp32f* out1,  Ipp32f* out2 ,bool printResult = false );

    bool LhtdownOrthConversion( Ipp32fc* v1, int len, int freq ,int sampleRate, Ipp32fc* out1,bool printResult = false );
    //------------------------------------滤波器---------------------------------------------------

    //FIR  初始化  比较耗时
    bool LhtFirInitFloat(const float* coeffs, int numCoeffs,IppAlgType type = ippAlgFFT);
    //FIR 析构
    void LhtFirFreeFloat();
    //FIR
    bool LhtFirFloat(const float* src,  int len,float* dst,bool printResult = false);


    //低通滤波
    //初始化  比较耗时
    bool LhtFirInitFloatLp(float * coeffs,int numCoeffs);
    // 析构
    void LhtFirFreeFloatLp();
    //
    bool LhtFirFloatLp(const float* src, float* dst, int len,bool printResult = false);

    //应用中位数滤波
    bool LhtFilterMedianFloat(const float* src, float* dst, int len,int masksize,bool printResult = false);

    //将低于阈值的值设定为某个值
    bool LhtThreshold(const float* src, float* dst, int len,float level,float value,bool printResult = false);

    //快速提取复数中的实部和虚部
    void LhtCopyRealAndimag(Ipp32fc *source, Ipp32f *real_dest, Ipp32f *imag_dest, int len) ;
    //快速将实部和虚部放到数组中
    void LhtCopyRealAndimag2Complex(Ipp32fc *dst, Ipp32f *real_dest, Ipp32f *imag_dest, int len) ;

    //这个函数将二维空间中点的 (x, y) 坐标转换为极坐标 (r, θ)，其中 r 是径向距离（幅度），θ 是角度（相位）。
    bool LhtCartToPolar(const float* in1, const float* in2, float* pDstMagn, float* pDstPhase, int len,bool printResult = false);
    //反转元素
    bool LhtFlip(const float* src, float* dst, int len,bool printResult = false);

    //-------------------------------重采样-----------------------------------
    /**
     * @brief LhtResampleInit非整数倍重采样初始化
     * @param inRate 输入采样率
     * @param outRate 输出采样率
    */
    void LhtResampleInit(int inRate,int outRate );
    /**
     * @brief LhtResample非整数倍重采样函数（必要LhtResampleInit）
     * @param src 原始数据
     * @param dst 结果数据
     * @param srcLen 原数据长度
     * @param norm 归一化因子1.0为不变  0.5为减半
     * @result dst结果长度dstLen = (srcLen * pUpFactor) / pDownFactor;
    */
    bool LhtResample(const float* src, float* dst, int srcLen,int & retLen,float norm = 1.0f,bool printResult = false);
    //IPPAPI(IppStatus, ippsSampleUp_32f,  (const Ipp32f*  pSrc, int  srcLen, Ipp32f*  pDst, int* pDstLen, int factor, int* pPhase))
    /**
     * @brief LhtSampleUp整数倍上抽
     * @param src 原始数据
     * @param dst 结果数据
     * @param srcLen 原数据长度
     * @param factor 上采样因子
     * @result dst结果长度dstLen = (srcLen * factor);
    */
    bool LhtSampleUp(const float*  pSrc, int  srcLen, float*  pDst, int* pDstLen, int factor);
    /**
     * @brief LhtSampleDown整数倍下抽
     * @param src 原始数据
     * @param dst 结果数据
     * @param srcLen 原数据长度
     * @param factor 降采样因子
     * @result dst结果长度dstLen = (srcLen / factor);
    */
    bool LhtSampleDown(const float*  pSrc, int  srcLen, float*  pDst, int* pDstLen, int factor);

    void LhtResampleFree();

    std::vector<LhtComplexDouble> LhtCztCopyFromMatlab(
        const std::vector<LhtComplexDouble>& x,  // 输入序列, length=n
        int k,                          // 输出长度
        LhtComplexDouble w,                      // czt 参数, e.g. exp(-j*2*pi*(f2-f1)/(k*fs))
        LhtComplexDouble a                       // czt 参数, e.g. exp( j*2*pi*f1/fs )
        );
    /**
     * @brief 初始化连续小波变换（CWT）对象。
     *
     * 该函数负责初始化CWT所需的参数，包括选择母小波、线程数、尺度类型、采样频率、频率范围、
     * 尺度数量以及是否使用优化方案和归一化。
     *
     * @param pwav 指向要使用的母小波对象的指针。
     * @param pthreads 用于CWT计算的线程数量。
     * @param st 尺度类型，定义尺度分布方式（例如线性尺度或对数尺度）。
     *              可以是以下枚举值之一：
     *              - `FCWT_LINFREQS`：线性频率分布
     *              - `FCWT_LOGSCALES`：对数量尺度分布
     * @param fs 信号的采样频率，以赫兹（Hz）为单位。
     * @param f0 分析频率范围的起始频率，以赫兹（Hz）为单位。
     * @param f1 分析频率范围的结束频率，以赫兹（Hz）为单位。
     * @param fn 频率范围内生成的小波数量（尺度数量）。
     * @param puse_optimalization_schemes 布尔标志，指示是否使用FFTW优化方案。
     *                                    - `true`：启用FFTW优化
     *                                    - `false`：禁用FFTW优化
     * @param puse_normalization 布尔标志，指示是否对CWT系数进行归一化处理。
     *                           - `true`：启用归一化
     *                           - `false`：禁用归一化
     *
     * @return 如果初始化成功，返回 `true`；否则，返回 `false`。
     *
     * @note
     * - 确保在调用此函数之前已正确创建并初始化母小波对象。
     * - `st` 参数决定了尺度的分布方式，影响频率分辨率和分析结果。
     * - 合理设置线程数量 (`pthreads`) 可以显著提升多核系统上的计算性能。
     * - FFTW优化方案 (`puse_optimalization_schemes`) 可以加快傅里叶变换的计算速度，但可能增加初始化时间。
     * - 归一化 (`puse_normalization`) 有助于标准化不同尺度下的CWT系数，使得结果更具可比性。
     */
    bool LhtFCwtInit(Wavelet *pwav,  SCALETYPE st, int fs, float f0, float f1, int fn,int pthreads = 1,
                     bool puse_optimalization_schemes = true, bool puse_normalization = false);

    // cwt(输入, 信号长度, 输出)
    //
    // 参数：
    // input     - 指向输入数组的浮动指针
    // length    - 整数类型的信号长度
    // output    - 指向输出数组的浮动指针
    void LhtFCwt(complex<float> *pinput, int psize, complex<float>* poutput);

    //查找最小间隔
    // 参数：
    // input ,len       - 指向输入数组的浮动指针以及对应的长度
    // th           - 阈值
    // useSimd      - 使用指令集加速  暂时只支持Intel
    // return  : int &index1 指针1 int &index2 指针2 int &length 长度
    void LhtFindMinInterval(float * input,int len,float th,int &index1 , int &index2 , int &length,bool useSimd = true);

IPPS库使用示例

测试界面

1. 安装IPPS

下载地址

2. 导入到库中

以QT为例
win32: LIBS += -L’你的地址/ipp/2021.12/lib/’ -lipps
win32: LIBS += -L’你的地址/ipp/2021.12/lib/’ -lippcore
win32: LIBS += -L’你的地址/ipp/2021.12/lib/’ -lippvm

INCLUDEPATH += ‘你的地址/ipp/2021.12/include/ipp’
DEPENDPATH += ‘你的地址/ipp/2021.12/include/ipp’
因为现在增加了小波变换所以增加了fftw库，需要的话请自己下载一下libfftw3