TAPsMatrix2x2.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsMatrix2x2.cpp

Matrix2x2 class is a class for 2-by-2 matrices.

SUKITTI PUNAK   (09/12/2004)
UPDATE          (07/30/2005)
******************************************************************************/
#include "TAPsMatrix2x2.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs
//=============================================================================
// Constructors and Destructor
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T>::Matrix2x2 ()
{
    // Identity Matrix
    e[0] = e[3] = Math<T>::ONE;
    e[1] = e[2] = Math<T>::ZERO;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T>::Matrix2x2 ( Matrix2x2<T> const &M )
{
    e[0] = M.e[0];  e[1] = M.e[1];  e[2] = M.e[2];  e[3] = M.e[3];
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T>::Matrix2x2 ( T t )
{
    e[0] = e[1] = e[2] = e[3] = t;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T>::Matrix2x2 ( T e00, T e01, T e10, T e11 )
{
    e[0] = e00;  e[1] = e01;  e[2] = e10;  e[3] = e11;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T>::Matrix2x2 ( T const af[4] )
{
    e[0] = af[0];  e[1] = af[1];  e[2] = af[2];  e[3] = af[3];
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T>::~Matrix2x2 ()
{}
//-----------------------------------------------------------------------------
//=============================================================================
// Member Access
//-----------------------------------------------------------------------------
template <typename T>
inline T & Matrix2x2<T>::operator[] ( int i )
{   return e[i];    }
//-----------------------------------------------------------------------------
template <typename T>
inline T const & Matrix2x2<T>::operator[] ( int i ) const
{   return e[i];    }
//-----------------------------------------------------------------------------
template <typename T>
inline T & Matrix2x2<T>::operator() ( int r, int c )
{   return e[r*2 + c];  }
//-----------------------------------------------------------------------------
template <typename T>
inline T const & Matrix2x2<T>::operator() ( int r, int c ) const
{   return e[r*2 + c];  }
//-----------------------------------------------------------------------------
//=============================================================================
// Convert to one dimension array
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T>::operator const T * () const
{   return e;   }
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T>::operator T * ()
{   return e;   }
//-----------------------------------------------------------------------------
//=============================================================================
// Useful Functions
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix2x2<T>::SetAllElements (  T t )
{
    e[0] = e[1] = e[2] = e[3] = t;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix2x2<T>::SetAllElements (  T e00, T e01, T e10, T e11 )
{
    e[0] = e00;  e[1] = e01;  e[2] = e10;  e[3] = e11;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix2x2<T>::SetAllElements ( T const af[4] )
{
    e[0] = af[0];  e[1] = af[1];  e[2] = af[2];  e[3] = af[3];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix2x2<T>::MakeIdentity ()
{
    e[0] = e[3] = Math<T>::ONE;
    e[1] = e[2] = Math<T>::ZERO;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix2x2<T>::MakeDiagonal ( T d )
{
    e[0] = e[3] = d;
    e[1] = e[2] = Math<T>::ZERO;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix2x2<T>::MakeDiagonal ( T const af[2] )
{
    e[0] = af[0];
    e[3] = af[1];
    e[1] = e[2] = Math<T>::ZERO;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix2x2<T>::MakeZero ()
{
    e[0] = e[1] = e[2] = e[3] = Math<T>::ZERO;
}
//-----------------------------------------------------------------------------
template <typename T>
inline bool Matrix2x2<T>::IsIdentity () const
{
    return  e[ 0] == Math<T>::ONE   &&
            e[ 1] == Math<T>::ZERO  &&
            e[ 2] == Math<T>::ZERO  &&
            e[ 3] == Math<T>::ONE;
}
//-----------------------------------------------------------------------------
//=============================================================================
// Matrix Operations
//-----------------------------------------------------------------------------
template <typename T>
inline Matrix2x2<T> & Matrix2x2<T>::Transposed ()
{
    T temp;
    temp = e[1];  e[1] = e[2];  e[2] = temp;
    return *this;
}
//-----------------------------------------------------------------------------
template <typename T>
inline Matrix2x2<T> Matrix2x2<T>::GetTranspose() const
{
    return  Matrix2x2<T> ( e[0], e[2], e[1], e[3] );
}
//-----------------------------------------------------------------------------
// Inverse the matrix
template <typename T>
inline Matrix2x2<T> & Matrix2x2<T>::Inversed ()
{
    *this = (*this).GetInverse();
    return *this;
}
//-----------------------------------------------------------------------------
// Get the matrix inverse
template <typename T>
Matrix2x2<T> Matrix2x2<T>::GetInverse () const
{
    T det = GetDeterminant();

    if ( -Math<T>::EPSILON < det && det < Math<T>::EPSILON )
        return Matrix2x2( Math<T>::INFINITY );

    return Matrix2x2<T>( e[3] / det, 
                        -e[1] / det, 
                        -e[2] / det, 
                         e[0] / det );
}
//-----------------------------------------------------------------------------
template <typename T>
inline T Matrix2x2<T>::GetDeterminant () const
{
    return e[0]*e[3] - e[1]*e[2];
}
//-----------------------------------------------------------------------------
//=============================================================================
// Assignment Overloaded Operators
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T> & Matrix2x2<T>::operator= ( Matrix2x2<T> const &M )
{
    if ( this != &M )
    {
        e[0] = M.e[0];  e[1] = M.e[1];  e[2] = M.e[2];  e[3] = M.e[3];
    }
    return *this;
}
//-----------------------------------------------------------------------------
//=============================================================================
// Unary Overloaded Operators
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T> Matrix2x2<T>::operator- ()
{
    return Matrix2x2<T>( -e[0], -e[1], -e[2], -e[3] );
}
//-----------------------------------------------------------------------------
//=============================================================================
// Assign Overloaded Operators
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T> & Matrix2x2<T>::operator+= ( Matrix2x2<T> const &M )
{
    e[0] += M.e[0];  e[1] += M.e[1];  e[2] += M.e[2];  e[3] += M.e[3];
    return *this;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T> & Matrix2x2<T>::operator-= ( Matrix2x2<T> const &M )
{
    e[0] -= M.e[0];  e[1] -= M.e[1];  e[2] -= M.e[2];  e[3] -= M.e[3];
    return *this;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T> & Matrix2x2<T>::operator*= ( Matrix2x2<T> const &M )
{
    *this = (*this) * M;
    return *this;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T> & Matrix2x2<T>::operator*= ( T s )
{
    e[0] *= s;  e[1] *= s;  e[2] *= s;  e[3] *= s;
    return *this;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T> & Matrix2x2<T>::operator/= ( T s )
{
    e[0] /= s;  e[1] /= s;  e[2] /= s;  e[3] /= s;
    return *this;
}
//-----------------------------------------------------------------------------
//=============================================================================
// Binary Overloade Operators
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T> Matrix2x2<T>::operator+ ( Matrix2x2<T> const &M ) const
{
    return Matrix2x2<T>( e[0]+M.e[0], e[1]+M.e[1], e[2]+M.e[2], e[3]+M.e[3] );
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T> Matrix2x2<T>::operator- ( Matrix2x2<T> const &M ) const
{
    return Matrix2x2<T>( e[0]-M.e[0], e[1]-M.e[1], e[2]-M.e[2], e[3]-M.e[3] );
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T> Matrix2x2<T>::operator* ( Matrix2x2<T> const &M ) const
{
    return Matrix2x2<T>(    e[0]*M.e[0] + e[1]*M.e[2], 
                            e[0]*M.e[1] + e[1]*M.e[3], 
                            e[2]*M.e[0] + e[3]*M.e[2], 
                            e[2]*M.e[1] + e[3]*M.e[3] );
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T> Matrix2x2<T>::operator* ( T s ) const
{
    return Matrix2x2<T>( e[0]*s, e[1]*s, e[2]*s, e[3]*s );
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix2x2<T> Matrix2x2<T>::operator/ ( T s ) const
{
    return Matrix2x2<T>( e[0]/s, e[1]/s, e[2]/s, e[3]/s );
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix2x2<T>::MultLeft ( Matrix2x2<T> const &M )
{
    *this = M * (*this);
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix2x2<T>::MultRight ( Matrix2x2<T> const &M )
{
    *this *= M;
}
//-----------------------------------------------------------------------------
// Matrix * Vector
template <typename T>
Vector2<T> Matrix2x2<T>::operator* ( Vector2<T> const &V ) const
{
    return Vector2<T>(
            V[0]*e[0] + V[1]*e[1],
            V[0]*e[2] + V[1]*e[3] );
}
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8