TAPsGenMath.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsGenMath.hpp

Under TAPs namespace
Defines a GenMath class for general math.
All member functions and data members are static.

SUKITTI PUNAK   (01/20/2006)
UPDATE          (02/01/2006)
******************************************************************************/
#ifndef TAPs_GEN_MATH_HPP
#define TAPs_GEN_MATH_HPP

#include "TAPsMatrix.hpp"
#include "TAPsMatrixp.hpp"
#include "TAPsVector.hpp"
//#include "TAPsVectorp.hpp"

#include <complex>

BEGIN_NAMESPACE_TAPs
//=============================================================================
template <typename T>
class GenMath {
public:
//=============================================================================
    //==========================================================================
    // Root Finding Fns
    //==========================================================================
    //-------------------------------------------------------------------------
    // Root of second degree polynomial
    //-------------------------------------------------------------------------
    // FN:  rootsOfQuadraticPolynomial()  **************************************
    // DESC:    Find all three roots of a cubic polynomial in this form;
    //          a*x^2 + b*x + c = 0
    //The formula is adapted from "Mathematical Handbook of Formulas and Tables"
    // I/P:  a, b, and c
    // O/P:  r1 and r2
    //       (r1 and r2 may be real or complex conjugate of one another)
    static void RootsOfQuadraticPolynomial (    
                T a, T b, T c,          // I/P: a*x^2 + b*x + c = 0
                std::complex<T> &r1,    // O/P: root number one
                std::complex<T> &r2 );  // O/P: root number two
    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
    // Root of third degree polynomial
    //-------------------------------------------------------------------------
    // FN:  rootsOfCubicPolynomial()  ******************************************
    // DESC:    Find all three roots of a cubic polynomial in this form;
    //          a*x^3 + b*x^2 + c*x + d = 0
    //The formula is adapted from "Mathematical Handbook of Formulas and Tables"
    // I/P:  a, b, c, and d
    // O/P:  r1, r2, and r3     ( r1 is the real root)
    //       (r2 and r3 may be real or complex conjugate of one another)
    static void RootsOfCubicPolynomial (    
                T a, T b, T c, T d,     // I/P: a*x^3 + b*x^2 + c*x + d = 0
                std::complex<T> &r1,    // O/P: root number one
                std::complex<T> &r2,    // O/P: root number two
                std::complex<T> &r3 );  // O/P: root number three
    //-------------------------------------------------------------------------
    //==========================================================================

    //==========================================================================
    // Matrix Fns
    //==========================================================================
    //-------------------------------------------------------------------------
    // FN:  eigenValsAndVecsOf3by3SymMatrixUsingQRFactor() *********************
    // DESC:    Find eigen vectors of a 3x3 symmetric matrix which has all 
    //          real eigen values
    // I/P:  (T) m11, m12, m13, m22, m23, m33
    // O/P:  (T) lamda1, lamda2, lamda3
    // O/P:  (T) v1[3], v2[3], v3[3]
    static void EigenValsAndVecsOf3by3SymMatrixUsingQRFactor (
                T m11,  T m12,  T m13,      // I/P:
                        T m22,  T m23,      // I/P:
                                T m33,      // I/P:
                T &l1, T &l2, T &l3,        // O/P: eigenvalues
                T v1[3], T v2[3], T v3[3],  // O/P: eigenvectors
                T errThreshold = 10*Math<T>::EPSILON,   // I/P: error threshold
                int times_limit = 256       // I/P: iteration limit
    );
    //-------------------------------------------------------------------------
    // Member Fn:   EigenValsByQRFactorization()        ------------------------
    // Desc:    Find all eigen values of a real square matrix only.
    // I/P:  A is a real square matrix.
    // I/P:  (default = 6), times is the number of iterations.
    // O/P:  (default = NULL), ptrO is a pointer to a matrix with will be the same 
    //       order as I/P Matrix, A.  Its diagonal are the approximated eigen values.
    // Return:  A column vector (n-by-1 matrix) contains all approximated eigenvalues.
    static Matrixp<T> EigenValsByQRFactorization ( 
                            const Matrixp<T> &A,    // I/P
                            int times,              // Number of iterations
                            Matrixp<T> *ptrO        // O/P
    );
    //-------------------------------------------------------------------------
    // FN:  FindAnEigenVector()
    // DESC:    Find an eigen vector of a 3x3 symmetric matrix
    static void FindAnEigenVector(  
                    T &m11, T &m12, T &m13,
                            T &m22, T &m23,
                                    T &m33, // I/P: 3x3 Symmetric Matrix
                    T l1,                   // O/P: eigen value
                    T v1[3]                 // O/P: eigen vector
    );
    //-------------------------------------------------------------------------
    // FN:  FindOrthogonalVectors()
    // DESC:    Find other two vectors (oB and oC) that are orthogonal to iA
    static void FindOrthogonalVectors( const T iA[3], T oB[3], T oC[3] );
    //-------------------------------------------------------------------------
    // Member Fn:   QRFactorization()
    // Desc:    Find a QR Factorization of a real square matrix only.
    static bool QRFactorization( 
                    const Matrixp<T> &A,            // I/P
                    Matrixp<T> &Q, Matrixp<T> &R    // O/P
    );
    //-------------------------------------------------------------------------
    // Member Fn:   HouseHolderMatrix()
    // Desc:    Find a HouseHolder matrix of a real square matrix only.
    static Matrixp<T> HouseHolderMatrix( 
                        const Matrixp<T> &A,    // I/P
                        Matrixp<T> *ptrH,       // O/P
                        Matrixp<T> *ptrR        // O/P
    );
    //-------------------------------------------------------------------------
    //==========================================================================

    //==========================================================================
    // Math Fns for array data, e.g. T b[].  For example dot product, etc.
    //==========================================================================
    //-------------------------------------------------------------------------
    // FN:  CrossProduct3()
    // DESC:    Find C = A^B
    inline static void CrossProduct3( const T A[3], const T B[3], T C[3] );
    //-------------------------------------------------------------------------
    // FN:  DotProduct3()
    // DESC:    Return T = A[3]*B[3]
    inline static T DotProduct3( const T A[3], const T B[3] );
    //-------------------------------------------------------------------------
    //==========================================================================
}; // END CLASS Math
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
//#if !defined( TAPs_USE_EXPORT )
    #include "TAPsGenMath.cpp"
//#endif
//-----------------------------------------------------------------------------
#endif
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8