MeVis/Foundation/Sources/MLLinearAlgebra/mlMatrix6.h

Go to the documentation of this file.

// **InsertLicense** code 
//=====================================================================================

//=====================================================================================

#ifndef __mlMatrix6_H
#define __mlMatrix6_H

// Include system independency file and project settings.
#ifndef __mlLinearAlgebraSystem_H
#include "mlLinearAlgebraSystem.h"
#endif
#ifndef __mlLinearAlgebraDefs_H
#include "mlLinearAlgebraDefs.h"
#endif


#ifndef __mlFloatingPointMatrix_H
#include "mlFloatingPointMatrix.h"
#endif

#ifndef __mlVector6_H
#include "mlVector6.h"
#endif

// All declarations of this header will be in the ML_LINEAR_ALGEBRA namespace.
ML_LA_START_NAMESPACE

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT>
class Tmat6 : public FloatingPointMatrix<Tvec6<DT>, 6>
{
public:
  
  typedef DT ComponentType;
  
  // Build 6x6 matrix from 36 zero elements.
  Tmat6();
  
  // Build matrix that has the argument at the diagonal values, zero otherwise
  Tmat6(const DT diagValue);

  // Build the matrix of the six row vectors row0, ..., row5.
  Tmat6(const Tvec6<DT> &row0, const Tvec6<DT> &row1, const Tvec6<DT> &row2,
        const Tvec6<DT> &row3, const Tvec6<DT> &row4, const Tvec6<DT> &row5);
  
  // Copy constructor from the Tmat6 mat.
  Tmat6(const Tmat6<DT> &m);
  
  // Constructor from 36 floats given as array mat, read row by row.
  Tmat6(const float mat[36]);
  
  // Constructor from 36 doubles given as array mat, read row by row.
  Tmat6(const double mat[36]);
  
  // Initialize all matrix elements explicitly with scalars,
  // filling it row by row.
  Tmat6(const double in00, const double in01, const double in02, const double in03, const double in04, const double in05,
        const double in10, const double in11, const double in12, const double in13, const double in14, const double in15,
        const double in20, const double in21, const double in22, const double in23, const double in24, const double in25,
        const double in30, const double in31, const double in32, const double in33, const double in34, const double in35,
        const double in40, const double in41, const double in42, const double in43, const double in44, const double in45,
        const double in50, const double in51, const double in52, const double in53, const double in54, const double in55);
  
  // Copy contents from float array m into *this. m must point to an
  // array with at least 36 valid entries, read row by row.
  void setValues(const float m[36]);
  
  // Copy contents of *this into float array m. Note that range
  // and precision of the float values may not be sufficient for
  // higher precision matrix contents. m must point to an array with
  // at least 36 accessible entries, written row by row.
  void getValues(float m[36]) const;
  
  // Copy contents from double array m into *this. m must point to an
  // array with at least 36 valid entries, read row by row.
  void setValues(const double m[36]);
  
  // Copy contents of *this into double array m. m must point to an
  // array with at least 36 accessible entries, written row by row.
  void getValues(double m[36]) const;
  
  // Set diagonal matrix with scale on diagonal.
  void setScaleMatrix(const DT scale);
  
  // Return a matrix filled with values val.
  static Tmat6<DT> getMat(const double val);
  
  // Set all values to val.
  void set(const DT val);
  
  bool operator<(const Tmat6<DT> &) const { return false; }
  
  // Assignment from a Tmat6.
  const Tmat6<DT>& operator=(const Tmat6<DT> &m);
  
  // Component wise addition with a Tmat6.
  const Tmat6<DT>& operator+=(const Tmat6<DT> &m);
  
  // Component wise subtraction by a Tmat6.
  const Tmat6<DT>& operator-=(const Tmat6<DT> &m);
  
  // Multiplication by a scalar constant
  const Tmat6<DT>& operator*=(const DT d);
  
  // Division by a scalar constant.
  // Division by zero is not handled and must be avoided by caller.
  const Tmat6<DT>& operator/=(const DT d);
  
  //-------------------------------------------------
  // Special functions
  //-------------------------------------------------
  // Determine the (sub)determinant of columns given by col1, col2, col3, col4 and col5.
  DT determinantLower5(const int col1, const int col2, const int col3, const int col4, const int col5) const;
  
  // Determinant.
  DT det() const;
  
  // Returns the inverse. Gauss-Jordan elimination with partial pivoting.
  // If a non-NULL Boolean pointer is passed to isInvertible
  // then true is returned in *isInvertible in the case of a
  // successful inversion or false if the inversion is not possible
  // (function return is the identity then).
  // If a NULL pointer is passed as isInvertible the matrix must
  // be invertible, otherwise errors will occur.
  Tmat6<DT> inverse(bool* isInvertible=NULL) const;
  
