dspop.cc

各种工程计算的库函数

void clDSPOp::Mul2 (float *fpDst1, float *fpDst2, const float *fpSrc1,
    const float *fpSrc2, const float *fpMul, long lCount)
{
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        fpDst1[lLoopCntr] = fpSrc1[lLoopCntr] * fpMul[lLoopCntr];
        fpDst2[lLoopCntr] = fpSrc2[lLoopCntr] * fpMul[lLoopCntr];
    }
}


void clDSPOp::Mul2 (double *dpDst1, double *dpDst2, const double *dpSrc1,
   const double *dpSrc2, const double *dpMul, long lCount)
{
   long lLoopCntr;

   for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
   {
      dpDst1[lLoopCntr] = dpSrc1[lLoopCntr] * dpMul[lLoopCntr];
      dpDst2[lLoopCntr] = dpSrc2[lLoopCntr] * dpMul[lLoopCntr];
   }
}


void clDSPOp::Div (float *fpVect, float fSrc, long lCount)
{
    #ifdef DSP_IPP
    ippsDivC_32f_I(fSrc, fpVect, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        fpVect[lLoopCntr] /= fSrc;
    }
    #endif
}


void clDSPOp::Div (double *dpVect, double dSrc, long lCount)
{
    #ifdef DSP_IPP
    ippsDivC_64f_I(dSrc, dpVect, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        dpVect[lLoopCntr] /= dSrc;
    }
    #endif
}


void clDSPOp::Div (stpSCplx spCplxDest, stSCplx sCplxSrc, long lCount)
{
    #ifdef DSP_IPP
    ippsDivC_32fc_I(*((Ipp32fc *) &sCplxSrc), (Ipp32fc *) spCplxDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        CplxDiv(&spCplxDest[lLoopCntr], &sCplxSrc);
    }
    #endif
}


void clDSPOp::Div (stpDCplx spCplxDest, stDCplx sCplxSrc, long lCount)
{
    #ifdef DSP_IPP
    ippsDivC_64fc_I(*((Ipp64fc *) &sCplxSrc), (Ipp64fc *) spCplxDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        CplxDiv(&spCplxDest[lLoopCntr], &sCplxSrc);
    }
    #endif
}


void clDSPOp::Div (float *fpDest, const float *fpSrc, long lCount)
{
    #ifdef DSP_IPP
    ippsDiv_32f_I(fpSrc, fpDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        fpDest[lLoopCntr] /= fpSrc[lLoopCntr];
    }
    #endif
}


void clDSPOp::Div (double *dpDest, const double *dpSrc, long lCount)
{
    #ifdef DSP_IPP
    ippsDiv_64f_I(dpSrc, dpDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        dpDest[lLoopCntr] /= dpSrc[lLoopCntr];
    }
    #endif
}


void clDSPOp::Div (stpSCplx spCplxDest, const stpSCplx spCplxSrc, long lCount)
{
    #ifdef DSP_IPP
    ippsDiv_32fc_I((Ipp32fc *) spCplxSrc, (Ipp32fc *) spCplxDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        CplxDiv(&spCplxDest[lLoopCntr], &spCplxSrc[lLoopCntr]);
    }
    #endif
}


void clDSPOp::Div (stpDCplx spCplxDest, const stpDCplx spCplxSrc, long lCount)
{
    #ifdef DSP_IPP
    ippsDiv_64fc_I((Ipp64fc *) spCplxSrc, (Ipp64fc *) spCplxDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        CplxDiv(&spCplxDest[lLoopCntr], &spCplxSrc[lLoopCntr]);
    }
    #endif
}


void clDSPOp::Div (float *fpDest, const float *fpSrc1, const float *fpSrc2, 
    long lCount)
{
    #ifdef DSP_IPP
    ippsDiv_32f(fpSrc1, fpSrc2, fpDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        fpDest[lLoopCntr] = fpSrc1[lLoopCntr] / fpSrc2[lLoopCntr];
    }
    #endif
}


void clDSPOp::Div (double *dpDest, const double *dpSrc1, const double *dpSrc2,
    long lCount)
{
    #ifdef DSP_IPP
    ippsDiv_64f(dpSrc1, dpSrc2, dpDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        dpDest[lLoopCntr] = dpSrc1[lLoopCntr] / dpSrc2[lLoopCntr];
    }
    #endif
}


