mlMatrix2.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_MATRIX2_H
#define ML_MATRIX2_H

 
// Include system independency file and project settings.
#include "mlLinearAlgebraSystem.h"
#include "mlLinearAlgebraDefs.h"
 
 
#include "mlFloatingPointMatrix.h"
 
#include "mlVector2.h"
 
// 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.
  //---------------------------------------------------------------
  // Constructs a matrix from four zero elements.
  Tmat2();
 
  // Constructs a matrix that has the argument \p diagValue as the diagonal values, zero otherwise.
  Tmat2(const DT diagValue);
 
  // Composes a matrix from the two row vectors \p row0 and \p row1.
  Tmat2(const Tvec2<DT>& row0,
        const Tvec2<DT>& row1);
 
  // Copy constructor from the Tmat2 \p mat.
  Tmat2(const Tmat2<DT>& mat);
 
  // Constructor from four floating point values in an array given by \p mat, row by row.
  Tmat2(const float mat[4]);
 
  // Constructor from four double values in an array given by \p mat, row by row.
  Tmat2(const double mat[4]);
 
  // Initializes all matrix elements explicitly with scalars,
  // filling it row by row.
  Tmat2(const DT in00, const DT in01,
        const DT in10, const DT in11);
 
  // Copies contents from float array \p mat into *this, row by row.
  void setValues(const float mat[4]);
 
  // Copies contents of *this into float array \p 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;
 
  // Copies contents from DT array \p mat into *this, row by row.
  void setValues(const double mat[4]);
 
  // Copies contents of *this into DT array \p mat, row by row.
  void getValues(double mat[4]) const;
 
  // Returns a matrix filled with values \p val.
  static Tmat2<DT> getMat(const DT val);
 
  // Sets all values to \p val.
  void set(const DT val);
 
  // Returns the identity matrix.
  static Tmat2<DT> getIdentity();
 
  // Sets a diagonal matrix with \p scale on the diagonal.
  void setScaleMatrix(const DT scale);
 
 
  //---------------------------------------------------------------
  // Operators and indexing functionality.
  //---------------------------------------------------------------
  bool operator<(const Tmat2<DT> &) const { return false; }
 
  // Assigns from a Tmat2.
  const Tmat2<DT>& operator=(const Tmat2<DT>& m);
 
  // Increments by a Tmat2.
  const Tmat2<DT>& operator+=(const Tmat2<DT>& m);
 
  // Decrements by a Tmat2.
  const Tmat2<DT>& operator-=(const Tmat2<DT>& m);
 
  // Multiplies by a constant \p d.
  const Tmat2<DT>& operator*=(const DT d);
 
  // Divides by a constant \p d. Division by zero is not handled and must be avoided by caller.
  const Tmat2<DT>& operator/=(const DT d);
 
 
  //---------------------------------------------------------------
  // Special functions
  //---------------------------------------------------------------
  // Returns the determinant of the matrix.
  DT det() const;
 
  // Transposes the matrix.
  Tmat2<DT> transpose() const;
 
  // Returns the inverse.
  // If a non-NULL boolean pointer is passed to isInvertible,
  // then \c true is returned in *isInvertible in the case of a
  // successful inversion or \c false if the inversion is not possible
  // (function returns 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=nullptr) const;
 
  // Applies the function \p fct to each component.
  const Tmat2<DT>& apply(MLDblFuncPtr fct);
 
}; // end of class *Tmat2*
 
 
 
//---------------------------------------------------------------
//---------------------------------------------------------------
template <class DT>
inline Tmat2<DT>::Tmat2()
{
  this->v[0] = this->v[1] = Tvec2<DT>(0);
}

template <class DT>
inline Tmat2<DT>::Tmat2(const DT 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)
{
  this->v[0] = row0;
  this->v[1] = row1;
}

template <class DT>
inline 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])
{
  setValues(mat);
}

template <class DT>
inline 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)
{
  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])
{
  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]);
}

template <class DT>
inline void Tmat2<DT>::setValues(const double mat[4])
{
  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]);
}

template <class DT>
inline void Tmat2<DT>::getValues(float mat[4]) const
{
  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]);
}

template <class DT>
inline void Tmat2<DT>::getValues(double mat[4]) const
{
  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]);
}

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

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

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

template <class DT>
inline void 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
{
  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
{
  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)
{
  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 \c true is returned in *isInvertible in the case of a
// successful inversion or \c false if the inversion is not possible
// (function returns 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
{
  // Matrix to be returned.
  Tmat2<DT> retMat;
  // Determinant must be non-zero.
  DT determinant = det();
  if (MLValueIs0WOM(determinant)) {
    if (isInvertible == nullptr){
      printTemplateError("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 != nullptr){ *isInvertible = true; }
  }
  return retMat;
}

 
 
 
//---------------------------------------------------------------
//---------------------------------------------------------------
template <class DT>
inline const Tmat2<DT>& 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)
{
  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)
{
  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)
{
  this->v[0] *= d;
  this->v[1] *= d;
  return *this;
}

template <class DT>
inline const Tmat2<DT>& Tmat2<DT>::operator/=(const DT d)
{
  this->v[0] /= d;
  this->v[1] /= d;
  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)
{
  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)
{
  return ((a[0] == b[0]) &&
          (a[1] == b[1]));
}

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

 
 
//---------------------------------------------------------------
//---------------------------------------------------------------
template <class DT>
inline Tmat2<DT> 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)
{
  return Tmat2<DT>(a) += b;
}

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

template <class DT>
inline Tmat2<DT> 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)
{
  return Tmat2<DT>(a) *= d;
}

template <class DT>
inline Tmat2<DT> operator/(const Tmat2<DT>& a, const DT d)
{
  Tmat2<DT> divi(a);
  divi /= d;
  return divi;
}

template <class DT>
inline Tvec2<DT> 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)
{
  return a.transpose() * v;
}

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

typedef Tmat2<MLfloat>   Matrix2f;
typedef Tmat2<MLdouble>  Matrix2d;
typedef Tmat2<MLldouble> Matrix2ld;
typedef Tmat2<MLdouble>  Matrix2;
 
ML_LA_END_NAMESPACE
 
//-------------------------------------------------------------------
// Support for standard I/O 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