  // Transpose.
  Tmat6 transpose() const;
  
  // Return identity matrix.
  static Tmat6 getIdentity();
  
  // Apply the function fct to each component.
  const Tmat6<DT> & apply(MLDblFuncPtr fct);
  
}; // end of class *Tmat6*




//---------------------------------------------------------------------

//---------------------------------------------------------------------
template <class DT>
inline Tmat6<DT>::Tmat6()
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat6<DT>::Tmat6()");
  
  this->v[0] = this->v[1] = this->v[2] = this->v[3] = this->v[4] = this->v[5] = Tvec6<DT>(0);
}

// Construct matrix that has the argument at the diagonal values, zero otherwise
template <class DT>
inline Tmat6<DT>::Tmat6(const DT diagValue)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat6<DT>::Tmat6(diagValue)");
  
  this->v[0][0] = this->v[1][1] = this->v[2][2] = this->v[3][3] = this->v[4][4] = this->v[5][5] = diagValue;
  this->v[1][0] = this->v[2][0] = this->v[3][0] = this->v[4][0] = this->v[5][0] = this->v[2][1] = this->v[3][1] = this->v[4][1] = this->v[5][1] = this->v[3][2] = this->v[4][2] = this->v[5][2] = this->v[4][3] = this->v[5][3] = this->v[5][4] = 0;
  this->v[0][1] = this->v[0][2] = this->v[0][3] = this->v[0][4] = this->v[0][5] = this->v[1][2] = this->v[1][3] = this->v[1][4] = this->v[1][5] = this->v[2][3] = this->v[2][4] = this->v[2][5] = this->v[3][4] = this->v[3][5] = this->v[4][5] = 0;
}

template <class DT>
inline Tmat6<DT>::Tmat6(const Tvec6<DT>& row0, const Tvec6<DT>& row1, const Tvec6<DT>& row2,
                        const Tvec6<DT>& row3, const Tvec6<DT>& row4, const Tvec6<DT>& row5)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat6<DT>::Tmat6(const Tvec6<DT>& row0, ... , const Tvec6<DT>& row5)");
  
  this->v[0] = row0;
  this->v[1] = row1;
  this->v[2] = row2;
  this->v[3] = row3;
  this->v[4] = row4;
  this->v[5] = row5;
}

template <class DT>
inline Tmat6<DT>::Tmat6(const Tmat6<DT> &mat)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat6<DT>::Tmat6(const Tmat6<DT> &mat)");
  
  this->v[0] = mat.v[0];
  this->v[1] = mat.v[1];
  this->v[2] = mat.v[2];
  this->v[3] = mat.v[3];
  this->v[4] = mat.v[4];
  this->v[5] = mat.v[5];
}

template <class DT>
inline Tmat6<DT>::Tmat6(const float mat[36])
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat6<DT>::Tmat6(const float mat[36])");
  
  setValues(mat);
}

template <class DT>
inline Tmat6<DT>::Tmat6(const double mat[36])
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat6<DT>::Tmat6(const double mat[36])");
  
  setValues(mat);
}

template <class DT>
inline Tmat6<DT> Tmat6<DT>::getMat(const double val)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat6<DT>::getMat(const double val)");
  
  return Tmat6<DT>(val, val, val, val, val, val,
                   val, val, val, val, val, val,
                   val, val, val, val, val, val,
                   val, val, val, val, val, val,
                   val, val, val, val, val, val,
                   val, val, val, val, val, val);
}

template <class DT>
inline void Tmat6<DT>::set(DT val)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat6<DT>::set(DT val)");
  
  this->v[0] = this->v[1] = this->v[2] = this->v[3] = this->v[4] = this->v[5] = Tvec6<DT>(val);
}

template <class DT>
inline const Tmat6<DT> & Tmat6<DT>::operator=(const Tmat6<DT> &m)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat6<DT>::operator=(const Tmat6<DT> &m)");
  
  if (&m != this){
    this->v[0] = m.v[0];
    this->v[1] = m.v[1];
    this->v[2] = m.v[2];
    this->v[3] = m.v[3];
    this->v[4] = m.v[4];
    this->v[5] = m.v[5];
  }
  
  return *this;
}

template <class DT>
inline const Tmat6<DT> & Tmat6<DT>::operator+=(const Tmat6<DT> &m)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat6<DT>::operator+=(const Tmat6<DT> &m)");
  
  this->v[0] += m.v[0];
  this->v[1] += m.v[1];
  this->v[2] += m.v[2];
  this->v[3] += m.v[3];
  this->v[4] += m.v[4];
  this->v[5] += m.v[5];
  
  return *this;
}