void clDSPOp::Div (stpSCplx spCplxDest, const stpSCplx spCplxSrc1,
    const stpSCplx spCplxSrc2, long lCount)
{
    #ifdef DSP_IPP
    ippsDiv_32fc((Ipp32fc *) spCplxSrc1, (Ipp32fc *) spCplxSrc2,
        (Ipp32fc *) spCplxDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        CplxDiv(&spCplxDest[lLoopCntr], &spCplxSrc1[lLoopCntr],
            &spCplxSrc2[lLoopCntr]);
    }
    #endif
}


void clDSPOp::Div (stpDCplx spCplxDest, const stpDCplx spCplxSrc1,
    const stpDCplx spCplxSrc2, long lCount)
{
    #ifdef DSP_IPP
    ippsDiv_64fc((Ipp64fc *) spCplxSrc1, (Ipp64fc *) spCplxSrc2,
        (Ipp64fc *) spCplxDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        CplxDiv(&spCplxDest[lLoopCntr], &spCplxSrc1[lLoopCntr],
            &spCplxSrc2[lLoopCntr]);
    }
    #endif
}


void clDSPOp::Div1x (float *fpVect, long lCount)
{
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        fpVect[lLoopCntr] = 1.0F / fpVect[lLoopCntr];
    }
}


void clDSPOp::Div1x (double *dpVect, long lCount)
{
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        dpVect[lLoopCntr] = 1.0 / dpVect[lLoopCntr];
    }
}


void clDSPOp::Div1x (float *fpDest, const float *fpSrc, long lCount)
{
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        fpDest[lLoopCntr] = 1.0F / fpSrc[lLoopCntr];
    }
}


void clDSPOp::Div1x (double *dpDest, const double *dpSrc, long lCount)
{
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        dpDest[lLoopCntr] = 1.0 / dpSrc[lLoopCntr];
    }
}


void clDSPOp::MulAdd (float *fpVect, float fMul, float fAdd, long lCount)
{
    long lLoopCntr;
    
    #ifdef DSP_X86
    if (bHave3DNow)
    {
        dsp_x86_3dnow_maf(fpVect, fMul, fAdd, lCount);
    }
    else if (bHaveSSE)
    {
        dsp_x86_sse_maf(fpVect, fMul, fAdd, lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            fpVect[lLoopCntr] = fpVect[lLoopCntr] * fMul + fAdd;
        }
    }
}


void clDSPOp::MulAdd (double *dpVect, double dMul, double dAdd, long lCount)
{
    long lLoopCntr;

    #ifdef DSP_X86
    if (bHaveSSE)
    {
        dsp_x86_sse_ma(dpVect, dMul, dAdd, lCount);
    }
    else
    #endif
    {    
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            dpVect[lLoopCntr] = dpVect[lLoopCntr] * dMul + dAdd;
        }
    }
}


void clDSPOp::MulAdd (float *fpDest, const float *fpSrc, 
    float fMul, float fAdd, long lCount)
{
    long lLoopCntr;
    
    #ifdef DSP_X86
    if (bHave3DNow)
    {
        dsp_x86_3dnow_ma2f(fpDest, fpSrc, fMul, fAdd, lCount);
    }
    else if (bHaveSSE)
    {
        dsp_x86_sse_ma2f(fpDest, fpSrc, fMul, fAdd, lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            fpDest[lLoopCntr] = fpSrc[lLoopCntr] * fMul + fAdd;
        }
    }
}


void clDSPOp::MulAdd (double *dpDest, const double *dpSrc, 
    double dMul, double dAdd, long lCount)
{
    long lLoopCntr;
    
    #ifdef DSP_X86
    if (bHaveSSE)
    {
        dsp_x86_sse_ma2(dpDest, dpSrc, dMul, dAdd, lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            dpDest[lLoopCntr] = dpSrc[lLoopCntr] * dMul + dAdd;
        }
    }
}


void clDSPOp::MulAddC (stpSCplx spDest, const stpSCplx spSrc1, 
    const stpSCplx spSrc2, long lCount)
{
    long lLoopCntr;
    stSCplx sTemp;
    
    #ifdef DSP_X86
    if (bHave3DNow)
    {
        dsp_x86_3dnow_cmaf((float *) spDest, (const float *) spSrc1,
            (const float *) spSrc2, lCount);
    }
    else if (bHaveSSE)
    {
        dsp_x86_sse_cmaf((float *) spDest, (const float *) spSrc1,
            (const float *) spSrc2, lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            CplxMul(&sTemp, &spSrc1[lLoopCntr], &spSrc2[lLoopCntr]);
            CplxAdd(&spDest[lLoopCntr], &sTemp);
        }
    }
}


