TAPsMatrixp.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsMatrixp.hpp

Matrixp class is a class for any dimension Matrixp.

SUKITTI PUNAK   (01/19/2006)
UPDATE          (01/20/2006)
******************************************************************************/
#ifndef TAPs_MATRIXP_HPP
#define TAPs_MATRIXP_HPP

#include "TAPsMath.hpp"

BEGIN_NAMESPACE_TAPs
//=============================================================================
// class forward
template <typename T> class Vectorp;
//=============================================================================
template <typename T>
class Matrixp {
//=============================================================================
protected:
// Data Members  ---------------------------------------------------------------
    // Matrix Elements
    //       --                --
    //      |                    |
    //      |      R by C        |
    //      |                    |
    //       --                --
    int R, C;
    T *e;
public:
    //-------------------------------------------------------------------------
    // Output Operator <<
    friend std::ostream &operator<<( std::ostream &output, const Matrixp<T> &M )
    {
        /*
        //output << typeid(*this).name() << "( ";
        output << "Matrixp<" << typeid(T).name() << ">" 
                << " a " << M.R << "-by-" << M.C << "\n";
        output.precision(10);
        for ( int r = 0; r < M.R*M.C; r+=M.C ) {
            output << "| ";
            for ( int c = 0; c < M.C; c++ ) {
                output.width( 20 ); output << M.e[r + c];
            }
            output << " |" << endl;
        }
        output.precision(6);
        return output;
        //*/
        return M.Display();
    }
    //-------------------------------------------------------------------------
    // Constructors and Destructor
    Matrixp ( int rows = 3, int cols = 3 );     // default constructor (Identity Matrix)
    Matrixp ( Matrixp<T> const &M );            // copy constructor
    Matrixp ( int rows, int cols, T val );      // constructor
    Matrixp ( int rows, int cols, T const a[] );// constructor from array
    virtual ~Matrixp ();                        // destructor
    //-------------------------------------------------------------------------
    // Member Access
    inline T &       operator[] ( int i );
    inline T const & operator[] ( int i ) const;
    inline T &       operator() ( int r, int c );
    inline T const & operator() ( int r, int c ) const;
    //-------------------------------------------------------------------------
    // Convert to one dimension array
    operator const T *() const;
    operator T *();
    //-------------------------------------------------------------------------
    // Useful Functions
    std::ostream & Display ( int precision = 10, std::ostream &output = std::cout ) const;
    int GetNumOfRows () const { return R; }
    int GetNumOfCols () const { return C; }
    void SetAllElements ( T );
    void SetAllElements ( T const a[] );
    void MakeIdentity ();
    void MakeDiagonal ( T d );
    void MakeDiagonal ( T const a[] );
    void MakeZero ();
    bool IsIdentity () const;
    bool IsSymmetric () const;
    bool IsSquare () const { return R==C; }

    void ChangeSize( int numOfRow, int numOfCol );
    //-------------------------------------------------------------------------
    // Matrix Operations

    Matrixp<T> & Transposed ();

    Matrixp<T>   GetTranspose () const;

    //Matrixp<T> & Inversed ();
    //Matrixp<T>   GetInverse () const;
    //T             GetDeterminant () const;
    //-------------------------------------------------------------------------
    // Assignment Overloaded Operator
    Matrixp<T> & operator= ( Matrixp<T> const &M );
    //-------------------------------------------------------------------------
    // Unary Overloaded Operators
    Matrixp<T> operator- ();    // negation
    //-------------------------------------------------------------------------
    // Assign Overloaded Operators
    Matrixp<T> &operator+= ( Matrixp<T> const &M ); // += with matrix
    Matrixp<T> &operator-= ( Matrixp<T> const &M ); // -= with matrix
    Matrixp<T> &operator*= ( Matrixp<T> const &M ); // *= with matrix
    Matrixp<T> &operator*= ( T s );                     // *= with scalar
    Matrixp<T> &operator/= ( T s );                     // /= with scalar
    //-------------------------------------------------------------------------
    // Binary Overloaded Operators
    Matrixp<T> operator+ ( Matrixp<T> const &M ) const; // matrix + matrix
    Matrixp<T> operator- ( Matrixp<T> const &M ) const; // matrix - matrix
    Matrixp<T> operator* ( Matrixp<T> const &M ) const; // matrix * matrix
    Matrixp<T> operator* ( T s ) const;                 // matrix * scalar
    friend inline Matrixp<T> operator* ( T s, Matrixp<T> const &M ) // scalar * matrix
    {   return M * s;   }
    Matrixp<T> operator/ ( T s ) const;             // matrix / scalar
    inline void MultLeft  ( Matrixp<T> const &M );  // this matrix = matrix M * this matrix
    inline void MultRight ( Matrixp<T> const &M );  // this matrix = this matrix * matrix M
    //-------------------------------------------------------------------------
    // Matrixp * Vectorp
    //Vectorp<T> operator* ( Vectorp<T> const &V ) const;
    //-------------------------------------------------------------------------
// Helper Fn Member     ---------------------------------------------
private:
    bool CheckRanges ( int numOfRows, int numOfCols ) const;
    //void DeleteMemory ();
    //void CopyElements ( const Matrixp< T > & );
}; // END CLASS Matrixp
//=============================================================================
//-----------------------------------------------------------------------------
// Define Matrixps
typedef Matrixp<int>            Matrixpi;
typedef Matrixp<float>          Matrixpf;
typedef Matrixp<double>         Matrixpd;
typedef Matrixp<long double>    Matrixpld;
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
//#if !defined( TAPs_USE_EXPORT )
    #include "TAPsMatrixp.cpp"