template <class DT>
inline const Tmat6<DT> & Tmat6<DT>::operator-=(const Tmat6<DT> &m)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat6<DT>::operator-=(const Tmat6<DT> &m)");
  
  this->v[0] -= m.v[0];
  this->v[1] -= m.v[1];
  this->v[2] -= m.v[2];
  this->v[3] -= m.v[3];
  this->v[4] -= m.v[4];
  this->v[5] -= m.v[5];
  
  return *this;
}

template <class DT>
inline const Tmat6<DT> & Tmat6<DT>::operator*=(const DT d)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat6<DT>::operator*=(const DT d)");
  
  this->v[0] *= d;
  this->v[1] *= d;
  this->v[2] *= d;
  this->v[3] *= d;
  this->v[4] *= d;
  this->v[5] *= d;
  
  return *this;
}

template <class DT>
inline const Tmat6<DT> & Tmat6<DT>::operator/=(const DT d)
{
  ML_TRACE_IN("Tmat6<DT>::operator/=(const DT d)");
  ML_TRY
  {
    if (MLValueIs0WOM(d)){ ML_CHECK_THROW(0); }
    this->v[0] /= d;
    this->v[1] /= d;
    this->v[2] /= d;
    this->v[3] /= d;
    this->v[4] /= d;
    this->v[5] /= d;
  }
  ML_CATCH_RETHROW;
  return *this;
}


//--------------------------------------------------------------------

//--------------------------------------------------------------------
template <class DT>
inline Tmat6<DT> operator-(const Tmat6<DT> &a)
{
  ML_TRACE_IN_TIME_CRITICAL("mlMatrix6.h: operator-(const Tmat6<DT> &a)");
  
  return Tmat6<DT>(a) *= static_cast<DT>(-1.0);
}

template <class DT>
inline Tmat6<DT> operator+(const Tmat6<DT> &a, const Tmat6<DT> &b)
{
  ML_TRACE_IN_TIME_CRITICAL("mlMatrix6.h: operator+(const Tmat6<DT> &a, const Tmat6<DT> &b)");
  
  return Tmat6<DT>(a) += b;
}

template <class DT>
inline Tmat6<DT> operator-(const Tmat6<DT> &a, const Tmat6<DT> &b)
{
  ML_TRACE_IN_TIME_CRITICAL("mlMatrix6.h: operator-(const Tmat6<DT> &a, const Tmat6<DT> &b)");
  
  return Tmat6<DT>(a) -= b;
}

template <class DT>
inline Tmat6<DT> operator*(const Tmat6<DT> &a, const DT d)
{
  ML_TRACE_IN_TIME_CRITICAL("mlMatrix6.h: operator*(const Tmat6<DT> &a, const DT d)");
  
  return Tmat6<DT>(a) *= d;
}

template <class DT>
inline Tmat6<DT> operator*(const DT d, const Tmat6<DT> &a)
{
  ML_TRACE_IN_TIME_CRITICAL("mlMatrix6.h: operator*(const DT d, const Tmat6<DT> &a)");
  
  return Tmat6<DT>(a) *= d;
}

template <class DT>
inline Tmat6<DT> operator/(const Tmat6<DT> &a, const DT d)
{
  ML_TRACE_IN("mlMatrix6.h: operator/(const Tmat6<DT> &a, const DT d)");
  
  Tmat6<DT> divided(a);
  ML_TRY
  {
    ML_CHECK_FLOAT_THROW(d);
    divided /= d;
  }
  ML_CATCH_RETHROW;
  return divided;
}

//-------------------------------------------------------------------
//

//
//-------------------------------------------------------------------

