dspop.hh

各种工程计算的库函数

                const float *, long);
            /// \overload
            static void PolarToCart (double *, double *, const double *,
                const double *, long);
            /**
                \overload
                \param Cart Cartesian
                \param Magn Magnitude
                \param Phase Phase
                \param Count Vector length
            */
            static void PolarToCart (stpSCplx, const float *, const float *, 
                long);
            /// \overload
            static void PolarToCart (stpDCplx, const double *, const double *, 
                long);
            /**
                \overload
                \param Polar Polar
                \param Cart Cartesian
                \param Count Vector length
            */
            static void PolarToCart (stpSCplx, const stpSPolar, long);
            /// \overload
            static void PolarToCart (stpDCplx, const stpDPolar, long);
            /**
                Convert cartesian to polar vectors (in-place)
            */
            static void PolarToCart (utpSCoord, long);
            /// \overload
            static void PolarToCart (utpDCoord, long);
            /**
                Calculate normalized cross correlation of two vectors without
                delay

                \f[z=\frac{\frac{1}{N}\sum_{i=0}^{N-1}x(i)y(i)}
                {\frac{1}{N}\sqrt{\sum_{i=0}^{N-1}x(i)^2\sum_{i=0}^{N-1}y(i)^2}}\f]

                \param Src1 Source 1, x()
                \param Src2 Source 2, y()
                \param Count Vector length, N
                \return Normalized cross-correlation
            */
            static float CrossCorr (const float *, const float *, long);
            /// \overload
            static double CrossCorr (const double *, const double *, long);
            /**
                Calculate normalized cross correlation of two vectors with
                delay in second

                \f[z=\frac{\frac{1}{K}\sum_{i=0}^{K-1}x(i)y(i+k)}
                {\frac{1}{K}\sqrt{\sum_{i=0}^{K-1}x(i)^2\sum_{i=0}^{K-1}y(i+k)^2}}
                ,K=N-k\f]

                \param Src1 Source 1, x()
                \param Src2 Source 2, y()
                \param Delay Delay, k
                \param Count Vector length, N
                \return Normalized cross-correlation
            */
            static float DelCrossCorr (const float *, const float *, long, 
                long);
            /// \overload
            static double DelCrossCorr (const double *, const double *, long, 
                long);
            /**
                Calculate normalized cross correlation of two vectors
                with delays specified in vector 

                \f[z(j)=\frac{\frac{1}{K}\sum_{i=0}^{K-1}x(i)y(i+k(j))}
                {\frac{1}{K}\sqrt{\sum_{i=0}^{K-1}x(i)^2\sum_{i=0}^{K-1}y(i+k(j))^2}}
                ,K=N-k(j),0\leq{j}\leq{M-1}\f]

                \param Dest Destination vector, z()
                \param Src1 Source 1, x()
                \param Src2 Source 2, y()
                \param Count Vector length, N
                \param Delay Delays, k()
                \param DelayCount Delay vector length, M
            */
            static void DelCrossCorr (float *, const float *, const float *, 
                long, const long *, long);
            /// \overload
            static void DelCrossCorr (double *, const double *, const double *, 
                long, const long *, long);
            /**
                Calculates energy (square) of vector

                \f[w=\sum_{i=0}^{N-1}x(i)^2\f]

                \param Src Source, x()
                \param Count Vector length, N
                \return Energy, w
            */
            static float Energy (const float *, long);
            /// \overload
            static double Energy (const double *, long);
            /**
                Calculates magnitudes (linear) of vector

                \f[V(i)=\sqrt{\Re_{X}(i)^2+\Im_{X}(i)^2}, 0\leq{i}\leq{N-1}\f]

                \param Dest Destination, V()
                \param Src Source, X()
                \param Count Vector length
            */
            static void Magnitude (float *, const stpSCplx, long);
            /// \overload
            static void Magnitude (double *, const stpDCplx, long);
            /**
                Calculates powers (in dB) of vector

                \f[P(i)=20\log\sqrt{\Re_{X}(i)^2+\Im_{X}(i)^2}, 0\leq{i}\leq{N-1}\f]

                \param Dest Destination, P()
                \param Src Source, X()
                \param Count Vector length
            */
            static void Power (float *, const stpSCplx, long);
            /// \overload
            static void Power (double *, const stpDCplx, long);
            /**
                Calculated phases (in rad) of vector

                \f[\varphi(i)=\arctan{\frac{\Im_{X}(i)}{\Re_{X}(i)}}, 0\leq{i}\leq{N-1}\f]

                \param Dest Destination, \f$\varphi(i)\f$
                \param Src Source, X()
                \param Count Vector length, N
            */
            static void Phase (float *, const stpSCplx, long);
            /// \overload
            static void Phase (double *, const stpDCplx, long);
            /**
                Calculates powers (in dB) and phases (in rad) of vector
                See ::Power() and ::Phase() for formulas

                \param Power Powers
                \param Phase Phases
                \param Src Source
                \param Count Vector length
            */
            static void PowerPhase (float *, float *, const stpSCplx, long);
            /// \overload
            static void PowerPhase (double *, double *, const stpDCplx, long);
            /**
                Decimate vector without average
                \note This can be used in-place also

                \param Dest Destination
                \param Src Source
                \param Factor Decimation factor
                \param Count Vector length (source)
            */
            static void Decimate (float *, const float *, long, long);
            /// \overload
            static void Decimate (double *, const double *, long, long);
            /**
                Decimate vector with average.
                Linear (arithmetic) mean is used to evaluate new values.

                \param Dest Destination
                \param Src Source
                \param Factor Decimation factor
                \param Count Vector length (source)
            */
            static void DecimateAvg (float *, const float *, long, long);
            /// \overload
            static void DecimateAvg (double *, const double *, long, long);
            /**
                Iterpolate vector without average (nulling)

                \param Dest Destination
                \param Src Source
                \param Factor Interpolation factor
                \param Count Vector length (source)
            */
            static void Interpolate (float *, const float *, long, long);
            /// \overload
            static void Interpolate (double *, const double *, long, long);
            /**
                Interpolate vector with average (linear).
                Lagrange interpolation is used to estimate new values.

                \f[y(k)=\frac{k-(i+1)}{i-(i+1)}\times{x(i)}+\frac{k-i}{(i+1)-i}\times{x(i+1)}, 0\leq{k}\leq{M-1}, 0\leq{i}\leq{N-1}\f]

                Where M is destination length and N is source length.

                \param Dest Destination
                \param Src Source
                \param Factor Interpolation factor
                \param Count Vector length (source)
            */
            static void InterpolateAvg (float *, const float *, long, long);
            static void InterpolateAvg (double *, const double *, long, long);
            /**
                Resample vector to different length.

                \param Dest Destination
                \param DestCount Destionation vector length
                \param Src Source
                \param SrcCount Source vector length
            */
            static void Resample (float *, long, const float *, long);
            static void Resample (double *, long, const double *, long);
            /**
                Resample vector to different length with average.

                \param Dest Destination
                \param DestCount Destination vector length
                \param Src Source
                \param SrcCount Source vector length
            */
            static void ResampleAvg (float *, long, const float *, long);
            static void ResampleAvg (double *, long, const double *, long);
            /**
                Calculate RMS (root mean square) of vector

                \f[I=\sqrt{\frac{\sum_{i=0}^{N-1}x(i)^2}{N}}\f]

                \param Src Source, x()
                \param Count Vector length, N
                \return RMS, I
            */
            static float RMS (const float *, long);
            /// \overload
            static double RMS (const double *, long);
            /**
                Calculate variance and mean of vector
                \note variance and mean pointers can be NULL

                \f[\mu=\frac{1}{N}\sum_{i=0}^{N-1}x(i)\f]
                \f[\sigma^2=\frac{\sum_{i=0}^{N}(x(i)-\mu)^2}{N}\f]

                \param Variance Variance, \f$\sigma^2\f$
                \param Mean Mean, \f$\mu\f$
                \param Src Source, x()
                \param Count Vector length, N
                \return Variance \f$\sigma^2\f$
            */
            static float Variance (float *, float *, const float *, long);
            /// \overload
            static double Variance (double *, double *, const double *, long);
            /**
                Find peak level of vector and return result in dB

                \param Src Source
                \param Count Vector length
                \return Peak level (dB)
            */
            static float PeakLevel (const float *, long);
            /// \overload
            static double PeakLevel (const double *, long);
            /**
                Calculate Bartlett (triangle) window coefficients

                \param Dest Destination
                \param Count Vector length
            */
            void WinBartlett (float *, long);
            /// \overload
            void WinBartlett (double *, long);
            /**
                Calculate Blackman window coefficients

                \f[y(n)=0.42-0.5\cos\left(\frac{2\pi{n}}{N}\right)+0.08\cos\left(\frac{4\pi{n}}{N}\right), 0\leq{n}\leq{N-1}\f]

                \param Dest Destination, y()
                \param Count Vector length, N
            */
            // (destination vector, length)
            void WinBlackman (float *, long);
            /// \overload
            void WinBlackman (double *, long);
            /**
                Calculate blackman window coefficients with specified alpha
                
                \f[y(n)=\frac{\alpha+1}{2}-0.5\cos\left(\frac{2\pi{n}}{N-1}\right)-\frac{\alpha}{2}\cos\left(\frac{4\pi{n}}{N-1}\right), 0\leq{n}\leq{N-1}\f]
                
                or with optimal alpha when alpha is specified as 0
                
                \f[\alpha=\frac{0.5}{1+\cos\left(\frac{2\pi}{N-1}\right)}\f]
                
                (around -0.25 for large windows)
            */
            void WinBlackman (float *, long, float);
            void WinBlackman (double *, long, double);
            /**
                Calculate Blackman-Harris window coefficients

                \f[y(n)=0.42323-0.49855\cos\left(\frac{2\pi{n}}{N}\right)+0.07922\cos\left(\frac{4\pi{n}}{N}\right), 0\leq{n}\leq{N-1}\f]

                \param Dest Destination, y()
                \param Count Vector length, N
            */
            void WinBlackmanHarris (float *, long);
            /// \overload
            void WinBlackmanHarris (double *, long);
            /**
                Calculate cosine tapered window coefficients

                \f[y(n)=0.5\left(1-\cos\left(\frac{2\pi{n}}{N}\right)\right), 0\leq{n}\leq{N-1}\f]

                \param Dest Destination, y()
                \param Count Vector length, N
            */
            void WinCosTapered (float *, long);
            /// \overload
            void WinCosTapered (double *, long);
            /**
                \overload
                Apply cosine tapered window to vector (in-place)
            */
            void WinCosTaperedA (float *, long);
            /// \overload
            void WinCosTaperedA (double *, long);
            /**
                \overload
                Apply cosine tapered window to vector (out-of-place)
            */
            void WinCosTaperedA (float *, const float *, long);
            /// \overload
            void WinCosTaperedA (double *, const double *, long);
            /**
                Calculate exact Blackman window coefficients

                \f[y(n)=\frac{7938}{18608}-\frac{9240}{18608}\cos\left(\frac{2\pi{n}}{N}\right)+\frac{1430}{18608}\cos\left(\frac{4\pi{n}}{N}\right), 0\leq{n}\leq{N-1}\f]

                \param Dest Destination, y()
                \param Count Vector length, N
            */
            void WinExactBlackman (float *, long);
            /// \overload
            void WinExactBlackman (double *, long);
            /**
                Calculate exponential window coefficients

                \f[y(n)=y(N-1-n)=\exp\left(\frac{\ln(z+1)}{N/2}n\right)-1, 0\leq{n}\leq{N/2}\f]

                \param Dest Destination, y()
                \param Final Final value, z
                \param Count Vector length, N
            */
            void WinExp (float *, float, long);
            /// \overload
            void WinExp (double *, double, long);