cdspop.cc

各种工程计算的库函数

void dsp_cset2 (stpDCplx spDest, stDCplx sSrc, long lStart, long lCount,
    long lLength)
{
    clDSPOp::Set(spDest, sSrc, lStart, lCount, lLength);
}


void dsp_clipf (float *fpVect, float fValue, long lCount)
{
    clDSPOp::Clip(fpVect, fValue, lCount);
}


void dsp_clip (double *dpVect, double dValue, long lCount)
{
    clDSPOp::Clip(dpVect, dValue, lCount);
}


void dsp_clipf_nip (float *fpDest, const float *fpSrc, float fValue, 
    long lCount)
{
    clDSPOp::Clip(fpDest, fpSrc, fValue, lCount);
}


void dsp_clip_nip (double *dpDest, const double *dpSrc, double dValue,
    long lCount)
{
    clDSPOp::Clip(dpDest, dpSrc, dValue, lCount);
}


void dsp_clip2f (float *fpVect, float fMin, float fMax, long lCount)
{
    clDSPOp::Clip(fpVect, fMin, fMax, lCount);
}


void dsp_clip2 (double *dpVect, double dMin, double dMax, long lCount)
{
    clDSPOp::Clip(dpVect, dMin, dMax, lCount);
}


void dsp_clip2f_nip (float *fpDest, const float *fpSrc, 
    float fMin, float fMax, long lCount)
{
    clDSPOp::Clip(fpDest, fpSrc, fMin, fMax, lCount);
}


void dsp_clip2_nip (double *dpDest, const double *dpSrc,
    double dMin, double dMax, long lCount)
{
    clDSPOp::Clip(dpDest, dpSrc, dMin, dMax, lCount);
}


void dsp_clipzerof (float *fpVect, long lCount)
{
    clDSPOp::ClipZero(fpVect, lCount);
}


void dsp_clipzero (double *dpVect, long lCount)
{
    clDSPOp::ClipZero(dpVect, lCount);
}


void dsp_clipzerof_nip (float *fpDest, const float *fpSrc, long lCount)
{
    clDSPOp::ClipZero(fpDest, fpSrc, lCount);
}


void dsp_clipzero_nip (double *dpDest, const double *dpSrc, long lCount)
{
    clDSPOp::ClipZero(dpDest, dpSrc, lCount);
}


void dsp_copyf (float *fpDest, const float *fpSrc, long lCount)
{
    clDSPOp::Copy(fpDest, fpSrc, lCount);
}


void dsp_copy (double *dpDest, const double *dpSrc, long lCount)
{
    clDSPOp::Copy(dpDest, dpSrc, lCount);
}


void dsp_ccopyf (stpSCplx spDest, const stpSCplx spSrc, long lCount)
{
    clDSPOp::Copy(spDest, spSrc, lCount);
}


void dsp_ccopy (stpDCplx spDest, const stpDCplx spSrc, long lCount)
{
    clDSPOp::Copy(spDest, spSrc, lCount);
}


float dsp_convolvef (const float *fpSrc1, const float *fpSrc2, long lCount)
{
    return clDSPOp::Convolve(fpSrc1, fpSrc2, lCount);
}


double dsp_convolve (const double *dpSrc1, const double *dpSrc2, long lCount)
{
    return clDSPOp::Convolve(dpSrc1, dpSrc2, lCount);
}


void dsp_convolve2f (float *fpDest, const float *fpSrc1, const float *fpSrc2,
    long lCount)
{
    clDSPOp::Convolve(fpDest, fpSrc1, fpSrc2, lCount);
}


void dsp_convolve2 (double *dpDest, const double *dpSrc1, const double *dpSrc2,
    long lCount)
{
    clDSPOp::Convolve(dpDest, dpSrc1, dpSrc2, lCount);
}


float dsp_correlatef (const float *fpSrc1, const float *fpSrc2, long lCount)
{
    return clDSPOp::Correlate(fpSrc1, fpSrc2, lCount);
}


double dsp_correlate (const double *dpSrc1, const double *dpSrc2, long lCount)
{
    return clDSPOp::Correlate(dpSrc1, dpSrc2, lCount);
}


void dsp_correlate2f (float *fpDest, const float *fpSrc1, const float *fpSrc2,
    long lCount)
{
    clDSPOp::Correlate(fpDest, fpSrc1, fpSrc2, lCount);
}