//-------------------------------------------------------------------
//-------------------------------------------------------------------
template <class DT>
Tmat6<DT>::Tmat6(const double in00, const double in01, const double in02, const double in03, const double in04, const double in05,
                 const double in10, const double in11, const double in12, const double in13, const double in14, const double in15,
                 const double in20, const double in21, const double in22, const double in23, const double in24, const double in25,
                 const double in30, const double in31, const double in32, const double in33, const double in34, const double in35,
                 const double in40, const double in41, const double in42, const double in43, const double in44, const double in45,
                 const double in50, const double in51, const double in52, const double in53, const double in54, const double in55)
{
  ML_TRACE_IN("Tmat6<DT>::Tmat6( )");
  ML_TRY
  {
    this->v[0][0]=static_cast<DT>(in00); this->v[0][1]=static_cast<DT>(in01); this->v[0][2]=static_cast<DT>(in02);  this->v[0][3]=static_cast<DT>(in03); this->v[0][4]=static_cast<DT>(in04); this->v[0][5]=static_cast<DT>(in05);
    this->v[1][0]=static_cast<DT>(in10); this->v[1][1]=static_cast<DT>(in11); this->v[1][2]=static_cast<DT>(in12);  this->v[1][3]=static_cast<DT>(in13); this->v[1][4]=static_cast<DT>(in14); this->v[1][5]=static_cast<DT>(in15);
    this->v[2][0]=static_cast<DT>(in20); this->v[2][1]=static_cast<DT>(in21); this->v[2][2]=static_cast<DT>(in22);  this->v[2][3]=static_cast<DT>(in23); this->v[2][4]=static_cast<DT>(in24); this->v[2][5]=static_cast<DT>(in25);
    this->v[3][0]=static_cast<DT>(in30); this->v[3][1]=static_cast<DT>(in31); this->v[3][2]=static_cast<DT>(in32);  this->v[3][3]=static_cast<DT>(in33); this->v[3][4]=static_cast<DT>(in34); this->v[3][5]=static_cast<DT>(in35);
    this->v[4][0]=static_cast<DT>(in40); this->v[4][1]=static_cast<DT>(in41); this->v[4][2]=static_cast<DT>(in42);  this->v[4][3]=static_cast<DT>(in43); this->v[4][4]=static_cast<DT>(in44); this->v[4][5]=static_cast<DT>(in45);
    this->v[5][0]=static_cast<DT>(in50); this->v[5][1]=static_cast<DT>(in51); this->v[5][2]=static_cast<DT>(in52);  this->v[5][3]=static_cast<DT>(in53); this->v[5][4]=static_cast<DT>(in54); this->v[5][5]=static_cast<DT>(in55);
  }
  ML_CATCH_RETHROW;
}


