TAPsMatrix3x3.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsMatrix3x3.cpp

Matrix3x3 class is a class for 3-by-3 matrices.

SUKITTI PUNAK   (09/14/2004)
UPDATE          (07/30/2005)
******************************************************************************/
#include "TAPsMatrix3x3.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
//=============================================================================
//-----------------------------------------------------------------------------
// Static Data Members for Data Conversions
template <typename T> float         Matrix3x3<T>::g_f[9];
template <typename T> double        Matrix3x3<T>::g_d[9];
template <typename T> long double   Matrix3x3<T>::g_ld[9];
//=============================================================================
// Constructors and Destructor
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T>::Matrix3x3 ()
{
    // Identity Matrix
    /*e0*/  e[1]  = e[2]  = 
    e[3]  = /*e4*/  e[5]  =
    e[6]  = e[7]  = /*e8*/ Math<T>::ZERO;
    e[0]  = e[4]  = e[8] = Math<T>::ONE;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T>::Matrix3x3 ( Matrix3x3<T> const &M )
{
    e[0] = M.e[0];  e[1] = M.e[1];  e[2] = M.e[2];
    e[3] = M.e[3];  e[4] = M.e[4];  e[5] = M.e[5];
    e[6] = M.e[6];  e[7] = M.e[7];  e[8] = M.e[8];
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T>::Matrix3x3 ( T t )
{
    e[0] = e[1] = e[2] = 
    e[3] = e[4] = e[5] =
    e[6] = e[7] = e[8] = t;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T>::Matrix3x3 ( T e00, T e01, T e02, 
                          T e10, T e11, T e12,
                          T e20, T e21, T e22 )
{
    e[0] = e00;  e[1] = e01;  e[2] = e02;
    e[3] = e10;  e[4] = e11;  e[5] = e12;
    e[6] = e20;  e[7] = e21;  e[8] = e22;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T>::Matrix3x3 ( T const af[9] )
{
    e[0] = af[0];  e[1] = af[1];  e[2] = af[2];
    e[3] = af[3];  e[4] = af[4];  e[5] = af[5];
    e[6] = af[6];  e[7] = af[7];  e[8] = af[8];
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T>::~Matrix3x3 ()
{}
//-----------------------------------------------------------------------------
//=============================================================================
// Member Access
//-----------------------------------------------------------------------------
template <typename T>
inline T & Matrix3x3<T>::operator[] ( int i )
{   return e[i];    }
//-----------------------------------------------------------------------------
template <typename T>
inline T const & Matrix3x3<T>::operator[] ( int i ) const
{   return e[i];    }
//-----------------------------------------------------------------------------
template <typename T>
inline T & Matrix3x3<T>::operator() ( int r, int c )
{   return e[r*3 + c];  }
//-----------------------------------------------------------------------------
template <typename T>
inline T const & Matrix3x3<T>::operator() ( int r, int c ) const
{   return e[r*3 + c];  }
//-----------------------------------------------------------------------------
//=============================================================================
// Convert to one dimension array
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T>::operator const T * () const
{   return e;   }
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T>::operator T * ()
{   return e;   }
//-----------------------------------------------------------------------------
//=============================================================================
// Useful Functions
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix3x3<T>::SetAllElements (  T t )
{
    e[0] = e[1] = e[2] =
    e[3] = e[4] = e[5] =
    e[6] = e[7] = e[8] = t;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix3x3<T>::SetAllElements (  T e00, T e01, T e02, 
                                            T e10, T e11, T e12,
                                            T e20, T e21, T e22 )
{
    e[0] = e00;  e[1] = e01;  e[2] = e02;
    e[3] = e10;  e[4] = e11;  e[5] = e12;
    e[6] = e20;  e[7] = e21;  e[8] = e22;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix3x3<T>::SetAllElements ( T const af[9] )
{
    e[0] = af[0];  e[1] = af[1];  e[2] = af[2];
    e[3] = af[3];  e[4] = af[4];  e[5] = af[5];
    e[6] = af[6];  e[7] = af[7];  e[8] = af[8];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix3x3<T>::MakeIdentity ()
{
    e[0] = e[4] = e[8] = Math<T>::ONE;
    e[1] = e[2] = e[3] = e[5] = e[6] = e[7] = Math<T>::ZERO;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix3x3<T>::MakeDiagonal ( T d )
{
    e[0] = e[4] = e[8] = d;
    e[1] = e[2] = e[3] = e[5] = e[6] = e[7] = Math<T>::ZERO;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix3x3<T>::MakeDiagonal ( T const af[3] )
{
    e[0] = af[0];
    e[4] = af[1];
    e[8] = af[2];
    e[1] = e[2] = e[3] = e[5] = e[6] = e[7] = Math<T>::ZERO;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix3x3<T>::MakeZero ()
{
    e[0] = e[1] = e[2] = 
    e[3] = e[4] = e[5] = 
    e[6] = e[7] = e[8] = Math<T>::ZERO;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
template <typename T>
inline bool Matrix3x3<T>::IsIdentity () const
{
    return  e[ 0] == Math<T>::ONE   &&
            e[ 1] == Math<T>::ZERO  &&
            e[ 2] == Math<T>::ZERO  &&

            e[ 3] == Math<T>::ZERO  &&
            e[ 4] == Math<T>::ONE   &&
            e[ 5] == Math<T>::ZERO  &&

            e[ 6] == Math<T>::ZERO  &&
            e[ 7] == Math<T>::ZERO  &&
            e[ 8] == Math<T>::ONE;
}
//=============================================================================
// Matrix Operations
//-----------------------------------------------------------------------------
template <typename T>
inline Matrix3x3<T> & Matrix3x3<T>::Transposed ()
{
    T temp;
    temp = e[1];  e[1] = e[3];  e[3] = temp;
    temp = e[2];  e[2] = e[6];  e[6] = temp;
    temp = e[5];  e[5] = e[7];  e[7] = temp;
    return *this;
}
//-----------------------------------------------------------------------------
template <typename T>
inline Matrix3x3<T> Matrix3x3<T>::GetTranspose() const
{
    return  Matrix3x3<T> (  e[0], e[3], e[6], 
                            e[1], e[4], e[7], 
                            e[2], e[5], e[8] );
}
//-----------------------------------------------------------------------------
// Inverse the matrix
template <typename T>
inline Matrix3x3<T> & Matrix3x3<T>::Inversed ()
{
    *this = (*this).GetInverse();
    return *this;
}
//-----------------------------------------------------------------------------
// Get the matrix inverse
template <typename T>
Matrix3x3<T> Matrix3x3<T>::GetInverse () const
{
    T detInv = T(1) / GetDeterminant();

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

    return Matrix3x3<T>(     ( e[4]*e[8] - e[7]*e[5] ) * detInv,
                            -( e[1]*e[8] - e[7]*e[2] ) * detInv,
                             ( e[1]*e[5] - e[4]*e[2] ) * detInv,
                            -( e[3]*e[8] - e[6]*e[5] ) * detInv,
                             ( e[0]*e[8] - e[6]*e[2] ) * detInv,
                            -( e[0]*e[5] - e[3]*e[2] ) * detInv,
                             ( e[3]*e[7] - e[6]*e[4] ) * detInv,
                            -( e[0]*e[7] - e[6]*e[1] ) * detInv,
                             ( e[0]*e[4] - e[3]*e[1] ) * detInv );
}
//-----------------------------------------------------------------------------
template <typename T>
inline T Matrix3x3<T>::GetDeterminant () const
{
    return      e[0] * ( e[4]*e[8] - e[5]*e[7] ) 
            -   e[3] * ( e[1]*e[8] - e[2]*e[7] )
            +   e[6] * ( e[1]*e[5] - e[2]*e[4] );
}
//-----------------------------------------------------------------------------
//=============================================================================
// Assignment Overloaded Operator
//--------------------------------------------------------------------------
// Assignment Operator
template <typename T>
inline Matrix3x3<T> & Matrix3x3<T>::operator= ( Matrix3x3<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];  e[4] = M.e[4];  e[5] = M.e[5];
        e[6] = M.e[6];  e[7] = M.e[7];  e[8] = M.e[8];
    }
    return *this;
}
//-----------------------------------------------------------------------------
//=============================================================================
// Unary Overloaded Operators
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T> Matrix3x3<T>::operator- ()
{
    return Matrix3x3<T>(    -e[0], -e[1], -e[2], 
                            -e[3], -e[4], -e[5], 
                            -e[6], -e[7], -e[8] );
}
//=============================================================================
// Assign Overloaded Operators
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T> & Matrix3x3<T>::operator+= ( Matrix3x3<T> const &M )
{
    e[0] += M.e[0];  e[1] += M.e[1];  e[2] += M.e[2];
    e[3] += M.e[3];  e[4] += M.e[4];  e[5] += M.e[5];
    e[6] += M.e[6];  e[7] += M.e[7];  e[8] += M.e[8];
    return *this;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T> & Matrix3x3<T>::operator-= ( Matrix3x3<T> const &M )
{
    e[0] -= M.e[0];  e[1] -= M.e[1];  e[2] -= M.e[2];
    e[3] -= M.e[3];  e[4] -= M.e[4];  e[5] -= M.e[5];
    e[6] -= M.e[6];  e[7] -= M.e[7];  e[8] -= M.e[8];
    return *this;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T> & Matrix3x3<T>::operator*= ( Matrix3x3<T> const &M )
{
    *this = (*this) * M;
    return *this;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T> & Matrix3x3<T>::operator*= ( T s )
{
    e[0] *= s;  e[1] *= s;  e[2] *= s;
    e[3] *= s;  e[4] *= s;  e[5] *= s;
    e[6] *= s;  e[7] *= s;  e[8] *= s;
    return *this;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T> & Matrix3x3<T>::operator/= ( T s )
{
    e[0] /= s;  e[1] /= s;  e[2] /= s;
    e[3] /= s;  e[4] /= s;  e[5] /= s;
    e[6] /= s;  e[7] /= s;  e[8] /= s;
    return *this;
}
//-----------------------------------------------------------------------------
//=============================================================================
// Binary Overloaded Operators
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T> Matrix3x3<T>::operator+ ( Matrix3x3<T> const &M ) const
{
    return Matrix3x3<T>(    e[0]+M.e[0], e[1]+M.e[1], e[2]+M.e[2],
                            e[3]+M.e[3], e[4]+M.e[4], e[5]+M.e[5],
                            e[6]+M.e[6], e[7]+M.e[7], e[8]+M.e[8] );
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T> Matrix3x3<T>::operator- ( Matrix3x3<T> const &M ) const
{
    return Matrix3x3<T>(    e[0]-M.e[0], e[1]-M.e[1], e[2]-M.e[2],
                            e[3]-M.e[3], e[4]-M.e[4], e[5]-M.e[5],
                            e[6]-M.e[6], e[7]-M.e[7], e[8]-M.e[8] );
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T> Matrix3x3<T>::operator* ( Matrix3x3<T> const &M ) const
{
    return Matrix3x3<T>(    e[0]*M.e[0] + e[1]*M.e[3] + e[2]*M.e[6],
                            e[0]*M.e[1] + e[1]*M.e[4] + e[2]*M.e[7],
                            e[0]*M.e[2] + e[1]*M.e[5] + e[2]*M.e[8],
                            e[3]*M.e[0] + e[4]*M.e[3] + e[5]*M.e[6],
                            e[3]*M.e[1] + e[4]*M.e[4] + e[5]*M.e[7],
                            e[3]*M.e[2] + e[4]*M.e[5] + e[5]*M.e[8],
                            e[6]*M.e[0] + e[7]*M.e[3] + e[8]*M.e[6],
                            e[6]*M.e[1] + e[7]*M.e[4] + e[8]*M.e[7],
                            e[6]*M.e[2] + e[7]*M.e[5] + e[8]*M.e[8] );
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T> Matrix3x3<T>::operator* ( T s ) const
{
    return Matrix3x3<T>(    e[0]*s, e[1]*s, e[2]*s,
                            e[3]*s, e[4]*s, e[5]*s,
                            e[6]*s, e[7]*s, e[8]*s );
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T> Matrix3x3<T>::operator/ ( T s ) const
{
    return Matrix3x3<T>(    e[0]/s, e[1]/s, e[2]/s,
                            e[3]/s, e[4]/s, e[5]/s,
                            e[6]/s, e[7]/s, e[8]/s );
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix3x3<T>::MultLeft ( Matrix3x3<T> const &M )
{
    *this = M * (*this);
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Matrix3x3<T>::MultRight ( Matrix3x3<T> const &M )
{
    *this *= M;
}
//-----------------------------------------------------------------------------
// Matrix * Vector
template <typename T>
Vector3<T> Matrix3x3<T>::operator* ( Vector3<T> const &V ) const
{
    return Vector3<T>(
            V[0]*e[0] + V[1]*e[1] + V[2]*e[2],
            V[0]*e[3] + V[1]*e[4] + V[2]*e[5],
            V[0]*e[6] + V[1]*e[7] + V[2]*e[8] );
}
//-----------------------------------------------------------------------------

//=============================================================================
// Static Member Functions for Data Conversions
//-----------------------------------------------------------------------------
template <typename T>
const float * Matrix3x3<T>::GetDataFloat () const
{
    for ( int i = 0; i < 9; ++i ) {
        g_f[i] = static_cast<float>( e[i] );
    }
    return g_f;
}
//-----------------------------------------------------------------------------
template <typename T>
const double * Matrix3x3<T>::GetDataDouble () const
{
    for ( int i = 0; i < 9; ++i ) {
        g_d[i] = static_cast<double>( e[i] );
    }
    return g_d;
}
//-----------------------------------------------------------------------------
template <typename T>
const long double * Matrix3x3<T>::GetDataLongDouble () const
{
    for ( int i = 0; i < 9; ++i ) {
        g_ld[i] = static_cast<long double>( e[i] );
    }
    return g_ld;
}
//-----------------------------------------------------------------------------
template <typename T>
const float * Matrix3x3<T>::GetTransposeDataFloat () const
{
    g_f[0] = static_cast<float>( e[0] );
    g_f[1] = static_cast<float>( e[3] );
    g_f[2] = static_cast<float>( e[6] );
    g_f[3] = static_cast<float>( e[1] );
    g_f[4] = static_cast<float>( e[4] );
    g_f[5] = static_cast<float>( e[7] );
    g_f[6] = static_cast<float>( e[2] );
    g_f[7] = static_cast<float>( e[5] );
    g_f[8] = static_cast<float>( e[8] );
    return g_f;
}
//-----------------------------------------------------------------------------
template <typename T>
const double * Matrix3x3<T>::GetTransposeDataDouble () const
{
    g_d[0] = static_cast<double>( e[0] );
    g_d[1] = static_cast<double>( e[3] );
    g_d[2] = static_cast<double>( e[6] );
    g_d[3] = static_cast<double>( e[1] );
    g_d[4] = static_cast<double>( e[4] );
    g_d[5] = static_cast<double>( e[7] );
    g_d[6] = static_cast<double>( e[2] );
    g_d[7] = static_cast<double>( e[5] );
    g_d[8] = static_cast<double>( e[8] );
    return g_d;
}
//-----------------------------------------------------------------------------
template <typename T>
const long double * Matrix3x3<T>::GetTransposeDataLongDouble () const
{
    g_ld[0] = static_cast<long double>( e[0] );
    g_ld[1] = static_cast<long double>( e[3] );
    g_ld[2] = static_cast<long double>( e[6] );
    g_ld[3] = static_cast<long double>( e[1] );
    g_ld[4] = static_cast<long double>( e[4] );
    g_ld[5] = static_cast<long double>( e[7] );
    g_ld[6] = static_cast<long double>( e[2] );
    g_ld[7] = static_cast<long double>( e[5] );
    g_ld[8] = static_cast<long double>( e[8] );
    return g_ld;
}
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8