dspvector.hh

各种工程计算的库函数

            clDSPVector & Convert (const float *fpSrc, long lSrcCount)
                {
                    SetSize(lSrcCount);
                    DSP.Convert(Ptr(), fpSrc, lSrcCount);
                    return (*this);
                }
            clDSPVector & Convert (const double *dpSrc, long lSrcCount)
                {
                    SetSize(lSrcCount);
                    DSP.Convert(Ptr(), dpSrc, lSrcCount);
                    return (*this);
                }
            void Convert (unsigned char *ucpDest)
                {
                    DSP.Convert(ucpDest, Ptr(), Size());
                }
            void Convert (signed short *ipDest, bool b12bit = false)
                {
                    DSP.Convert(ipDest, Ptr(), Size(), b12bit);
                }
            void Convert (signed int *ipDest, bool b24bit = false)
                {
                    DSP.Convert(ipDest, Ptr(), Size(), b24bit);
                }
            void Convert (float *fpDest)
                {
                    DSP.Convert(fpDest, Ptr(), Size());
                }
            void Convert (double *dpDest)
                {
                    DSP.Convert(dpDest, Ptr(), Size());
                }
            clDSPVector & CartToPolar ()
                {
                    DSP.CartToPolar(Ptr(), Size());
                    return (*this);
                }
            clDSPVector & CartToPolar (clDSPVector &Cart)
                {
                    SetSize(Cart.Size());
                    DSP.CartToPolar(Ptr(), Cart.Ptr(), Size());
                    return (*this);
                }
            void CartToPolar (clDSPVector<float> &Magn, 
                clDSPVector<float> &Phase)
                {
                    Magn.SetSize(Size());
                    Phase.SetSize(Size());
                    DSP.CartToPolar(Magn.Ptr(), Phase.Ptr(), Ptr(), Size());
                }
            void CartToPolar (clDSPVector<double> &Magn, 
                clDSPVector<double> &Phase)
                {
                    Magn.SetSize(Size());
                    Phase.SetSize(Size());
                    DSP.CartToPolar(Magn.Ptr(), Phase.Ptr(), Ptr(), Size());
                }
            clDSPVector & PolarToCart ()
                {
                    DSP.PolarToCart(Ptr(), Size());
                    return (*this);
                }
            clDSPVector & PolarToCart (clDSPVector &Polar)
                {
                    SetSize(Polar.Size());
                    DSP.PolarToCart(Ptr(), Polar.Ptr(), Size());
                    return (*this);
                }
            void PolarToCart (clDSPVector<float> &Real, 
                clDSPVector<float> &Imag)
                {
                    Real.SetSize(Size());
                    Imag.SetSize(Size());
                    DSP.PolarToCart(Real.Ptr(), Imag.Ptr(), Ptr(), Size());
                }
            void PolarToCart (clDSPVector<double> &Real, 
                clDSPVector<double> &Imag)
                {
                    Real.SetSize(Size());
                    Imag.SetSize(Size());
                    DSP.PolarToCart(Real.Ptr(), Imag.Ptr(), Ptr(), Size());
                }
            clDSPVector & Magnitude (clDSPVector<stSCplx> &Src)
                {
                    SetSize(Src.Size());
                    DSP.Magnitude(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
                    return (*this);
                }
            clDSPVector & Magnitude (clDSPVector<stDCplx> &Src)
                {
                    SetSize(Src.Size());
                    DSP.Magnitude(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
                    return (*this);
                }
            clDSPVector & Power (clDSPVector<stSCplx> &Src)
                {
                    SetSize(Src.Size());
                    DSP.Power(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
                    return (*this);
                }
            clDSPVector & Power (clDSPVector<stDCplx> &Src)
                {
                    SetSize(Src.Size());
                    DSP.Power(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
                    return (*this);
                }
            clDSPVector & Phase (clDSPVector<stSCplx> &Src)
                {
                    SetSize(Src.Size());
                    DSP.Phase(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
                    return (*this);
                }
            clDSPVector & Phase (clDSPVector<stDCplx> &Src)
                {
                    SetSize(Src.Size());
                    DSP.Phase(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
                    return (*this);
                }
            void PowerPhase (clDSPVector<float> &Power, 
                clDSPVector<float> &Phase)
                {
                    Power.SetSize(Size());
                    Phase.SetSize(Size());
                    DSP.PowerPhase(Power.Ptr(), Phase.Ptr(), Ptr(), Size());
                }
            void PowerPhase (clDSPVector<double> &Power, 
                clDSPVector<double> &Phase)
                {
                    Power.SetSize(Size());
                    Phase.SetSize(Size());
                    DSP.PowerPhase(Power.Ptr(), Phase.Ptr(), Ptr(), Size());
                }
            clDSPVector & Decimate (long lFactor)
                {
                    DSP.Decimate(Ptr(), Ptr(), lFactor, Size());
                    return (*this);
                }
            clDSPVector & Decimate (clDSPVector &Src, long lFactor)
                {
                    SetSize(Src.Size() / lFactor);
                    DSP.Decimate(Ptr(), Src.Ptr(), lFactor, Src.Size());
                    return (*this);
                }
            clDSPVector & DecimateAvg (clDSPVector &Src, long lFactor)
                {
                    SetSize(Src.Size() / lFactor);
                    DSP.DecimateAvg(Ptr(), Src.Ptr(), lFactor, Src.Size());
                    return (*this);
                }
            clDSPVector & Interpolate (clDSPVector &Src, long lFactor)
                {
                    SetSize(Src.Size() * lFactor);
                    DSP.Interpolate(Ptr(), Src.Ptr(), lFactor, Src.Size());
                    return (*this);
                }
            clDSPVector & InterpolateAvg (clDSPVector &Src, long lFactor)
                {
                    SetSize(Src.Size() * lFactor);
                    DSP.InterpolateAvg(Ptr(), Src.Ptr(), lFactor, Src.Size());
                    return (*this);
                }
            clDSPVector & Resample (clDSPVector &Src)
                {
                    DSP.Resample(Ptr(), Size(), Src.Ptr(), Src.Size());
                    return (*this);
                }
            clDSPVector & ResampleAvg (clDSPVector &Src)
                {
                    DSP.ResampleAvg(Ptr(), Size(), Src.Ptr(), Src.Size());
                    return (*this);
                }

            clDSPVector & WinBartlett (long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinBartlett(Ptr(), Size());
                    return (*this);
                }
            clDSPVector & WinBlackman (long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinBlackman(Ptr(), Size());
                    return (*this);
                }
            clDSPVector & WinBlackman (long lWinSize, TDSPVector_t fAlpha)
                {
                    SetSize(lWinSize);
                    DSP.WinBlackman(Ptr(), Size(), fAlpha);
                    return (*this);
                }
            clDSPVector & WinBlackmanHarris (long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinBlackmanHarris(Ptr(), Size());
                    return (*this);
                }
            clDSPVector & WinCosTapered (long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinCosTapered(Ptr(), Size());
                    return (*this);
                }
            clDSPVector & WinExactBlackman (long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinExactBlackman(Ptr(), Size());
                    return (*this);
                }
            clDSPVector & WinExp (TDSPVector_t fZ, long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinExp(Ptr(), fZ, Size());
                    return (*this);
                }
            clDSPVector & WinFlatTop (long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinFlatTop(Ptr(), Size());
                    return (*this);
                }
            clDSPVector & WinGenericCos (clDSPVector &Coeffs, long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinGenericCos(Ptr(), Size(), 
                        Coeffs.Ptr(), Coeffs.Size());
                    return (*this);
                }
            clDSPVector & WinHamming (long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinHamming(Ptr(), Size());
                    return (*this);
                }
            clDSPVector & WinHanning (long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinHanning(Ptr(), Size());
                    return (*this);
                }
            clDSPVector & WinKaiser (TDSPVector_t fBeta, long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinKaiser(Ptr(), fBeta, Size());
                    return (*this);
                }
            clDSPVector & WinKaiserBessel (TDSPVector_t fAlpha, long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinKaiserBessel(Ptr(), fAlpha, Size());
                    return (*this);
                }
            clDSPVector & WinTukey (long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinTukey(Ptr(), Size());
                    return (*this);
                }
            clDSPVector & WinDolphChebyshev (TDSPVector_t fGamma, long lWinSize)
                {
                    SetSize(lWinSize);
                    DSP.WinDolphChebyshev(Ptr(), fGamma, Size());
                    return (*this);
                }

            clDSPVector & Mix (clDSPVector &Src, long lChCount)
                {
                    SetSize(Src.Size() / lChCount);
                    DSP.Mix(Ptr(), Src.Ptr(), lChCount, Size());
                    return (*this);
                }
            clDSPVector & Extract (clDSPVector &Src, long lCh, long lChCount)
                {
                    SetSize(Src.Size() / lChCount);
                    DSP.Extract(Ptr(), Src.Ptr(), lCh, lChCount, Src.Size());
                    return (*this);
                }
            clDSPVector & Pack (clDSPVector &Src, long lCh, long lChCount)
                {
                    Resize(Src.Size() * lChCount);
                    DSP.Pack(Ptr(), Src.Ptr(), lCh, lChCount, Src.Size());
                    return (*this);
                }
            /// \note Vector must be sized before calling this!
            clDSPVector & FFTWConvert (clDSPVector &Src)
                {
                    DSP.FFTWConvert(Ptr(), Src.Ptr(), Src.Size());
                    return (*this);
                }

            void FIRAllocate (clDSPVector &Src)
                {
                    DSP.FIRAllocate(Src.Ptr(), Src.Size());
                }
            clDSPVector & FIRFilter ()
                {
                    DSP.FIRFilter(Ptr(), Size());
                    return (*this);
                }
            clDSPVector & FIRFilter (clDSPVector &Src)
                {
                    SetSize(Src.Size());
                    DSP.FIRFilter(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
                    return (*this);
                }
            void FIRFree ()
                {
                    DSP.FIRFree();
                }

            void FFTInitialize (long lWinSize, bool bReal)
                {
                    lFFTSize = lWinSize;
                    DSP.FFTInitialize(lFFTSize, bReal);
                }
            clDSPVector & FFT (clDSPVector<float> &Src)
                {
                    SetSize(lFFTSize / 2 + 1);
                    DSP.FFTo(Ptr(), Src.Ptr());
                    return (*this);
                }
            clDSPVector & FFT (clDSPVector<double> &Src)
                {
                    SetSize(lFFTSize / 2 + 1);
                    DSP.FFTo(Ptr(), Src.Ptr());
                    return (*this);
                }
            clDSPVector & FFT (clDSPVector<stSCplx> &Src)
                {
                    SetSize(lFFTSize);
                    DSP.FFTo(Ptr(), Src.Ptr());
                    return (*this);
                }
            clDSPVector & FFT (clDSPVector<stDCplx> &Src)
                {
                    SetSize(lFFTSize);
                    DSP.FFTo(Ptr(), Src.Ptr());
                    return (*this);
                }
            clDSPVector & IFFT (clDSPVector<stSCplx> &Src)
                {
                    SetSize(lFFTSize);
                    DSP.IFFTo(Ptr(), Src.Ptr());
                    return (*this);
                }
            clDSPVector & IFFT (clDSPVector<stDCplx> &Src)
                {
                    SetSize(lFFTSize);
                    DSP.IFFTo(Ptr(), Src.Ptr());
                    return (*this);
                }
            void FFTUninitialize ()
                {
                    DSP.FFTUninitialize();
                }
                
            void DCTInitialize (long lWinSize)
                {
                    lFFTSize = lWinSize;
                    DSP.DCTInitialize(lWinSize);
                }
            void DCTUninitialize ()
                {
                    DSP.DCTUninitialize();
                }
            clDSPVector & DCT ()
                {
                    DSP.DCTi(Ptr());
                    return (*this);
                }
            clDSPVector & DCT (clDSPVector<float> &Src)
                {
                    SetSize(lFFTSize);
                    DSP.DCTo(Ptr(), Src.Ptr());
                    return (*this);
                }
            clDSPVector & DCT (clDSPVector<double> &Src)
                {
                    SetSize(lFFTSize);
                    DSP.DCTo(Ptr(), Src.Ptr());
                    return (*this);
                }
            clDSPVector & IDCT ()
                {
                    DSP.IDCTi(Ptr());
                    return (*this);
                }
            clDSPVector & IDCT (clDSPVector<float> &Src)
                {
                    SetSize(lFFTSize);
                    DSP.IDCTo(Ptr(), Src.Ptr());
                    return (*this);
                }
            clDSPVector & IDCT (clDSPVector<double> &Src)
                {
                    SetSize(lFFTSize);
                    DSP.IDCTo(Ptr(), Src.Ptr());
                    return (*this);
                }
    };


#endif