//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT>
void Tmat6<DT>::setValues(const float m[36])
{
  ML_TRACE_IN("Tmat6<DT>::setValues( )");
  ML_TRY
  {
    this->v[0][0] = static_cast<DT>(m[ 0]);  this->v[0][1] = static_cast<DT>(m[ 1]);  this->v[0][2] = static_cast<DT>(m[ 2]);  this->v[0][3] = static_cast<DT>(m[ 3]);  this->v[0][4] = static_cast<DT>(m[ 4]);  this->v[0][5] = static_cast<DT>(m[ 5]);
    this->v[1][0] = static_cast<DT>(m[ 6]);  this->v[1][1] = static_cast<DT>(m[ 7]);  this->v[1][2] = static_cast<DT>(m[ 8]);  this->v[1][3] = static_cast<DT>(m[ 9]);  this->v[1][4] = static_cast<DT>(m[10]);  this->v[1][5] = static_cast<DT>(m[11]);
    this->v[2][0] = static_cast<DT>(m[12]);  this->v[2][1] = static_cast<DT>(m[13]);  this->v[2][2] = static_cast<DT>(m[14]);  this->v[2][3] = static_cast<DT>(m[15]);  this->v[2][4] = static_cast<DT>(m[16]);  this->v[2][5] = static_cast<DT>(m[17]);
    this->v[3][0] = static_cast<DT>(m[18]);  this->v[3][1] = static_cast<DT>(m[19]);  this->v[3][2] = static_cast<DT>(m[20]);  this->v[3][3] = static_cast<DT>(m[21]);  this->v[3][4] = static_cast<DT>(m[22]);  this->v[3][5] = static_cast<DT>(m[23]);
    this->v[4][0] = static_cast<DT>(m[24]);  this->v[4][1] = static_cast<DT>(m[25]);  this->v[4][2] = static_cast<DT>(m[26]);  this->v[4][3] = static_cast<DT>(m[27]);  this->v[4][4] = static_cast<DT>(m[28]);  this->v[4][5] = static_cast<DT>(m[29]);
    this->v[5][0] = static_cast<DT>(m[30]);  this->v[5][1] = static_cast<DT>(m[31]);  this->v[5][2] = static_cast<DT>(m[32]);  this->v[5][3] = static_cast<DT>(m[33]);  this->v[5][4] = static_cast<DT>(m[34]);  this->v[5][5] = static_cast<DT>(m[35]);
  }
  ML_CATCH_RETHROW;
}

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT>
void Tmat6<DT>::getValues(float m[36]) const
{
  ML_TRACE_IN("Tmat6<DT>::setValues( )");
  ML_TRY
  {
    m[ 0] = static_cast<float>(this->v[0][0]);  m[ 1] = static_cast<float>(this->v[0][1]);  m[ 2] = static_cast<float>(this->v[0][2]);  m[ 3] = static_cast<float>(this->v[0][3]);  m[ 4] = static_cast<float>(this->v[0][4]);  m[ 5] = static_cast<float>(this->v[0][5]);
    m[ 6] = static_cast<float>(this->v[1][0]);  m[ 7] = static_cast<float>(this->v[1][1]);  m[ 8] = static_cast<float>(this->v[1][2]);  m[ 9] = static_cast<float>(this->v[1][3]);  m[10] = static_cast<float>(this->v[1][4]);  m[11] = static_cast<float>(this->v[1][5]);
    m[12] = static_cast<float>(this->v[2][0]);  m[13] = static_cast<float>(this->v[2][1]);  m[14] = static_cast<float>(this->v[2][2]);  m[15] = static_cast<float>(this->v[2][3]);  m[16] = static_cast<float>(this->v[2][4]);  m[17] = static_cast<float>(this->v[2][5]);
    m[18] = static_cast<float>(this->v[3][0]);  m[19] = static_cast<float>(this->v[3][1]);  m[20] = static_cast<float>(this->v[3][2]);  m[21] = static_cast<float>(this->v[3][3]);  m[22] = static_cast<float>(this->v[3][4]);  m[23] = static_cast<float>(this->v[3][5]);
    m[24] = static_cast<float>(this->v[4][0]);  m[25] = static_cast<float>(this->v[4][1]);  m[26] = static_cast<float>(this->v[4][2]);  m[27] = static_cast<float>(this->v[4][3]);  m[28] = static_cast<float>(this->v[4][4]);  m[29] = static_cast<float>(this->v[4][5]);
    m[30] = static_cast<float>(this->v[5][0]);  m[31] = static_cast<float>(this->v[5][1]);  m[32] = static_cast<float>(this->v[5][2]);  m[33] = static_cast<float>(this->v[5][3]);  m[34] = static_cast<float>(this->v[5][4]);  m[35] = static_cast<float>(this->v[5][5]);
  }
  ML_CATCH_RETHROW;
}

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT>
void Tmat6<DT>::setValues(const double m[36])
{
  ML_TRACE_IN("Tmat6<DT>::setValues( )");
  ML_TRY
  {
    this->v[0][0] = static_cast<DT>(m[ 0]);  this->v[0][1] = static_cast<DT>(m[ 1]);  this->v[0][2] = static_cast<DT>(m[ 2]);  this->v[0][3] = static_cast<DT>(m[ 3]);  this->v[0][4] = static_cast<DT>(m[ 4]);  this->v[0][5] = static_cast<DT>(m[ 5]);
    this->v[1][0] = static_cast<DT>(m[ 6]);  this->v[1][1] = static_cast<DT>(m[ 7]);  this->v[1][2] = static_cast<DT>(m[ 8]);  this->v[1][3] = static_cast<DT>(m[ 9]);  this->v[1][4] = static_cast<DT>(m[10]);  this->v[1][5] = static_cast<DT>(m[11]);
    this->v[2][0] = static_cast<DT>(m[12]);  this->v[2][1] = static_cast<DT>(m[13]);  this->v[2][2] = static_cast<DT>(m[14]);  this->v[2][3] = static_cast<DT>(m[15]);  this->v[2][4] = static_cast<DT>(m[16]);  this->v[2][5] = static_cast<DT>(m[17]);
    this->v[3][0] = static_cast<DT>(m[18]);  this->v[3][1] = static_cast<DT>(m[19]);  this->v[3][2] = static_cast<DT>(m[20]);  this->v[3][3] = static_cast<DT>(m[21]);  this->v[3][4] = static_cast<DT>(m[22]);  this->v[3][5] = static_cast<DT>(m[23]);
    this->v[4][0] = static_cast<DT>(m[24]);  this->v[4][1] = static_cast<DT>(m[25]);  this->v[4][2] = static_cast<DT>(m[26]);  this->v[4][3] = static_cast<DT>(m[27]);  this->v[4][4] = static_cast<DT>(m[28]);  this->v[4][5] = static_cast<DT>(m[29]);
    this->v[5][0] = static_cast<DT>(m[30]);  this->v[5][1] = static_cast<DT>(m[31]);  this->v[5][2] = static_cast<DT>(m[32]);  this->v[5][3] = static_cast<DT>(m[33]);  this->v[5][4] = static_cast<DT>(m[34]);  this->v[5][5] = static_cast<DT>(m[35]);
  }
  ML_CATCH_RETHROW;
}

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT>
void Tmat6<DT>::getValues(double m[36]) const
{
  ML_TRACE_IN("Tmat6<DT>::setValues( )");
  ML_TRY
  {
    m[ 0] = static_cast<double>(this->v[0][0]);  m[ 1] = static_cast<double>(this->v[0][1]);  m[ 2] = static_cast<double>(this->v[0][2]);  m[ 3] = static_cast<double>(this->v[0][3]);  m[ 4] = static_cast<double>(this->v[0][4]);  m[ 5] = static_cast<double>(this->v[0][5]);
    m[ 6] = static_cast<double>(this->v[1][0]);  m[ 7] = static_cast<double>(this->v[1][1]);  m[ 8] = static_cast<double>(this->v[1][2]);  m[ 9] = static_cast<double>(this->v[1][3]);  m[10] = static_cast<double>(this->v[1][4]);  m[11] = static_cast<double>(this->v[1][5]);
    m[12] = static_cast<double>(this->v[2][0]);  m[13] = static_cast<double>(this->v[2][1]);  m[14] = static_cast<double>(this->v[2][2]);  m[15] = static_cast<double>(this->v[2][3]);  m[16] = static_cast<double>(this->v[2][4]);  m[17] = static_cast<double>(this->v[2][5]);
    m[18] = static_cast<double>(this->v[3][0]);  m[19] = static_cast<double>(this->v[3][1]);  m[20] = static_cast<double>(this->v[3][2]);  m[21] = static_cast<double>(this->v[3][3]);  m[22] = static_cast<double>(this->v[3][4]);  m[23] = static_cast<double>(this->v[3][5]);
    m[24] = static_cast<double>(this->v[4][0]);  m[25] = static_cast<double>(this->v[4][1]);  m[26] = static_cast<double>(this->v[4][2]);  m[27] = static_cast<double>(this->v[4][3]);  m[28] = static_cast<double>(this->v[4][4]);  m[29] = static_cast<double>(this->v[4][5]);
    m[30] = static_cast<double>(this->v[5][0]);  m[31] = static_cast<double>(this->v[5][1]);  m[32] = static_cast<double>(this->v[5][2]);  m[33] = static_cast<double>(this->v[5][3]);  m[34] = static_cast<double>(this->v[5][4]);  m[35] = static_cast<double>(this->v[5][5]);
  }
  ML_CATCH_RETHROW;
}