void clDSPOp::MulAddC (stpDCplx spDest, const stpDCplx spSrc1, 
    const stpDCplx spSrc2, long lCount)
{
    long lLoopCntr;
    stDCplx sTemp;
    
    #ifdef DSP_X86
    if (bHaveSSE)
    {
        dsp_x86_sse_cma((double *) spDest, (const double *) spSrc1,
            (const double *) spSrc2, lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            CplxMul(&sTemp, &spSrc1[lLoopCntr], &spSrc2[lLoopCntr]);
            CplxAdd(&spDest[lLoopCntr], &sTemp);
        }
    }
}


void clDSPOp::Abs (float *fpVect, long lCount)
{
    #ifdef DSP_IPP
    ippsAbs_32f_I(fpVect, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        fpVect[lLoopCntr] = fabsf(fpVect[lLoopCntr]);
    }
    #endif
}


void clDSPOp::Abs (double *dpVect, long lCount)
{
    #ifdef DSP_IPP
    ippsAbs_64f_I(dpVect, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        dpVect[lLoopCntr] = fabs(dpVect[lLoopCntr]);
    }
    #endif
}


void clDSPOp::Abs (float *fpDest, const float *fpSrc, long lCount)
{
    #ifdef DSP_IPP
    ippsAbs_32f(fpSrc, fpDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        fpDest[lLoopCntr] = fabsf(fpSrc[lLoopCntr]);
    }
    #endif
}


void clDSPOp::Abs (double *dpDest, const double *dpSrc, long lCount)
{
    #ifdef DSP_IPP
    ippsAbs_64f(dpSrc, dpDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        dpDest[lLoopCntr] = fabs(dpSrc[lLoopCntr]);
    }
    #endif
}


void clDSPOp::Sqrt (float *fpVect, long lCount)
{
    #ifdef DSP_IPP
    ippsSqrt_32f_I(fpVect, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        fpVect[lLoopCntr] = sqrtf(fpVect[lLoopCntr]);
    }
    #endif
}


void clDSPOp::Sqrt (double *dpVect, long lCount)
{
    #ifdef DSP_IPP
    ippsSqrt_64f_I(dpVect, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        dpVect[lLoopCntr] = sqrt(dpVect[lLoopCntr]);
    }
    #endif
}


void clDSPOp::Sqrt (float *fpDest, const float *fpSrc, long lCount)
{
    #ifdef DSP_IPP
    ippsSqrt_32f(fpSrc, fpDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        fpDest[lLoopCntr] = sqrtf(fpSrc[lLoopCntr]);
    }
    #endif
}


void clDSPOp::Sqrt (double *dpDest, const double *dpSrc, long lCount)
{
    #ifdef DSP_IPP
    ippsSqrt_64f(dpSrc, dpDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        dpDest[lLoopCntr] = sqrt(dpSrc[lLoopCntr]);
    }
    #endif
}


void clDSPOp::Zero (float *fpDest, long lCount)
{
    #ifdef DSP_IPP
    ippsZero_32f(fpDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        fpDest[lLoopCntr] = 0.0F;
    }
    #endif
}


void clDSPOp::Zero (double *dpDest, long lCount)
{
    #ifdef DSP_IPP
    ippsZero_64f(dpDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        dpDest[lLoopCntr] = 0.0;
    }
    #endif
}


void clDSPOp::Zero (stpSCplx spCplxDest, long lCount)
{
    #ifdef DSP_IPP
    ippsZero_32fc((Ipp32fc *) spCplxDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        spCplxDest[lLoopCntr].R = 0.0F;
        spCplxDest[lLoopCntr].I = 0.0F;
    }
    #endif
}


void clDSPOp::Zero (stpDCplx spCplxDest, long lCount)
{
    #ifdef DSP_IPP
    ippsZero_64fc((Ipp64fc *) spCplxDest, lCount);
    #else
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        spCplxDest[lLoopCntr].R = 0.0;
        spCplxDest[lLoopCntr].I = 0.0;
    }
    #endif
}


void clDSPOp::Set (float *fpDest, float fSrc, long lCount)