MeVis/Foundation/Sources/MLLinearAlgebra/mlMatrix2.h

Go to the documentation of this file.

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

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

#ifndef __mlMatrix2_H
#define __mlMatrix2_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 __mlVector2_H
#include "mlVector2.h"
#endif

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

//---------------------------------------------------------------
//---------------------------------------------------------------
template <class DT>
class Tmat2 : public FloatingPointMatrix<Tvec2<DT>, 2>
{
public:
  
  typedef DT ComponentType;
  
  //---------------------------------------------------------------
  // Constructors, set and get methods.
  //---------------------------------------------------------------
  // Construct matrix from 4 zero elements.
  Tmat2();

  // Construct matrix that has the argument at the diagonal values, zero otherwise
  Tmat2(const DT diagValue);

  // Composes a matrix from the two row vectors row0 and row1.
  Tmat2(const Tvec2<DT>& row0, 
        const Tvec2<DT>& row1);
  
  // Copy constructor from the Tmat2 mat.
  Tmat2(const Tmat2<DT>& mat);
  
  // Constructor from 4 floating point values in an array given by mat, row by row.
  Tmat2(const float mat[4]);
  
  // Constructor from 4 double values in an array given by mat, row by row.
  Tmat2(const double mat[4]);
  
  // Initialize all matrix elements explicitly with scalars,
  // filling it row by row.
  Tmat2(const DT in00, const DT in01,
        const DT in10, const DT in11);
  
  // Copy contents from float array mat into *this, row by row.
  void setValues(const float mat[4]);
  
  // Copy contents of *this into float array mat, row by row.
  // Note that range and precision of the float values may not be
  // sufficient for the DT matrix contents, written row by row.
  void getValues(float mat[4]) const;
  
  // Copy contents from DT array mat into *this, row by row.
  void setValues(const double mat[4]);
  
  // Copy contents of *this into DT array mat, row by row.
  void getValues(double mat[4]) const;
  
  // Return a matrix filled with values val.
  static Tmat2<DT> getMat(const DT val);
  
  // Set all values to val.
  void set(const DT val);
  
  // Return identity matrix. 
  static Tmat2<DT> getIdentity();
  
  // Set diagonal matrix with scale on diagonal.
  void setScaleMatrix(const DT scale);
  
  
  //---------------------------------------------------------------
  // Operators and indexing functionality.
  //---------------------------------------------------------------
  bool operator<(const Tmat2<DT> &) const { return false; }
  
  // Assignment from a Tmat2.
  const Tmat2<DT>& operator=(const Tmat2<DT>& m);
  
  // Incrementation by a Tmat2.
  const Tmat2<DT>& operator+=(const Tmat2<DT>& m);
  
  // Decrement by a Tmat2.
  const Tmat2<DT>& operator-=(const Tmat2<DT>& m);
  
  // Multiplication by a constant d.
  const Tmat2<DT>& operator*=(const DT d);
  
  // Division by a constant d. Division by zero is not handled and must be avoided by caller.
  const Tmat2<DT>& operator/=(const DT d);
  
  
  //---------------------------------------------------------------
  // Special functions
  //---------------------------------------------------------------
  // Determinant.
  DT det() const;
  
  // Transpose.
  Tmat2<DT> transpose() const;
  
  // Returns the inverse. 
  // 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.
  Tmat2<DT> inverse(bool* isInvertible=NULL) const;
  
  // Apply the function fct to each component.
  const Tmat2<DT>& apply(MLDblFuncPtr fct);
  
}; // end of class *Tmat2*



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

//---------------------------------------------------------------
template <class DT>
inline Tmat2<DT>::Tmat2()
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::Tmat2()");
  
  this->v[0] = this->v[1] = Tvec2<DT>(0);
}

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


template <class DT>
inline Tmat2<DT>::Tmat2(const Tvec2<DT>& row0, 
                        const Tvec2<DT>& row1)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::Tmat2(row1, row2)");
  
  this->v[0] = row0;
  this->v[1] = row1;
}

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

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

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

template <class DT>
inline Tmat2<DT>::Tmat2(const DT in00, const DT in01,
                        const DT in10, const DT in11)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::Tmat2(in00, in01, in10, in11)");
  
  this->v[0][0] = in00; this->v[0][1] = in01;
  this->v[1][0] = in10; this->v[1][1] = in11;
}

