SPT_Matrix3x3.h

Go to the documentation of this file.

/******************************************************************************
SPT_Matrix3x3.h

3-by-3 Matrix class and its operations

Adapted from "Physics for Game Developers" by David M. Bourg (2002)

Sukitti Punak   (11/12/2003)
Latest Update   (11/20/2003)
******************************************************************************/

#ifndef SPT_MATRIX3X3_H
#define SPT_MATRIX3X3_H

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

#include <iomanip>
using std::setw;

//===============================================================================================
// START Class:     SPtMatrix3x3        ***********************************************************
template< typename T >
class SPtMatrix3x3
{
// Data Members     -----------------------------------------------------------
private:
    T   e[3][3];

// Member Functions     -------------------------------------------------------
public:
    // Constructors
    SPtMatrix3x3();                             // default constructor
    SPtMatrix3x3( SPtMatrix3x3< T > &M );       // copy constructor
    SPtMatrix3x3( T, T, T, T, T, T, T, T, T );  // typical constructor

    // Useful Functions
    void DisplayElements() const;       // display the matrix on the screen
    T       Get( int, int ) const;      // get an element
    void    Set( int, int, T );         // set an element
    void    SetAll( T, T, T, T, T, T, T, T, T );    // set all elements
    void    LoadIdentity();             // set to identity matrix


    // Operations
    SPtMatrix3x3< T > & Transpose();
    SPtMatrix3x3< T >   GetTranspose() const;
    T                   GetDeterminant() const;
    SPtMatrix3x3< T > & Inverse();
    SPtMatrix3x3< T >   GetInverse() const;

    // Unary Overloaded Operators
    SPtMatrix3x3< T > &operator+=( SPtMatrix3x3< T > &M );  // += with matrix
    SPtMatrix3x3< T > &operator-=( SPtMatrix3x3< T > &M );  // -= with matrix
    SPtMatrix3x3< T > &operator*=( SPtMatrix3x3< T > &M );  // *= with matrix
    SPtMatrix3x3< T > &operator*=( T s );               // *= with scalar
    SPtMatrix3x3< T > &operator/=( T s );               // /= with scalar

    // Binary Overloaded Operators
    SPtMatrix3x3< T > operator+( SPtMatrix3x3< T > &M ) const;  // + with matrix
    SPtMatrix3x3< T > operator-( SPtMatrix3x3< T > &M ) const;  // - with matrix
    SPtMatrix3x3< T > operator*( SPtMatrix3x3< T > &M ) const;  // * with matrix
    SPtMatrix3x3< T > operator*( T s ) const;               // * with scalar
    SPtMatrix3x3< T > operator/( T s ) const;               // / with scalar

    // Friend Overloaded Operators
    friend SPtMatrix3x3< T > operator*( double s, const SPtMatrix3x3< T > &M )      // scalar * matrix
    {
        return SPtMatrix3x3< T >(   M.e[0][0]*s,    M.e[0][1]*s,    M.e[0][2]*s,
                                    M.e[1][0]*s,    M.e[1][1]*s,    M.e[1][2]*s,
                                    M.e[2][0]*s,    M.e[2][1]*s,    M.e[2][2]*s );
    }
    friend SPtMatrix3x3< T > operator/( double s, const SPtMatrix3x3< T > &M )      // scalar / matrix
    {
        return SPtMatrix3x3< T >(   M.e[0][0]/s,    M.e[0][1]/s,    M.e[0][2]/s,
                                    M.e[1][0]/s,    M.e[1][1]/s,    M.e[1][2]/s,
                                    M.e[2][0]/s,    M.e[2][1]/s,    M.e[2][2]/s );
    }
    friend ostream &operator<<( ostream &output, const SPtMatrix3x3< T > &M )               // put it through ostream
    {
        output  << "3-by-3 matrix\n"
                << "| " << setw(12) << M.e[0][0] << setw(12) << M.e[0][1] << setw(12) << M.e[0][2] << " |\n"
                << "| " << setw(12) << M.e[1][0] << setw(12) << M.e[1][1] << setw(12) << M.e[1][2] << " |\n"
                << "| " << setw(12) << M.e[2][0] << setw(12) << M.e[2][1] << setw(12) << M.e[2][2] << " |\n";

        return output;
    }

}; // END Class:    SPtMatrix3x3
//===============================================================================================

//===============================================================================================
// Member Fns Definition of class:  SPtMatrix3x3  *************************************************

// Constructors     ***********************************************************
//------------------------------------------------------------------------------------------------
// Default Constructor
template< typename T >
SPtMatrix3x3< T >::SPtMatrix3x3()
{
    e[0][0] = e[0][1] = e[0][2] = 
    e[1][0] = e[1][1] = e[1][2] =
    e[2][0] = e[2][1] = e[2][2] = T();
}