//-------------------------------------------------------------------
//-------------------------------------------------------------------
template <class DT>
void Tmat6<DT>::setScaleMatrix(const DT scale)
{
  ML_TRACE_IN("Tmat6<DT>::setScaleMatrix( )");
  ML_TRY
  {
    this->v[0][0] = scale;   this->v[0][1] =     0;   this->v[0][2] =     0;   this->v[0][3] =     0;   this->v[0][4] =     0;   this->v[0][5] =     0;
    this->v[1][0] =     0;   this->v[1][1] = scale;   this->v[1][2] =     0;   this->v[1][3] =     0;   this->v[1][4] =     0;   this->v[1][5] =     0;
    this->v[2][0] =     0;   this->v[2][1] =     0;   this->v[2][2] = scale;   this->v[2][3] =     0;   this->v[2][4] =     0;   this->v[2][5] =     0;
    this->v[3][0] =     0;   this->v[3][1] =     0;   this->v[3][2] =     0;   this->v[3][3] = scale;   this->v[3][4] =     0;   this->v[3][5] =     0;
    this->v[4][0] =     0;   this->v[4][1] =     0;   this->v[4][2] =     0;   this->v[4][3] =     0;   this->v[4][4] = scale;   this->v[4][5] =     0;
    this->v[5][0] =     0;   this->v[5][1] =     0;   this->v[5][2] =     0;   this->v[5][3] =     0;   this->v[5][4] =     0;   this->v[5][5] = scale;
  }
  ML_CATCH_RETHROW;
}

//-------------------------------------------------------------------

//-------------------------------------------------------------------

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT>
DT Tmat6<DT>::determinantLower5(const int col1, const int col2, const int col3, const int col4, const int col5) const
{
  ML_TRACE_IN("Tmat6<DT>::determinantLower5()");
  
  DT determ = 0;
  ML_TRY
  {
    /* Determinant of 5x5 matrix with given entries */
    determ = Tmat5<DT>(this->v[1][col1], this->v[1][col2], this->v[1][col3], this->v[1][col4], this->v[1][col5],
                       this->v[2][col1], this->v[2][col2], this->v[2][col3], this->v[2][col4], this->v[2][col5],
                       this->v[3][col1], this->v[3][col2], this->v[3][col3], this->v[3][col4], this->v[3][col5],
                       this->v[4][col1], this->v[4][col2], this->v[4][col3], this->v[4][col4], this->v[4][col5],
                       this->v[5][col1], this->v[5][col2], this->v[5][col3], this->v[5][col4], this->v[5][col5]).det();
  }
  ML_CATCH_RETHROW;
  return determ;
}

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT>
DT Tmat6<DT>::det() const
{
  ML_TRACE_IN("Tmat6<DT>::det()");
  
  DT determ = 0;
  ML_TRY
  {
    determ = (  this->v[0][0] * determinantLower5(1, 2, 3, 4, 5)
              - this->v[0][1] * determinantLower5(0, 2, 3, 4, 5)
              + this->v[0][2] * determinantLower5(0, 1, 3, 4, 5)
              - this->v[0][3] * determinantLower5(0, 1, 2, 4, 5)
              + this->v[0][4] * determinantLower5(0, 1, 2, 3, 5)
              - this->v[0][5] * determinantLower5(0, 1, 2, 3, 4));
  }
  ML_CATCH_RETHROW;
  return determ;
}

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT>
Tmat6<DT> Tmat6<DT>::inverse(bool* isInvertible) const
{
  ML_TRACE_IN("Tmat6<DT>::inverse( )");
  
  Tmat6<DT> retVal;
  ML_TRY
  {
    // Epsilon for comparison with 0 in inversion process.
    static const DT Epsilon = static_cast<DT>(10e-12);
    
    // Use helper function from tools to invert the matrix.
    retVal = MLInverseMatHelper(*this,
                                isInvertible,
                                Epsilon,
                                "Tmat6<DT> Tmat6<DT>::inverse(bool* isInvertible) const, matrix not invertable",
                                getIdentity(),
                                6);
  }
  ML_CATCH_RETHROW;
  return retVal;
}


