SPT_Matrix.h

Go to the documentation of this file.

/******************************************************************************
SP_Matrix.h

Matrix class and its operations

Sukitti Punak   (11/10/2003)
Latest Update   (11/11/2003)
******************************************************************************/

#ifndef SPT_MATRIX_H
#define SPT_MATRIX_H

#include <iostream>
#include <cassert>
#include <cmath>
using std::cout;
using std::endl;
using std::ostream;

#include "SPT_Point3_Vector3.h"

template< typename T >
class MATRIX;   // forward reference

//===============================================================================================
//
//                          C L A S S    D E C L A R A T I O N S
//
//===============================================================================================
// CLASS:   SPtMatrix  ********************************************************
// Desc:  3-D Point
template< typename T >
class SPtMatrix
{
    // Friend Functions for Operator Overloading
    // Add vector v2 to vector v1
    friend 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;
    }

    friend SPtMatrix< T > operator*( double s, const SPtMatrix< T > &M )
    {
        SPtMatrix< double > temp( M );
        temp *= s;
        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 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;

// Data Members  --------------------------------------------------------------
public:
    T   **m_tElement;
    int m_iRows, m_iCols;

// 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;
}
*/
//------------------------------------------------------------------------------------------------
//===============================================================================================

#endif