//------------------------------------------------------------------------------------------------
template< typename T >
SPtMatrix3x3< T >::SPtMatrix3x3( SPtMatrix3x3< T > &M )
{
    e[0][0] = M.e[0][0];  e[0][1] = M.e[0][1];  e[0][2] = M.e[0][2];
    e[1][0] = M.e[1][0];  e[1][1] = M.e[1][1];  e[1][2] = M.e[1][2];
    e[2][0] = M.e[2][0];  e[2][1] = M.e[2][1];  e[2][2] = M.e[2][2];
}

//------------------------------------------------------------------------------------------------
// Typical Constructor
template< typename T >
SPtMatrix3x3< T >::SPtMatrix3x3( T e00, T e01, T e02, 
                                 T e10, T e11, T e12,
                                 T e20, T e21, T e22 )
{
    e[0][0] = e00;  e[0][1] = e01;  e[0][2] = e02;
    e[1][0] = e10;  e[1][1] = e11;  e[1][2] = e12;
    e[2][0] = e20;  e[2][1] = e21;  e[2][2] = e22;
}


//------------------------------------------------------------------------------------------------
// Useful Functions     *******************************************************
// Display The Matrix on Screen
template< typename T >
void SPtMatrix3x3< T >::DisplayElements() const
{
    cout << "\n3-by-3 matrix is\n";
    cout << "| " << setw(12) << e[0][0] << setw(12) << e[0][1] << setw(12) << e[0][2] << " |\n";
    cout << "| " << setw(12) << e[1][0] << setw(12) << e[1][1] << setw(12) << e[1][2] << " |\n";
    cout << "| " << setw(12) << e[2][0] << setw(12) << e[2][1] << setw(12) << e[2][2] << " |\n";
}

//------------------------------------------------------------------------------------------------
// Get an element
template< typename T >
T SPtMatrix3x3< T >::Get( int r, int c ) const
{
    if ( 0 <= r && r < 3 && 0 <= c && c < 3 )   return e[r][c];
    else                                        return -777;
}

//------------------------------------------------------------------------------------------------
// Set an element
template< typename T >
void SPtMatrix3x3< T >::Set( int r, int c, T value )
{
    if ( 0 <= r && r < 3 && 0 <= c && c < 3 )   e[r][c] = value;
}

//------------------------------------------------------------------------------------------------
// Set all elements
template< typename T >
void SPtMatrix3x3< T >::SetAll( T e00, T e01, T e02,
                                T e10, T e11, T e12,
                                T e20, T e21, T e22
                               )
{
    e[0][0] = e00;  e[0][1] = e01;  e[0][2] = e02;
    e[1][0] = e10;  e[1][1] = e11;  e[1][2] = e12;
    e[2][0] = e20;  e[2][1] = e21;  e[2][2] = e22;
}

//------------------------------------------------------------------------------------------------
// Set to identity matrix
template< typename T >
void SPtMatrix3x3< T >::LoadIdentity()
{
    e[0][0] = 1;    e[0][1] = 0;    e[0][2] = 0;
    e[1][0] = 0;    e[1][1] = 1;    e[1][2] = 0;
    e[2][0] = 0;    e[2][1] = 0;    e[2][2] = 1;
}

//------------------------------------------------------------------------------------------------
// Operations       ***********************************************************
// Transpose the matrix
template< typename T >
SPtMatrix3x3< T > &SPtMatrix3x3< T >::Transpose()
{
    T temp;

    temp = e[0][1];  e[0][1] = e[1][0];  e[1][0] = temp;
    temp = e[0][2];  e[0][2] = e[2][0];  e[2][0] = temp;
    temp = e[2][1];  e[2][1] = e[1][2];  e[1][2] = temp;

    return *this;
}

//------------------------------------------------------------------------------------------------
// Get the matrix transpose
template< typename T >
SPtMatrix3x3< T > SPtMatrix3x3< T >::GetTranspose() const
{
    return  SPtMatrix3x3< T >(  e[0][0], e[1][0], e[2][0],
                                e[0][1], e[1][1], e[2][1],
                                e[0][2], e[1][2], e[2][2] );
}

//------------------------------------------------------------------------------------------------
// Find the determinant
template< typename T >
T SPtMatrix3x3< T >::GetDeterminant() const
{
    return      e[0][0] * ( e[1][1]*e[2][2] - e[2][1]*e[1][2] ) 
            -   e[1][0] * ( e[0][1]*e[2][2] - e[2][1]*e[0][2] )
            +   e[2][0] * ( e[0][1]*e[1][2] - e[1][1]*e[0][2] );
}