//#endif
//-----------------------------------------------------------------------------
#endif
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8









/*


    //-------------------------------------------------------------------------
    // Friend Functions for Operator Overloading

    //-------------------------------------------------------------------------
    // Operator Overloading
    Matrix<T,R,C> operator*( T s )
    {
        Matrix<T,R,C> M( *this );
        M *= s;
        return M;
    }

    friend SPtMatrix< T > operator-( const SPtMatrix< T > &A, const SPtMatrix< T > &B )
    {
        // Both matrices have to be the same order!
        if ( A.m_iRows != B.m_iRows || A.m_iCols != B.m_iCols )     return NULL;

        SPtMatrix< T > temp( A );
        for ( int r = 0; r < temp.m_iRows; r++ ) {
            for ( int c = 0; c < temp.m_iCols; c++ ) {
                temp.m_tElement[r][c] -= B.m_tElement[r][c];
            }
        }

        return temp;
    }
    friend SPtMatrix< T > operator+( const SPtMatrix< T > &A, const SPtMatrix< T > &B )
    {
        // Both matrices have to be the same order!
        if ( A.m_iRows != B.m_iRows || A.m_iCols != B.m_iCols )     return NULL;

        SPtMatrix< T > temp( A );
        for ( int r = 0; r < temp.m_iRows; r++ ) {
            for ( int c = 0; c < temp.m_iCols; c++ ) {
                temp.m_tElement[r][c] += B.m_tElement[r][c];
            }
        }

        return temp;
    }
    friend class MatrixOperations;

// Member Functions  ----------------------------------------------------------
public:
    // Constructors  ------------------------------------------------
    SPtMatrix( int = 3, int = 3 );
    //SPtMatrix( T **e, int r, int c ) : m_tElement< T >( e ), m_iRows( r ), m_iCols( c ) { }
    SPtMatrix( const SPtMatrix< T > & );
    SPtMatrix( const SPtVector3< T > & );
    SPtMatrix( const SPtPoint3< T > & );
    ~SPtMatrix();


    // Useful Member Functions      ---------------------------------
    // Display Elements
    void DisplayElements() const;
    T    Get( int, int ) const;
    void Set( int, int, T );
    bool SetToIdentity();
    int GetNoOfRows() const;
    int GetNoOfCols() const;
    void GetNoOfRowsAndCols( int &, int & ) const;
    

    // Matrix Operations        -------------------------------------
    SPtMatrix< T > GetTranspose() const;
    SPtMatrix< T > &Transpose();


    // Overloaded Operators     -------------------------------------
    // assign matrix
    SPtMatrix< T > &operator=( const SPtMatrix< T > & );
    // negation
    SPtMatrix< T > operator-() const;
    // add/assign matrix
    SPtMatrix< T > &operator+=( const SPtMatrix< T > & );
    // subtract/assign vector v
    SPtMatrix< T > &operator-=( const SPtMatrix< T > & );
    // multiply/assign by scalar s
    SPtMatrix< T > &operator*=( double );
    // divide/assign by scalar s
    SPtMatrix< T > &operator/=( double );

    // multiply by a matrix
    SPtMatrix< T > operator*( const SPtMatrix< T > & ) const;


// Helper Fn Member     ---------------------------------------------
private:
    bool CheckRanges( int, int ) const;
    void DeleteMemory();
    void CopyElements( const SPtMatrix< T > & );


}; // END:  SPtMatrix
//===============================================================================================


//===============================================================================================
//
//                      M E M B E R    F U N C T I O N    D E F I N I T I O N S
//
//===============================================================================================
// START:   SPtMatrix Member Functions  ******************************************
//------------------------------------------------------------------------------------------------
// Default Constructor
template< typename T >
SPtMatrix< T >::SPtMatrix( int r, int c ) : m_iRows( r ), m_iCols( c )
{
    m_tElement = new T*[ m_iRows ];
    for ( r = 0; r < m_iRows; r++ ) {
        m_tElement[ r ] = new T[ m_iCols ];
        for ( c = 0; c < m_iCols; c++ ) {
            m_tElement[r][c] = T();
        }
    }
}

//------------------------------------------------------------------------------------------------
// Copy Constructor
template< typename T >
SPtMatrix< T >::SPtMatrix( const SPtMatrix< T > &M )
{
    CopyElements( M );
}

//------------------------------------------------------------------------------------------------
// Vector3-To-Matrix Constructor
template< typename T >
SPtMatrix< T >::SPtMatrix( const SPtVector3< T > &V )
{
    SPtMatrix( 3, 1 );
    this->m_tElement[0] = V.GetX();
    this->m_tElement[1] = V.GetY();
    this->m_tElement[2] = V.GetZ();
}

//------------------------------------------------------------------------------------------------
// Point3-To-Matrix Constructor
template< typename T >
SPtMatrix< T >::SPtMatrix( const SPtPoint3< T > &P )
{
    SPtMatrix( 3, 1 );
    this->m_tElement[0] = P.GetX();
    this->m_tElement[1] = P.GetY();
    this->m_tElement[2] = P.GetZ();
}

//------------------------------------------------------------------------------------------------
// Destructor
template< typename T >
SPtMatrix< T >::~SPtMatrix()
{
    DeleteMemory();
}

//------------------------------------------------------------------------------------------------
// Useful Member Functions      -----------------------------------------------
// Fn Member:   DisplayElements()  ********************************************
// Desc:  Display the matrix elements
template< typename T >
void SPtMatrix< T >::DisplayElements() const
{
    int r, c;

    cout << "A(n) " << m_iRows << " x " << m_iCols << " Matrix \n";
    cout.precision(10);
    for ( r = 0; r < m_iRows; r++ ) {
        cout << "| ";
        for ( c = 0; c < m_iCols; c++ ) {
            cout.width( 20 );   cout << m_tElement[r][c];
        }
        cout << " |" << endl;
    }
    cout.precision(6);
} // END Fn Member: DisplayElements()

//------------------------------------------------------------------------------------------------
// Fn Member:   Get()       ***************************************************
// Desc:  Get the element value at row r, and column c.
template< typename T >
T SPtMatrix< T >::Get( int r, int c ) const
{
    if ( CheckRanges( r, c ) ) {
        return m_tElement[ r ][ c ];
    }
    else {
        return -777;
    }

} // END Fn Member: Get()

//------------------------------------------------------------------------------------------------
// Fn Member:   Set()       ***************************************************
// Desc:  Set the element value at row r, and column c.
template< typename T >
void SPtMatrix< T >::Set( int r, int c, T value )
{
    if ( CheckRanges( r, c ) ) {
        m_tElement[ r ][ c ] = value;
    }
} // END Fn Member: Set()

//------------------------------------------------------------------------------------------------
// Fn Member:   SetToIdentity()
template< typename T >
bool SPtMatrix< T >::SetToIdentity()
{
    if ( m_iRows != m_iCols )   return false;
    for ( int r = 0; r < m_iRows; r++ ) {
        for ( int c = 0; c < m_iCols; c++ ) {
            this->m_tElement[r][c] = T( 0 );
        }
    }
    for ( int i = 0; i < m_iRows; i++ ) {
        this->m_tElement[i][i] = T( 1 );
    }
    return true;
} // END Fn Member: SetToIdentity()

//------------------------------------------------------------------------------------------------
// Fn Member:   GetNoOfRows()
template< typename T >
int SPtMatrix< T >::GetNoOfRows() const
{
    return m_iRows;
} // END Fn Member: GetNoOfRows()

//------------------------------------------------------------------------------------------------
// Fn Member:   GetNoOfCols()
template< typename T >
int SPtMatrix< T >::GetNoOfCols() const
{
    return m_iCols;
} // END Fn Member: GetNoOfCols()

//------------------------------------------------------------------------------------------------
// Fn Member:   GetNoOfRowsAndCols()
template< typename T >
void SPtMatrix< T >::GetNoOfRowsAndCols( int &r, int &c ) const
{
    r = m_iRows;
    c = m_iCols;
} // END Fn Member: GetNoOfRowsAndCols()


//------------------------------------------------------------------------------------------------
// Matrix Operations        ---------------------------------------------------
template< typename T >
SPtMatrix< T > SPtMatrix< T >::GetTranspose() const
{
    SPtMatrix< T > temp( m_iCols, m_iRows );

    for ( int r = 0; r < temp.m_iRows; r++ ) {
        for ( int c = 0; c < temp.m_iCols; c++ ) {
            temp.m_tElement[r][c] = this->m_tElement[c][r];
        }
    }

    return temp;
}

//------------------------------------------------------------------------------------------------
template< typename T >
SPtMatrix< T > &SPtMatrix< T >::Transpose()
{
    *this = this->GetTranspose();

    return *this;
}

//------------------------------------------------------------------------------------------------
// Overloaded Operators     ---------------------------------------------------

// assign matrix
template< typename T >
SPtMatrix< T > &SPtMatrix< T >::operator=( const SPtMatrix< T > & M )
{
    // check self assignment
    if ( this != &M ) {
        DeleteMemory();         // delete the space
        CopyElements( M );      // copy all elements from M matrix
    }

    return *this;
}

//------------------------------------------------------------------------------------------------
// negation
template< typename T >
SPtMatrix< T > SPtMatrix< T >::operator-() const
{
    SPtMatrix< T > temp( *this );
    temp *= -1.0;
    return temp;
}

//------------------------------------------------------------------------------------------------
// add/assign matrix
template< typename T >
SPtMatrix< T > &SPtMatrix< T >::operator+=( const SPtMatrix< T > & M )
{
    if ( m_iRows == M.m_iRows && m_iCols == M.m_iCols ) {
        for ( int r = 0; r < m_iRows; r++ ) {
            for ( int c = 0; c < m_iCols; c++ ) {
                this->m_tElement[r][c] += M.m_tElement[r][c];
            }
        }
    }

    return *this;
}

//------------------------------------------------------------------------------------------------
// subtract/assign matrix
template< typename T >
SPtMatrix< T > &SPtMatrix< T >::operator-=( const SPtMatrix< T > & M )
{
    if ( m_iRows == M.m_iRows && m_iCols == M.m_iCols ) {
        for ( int r = 0; r < m_iRows; r++ ) {
            for ( int c = 0; c < m_iCols; c++ ) {
                this->m_tElement[r][c] -= M.m_tElement[r][c];
            }
        }
    }

    return *this;
}

//------------------------------------------------------------------------------------------------
// multiply/assign by scalar s
template< typename T >
SPtMatrix< T > &SPtMatrix< T >::operator*=( double s )
{
    for ( int r = 0; r < m_iRows; r++ ) {
        for ( int c = 0; c < m_iCols; c++ ) {
            this->m_tElement[r][c] *= s;
        }
    }

    return *this;
}

//------------------------------------------------------------------------------------------------
// divide/assign by scalar s
template< typename T >
SPtMatrix< T > &SPtMatrix< T >::operator/=( double s )
{
    for ( int r = 0; r < m_iRows; r++ ) {
        for ( int c = 0; c < m_iCols; c++ ) {
            this->m_tElement[r][c] /= s;
        }
    }

    return *this;
}

//------------------------------------------------------------------------------------------------
// multiply by a matrix
template< typename T >
SPtMatrix< T > SPtMatrix< T >::operator*( const SPtMatrix< T > &M ) const
{
    // The rows# of the first matrix must equals the cols# of the second matrix
    if ( this->m_iCols == M.m_iRows ) {
        SPtMatrix< T > temp( this->m_iRows, M.m_iCols );
        if ( temp.m_iRows < temp.m_iCols ) {
            for ( int r = 0; r < temp.m_iRows; r++ ) {
                for ( int c = 0; c < temp.m_iCols; c++ ) {
                    for ( int k = 0; k < M.m_iRows; k++ ) {
                        temp.m_tElement[r][c] += this->m_tElement[r][k] * M.m_tElement[k][c];
                    }
                    //if ( fabs(temp.m_tElement[r][c]) < 5E-20 ) temp.m_tElement[r][c] = 0;
                }
            }
        }
        else {
            for ( int c = 0; c < temp.m_iCols; c++ ) {
                for ( int r = 0; r < temp.m_iRows; r++ ) {
                    for ( int k = 0; k < M.m_iRows; k++ ) {
                        temp.m_tElement[r][c] += this->m_tElement[r][k] * M.m_tElement[k][c];
                    }
                    //if ( fabs(temp.m_tElement[r][c]) < 5E-20 ) temp.m_tElement[r][c] = 0;
                }
            }
        }

        return temp;
    }

    else return NULL;
}




//------------------------------------------------------------------------------------------------
// Helper Fn Member     -------------------------------------------------------
// Check that row and column numbers are in the valid ranges.
template< typename T >
bool SPtMatrix< T >::CheckRanges( int r, int c ) const
{
    assert( 0 <= r && r < m_iRows );
    assert( 0 <= c && c < m_iCols );

    return true;
}

//------------------------------------------------------------------------------------------------
// Deallocate memory held by the matrix
template< typename T >
void SPtMatrix< T >::DeleteMemory()
{
    for ( int r = 0; r < m_iRows; r++ ) {
        delete [] m_tElement[ r ];
    }
    delete [] m_tElement;
}

//------------------------------------------------------------------------------------------------
// Copy all elements from M to this matrix
template< typename T >
void SPtMatrix< T >::CopyElements( const SPtMatrix< T > & M )
{
    int r, c;

    // copy the data members from M
    m_iRows = M.m_iRows;
    m_iCols = M.m_iCols;
    m_tElement = new T*[ m_iRows ];
    for ( r = 0; r < m_iRows; r++ ) {
        m_tElement[ r ] = new T[ m_iCols ];
        for ( c = 0; c < m_iCols; c++ ) {
            m_tElement[ r ][ c ] = M.m_tElement[ r ][ c ];
        }
    }
}
// END:     SPtMatrix Member Functions  ***************************************


/*
//------------------------------------------------------------------------------------------------
// Friend Functions for Operator Overloading        ***************************
template< typename T >
ostream &operator<<( ostream &output, const SPtMatrix< T > &M )
{
    int r, c;

    output << "A(n) " << m_iRows << " x " << m_iCols << " Matrix \n";
    output.precision(10);
    for ( r = 0; r < m_iRows; r++ ) {
        output << "| ";
        for ( c = 0; c < m_iCols; c++ ) {
            output.width( 20 ); output << m_tElement[r][c];
        }
        output << " |" << endl;
    }
    output.precision(6);
    
    return output;
}

//------------------------------------------------------------------------------------------------
template< typename T >
SPtMatrix< T > operator*( double s, const SPtMatrix< T > &M )
{
    SPtMatrix< double > temp( M );
    temp *= s;
    return temp;
}

//------------------------------------------------------------------------------------------------
template< typename T >
SPtMatrix< T > operator+( const SPtMatrix< T > &A, const SPtMatrix< T > &B )
{
    // Both matrices have to be the same order!
    if ( A.m_iRows != B.m_iRows || A.m_iCols != B.m_iCols )     return NULL;

    SPtMatrix< T > temp( A );
    for ( int r = 0; r < temp.m_iRows; r++ ) {
        for ( int c = 0; c < temp.m_iCols; c++ ) {
            temp.m_tElement[r][c] += B.m_tElement[r][c];
        }
    }

    return temp;
}

//------------------------------------------------------------------------------------------------
template< typename T >
SPtMatrix< T > operator-( const SPtMatrix< T > &A, const SPtMatrix< T > &B )
{
    // Both matrices have to be the same order!
    if ( A.m_iRows != B.m_iRows || A.m_iCols != B.m_iCols )     return NULL;

    SPtMatrix< T > temp( A );
    for ( int r = 0; r < temp.m_iRows; r++ ) {
        for ( int c = 0; c < temp.m_iCols; c++ ) {
            temp.m_tElement[r][c] -= B.m_tElement[r][c];
        }
    }

    return temp;
}
*/