dspop.hh

各种工程计算的库函数

                \note Circular, result is scaled

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

                \param Dest Destination, y()
                \param Src Source, x()
                \param Count Vector length, N
            */
            static void AutoCorrelate (float *, const float *, long);
            /// \overload
            static void AutoCorrelate (double *, const double *, long);
            /**
                Dot product of two vectors

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

                \param Src1 Source 1, x()
                \param Src2 Source 2, y()
                \param Count Vector length, N
                \return Dot product
            */
            static float DotProduct (const float *, const float *, long);
            /// \overload
            static double DotProduct (const double *, const double *, long);
            /**
                Find minimum and maximum values of vector

                \param Min Minimum
                \param Max Maximum
                \param Src Source
                \param Count Vector length
            */
            static void MinMax (float *, float *, const float *, long);
            /// \overload
            static void MinMax (double *, double *, const double *, long);
            /**
                Calculate mean of vector

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

                \param Src Source
                \param Count Vector length
                \return Mean
            */
            static float Mean (const float *, long);
            /// \overload
            static double Mean (const double *, long);
            /**
                Calculate median of vector

                \f[m=\left\{\begin{array}{ll}x_{sorted}\left(\frac{N}{2}\right)&,N\bmod{2}\neq{0}\\
                0.5\times\left(x_{sorted}\left(\frac{N}{2}-1\right)+x_{sorted}\left(\frac{N}{2}\right)\right)&,N\bmod{2}=0
                \end{array}\right.\f]

                \param Src Source, x()
                \param Count Vector length, N
                \return Median, m
            */
            static float Median (const float *, long);
            /// \overload
            static double Median (const double *, long);
            /**
                Negate vector elements

                \f[x(i)=-x(i), 0\leq{i}\leq{N-1}\f]

                \param Vect Source & destination
                \param Count Vector length
            */
            static void Negate (float *, long);
            /// \overload
            static void Negate (double *, long);
            /**
                Negate vector elements

                \f[y(i)=-x(i), 0\leq{i}\leq{N-1}\f]

                \param Dest Destination, y()
                \param Src Source, x()
                \param Count Vector length, N
            */
            static void Negate (float *, const float *, long);
            /// \overload
            static void Negate (double *, const double *, long);
            /**
                Normalize vector elements

                \f[x(i)=\frac{x(i)-\mu}{\sigma}, 0\leq{i}\leq{N-1}\f]

                \param Vect Source & destination, x()
                \param Count Vector length, N
            */
            static void Normalize (float *, long);
            /// \overload
            static void Normalize (double *, long);
            /**
                Normalize vector elements

                \f[y(i)=\frac{x(i)-\mu}{\sigma}, 0\leq{i}\leq{N-1}\f]

                \param Dest Destination, y()
                \param Src Source, x()
                \param Count Vector length, N
            */
            static void Normalize (float *, const float *, long);
            /// \overload
            static void Normalize (double *, const double *, long);
            /**
                Product of vector elements

                \f[p=\prod{x(i)}, 0\leq{i}\leq{N-1}\f]

                \param Src Source, x()
                \param Count Vector length, N
                \return Product, p
            */
            static float Product (const float *, long);
            /// \overload
            static double Product (const double *, long);
            /**
                Reverse vector (in-place)
                
                \f[y(i)=x(K-i), K=N-1, 0\leq{i}\leq{N-1}\f]
                
                \param Vect Source & destination x()
                \param Count Vector length, N
            */
            static void Reverse (float *, long);
            /// \overload
            static void Reverse (double *, long);
            /// \overload
            static void Reverse (stpSCplx, long);
            /// \overload
            static void Reverse (stpDCplx, long);
            /**
                Reverse vector (out-of-place)

                \f[y(i)=x(K-i), K=N-1, 0\leq{i}\leq{N-1}\f]

                \param Dest Destination, y()
                \param Src Source, x()
                \param Count Vector length
            */
            static void Reverse (float *, const float *, long);
            /// \overload
            static void Reverse (double *, const double *, long);
            /// \overload
            static void Reverse (stpSCplx, const stpSCplx, long);
            /// \overload
            static void Reverse (stpDCplx, const stpDCplx, long);
            /**
                Scale (normalize) vector to range [-1:1]

                \f[x(i)=x(i)\frac{2}{\max-\min}+\left(1-\max\frac{2}{\max-\min}\right), 0\leq{i}\leq{N-1}\f]

                \param Vect Source & destination, x()
                \param Count Vector length, N
            */
            static void Scale (float *, long);
            /// \overload
            static void Scale (double *, long);
            /**
                \overload
                \param Dest Destination
                \param Src Source
                \param Count Vector length
            */
            static void Scale (float *, const float *, long);
            /// \overload
            static void Scale (double *, const double *, long);
            /**
                Scale (normalize) vector to range [0:1]

                \f[x(i)=x(i)\frac{1}{\max-\min}+\left(-\min\frac{1}{\max-\min}\right), 0\leq{i}\leq{N-1}\f]

                \param Vect Source & destination, x()
                \param Count Vector length, N
            */
            static void Scale01 (float *, long);
            /// \overload
            static void Scale01 (double *, long);
            /**
                \overload
                \param Dest Destination
                \param Src Source
                \param Count Vector length
            */
            static void Scale01 (float *, const float *, long);
            /// \overload
            static void Scale01 (double *, const double *, long);
            /**
                Sort vector elements (in-place).
                Vector is sorted using quick-sort algorithm.

                \param Vect Source & destination
                \param Count Vector length
            */                
            static void Sort (float *, long);
            /// \overload
            static void Sort (double *, long);
            /// \overload
            static void Sort (long *, long);
            /**
                Calculate standard deviation and mean of vector

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

                \param StdDev Standard deviation, \f$\sigma\f$
                \param Mean Mean, \f$\mu\f$
                \param Src Source, x()
                \param Count Vector length, N
            */
            static void StdDev (float *, float *, const float *, long);
            /// \overload
            static void StdDev (double *, double *, const double *, long);
            /**
                Calculate sum of vector elements

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

                \param Src Source, x()
                \param Count Vector length, N
                \return Sum, y
            */
            static float Sum (const float *, long);
            /// \overload
            static double Sum (const double *, long);
            /**
                Square vector in-place

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

                \param Vect Source & destination, x()
                \param Count Vector length, N
            */
            static void Square (float *, long);
            /// \overload
            static void Square (double *, long);
            /**
                Square vector out-of-place

                \f[y(i)=x(i)^2, 0\leq{i}\leq{N-1}\f]

                \param Dest Destination, y()
                \param Src Source, x()
                \param Count Vector length, N
            */
            static void Square (float *, const float *, long);
            /// \overload
            static void Square (double *, const double *, long);
            /**
                Vector datatype conversion

                \note 12-bit data in LSBs, 24-bit data in MSBs

                \param Dest Destination
                \param Src Source
                \param Count Vector length
            */
            static void Convert (float *, const unsigned char *, long);
            /**
                \overload
                \param Dest Destination
                \param Src Source
                \param Count Vector length
                \param 12bit 12-bit data
            */
            static void Convert (float *, const signed short *, long, bool);
            /**
                \overload
                \param Dest Destination
                \param Src Source
                \param Count Vector length
                \param 24bit 24-bit data
            */
            static void Convert (float *, const signed int *, long, bool);
            /// \overload
            static void Convert (float *, const double *, long);
            /// \overload
            static void Convert (double *, const unsigned char *, long);
            /// \overload
            static void Convert (double *, const signed short *, long, bool);
            /// \overload
            static void Convert (double *, const signed int *, long, bool);
            /// \overload
            static void Convert (double *, const float *, long);
            /// \overload
            static void Convert (unsigned char *, const float *, long);
            /// \overload
            static void Convert (unsigned char *, const double *, long);
            /// \overload
            static void Convert (signed short *, const float *, long, bool);
            /// \overload
            static void Convert (signed short *, const double *, long, bool);
            /// \overload
            static void Convert (signed int *, const float *, long, bool);
            /// \overload
            static void Convert (signed int *, const double *, long, bool);
            /**
                Convert cartesian to polar vectors (out-of-place).
                See ::Cart2Polar for formula

                \param Magn Magnitude
                \param Phase Phase
                \param Real Real
                \param Imag Imaginary
                \param Count Vector length
            */
            static void CartToPolar (float *, float *, const float *, 
                const float *, long);
            /// \overload
            static void CartToPolar (double *, double *, const double *, 
                const double *, long);
            /**
                \overload
                \param Magn Magnitude
                \param Phase Phase
                \param Cart Cartesian
                \param Count Vector length
            */
            static void CartToPolar (float *, float *, const stpSCplx, long);
            /// \overload
            static void CartToPolar (double *, double *, const stpDCplx, long);
            /**
                \overload
                \param Polar Polart
                \param Cart Cartesian
                \param Count Vector length
            */
            static void CartToPolar (stpSPolar, const stpSCplx, long);
            /// \overload
            static void CartToPolar (stpDPolar, const stpDCplx, long);
            /**
                Convert cartesian to polar vectors (in-place)
            */
            static void CartToPolar (utpSCoord, long);
            /// \overload
            static void CartToPolar (utpDCoord, long);
            /**
                Convert polar to cartesian vectors (out-of-place).
                See ::Polar2Cart for formula

                \param Real Real
                \param Imag Imaginary
                \param Magn Magnitude
                \param Phase Phase
                \param Count Vector length
            */
            static void PolarToCart (float *, float *, const float *,