//------------------------------------------------------------------------------------------------
// Inverse the matrix
template< typename T >
SPtMatrix3x3< T > &SPtMatrix3x3< T >::Inverse()
{
    *this = (*this).GetInverse();

    return *this;
}

//------------------------------------------------------------------------------------------------
// Get the matrix inverse
template< typename T >
SPtMatrix3x3< T > SPtMatrix3x3< T >::GetInverse() const
{
    T det = GetDeterminant();

    if ( -1E-20 < det && det < 1E-20 )  return SPtMatrix3x3();

    return SPtMatrix3x3< T >(    ( e[1][1]*e[2][2] - e[2][1]*e[1][2] ) / det,
                                -( e[0][1]*e[2][2] - e[2][1]*e[0][2] ) / det,
                                 ( e[0][1]*e[1][2] - e[1][1]*e[0][2] ) / det,
                                -( e[1][0]*e[2][2] - e[2][0]*e[1][2] ) / det,
                                 ( e[0][0]*e[2][2] - e[2][0]*e[0][2] ) / det,
                                -( e[0][0]*e[1][2] - e[1][0]*e[0][2] ) / det,
                                 ( e[1][0]*e[2][1] - e[2][0]*e[1][1] ) / det,
                                -( e[0][0]*e[2][1] - e[2][0]*e[0][1] ) / det,
                                 ( e[0][0]*e[1][1] - e[1][0]*e[0][1] ) / det    );
}

//------------------------------------------------------------------------------------------------
// Unary Overloaded Operators       *******************************************
// += with matrix
template< typename T >
SPtMatrix3x3< T > &SPtMatrix3x3< T >::operator+=( SPtMatrix3x3< T > &M )
{
    e[0][0] += M.e[0][0];   e[0][1] += M.e[0][1];   e[0][2] += M.e[0][2];
    e[1][0] += M.e[1][0];   e[1][1] += M.e[1][1];   e[1][2] += M.e[1][2];
    e[2][0] += M.e[2][0];   e[2][1] += M.e[2][1];   e[2][2] += M.e[2][2];

    return *this;
}

//------------------------------------------------------------------------------------------------
// += with matrix
template< typename T >
SPtMatrix3x3< T > &SPtMatrix3x3< T >::operator-=( SPtMatrix3x3< T > &M )
{
    e[0][0] -= M.e[0][0];   e[0][1] -= M.e[0][1];   e[0][2] -= M.e[0][2];
    e[1][0] -= M.e[1][0];   e[1][1] -= M.e[1][1];   e[1][2] -= M.e[1][2];
    e[2][0] -= M.e[2][0];   e[2][1] -= M.e[2][1];   e[2][2] -= M.e[2][2];

    return *this;
}

//------------------------------------------------------------------------------------------------
// *= with matrix
template< typename T >
SPtMatrix3x3< T > &SPtMatrix3x3< T >::operator*=( SPtMatrix3x3< T > &M )
{
    *this = (*this) * M;
    return *this;
}

//------------------------------------------------------------------------------------------------
// *= with scalar
template< typename T >
SPtMatrix3x3< T > &SPtMatrix3x3< T >::operator*=( T s )
{
    e[0][0] *= s;   e[0][1] *= s;   e[0][2] *= s;
    e[1][0] *= s;   e[1][1] *= s;   e[1][2] *= s;
    e[2][0] *= s;   e[2][1] *= s;   e[2][2] *= s;

    return *this;
}

//------------------------------------------------------------------------------------------------
// /= with scalar
template< typename T >
SPtMatrix3x3< T > &SPtMatrix3x3< T >::operator/=( T s )
{
    e[0][0] /= s;   e[0][1] /= s;   e[0][2] /= s;
    e[1][0] /= s;   e[1][1] /= s;   e[1][2] /= s;
    e[2][0] /= s;   e[2][1] /= s;   e[2][2] /= s;

    return *this;
}

//------------------------------------------------------------------------------------------------
// Binary Overloade Operators       *******************************************
// + with matrix
template< typename T >
SPtMatrix3x3< T > SPtMatrix3x3< T >::operator+( SPtMatrix3x3< T > &M ) const
{
    return SPtMatrix3x3< T >(   e[0][0]+M.e[0][0],  e[0][1]+M.e[0][1],  e[0][2]+M.e[0][2],
                                e[1][0]+M.e[1][0],  e[1][1]+M.e[1][1],  e[1][2]+M.e[1][2],
                                e[2][0]+M.e[2][0],  e[2][1]+M.e[2][1],  e[2][2]+M.e[2][2] );
}