void dsp_correlate2 (double *dpDest, const double *dpSrc1, const double *dpSrc2,
    long lCount)
{
    clDSPOp::Correlate(dpDest, dpSrc1, dpSrc2, lCount);
}


float dsp_autocorrf (const float *fpSrc, long lCount)
{
    return clDSPOp::AutoCorrelate(fpSrc, lCount);
}


double dsp_autocorr (const double *dpSrc, long lCount)
{
    return clDSPOp::AutoCorrelate(dpSrc, lCount);
}


void dsp_autocorr2f (float *fpDest, const float *fpSrc, long lCount)
{
    clDSPOp::AutoCorrelate(fpDest, fpSrc, lCount);
}


void dsp_autocorr2 (double *dpDest, const double *dpSrc, long lCount)
{
    clDSPOp::AutoCorrelate(dpDest, dpSrc, lCount);
}


float dsp_dotproductf (const float *fpSrc1, const float *fpSrc2, long lCount)
{
    return clDSPOp::DotProduct(fpSrc1, fpSrc2, lCount);
}


double dsp_dotproduct (const double *dpSrc1, const double *dpSrc2, long lCount)
{
    return clDSPOp::DotProduct(dpSrc1, dpSrc2, lCount);
}


void dsp_minmaxf (float *fpMin, float *fpMax, const float *fpSrc, long lCount)
{
    clDSPOp::MinMax(fpMin, fpMax, fpSrc, lCount);
}


void dsp_minmax (double *dpMin, double *dpMax, const double *dpSrc, long lCount)
{
    clDSPOp::MinMax(dpMin, dpMax, dpSrc, lCount);
}


float dsp_meanf (const float *fpSrc, long lCount)
{
    return clDSPOp::Mean(fpSrc, lCount);
}


double dsp_mean (const double *dpSrc, long lCount)
{
    return clDSPOp::Mean(dpSrc, lCount);
}


float dsp_medianf (const float *fpSrc, long lCount)
{
    return clDSPOp::Median(fpSrc, lCount);
}


double dsp_median (const double *dpSrc, long lCount)
{
    return clDSPOp::Median(dpSrc, lCount);
}


void dsp_negatef (float *fpVect, long lCount)
{
    clDSPOp::Negate(fpVect, lCount);
}


void dsp_negate (double *dpVect, long lCount)
{
    clDSPOp::Negate(dpVect, lCount);
}


void dsp_negatef_nip (float *fpDest, const float *fpSrc, long lCount)
{
    clDSPOp::Negate(fpDest, fpSrc, lCount);
}


void dsp_negate_nip (double *dpDest, const double *dpSrc, long lCount)
{
    clDSPOp::Negate(dpDest, dpSrc, lCount);
}


void dsp_normalizef (float *fpVect, long lCount)
{
    clDSPOp::Normalize(fpVect, lCount);
}


void dsp_normalize (double *dpVect, long lCount)
{
    clDSPOp::Normalize(dpVect, lCount);
}


void dsp_normalizef_nip (float *fpDest, const float *fpSrc, long lCount)
{
    clDSPOp::Normalize(fpDest, fpSrc, lCount);
}


void dsp_normalize_nip (double *dpDest, const double *dpSrc, long lCount)
{
    clDSPOp::Normalize(dpDest, dpSrc, lCount);
}


float dsp_productf (const float *fpSrc, long lCount)
{
    return clDSPOp::Product(fpSrc, lCount);
}


double dsp_product (const double *dpSrc, long lCount)
{
    return clDSPOp::Product(dpSrc, lCount);
}


void dsp_reversef (float *fpVect, long lCount)
{
    clDSPOp::Reverse(fpVect, lCount);
}


void dsp_reverse (double *dpVect, long lCount)
{
    clDSPOp::Reverse(dpVect, lCount);
}


void dsp_reversef_nip (float *fpDest, const float *fpSrc, long lCount)
{
    clDSPOp::Reverse(fpDest, fpSrc, lCount);
}


void dsp_reverse_nip (double *dpDest, const double *dpSrc, long lCount)
{
    clDSPOp::Reverse(dpDest, dpSrc, lCount);
}


void dsp_scalef (float *fpVect, long lCount)
{
    clDSPOp::Scale(fpVect, lCount);
}