template <class DT>
inline void Tmat2<DT>::setValues(const float mat[4])
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::setValues(const float mat[4])");
  ML_TRY
  {
    this->v[0][0] = static_cast<DT>(mat[0]); this->v[0][1] = static_cast<DT>(mat[1]);
    this->v[1][0] = static_cast<DT>(mat[2]); this->v[1][1] = static_cast<DT>(mat[3]);
  }
  ML_CATCH_RETHROW;
}

template <class DT>
inline void Tmat2<DT>::setValues(const double mat[4])
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::setValues(const double mat[4])");
  ML_TRY
  {
    this->v[0][0] = static_cast<DT>(mat[0]); this->v[0][1] = static_cast<DT>(mat[1]);
    this->v[1][0] = static_cast<DT>(mat[2]); this->v[1][1] = static_cast<DT>(mat[3]);
  }
  ML_CATCH_RETHROW;
}

template <class DT>
inline void Tmat2<DT>::getValues(float mat[4]) const
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::getValues(float mat[4])");
  ML_TRY
  {
    mat[0] = static_cast<float>(this->v[0][0]); mat[1] = static_cast<float>(this->v[0][1]);
    mat[2] = static_cast<float>(this->v[1][0]); mat[3] = static_cast<float>(this->v[1][1]);
  }
  ML_CATCH_RETHROW;
}

template <class DT>
inline void Tmat2<DT>::getValues(double mat[4]) const
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::getValues(double mat[4])");
  ML_TRY
  {
    mat[0] = static_cast<double>(this->v[0][0]); mat[1] = static_cast<double>(this->v[0][1]);
    mat[2] = static_cast<double>(this->v[1][0]); mat[3] = static_cast<double>(this->v[1][1]);
  }
  ML_CATCH_RETHROW;
}

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

template <class DT>
inline void Tmat2<DT>::set(const DT val)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::set()");
  
  this->v[0] = this->v[1] = Tvec2<DT>(val);
}

template <class DT>
inline Tmat2<DT> Tmat2<DT>::getIdentity()
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::getIdentity()");
  
  return Tmat2<DT>(1, 0, 0, 1);
}

template <class DT>
inline void Tmat2<DT>::setScaleMatrix(const DT scale)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::setScaleMatrix(const DT scale)");
  
  this->v[0][0] = scale; this->v[0][1] = 0; 
  this->v[1][0] = 0;     this->v[1][1] = scale;
}




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

//---------------------------------------------------------------
template <class DT>
inline DT Tmat2<DT>::det() const
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::det()");
  
  return this->v[0][0]*this->v[1][1] - this->v[0][1]*this->v[1][0];
}

template <class DT>
inline Tmat2<DT> Tmat2<DT>::transpose() const
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::transpose()");
  
  return Tmat2<DT>(Tvec2<DT>(this->v[0][0], this->v[1][0]), 
                   Tvec2<DT>(this->v[0][1], this->v[1][1]));
}

template <class DT>
inline const Tmat2<DT>& Tmat2<DT>::apply(MLDblFuncPtr fct)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::apply(MLDblFuncPtr fct)");
  
  this->v[0].apply(fct);
  this->v[1].apply(fct);
  return *this;
}

//--------------------------------------------------------------------
// Returns the inverse. 
// 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.
//--------------------------------------------------------------------
template <class DT>
Tmat2<DT> Tmat2<DT>::inverse(bool* isInvertible) const
{
  ML_TRACE_IN("Tmat2<DT>::inverse( )");
  
  // Matrix to be returned.
  Tmat2<DT> retMat;
  ML_TRY
  {
    // Determinant must be non-zero.
    DT determinant = det();
    if (MLValueIs0WOM(determinant)) {
      if (isInvertible == NULL){
        ML_PRINT_ERROR("Tmat2<DT> Tmat2<DT>::inverse() const, matrix not invertible",
                       ML_BAD_PARAMETER,
                       "Returning identity");
      }
      else{
        *isInvertible = false;
      }
      retMat = getIdentity();
    }
    else{
      // Get inverse to reduce number of expensive divisions.
      determinant = (static_cast<DT>(1))/determinant;
      retMat[0][0] =  static_cast<DT>(this->v[1][1]*determinant);
      
      retMat[1][0] =  this->v[1][0];
      retMat[1][0] *= static_cast<DT>(-determinant);
      
      retMat[0][1] =  this->v[0][1];
      retMat[0][1] *= static_cast<DT>(-determinant);
      
      retMat[1][1] =  static_cast<DT>(this->v[0][0]*determinant);
      
      // Set state and return inverse.
      if (isInvertible != NULL){ *isInvertible = true; }
    }
  }
  ML_CATCH_RETHROW;
  return retMat;
}



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

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

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

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

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