//-------------------------------------------------------------------
//-------------------------------------------------------------------
template <class DT>
Tmat6<DT> Tmat6<DT>::transpose() const
{
  ML_TRACE_IN("Tmat6<DT>::transpose()");
  
  return Tmat6<DT>(Tvec6<DT>(this->v[0][0], this->v[1][0], this->v[2][0], this->v[3][0], this->v[4][0], this->v[5][0]),
                   Tvec6<DT>(this->v[0][1], this->v[1][1], this->v[2][1], this->v[3][1], this->v[4][1], this->v[5][1]),
                   Tvec6<DT>(this->v[0][2], this->v[1][2], this->v[2][2], this->v[3][2], this->v[4][2], this->v[5][2]),
                   Tvec6<DT>(this->v[0][3], this->v[1][3], this->v[2][3], this->v[3][3], this->v[4][3], this->v[5][3]),
                   Tvec6<DT>(this->v[0][4], this->v[1][4], this->v[2][4], this->v[3][4], this->v[4][4], this->v[5][4]),
                   Tvec6<DT>(this->v[0][5], this->v[1][5], this->v[2][5], this->v[3][5], this->v[4][5], this->v[5][5]));
}

//-------------------------------------------------------------------
//-------------------------------------------------------------------
template <class DT>
Tmat6<DT> Tmat6<DT>::getIdentity()
{
  ML_TRACE_IN("Tmat6<DT>::getIdentity()");
  
  return Tmat6<DT>(Tvec6<DT>(1,0,0,0,0,0),
                   Tvec6<DT>(0,1,0,0,0,0),
                   Tvec6<DT>(0,0,1,0,0,0),
                   Tvec6<DT>(0,0,0,1,0,0),
                   Tvec6<DT>(0,0,0,0,1,0),
                   Tvec6<DT>(0,0,0,0,0,1));
}

//-------------------------------------------------------------------
//-------------------------------------------------------------------
template <class DT>
const Tmat6<DT> & Tmat6<DT>::apply(MLDblFuncPtr fct)
{
  ML_TRACE_IN("Tmat6<DT>::apply(MLDblFuncPtr fct)");
  ML_TRY
  {
    this->v[0].apply(fct);
    this->v[1].apply(fct);
    this->v[2].apply(fct);
    this->v[3].apply(fct);
    this->v[4].apply(fct);
    this->v[5].apply(fct);
  }
  ML_CATCH_RETHROW;
  return *this;
}


#define _ML_MAT6_RC(i, j) a[i][0]*b[0][j] + a[i][1]*b[1][j] + a[i][2]*b[2][j] + \
a[i][3]*b[3][j] + a[i][4]*b[4][j] + a[i][5]*b[5][j]
//-------------------------------------------------------------------
//-------------------------------------------------------------------
template <class DT>
Tmat6<DT> operator*(const Tmat6<DT> &a, const Tmat6<DT> &b)
{
  ML_TRACE_IN_TIME_CRITICAL("mlMmat6.h: operator*(const Tmat6<DT> &a, const Tmat6<DT> &b)");
  
  
  return Tmat6<DT>(Tvec6<DT>(_ML_MAT6_RC(0,0), _ML_MAT6_RC(0,1), _ML_MAT6_RC(0,2), _ML_MAT6_RC(0,3), _ML_MAT6_RC(0,4), _ML_MAT6_RC(0,5)),
                   Tvec6<DT>(_ML_MAT6_RC(1,0), _ML_MAT6_RC(1,1), _ML_MAT6_RC(1,2), _ML_MAT6_RC(1,3), _ML_MAT6_RC(1,4), _ML_MAT6_RC(1,5)),
                   Tvec6<DT>(_ML_MAT6_RC(2,0), _ML_MAT6_RC(2,1), _ML_MAT6_RC(2,2), _ML_MAT6_RC(2,3), _ML_MAT6_RC(2,4), _ML_MAT6_RC(2,5)),
                   Tvec6<DT>(_ML_MAT6_RC(3,0), _ML_MAT6_RC(3,1), _ML_MAT6_RC(3,2), _ML_MAT6_RC(3,3), _ML_MAT6_RC(3,4), _ML_MAT6_RC(3,5)),
                   Tvec6<DT>(_ML_MAT6_RC(4,0), _ML_MAT6_RC(4,1), _ML_MAT6_RC(4,2), _ML_MAT6_RC(4,3), _ML_MAT6_RC(4,4), _ML_MAT6_RC(4,5)),
                   Tvec6<DT>(_ML_MAT6_RC(5,0), _ML_MAT6_RC(5,1), _ML_MAT6_RC(5,2), _ML_MAT6_RC(5,3), _ML_MAT6_RC(5,4), _ML_MAT6_RC(5,5)));
}
#undef _ML_MAT6_RC

