dspop.hh

各种工程计算的库函数

            static void Div (double *, const double *, long);
            /// \overload
            static void Div (stpSCplx, const stpSCplx, long);
            /// \overload
            static void Div (stpDCplx, const stpDCplx, long);
            /**
                Divide two vectors and return result in third

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

                \param Dest Destination, z()
                \param Src1 Source 1, x()
                \param Src2 Source 2, y()
                \param Count Vector length, N
            */
            static void Div (float *, const float *, const float *, long);
            /// \overload
            static void Div (double *, const double *, const double *, long);
            /// \overload
            static void Div (stpSCplx, const stpSCplx, const stpSCplx, long);
            /// \overload
            static void Div (stpDCplx, const stpDCplx, const stpDCplx, long);
            /**
                Calculate 1 / value in-place

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

                \param Vect Source & destination
                \param Count Vector length, N
            */
            static void Div1x (float *, long);
            /// \overload
            static void Div1x (double *, long);
            /**
                Calculate 1 / value out-of-place

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

                \param Dest Destination, y()
                \param Src Source, x()
                \param Count Vector length, N
            */
            static void Div1x (float *, const float *, long);
            /// \overload
            static void Div1x (double *, const double *, long);
            /**
                Multiply-add vector in-place
                
                \f[x(i)=x(i)s+o, 0\leq{i}\leq{N-1}\f]
                
                \param Vect Source & destination, x()
                \param Mul Multiply value, s
                \param Add Addition value, o
                \param Count Vector length, N
            */
            static void MulAdd (float *, float, float, long);
            static void MulAdd (double *, double, double, long);
            /**
                Multiply-add vector out-of-place
                
                \f[y(i)=x(i)s+o, 0\leq{i}\leq{N-1}\f]
                
                \param Dest Destination, y()
                \param Src Source, x()
                \param Mul Multiply value, s
                \param Add Addition value, o
                \param Count Vector length, N
            */
            static void MulAdd (float *, const float *, float, float, long);
            static void MulAdd (double *, const double *, double, double, long);
            /**
                Multiply-add complex vectors out-of-place
                
                \f[Z(i)=X(i)Y(i), 0\leq{i}\leq{N-1}\f]
                
                \param Dest Destination, Z()
                \param Src1 Source 1, X()
                \param Src2 Source 2, Y()
                \param Count Vector length, N
            */
            static void MulAddC (stpSCplx, const stpSCplx, const stpSCplx, 
                long);
            static void MulAddC (stpDCplx, const stpDCplx, const stpDCplx,
                long);
            /**
                Get absolute value in-place

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

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

                \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 Abs (float *, const float *, long);
            /// \overload
            static void Abs (double *, const double *, long);
            /**
                Calculate square-roots in-place

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

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

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

                \param Dest Destination, y()
                \param Src Source, x()
                \param Count Vector length, N
            */
            static void Sqrt (float *, const float *, long);
            /// \overload
            static void Sqrt (double *, const double *, long);
            /**
                Set all vector elements to zero

                \param Vect Vector
                \param Count Vector length
            */
            static void Zero (float *, long);
            /// \overload
            static void Zero (double *, long);
            /// \overload
            static void Zero (stpSCplx, long);
            /// \overload
            static void Zero (stpDCplx, long);
            /**
                Set all vector elements to specified value

                \param Dest Destination
                \param Src Source value
                \param Count Vector length
            */
            static void Set (float *, float, long);
            /// \overload
            static void Set (double *, double, long);
            /// \overload
            static void Set (stpSCplx, stSCplx, long);
            /// \overload
            static void Set (stpDCplx, stDCplx, long);
            /**
                Set specified vector elements to specified value with
                boundary check

                \param Dest Destination
                \param Src Source value
                \param Start Starting index
                \param Count Number of elements to set
                \param Length Vector length
            */
            static void Set (float *, float, long, long, long);
            /// \overload
            static void Set (double *, double, long, long, long);
            /// \overload
            static void Set (stpSCplx, stSCplx, long, long, long);
            /// \overload
            static void Set (stpDCplx, stDCplx, long, long, long);
            /**
                Clip vector in-place to specified value

                \f[x(i)=\left\{\begin{array}{ll}x(i)&,x(i)\leq{y}\\
                y&,x(i)>y\end{array}\right., 0\leq{i}\leq{N-1}\f]

                \param Vect Source & destination, x()
                \param Value Clipping value, y
                \param Count Vector length, N
            */
            static void Clip (float *, float, long);
            /// \overload
            static void Clip (double *, double, long);
            /**
                Clip vector out-of-place to specified value

                \f[z(i)=\left\{\begin{array}{ll}x(i)&,x(i)\leq{y}\\
                y&,x(i)>y\end{array}\right., 0\leq{i}\leq{N-1}\f]

                \param Dest Destination, z()
                \param Src Source, x()
                \param Value Clipping value, y
                \param Count Vector length, N
            */
            static void Clip (float *, const float *, float, long);
            /// \overload
            static void Clip (double *, const double *, double, long);
            /**
                Clip vector in-place to fit between specified values

                \f[x(i)=\left\{\begin{array}{ll}a&,x(i)<a\\
                x(i)&,a\leq{x(i)}\leq{b}\\
                b&,x(i)>b\end{array}\right., 0\leq{i}\leq{N-1}\f]

                \param Vect Source & destination, x()
                \param Min Minimum value, a
                \param Max Maximum value, b
                \param Count Vector length, N
            */
            static void Clip (float *, float, float, long);
            /// \overload
            static void Clip (double *, double, double, long);
            /**
                Clip vector out-of-place to fit between specified values

                \f[y(i)=\left\{\begin{array}{ll}a&,x(i)<a\\
                x(i)&,a\leq{x(i)}\leq{b}\\
                b&,x(i)>b\end{array}\right., 0\leq{i}\leq{N-1}\f]

                \param Dest Destination, y()
                \param Src Source, x()
                \param Min Minimum value, a
                \param Max Maximum value, b
                \param Count Vector length, N
            */
            static void Clip (float *, const float *, float, float, long);
            /// \overload
            static void Clip (double *, const double *, double, double, long);
            /**
                Clip smallest values in vector to zero (in-place)

                \f[x(i)=\left\{\begin{array}{ll}0&,x(i)<0\\
                x(i)&,x(i)\leq{0}\end{array}\right., 0\leq{i}\leq{N-1}\f]

                \param Vect Source & destination, x()
                \param Count Vector length, N
            */
            static void ClipZero (float *, long);
            /// \overload
            static void ClipZero (double *, long);
            /**
                Clip smallest values in vector to zero (out-of-place)

                \f[y(i)=\left\{\begin{array}{ll}0&,x(i)<0\\
                x(i)&,x(i)\leq{0}\end{array}\right., 0\leq{i}\leq{N-1}\f]

                \param Dest Destination, y()
                \param Src Source, x()
                \param Count Vector length, N
            */
            static void ClipZero (float *, const float *, long);
            /// \overload
            static void ClipZero (double *, const double *, long);
            /**
                Copy source vector to destination vector(s)

                \param Dest Destination vector
                \param Src Source vector
                \param Count Vector length
            */
            static void Copy (float *, const float *, long);
            /// \overload
            static void Copy (double *, const double *, long);
            /// \overload
            static void Copy (stpSCplx, const stpSCplx, long);
            /// \overload
            static void Copy (stpDCplx, const stpDCplx, long);
            /// \overload
            static void Copy (float *, float *, const float *, long);
            /// \overload
            static void Copy (double *, double *, const double *, long);
            /**
                Convolve two vectors (same length, finite) without lag
                \note Circular convolution, result is not scaled

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

                \param Src1 Source 1, x()
                \param Src2 Source 2, y()
                \param Count Vector length, N
                \return Convolution result, z
            */
            static float Convolve (const float *, const float *, long);
            /// \overload
            static double Convolve (const double *, const double *, long);
            /**
                Convolve two vectors (same length, finite) with lag
                \note Circular convolution, result is not scaled

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

                \param Dest Destination, z()
                \param Src1 Source 1, x()
                \param Src2 Source 2, y()
                \param Count Vector length, N
            */
            static void Convolve (float *, const float *, const float *, 
                long);
            /// \overload
            static void Convolve (double *, const double *, const double *, 
                long);
            /**
                Correlate two vectors (same length, finite) without lag
                \note Circular correlation, result is scaled

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

                \param Src1 Source1, x()
                \param Src2 Source2, y()
                \param Count Vector length, N
                \return Correlation result, z
            */
            static float Correlate (const float *, const float *, long);
            /// \overload
            static double Correlate (const double *, const double *, long);
            /**
                Correlate two vectors (same length, finite) with lag
                \note Circular correlation, result is scaled

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

                \param Dest Destination, z()
                \param Src1 Source 1, x()
                \param Src2 Source 2, y()
                \param Count Vector length, N
            */
            static void Correlate (float *, const float *, const float *, 
                long);
            /// \overload
            static void Correlate (double *, const double *, const double *, 
                long);
            /**
                Autocorrelate vector
                \note Circular, result is scaled

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

                \param Src Source, x()
                \param Count Vector length, N
                \return Autocorrelation (energy)
            */
            static float AutoCorrelate (const float *, long);
            /// \overload
            static double AutoCorrelate (const double *, long);
            /**
                Autocorrelate vector