//------------------------------------------------------------------------------------------------
// - with matrix
template< typename T >
SPtMatrix3x3< T > SPtMatrix3x3< T >::operator-( SPtMatrix3x3< T > &M ) const
{
    return SPtMatrix3x3< T >(   e[0][0]-M.e[0][0],  e[0][1]-M.e[0][1],  e[0][2]-M.e[0][2],
                                e[1][0]-M.e[1][0],  e[1][1]-M.e[1][1],  e[1][2]-M.e[1][2],
                                e[2][0]-M.e[2][0],  e[2][1]-M.e[2][1],  e[2][2]-M.e[2][2] );
}

//------------------------------------------------------------------------------------------------
// * with matrix
template< typename T >
SPtMatrix3x3< T > SPtMatrix3x3< T >::operator*( SPtMatrix3x3< T > &M ) const
{
    return SPtMatrix3x3< T >(   e[0][0]*M.e[0][0] + e[0][1]*M.e[1][0] + e[0][2]*M.e[2][0],
                                e[0][0]*M.e[0][1] + e[0][1]*M.e[1][1] + e[0][2]*M.e[2][1],
                                e[0][0]*M.e[0][2] + e[0][1]*M.e[1][2] + e[0][2]*M.e[2][2],
                                e[1][0]*M.e[0][0] + e[1][1]*M.e[1][0] + e[1][2]*M.e[2][0],
                                e[1][0]*M.e[0][1] + e[1][1]*M.e[1][1] + e[1][2]*M.e[2][1],
                                e[1][0]*M.e[0][2] + e[1][1]*M.e[1][2] + e[1][2]*M.e[2][2],
                                e[2][0]*M.e[0][0] + e[2][1]*M.e[1][0] + e[2][2]*M.e[2][0],
                                e[2][0]*M.e[0][1] + e[2][1]*M.e[1][1] + e[2][2]*M.e[2][1],
                                e[2][0]*M.e[0][2] + e[2][1]*M.e[1][2] + e[2][2]*M.e[2][2] );
}

//------------------------------------------------------------------------------------------------
// * with scalar
template< typename T >
SPtMatrix3x3< T > SPtMatrix3x3< T >::operator*( T s ) const
{
    return SPtMatrix3x3< T >(   e[0][0]*s,  e[0][1]*s,  e[0][2]*s,
                                e[1][0]*s,  e[1][1]*s,  e[1][2]*s,
                                e[2][0]*s,  e[2][1]*s,  e[2][2]*s );
}

//------------------------------------------------------------------------------------------------
// / with scalar
template< typename T >
SPtMatrix3x3< T > SPtMatrix3x3< T >::operator/( T s ) const
{
    return SPtMatrix3x3< T >(   e[0][0]/s,  e[0][1]/s,  e[0][2]/s,
                                e[1][0]/s,  e[1][1]/s,  e[1][2]/s,
                                e[2][0]/s,  e[2][1]/s,  e[2][2]/s );
}

/*
// Friend Overloaded Operators
// scalar * matrix
template< typename T >
SPtMatrix3x3< T > operator*( double s, const SPtMatrix3x3< T > &M )
{
    return SPtMatrix3x3< T >(   M.e[0][0]*s,    M.e[0][1]*s,    M.e[0][2]*s,
                                M.e[1][0]*s,    M.e[1][1]*s,    M.e[1][2]*s,
                                M.e[2][0]*s,    M.e[2][1]*s,    M.e[2][2]*s );
}

//------------------------------------------------------------------------------------------------
// scalar / matrix
template< typename T >
SPtMatrix3x3< T > operator/( double s, const SPtMatrix3x3< T > &M )
{
    return SPtMatrix3x3< T >(   M.e[0][0]/s,    M.e[0][1]/s,    M.e[0][2]/s,
                                M.e[1][0]/s,    M.e[1][1]/s,    M.e[1][2]/s,
                                M.e[2][0]/s,    M.e[2][1]/s,    M.e[2][2]/s );
}

//------------------------------------------------------------------------------------------------
// put it through ostream
template< typename T >
ostream &operator<<( ostream &output, const SPtMatrix3x3< T > &M )
{
    output  << "3-by-3 matrix\n"
            << "| " << setw(12) << M.e[0][0] << setw(12) << M.e[0][1] << setw(12) << M.e[0][2] << " |\n"
            << "| " << setw(12) << M.e[1][0] << setw(12) << M.e[1][1] << setw(12) << M.e[1][2] << " |\n"
            << "| " << setw(12) << M.e[2][0] << setw(12) << M.e[2][1] << setw(12) << M.e[2][2] << " |\n";

    return output;
}
*/
//===============================================================================================

#endif