void dsp_scale (double *dpVect, long lCount)
{
    clDSPOp::Scale(dpVect, lCount);
}


void dsp_scalef_nip (float *fpDest, const float *fpSrc, long lCount)
{
    clDSPOp::Scale(fpDest, fpSrc, lCount);
}


void dsp_scale_nip (double *dpDest, const double *dpSrc, long lCount)
{
    clDSPOp::Scale(dpDest, dpSrc, lCount);
}


void dsp_scale01f (float *fpVect, long lCount)
{
    clDSPOp::Scale01(fpVect, lCount);
}


void dsp_scale01 (double *dpVect, long lCount)
{
    clDSPOp::Scale01(dpVect, lCount);
}


void dsp_scale01f_nip (float *fpDest, const float *fpSrc, long lCount)
{
    clDSPOp::Scale01(fpDest, fpSrc, lCount);
}


void dsp_scale01_nip (double *dpDest, const double *dpSrc, long lCount)
{
    clDSPOp::Scale01(dpDest, dpSrc, lCount);
}


void dsp_sortf (float *fpVect, long lCount)
{
    clDSPOp::Sort(fpVect, lCount);
}


void dsp_sort (double *dpVect, long lCount)
{
    clDSPOp::Sort(dpVect, lCount);
}


void dsp_sortl (long *lpVect, long lCount)
{
    clDSPOp::Sort(lpVect, lCount);
}


void dsp_stddevf (float *fpStdDev, float *fpMean, const float *fpSrc,
    long lCount)
{
    clDSPOp::StdDev(fpStdDev, fpMean, fpSrc, lCount);
}


void dsp_stddev (double *dpStdDev, double *dpMean, const double *dpSrc,
    long lCount)
{
    clDSPOp::StdDev(dpStdDev, dpMean, dpSrc, lCount);
}


float dsp_sumf (const float *fpSrc, long lCount)
{
    return clDSPOp::Sum(fpSrc, lCount);
}


double dsp_sum (const double *dpSrc, long lCount)
{
    return clDSPOp::Sum(dpSrc, lCount);
}


void dsp_squaref (float *fpVect, long lCount)
{
    clDSPOp::Square(fpVect, lCount);
}


void dsp_square (double *dpVect, long lCount)
{
    clDSPOp::Square(dpVect, lCount);
}


void dsp_squaref_nip (float *fpDest, const float *fpSrc, long lCount)
{
    clDSPOp::Square(fpDest, fpSrc, lCount);
}


void dsp_square_nip (double *dpDest, const double *dpSrc, long lCount)
{
    clDSPOp::Square(dpDest, dpSrc, lCount);
}


void dsp_convertu8f (float *fpDest, const unsigned char *ucpSrc, long lCount)
{
    clDSPOp::Convert(fpDest, ucpSrc, lCount);
}


void dsp_convertu8 (double *dpDest, const unsigned char *ucpSrc, long lCount)
{
    clDSPOp::Convert(dpDest, ucpSrc, lCount);
}


void dsp_converts16f (float *fpDest, const signed short *ipSrc, long lCount,
    int i12bit)
{
    clDSPOp::Convert(fpDest, ipSrc, lCount, (i12bit) ? true : false);
}


void dsp_converts16 (double *dpDest, const signed short *ipSrc, long lCount,
    int i12bit)
{
    clDSPOp::Convert(dpDest, ipSrc, lCount, (i12bit) ? true : false);
}


void dsp_converts32f (float *fpDest, const signed int *ipSrc, long lCount,
    int i24bit)
{
    clDSPOp::Convert(fpDest, ipSrc, lCount, (i24bit) ? true : false);
}


void dsp_converts32 (double *dpDest, const signed int *ipSrc, long lCount,
    int i24bit)
{
    clDSPOp::Convert(dpDest, ipSrc, lCount, (i24bit) ? true : false);
}


void dsp_convertd64f (float *fpDest, const double *dpSrc, long lCount)
{
    clDSPOp::Convert(fpDest, dpSrc, lCount);
}


void dsp_convertf32 (double *dpDest, const float *fpSrc, long lCount)
{
    clDSPOp::Convert(dpDest, fpSrc, lCount);
}


