dspop.cc

各种工程计算的库函数

    ippsSub_64fc_I((Ipp64fc *) spCplxSrc, (Ipp64fc *) spCplxDest, lCount);
    #else
    long lLoopCntr;

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


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

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


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

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


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

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


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

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



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

    #ifdef DSP_X86
    if (bHave3DNow)
    {
        dsp_x86_3dnow_mulf(fpVect, fSrc, lCount);
    }
    else if (bHaveSSE)
    {
        dsp_x86_sse_mulf(fpVect, fSrc, lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            fpVect[lLoopCntr] *= fSrc;
        }
    }
    #endif
}


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

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


void clDSPOp::Mul (stpSCplx spCplxDest, float fSrc, long lCount)
{
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        CplxMul(&spCplxDest[lLoopCntr], fSrc);
    }
}


void clDSPOp::Mul (stpDCplx spCplxDest, double dSrc, long lCount)
{
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        CplxMul(&spCplxDest[lLoopCntr], dSrc);
    }
}


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

    #ifdef DSP_X86
    if (bHave3DNow)
    {
        dsp_x86_3dnow_cmulf((float *) spCplxDest,
            (const float *) &sCplxSrc, lCount);
    }
    else if (bHaveSSE)
    {
        dsp_x86_sse_cmulf((float *) spCplxDest,
            (const float *) &sCplxSrc, lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            CplxMul(&spCplxDest[lLoopCntr], &sCplxSrc);
        }
    }
    #endif
}


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

    #ifdef DSP_X86
    if (bHaveSSE)
    {
        dsp_x86_sse_cmul((double *) spCplxDest,
            (const double *) &sCplxSrc, lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            CplxMul(&spCplxDest[lLoopCntr], &sCplxSrc);
        }
    }
    #endif
}


void clDSPOp::Mul (float *fpDest, const float *fpSrc1, float fSrc2, 
    long lCount)
{
    #ifdef DSP_IPP
    ippsMulC_32f(fpSrc1, fSrc2, fpDest, lCount);
    #else
    long lLoopCntr;

    #ifdef DSP_X86
    if (bHave3DNow)
    {
        dsp_x86_3dnow_mulf_nip(fpDest, fpSrc1, fSrc2, lCount);
    }
    else if (bHaveSSE)
    {
        dsp_x86_sse_mulf_nip(fpDest, fpSrc1, fSrc2, lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            fpDest[lLoopCntr] = fpSrc1[lLoopCntr] * fSrc2;
        }
    }
    #endif
}


void clDSPOp::Mul (double *dpDest, const double *dpSrc1, double dSrc2,
    long lCount)
{
    #ifdef DSP_IPP
    ippsMulC_64f(dpSrc1, dSrc2, dpDest, lCount);
    #else
    long lLoopCntr;

    #ifdef DSP_X86
    if (bHaveSSE)
    {
        dsp_x86_sse_mul_nip(dpDest, dpSrc1, dSrc2, lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            dpDest[lLoopCntr] = dpSrc1[lLoopCntr] * dSrc2;
        }
    }
    #endif
}


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

    #ifdef DSP_X86
    if (bHave3DNow)
    {
        dsp_x86_3dnow_mul2f(fpDest, fpSrc, lCount);
    }
    else if (bHaveSSE)
    {
        dsp_x86_sse_mul2f(fpDest, fpSrc, lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            fpDest[lLoopCntr] *= fpSrc[lLoopCntr];
        }
    }
    #endif
}


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

    #ifdef DSP_X86
    if (bHaveSSE)
    {
        dsp_x86_sse_mul2(dpDest, dpSrc, lCount);
    }
    else
    #endif
    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        dpDest[lLoopCntr] *= dpSrc[lLoopCntr];
    }
    #endif
}


void clDSPOp::Mul (stpSCplx spCplxDest, const float *fpSrc, long lCount)
{
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        CplxMul(&spCplxDest[lLoopCntr], fpSrc[lLoopCntr]);
    }
}


