dspop.hh

各种工程计算的库函数

            static void CplxMulC (stpSCplx, const stpSCplx, const stpSCplx);
            /// \overload
            static void CplxMulC (stpDCplx, const stpDCplx, const stpDCplx);
            /**
                Complex division

                \f[\Re_{z}=\frac{\Re_{x}\Re_{y}+\Im_{x}\Im_{y}}{\Re_{y}^2+\Im_{y}^2}\f]
                \f[\Im_{z}=\frac{\Im_{x}\Re_{y}-\Re_{x}\Im_{y}}{\Re_{y}^2+\Im_{y}^2}\f]

                \param CplxDest Source & destination
                \param CplxSrc Source
            */
            static void CplxDiv (stpSCplx, const stpSCplx);
            /// \overload
            static void CplxDiv (stpDCplx, const stpDCplx);
            /**
                \overload
                \param CplxDest Destination
                \param CplxSrc Source 1
                \param CplxSrc Source 2
            */
            static void CplxDiv (stpSCplx, const stpSCplx, const stpSCplx);
            /// \overload
            static void CplxDiv (stpDCplx, const stpDCplx, const stpDCplx);
            // In-place is allowed for following
            /**
                Complex exp function (e raised to y)

                \f[\Re_{z}=\exp(\Re_{y})\cos(\Im_{y})\f]
                \f[\Im_{z}=\exp(\Re_{y})\sin(\Im_{y})\f]

                \param CplxDest Destination
                \param CplxSrc Source
            */
            static void CplxExp (stpSCplx, const stpSCplx);
            static void CplxExp (stpDCplx, const stpDCplx);
            /**
                Complex natural logarithm

                \f[\Re_{z}=\ln(|y|)\f]
                \f[\Im_{z}=\arg(y)\f]
            */
            static void CplxLog (stpSCplx, const stpSCplx);
            static void CplxLog (stpDCplx, const stpDCplx);
            /**
                Complex 10-base logarithm

                \f[\Re_{z}=\log(|y|)\f]
                \f[\Im_{z}=\arg(y)\f]
            */
            static void CplxLog10 (stpSCplx, const stpSCplx);
            static void CplxLog10 (stpDCplx, const stpDCplx);
            /**
                Complex x raised to y

                \f[z=\exp(\ln(x)y)\f]
            */
            static void CplxPow (stpSCplx, const stpSCplx, const stpSCplx);
            static void CplxPow (stpDCplx, const stpDCplx, const stpDCplx);
            /**
                Complex root y of x

                \f[z=x^{\frac{1}{y}}\f]
            */
            static void CplxRoot (stpSCplx, const stpSCplx, const stpSCplx);
            static void CplxRoot (stpDCplx, const stpDCplx, const stpDCplx);
            static void CplxConj (stpSCplx spCplx)
                { spCplx->I = -(spCplx->I); }
            static void CplxConj (stpDCplx spCplx)
                { spCplx->I = -(spCplx->I); }
            static void CplxConj (stpSCplx, const stpSCplx);
            static void CplxConj (stpDCplx, const stpDCplx);
            /**
                Return multiple of n

                \f[!n\f]

                \param Value Value of n
            */
            static double Multiple (long);
            /**
                Zero-order modified Bessel function of the first kind.

                \f[I_{0}(x)=\sum_{k=0}^{K}\left[\frac{(x/2)^{k}}{k!}\right]^{2}\f]

                \param Value Value of x
            */
            static float ModZeroBessel (float);
            /// \overload
            static double ModZeroBessel (double);
            /**
                nth-order Chebyshev polynomial
                
                \f[T_{n}(x)=\left\{\begin{array}{l}\cos(n\cos^{-1}x), |x|\leq{1}\\
                \cosh(n\cosh^{-1}x), |x|>1\end{array}\right.\f]
                
                \param Order Order of polynomial
                \param Value Value of x
            */
            static float ChebyshevPolynom (float, float);
            static double ChebyshevPolynom (double, double);
        public:
            clDSPOp();
            virtual ~clDSPOp();
            /**
                Round floatingpoint number to integer
            */
            static signed long Round (float);
            static signed long Round (double);
            /**
                Add single value to vector

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

                \param Dest Source & destination, x()
                \param Src Source, y
                \param Count Vector length, N
            */
            static void Add (float *, float, long);
            /// \overload
            static void Add (double *, double, long);
            /// \overload
            static void Add (stpSCplx, stSCplx, long);
            /// \overload
            static void Add (stpDCplx, stDCplx, long);
            /**
                Add two vectors

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

                \param Dest Source & destination, x()
                \param Src Source, y()
                \param Count Vector length, N
            */
            static void Add (float *, const float *, long);
            /// \overload
            static void Add (double *, const double *, long);
            /// \overload
            static void Add (stpSCplx, const stpSCplx, long);
            /// \overload
            static void Add (stpDCplx, const stpDCplx, long);
            /**
                Add two vectors and return result in third

                \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 Add (float *, const float *, const float *, long);
            /// \overload
            static void Add (double *, const double *, const double *, long);
            /// \overload
            static void Add (stpSCplx, const stpSCplx, const stpSCplx, long);
            /// \overload
            static void Add (stpDCplx, const stpDCplx, const stpDCplx, long);
            /**
                Subtract single value from vector

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

                \param Dest Source & destination, x()
                \param Src Source, y
                \param Count Vector length, N
            */
            static void Sub (float *, float, long);
            /// \overload
            static void Sub (double *, double, long);
            /// \overload
            static void Sub (stpSCplx, stSCplx, long);
            /// \overload
            static void Sub (stpDCplx, stDCplx, long);
            /**
                Subtract two vectors

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

                \param Dest Source & destination, x()
                \param Src Source, y()
                \param Count Vector length, N
            */
            static void Sub (float *, const float *, long);
            /// \overload
            static void Sub (double *, const double *, long);
            /// \overload
            static void Sub (stpSCplx, const stpSCplx, long);
            /// \overload
            static void Sub (stpDCplx, const stpDCplx, long);
            /**
                Subtract two vectors and return result in third

                \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 Sub (float *, const float *, const float *, long);
            /// \overload
            static void Sub (double *, const double *, const double *, long);
            /// \overload
            static void Sub (stpSCplx, const stpSCplx, const stpSCplx, long);
            /// \overload
            static void Sub (stpDCplx, const stpDCplx, const stpDCplx, long);
            /**
                Multiply vector with single value in-place

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

                \param Dest Source & destination, x()
                \param Src Source, y
                \param Count Vector length, N
            */
            static void Mul (float *, float, long);
            /// \overload
            static void Mul (double *, double, long);
            /// \overload
            static void Mul (stpSCplx, float, long);
            /// \overload
            static void Mul (stpDCplx, double, long);
            /// \overload
            static void Mul (stpSCplx, stSCplx, long);
            /// \overload
            static void Mul (stpDCplx, stDCplx, long);
            /**
                Multiply vector with single value out-of-place

                \f[z(i)=x(i)y, 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 Mul (float *, const float *, float, long);
            /// \overload
            static void Mul (double *, const double *, double, long);
            /**
                Multiply two vectors

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

                \param Dest Source & destination, x()
                \param Src Source, y()
                \param Count Vector length, N
            */
            static void Mul (float *, const float *, long);
            /// \overload
            static void Mul (double *, const double *, long);
            /// \overload
            static void Mul (stpSCplx, const float *, long);
            /// \overload
            static void Mul (stpDCplx, const double *, long);
            /// \overload
            static void Mul (stpSCplx, const stpSCplx, long);
            /// \overload
            static void Mul (stpDCplx, const stpDCplx, long);
            /**
                Multiply two vectors and return result in third

                \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 Mul (float *, const float *, const float *, long);
            /// \overload
            static void Mul (double *, const double *, const double *, long);
            /// \overload
            static void Mul (stpSCplx, const stpSCplx, const stpSCplx, long);
            /// \overload
            static void Mul (stpDCplx, const stpDCplx, const stpDCplx, long);
            /**
                Multiply vector with others complex conjugate

                \f[X(i)=X(i)Y(i)^{*}, 0\leq{i}\leq{N-1}\f]
                \f[Z(i)=X(i)Y(i)^{*}, 0\leq{i}\leq{N-1}\f]

                \param Dest Source & destination, X()
                \param Src Source, Y()
                \param Count Vector length, N
            */
            static void MulC (stpSCplx, const stpSCplx, long);
            /// \overload
            static void MulC (stpDCplx, const stpDCplx, long);
            /// \overload
            static void MulC (stpSCplx, const stpSCplx, const stpSCplx, long);
            /// \overload
            static void MulC (stpDCplx, const stpDCplx, const stpDCplx, long);
            /**
                Multiply two vectors in-place with third vector

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

                \param Dest1 Source & destination 1, x()
                \param Dest2 Source & destination 2, y()
                \param Src Source, z()
                \param Count Vector length, N
            */
            static void Mul2 (float *, float *, const float *, long);
            /// \overload
            static void Mul2 (double *, double *, const double *, long);
            /**
                Multiply two vectors out-of-place with third vector and
                return results in separate two vectors

                \param Dest1 Destination 1
                \param Dest2 Destination 2
                \param Src1 Source 1
                \param Src2 Source 2
                \param Count Vector length
            */
            static void Mul2 (float *, float *, const float *, 
                const float *, const float *, long);
            /// \overload
            static void Mul2 (double *, double *, const double *, 
                const double *, const double *, long);
            /**
                Divide vector with single value

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

                \param Dest Source & destination, x()
                \param Src Source, y
                \param Count Vector length, N
            */
            static void Div (float *, float, long);
            /// \overload
            static void Div (double *, double, long);
            /// \overload
            static void Div (stpSCplx, stSCplx, long);
            /// \overload
            static void Div (stpDCplx, stDCplx, long);
            /**
                Divide two vectors

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

                \param Dest Source & destination, x()
                \param Src Source, y()
                \param Count Vector length, N
            */
            static void Div (float *, const float *, long);
            /// \overload