void dsp_convertf32c (unsigned char *ucpDest, const float *fpSrc, long lCount)
{
    clDSPOp::Convert(ucpDest, fpSrc, lCount);
}


void dsp_convertd64c (unsigned char *ucpDest, const double *dpSrc, long lCount)
{
    clDSPOp::Convert(ucpDest, dpSrc, lCount);
}


void dsp_convertf32s (signed short *ipDest, const float *fpSrc, long lCount,
    int i12bit)
{
    clDSPOp::Convert(ipDest, fpSrc, lCount, (i12bit) ? true : false);
}


void dsp_convertd64s (signed short *ipDest, const double *dpSrc, long lCount,
    int i12bit)
{
    clDSPOp::Convert(ipDest, dpSrc, lCount, (i12bit) ? true : false);
}


void dsp_convertf32i (signed int *ipDest, const float *fpSrc, long lCount,
    int i24bit)
{
    clDSPOp::Convert(ipDest, fpSrc, lCount, (i24bit) ? true : false);
}


void dsp_convertd64i (signed int *ipDest, const double *dpSrc, long lCount,
    int i24bit)
{
    clDSPOp::Convert(ipDest, dpSrc, lCount, (i24bit) ? true : false);
}


void dsp_cart2polarf (float *fpMagn, float *fpPhase, const float *fpReal,
    const float *fpImag, long lCount)
{
    clDSPOp::CartToPolar(fpMagn, fpPhase, fpReal, fpImag, lCount);
}


void dsp_cart2polar (double *dpMagn, double *dpPhase, const double *dpReal,
    const double *dpImag, long lCount)
{
    clDSPOp::CartToPolar(dpMagn, dpPhase, dpReal, dpImag, lCount);
}


void dsp_cart2polar2f (float *fpMagn, float *fpPhase, const stpSCplx spCart,
    long lCount)
{
    clDSPOp::CartToPolar(fpMagn, fpPhase, spCart, lCount);
}


void dsp_cart2polar2 (double *dpMagn, double *dpPhase, const stpDCplx spCart,
    long lCount)
{
    clDSPOp::CartToPolar(dpMagn, dpPhase, spCart, lCount);
}


void dsp_cart2polar3f (stpSPolar spPolar, const stpSCplx spCart, long lCount)
{
    clDSPOp::CartToPolar(spPolar, spCart, lCount);
}


void dsp_cart2polar3 (stpDPolar spPolar, const stpDCplx spCart, long lCount)
{
    clDSPOp::CartToPolar(spPolar, spCart, lCount);
}


void dsp_cart2polar4f (utpSCoord upCoord, long lCount)
{
    clDSPOp::CartToPolar(upCoord, lCount);
}


void dsp_cart2polar4 (utpDCoord upCoord, long lCount)
{
    clDSPOp::CartToPolar(upCoord, lCount);
}


void dsp_polar2cartf (float *fpReal, float *fpImag, const float *fpMagn,
    const float *fpPhase, long lCount)
{
    clDSPOp::PolarToCart(fpReal, fpImag, fpMagn, fpPhase, lCount);
}


void dsp_polar2cart (double *dpReal, double *dpImag, const double *dpMagn,
    const double *dpPhase, long lCount)
{
    clDSPOp::PolarToCart(dpReal, dpImag, dpMagn, dpPhase, lCount);
}


void dsp_polar2cart2f (stpSCplx spCart, const float *fpMagn, 
    const float *fpPhase, long lCount)
{
    clDSPOp::PolarToCart(spCart, fpMagn, fpPhase, lCount);
}


void dsp_polar2cart2 (stpDCplx spCart, const double *dpMagn,
    const double *dpPhase, long lCount)
{
    clDSPOp::PolarToCart(spCart, dpMagn, dpPhase, lCount);
}


void dsp_polar2cart3f (stpSCplx spCart, const stpSPolar spPolar, long lCount)
{
    clDSPOp::PolarToCart(spCart, spPolar, lCount);
}


void dsp_polar2cart3 (stpDCplx spCart, const stpDPolar spPolar, long lCount)
{
    clDSPOp::PolarToCart(spCart, spPolar, lCount);
}


void dsp_polar2cart4f (utpSCoord upCoord, long lCount)
{
    clDSPOp::PolarToCart(upCoord, lCount);
}


void dsp_polar2cart4 (utpDCoord upCoord, long lCount)