void clDSPOp::Mul (stpDCplx spCplxDest, const double *dpSrc, long lCount)
{
    long lLoopCntr;

    for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
    {
        CplxMul(&spCplxDest[lLoopCntr], dpSrc[lLoopCntr]);
    }
}


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

    #ifdef DSP_X86
    if (bHave3DNow)
    {
        dsp_x86_3dnow_cmul2f((float *) spCplxDest, (const float *) spCplxSrc, 
            lCount);
    }
    else if (bHaveSSE)
    {
        dsp_x86_sse_cmul2f((float *) spCplxDest, (const float *) spCplxSrc,
            lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            CplxMul(&spCplxDest[lLoopCntr], &spCplxSrc[lLoopCntr]);
        }
    }
    #endif
}


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

    #ifdef DSP_X86
    if (bHaveSSE)
    {
        dsp_x86_sse_cmul2((double *) spCplxDest, (const double *) spCplxSrc,
            lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            CplxMul(&spCplxDest[lLoopCntr], &spCplxSrc[lLoopCntr]);
        }
    }
    #endif
}


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

    #ifdef DSP_X86
    if (bHave3DNow)
    {
        dsp_x86_3dnow_mul3f(fpDest, fpSrc1, fpSrc2, lCount);
    }
    else if (bHaveSSE)
    {
        dsp_x86_sse_mul3f(fpDest, fpSrc1, fpSrc2, lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            fpDest[lLoopCntr] = fpSrc1[lLoopCntr] * fpSrc2[lLoopCntr];
        }
    }
    #endif
}


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

    #ifdef DSP_X86
    if (bHaveSSE)
    {
        dsp_x86_sse_mul3(dpDest, dpSrc1, dpSrc2, lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            dpDest[lLoopCntr] = dpSrc1[lLoopCntr] * dpSrc2[lLoopCntr];
        }
    }
    #endif
}


void clDSPOp::Mul (stpSCplx spCplxDest, const stpSCplx spCplxSrc1,
    const stpSCplx spCplxSrc2, long lCount)
{
    #ifdef DSP_IPP
    ippsMul_64fc((Ipp64fc *) spCplxSrc1, (Ipp64fc *) spCplxSrc2, 
        (Ipp64fc *) spCplxDest, lCount);
    #else
    long lLoopCntr;

    #ifdef DSP_X86
    if (bHave3DNow)
    {
        dsp_x86_3dnow_cmul3f((float *) spCplxDest, 
            (const float *) spCplxSrc1,
            (const float *) spCplxSrc2,
            lCount);
    }
    else if (bHaveSSE)
    {
        dsp_x86_sse_cmul3f((float *) spCplxDest,
            (const float *) spCplxSrc1,
            (const float *) spCplxSrc2,
            lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            CplxMul(&spCplxDest[lLoopCntr], &spCplxSrc1[lLoopCntr],
                &spCplxSrc2[lLoopCntr]);
        }
    }
    #endif
}


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

    #ifdef DSP_X86
    if (bHaveSSE)
    {
        dsp_x86_sse_cmul3((double *) spCplxDest,
            (const double *) spCplxSrc1,
            (const double *) spCplxSrc2,
            lCount);
    }
    else
    #endif
    {
        for (lLoopCntr = 0L; lLoopCntr < lCount; lLoopCntr++)
        {
            CplxMul(&spCplxDest[lLoopCntr], &spCplxSrc1[lLoopCntr],
                &spCplxSrc2[lLoopCntr]);
        }
    }
    #endif
}


void clDSPOp::MulC (stpSCplx spCplxDest, const stpSCplx spCplxSrc, long lCount)
{
    long lLoopCntr;

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


void clDSPOp::MulC (stpDCplx spCplxDest, const stpDCplx spCplxSrc, long lCount)
{
    long lLoopCntr;

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


void clDSPOp::MulC (stpSCplx spCplxDest, const stpSCplx spCplxSrc1,
    const stpSCplx spCplxSrc2, long lCount)
{
    long lLoopCntr;

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


void clDSPOp::MulC (stpDCplx spCplxDest, const stpDCplx spCplxSrc1,
    const stpDCplx spCplxSrc2, long lCount)
{
    long lLoopCntr;

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


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

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


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

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