template <class DT>
inline const Tmat2<DT>& Tmat2<DT>::operator/=(const DT d)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>::operator/=(const DT d)");
  
  ML_TRY
  {
    this->v[0] /= d;
    this->v[1] /= d;
  }
  ML_CATCH_RETHROW;
  return *this;
}



//---------------------------------------------------------------
// Global operators and functions for class Tmat2
//---------------------------------------------------------------


#define _ML_MAT2_RC(i, j) a[i][0]*b[0][j] + a[i][1]*b[1][j]

// a * b. Standard matrix multiplication.
template <class DT>
inline Tmat2<DT> operator*(const Tmat2<DT>& a, const Tmat2<DT>& b)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>.h: operator*(const Tmat2<DT>& a, const Tmat2<DT>& b)");
  
  return Tmat2<DT>(
                   Tvec2<DT>(_ML_MAT2_RC(0,0), _ML_MAT2_RC(0,1)),
                   Tvec2<DT>(_ML_MAT2_RC(1,0), _ML_MAT2_RC(1,1))
                   );
}
#undef _ML_MAT2_RC

template <class DT>
inline bool operator==(const Tmat2<DT>& a, const Tmat2<DT>& b)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>.h: operator==(const Tmat2<DT>& a, const Tmat2<DT>& b)");
  
  return ((a[0] == b[0]) &&
          (a[1] == b[1]));
}

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


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

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

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

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

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

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

template <class DT>
inline Tmat2<DT> operator/(const Tmat2<DT>& a, const DT d)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>.h: operator/(const Tmat2<DT>& a, const DT d)");
  
  Tmat2<DT> divi(a);
  ML_TRY
  {
    divi /= d;
  }
  ML_CATCH_RETHROW;
  return divi;
}

template <class DT>
inline Tvec2<DT> operator*(const Tmat2<DT>& a, const Tvec2<DT>& v)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>.h: operator*(const Tmat2<DT>& a, const Tvec2<DT>& v)");
  
  return Tvec2<DT>(a[0][0]*v[0] + a[0][1]*v[1], a[1][0]*v[0] + a[1][1]*v[1]);
}

template <class DT>
inline Tvec2<DT> operator*(const Tvec2<DT>& v, const Tmat2<DT>& a)
{
  ML_TRACE_IN_TIME_CRITICAL("Tmat2<DT>.h: operator*(const Tvec2<DT>& v, const Tmat2<DT>& a)");
  
  return a.transpose() * v;
}

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

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

typedef Tmat2<MLfloat>   Matrix2f;
typedef Tmat2<MLdouble>  Matrix2d;
typedef Tmat2<MLldouble> Matrix2ld;
typedef Tmat2<MLdouble>  Matrix2;


#ifdef ML_DEPRECATED



ML_DEPRECATED typedef Tmat2<MLfloat>   matf2;
ML_DEPRECATED typedef Tmat2<MLdouble>  matd2;
ML_DEPRECATED typedef Tmat2<MLldouble> matld2;
ML_DEPRECATED typedef Tmat2<MLdouble> mat2;


#endif // ML_DEPRECATED



ML_LA_END_NAMESPACE

//-------------------------------------------------------------------
// Support for standard IO streams.
//-------------------------------------------------------------------
namespace std 
{
  template <class DT>
  inline std::ostream& operator<<(std::ostream& os, const ML_LA_NAMESPACE::Tmat2<DT> &m)
  {
    return os << m[0] << '\n' << m[1];
  }
  
  template <class DT>
  inline std::istream& operator>>(std::istream& is, ML_LA_NAMESPACE::Tmat2<DT>& m)
  {
    ML_LA_NAMESPACE::Tmat2<DT> m_tmp;
    is >> m_tmp[0] >> m_tmp[1];
    if (is){ m = m_tmp; }
    return is;
  }
}

#endif // __mlMatrix2_H