//-------------------------------------------------------------------
//-------------------------------------------------------------------
template <class DT>
bool operator==(const Tmat6<DT> &a, const Tmat6<DT> &b)
{
  ML_TRACE_IN_TIME_CRITICAL("mlMmat6.h: operator==(const Tmat6<DT> &a, const Tmat6<DT> &b)");
  
  return (a[0] == b[0]) &&
  (a[1] == b[1]) &&
  (a[2] == b[2]) &&
  (a[3] == b[3]) &&
  (a[4] == b[4]) &&
  (a[5] == b[5]);
}

//-------------------------------------------------------------------
//-------------------------------------------------------------------
template <class DT>
bool operator!=(const Tmat6<DT> &a, const Tmat6<DT> &b)
{
  ML_TRACE_IN_TIME_CRITICAL("mlMmat6.h: operator!=(const Tmat6<DT> &a, const Tmat6<DT> &b)");
  
  return !(a == b);
}

#define _ML_MAT6_RC(i) a[i][0]*v[0] + a[i][1]*v[1] + a[i][2]*v[2] + a[i][3]*v[3] + a[i][4]*v[4] + a[i][5]*v[5]
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class DT>
inline Tvec6<DT> operator*(const Tmat6<DT>& a, const Tvec6<DT>& v)
{
  ML_TRACE_IN_TIME_CRITICAL("mlMmat6.h: operator*(const Tmat6<DT>& a, const Tvec6<DT>& v)");
  
  return Tvec6<DT>(_ML_MAT6_RC(0), _ML_MAT6_RC(1), _ML_MAT6_RC(2), _ML_MAT6_RC(3), _ML_MAT6_RC(4), _ML_MAT6_RC(5));
}
#undef _ML_MAT6_RC

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class DT>
inline Tvec6<DT> operator*(const Tvec6<DT>& v, const Tmat6<DT>& a)
{
  ML_TRACE_IN_TIME_CRITICAL("mlMmat6.h: operator*(const Tvec6<DT>& v, const Tmat6<DT>& a)");
  
  return a.transpose() * v;
}


//-----------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------

typedef Tmat6<MLfloat>   Matrix6f;
typedef Tmat6<MLdouble>  Matrix6d;
typedef Tmat6<MLldouble> Matrix6ld;
typedef Tmat6<MLdouble>  Matrix6;


#ifdef ML_DEPRECATED



ML_DEPRECATED typedef Tmat6<MLfloat>   matf6;
ML_DEPRECATED typedef Tmat6<MLdouble>  matd6;
ML_DEPRECATED typedef Tmat6<MLldouble> matld6;
ML_DEPRECATED typedef Tmat6<MLdouble> mat6;


#endif // ML_DEPRECATED



ML_LA_END_NAMESPACE

namespace std
{
  //-------------------------------------------------------------------
  //-------------------------------------------------------------------
  template <class DT>
  inline std::ostream& operator<<(std::ostream& os, const ML_LA_NAMESPACE::Tmat6<DT> & m)
  {
    return os << m[0] << '\n' << m[1] << '\n' << m[2] << '\n' << m[3] << '\n' << m[4] << '\n' << m[5];
  }
  
  //-------------------------------------------------------------------
  //-------------------------------------------------------------------
  template <class DT>
  inline std::istream& operator>>(std::istream& is, ML_LA_NAMESPACE::Tmat6<DT> & m)
  {
    ML_LA_NAMESPACE::Tmat6<DT> m_tmp;
    
    is >> m_tmp[0] >> m_tmp[1] >> m_tmp[2] >> m_tmp[3] >> m_tmp[4] >> m_tmp[5];
    if (is){ m = m_tmp; }
    return is;
  }
}


#endif // __mlMatrix6_H