MeVis/Foundation/Sources/MLLinearAlgebra/mlFloatingPointMatrix.h

Go to the documentation of this file.

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

//=====================================================================================
#ifndef __mlFloatingPointMatrix_H
#define __mlFloatingPointMatrix_H

//------------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#ifndef __mlLinearAlgebraSystem_H
#include "mlLinearAlgebraSystem.h"
#endif

//------------------------------------------------------------------------
// Put all stuff in a specific ML_LA_NAMESPACE namespace to avoid
// collisions with other libraries.
//------------------------------------------------------------------------
ML_LA_START_NAMESPACE

template <class VectorT, size_t size>
class FloatingPointMatrix
{
public:
  typedef typename VectorT::ComponentType ComponentType;

  typedef VectorT VectorType;

  enum { RowCount = size };

  enum { ColumnCount = VectorT::Size };

  enum { ComponentCount = RowCount*ColumnCount };

  // Constant indexed read access to row vectors, indexes must not exceed the valid range or errors will occur
  // and the value for index 0 is returned.
  const VectorT& operator[](const size_t i) const;
  
  // Indexed read/write access to row vectors, indexes must not exceed the valid range or errors will occur
  // and the value for index 0 is returned.
  VectorT& operator[](const size_t i);

  // Linear read/write access to matrix elements correctly ordered starting 
  // with first, second, ... elements of first row up to last element in last row.
  // The first DT may NOT be used as an array base to address all DTs directly
  // in memory since values are organized as vectors and not as an array.
  // idx has to be smaller than ComponentCount. Other idx values must be avoided by the caller,
  // because they lead to an error post and a the return of value at index 0.
  ComponentType &linearIndexed(const size_t idx);
  
  // Linear and constant read access to matrix elements correctly ordered starting 
  // with first, second, ... elements of first row up to last element in last row.
  // idx has to be smaller than ComponentCount. Other idx values must be avoided by the caller,
  // because they lead to an error post and a the return of value at index 0.
  ComponentType linearIndexedConst(const size_t idx) const;
 
  // Return sum of all MLAbs values of all matrix elements. This is useful
  // for testing differences of matrices less than a certain value.
  ComponentType compAbsSum() const;

  void setValuesFromPtr(const ComponentType* const values);
  
  void getValuesToPtr(ComponentType* values) const;
  
protected:
  VectorT v[size];
};

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

template <class VectorT, size_t size>
const VectorT& FloatingPointMatrix<VectorT,size>::operator[](const size_t i) const
{
  ML_TRACE_IN_TIME_CRITICAL("FloatingPointMatrix::operator[] const");
  
  if (i >= size){
    ML_PRINT_ERROR("FloatingPointMatrix::operator[] const, illegal index", ML_BAD_INDEX, "Using index 0");
    return v[0];
  }
  return v[i];
}

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

template <class VectorT, size_t size>
VectorT& FloatingPointMatrix<VectorT,size>::operator[](const size_t i)
{
  ML_TRACE_IN_TIME_CRITICAL("FloatingPointMatrix::operator[]");
  
  if (i >= size){
    ML_PRINT_ERROR("FloatingPointMatrix::operator[], illegal index", ML_BAD_INDEX, "Using index 0");
    return v[0];
  }
  return v[i];
}

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

template <class VectorT, size_t size>
inline typename VectorT::ComponentType &FloatingPointMatrix<VectorT,size>::linearIndexed(const size_t idx)
{
  ML_TRACE_IN_TIME_CRITICAL("FloatingPointMatrix::linearIndexed()");
  ML_TRY
  {
    if (idx < ComponentCount) {
      return v[idx/VectorT::Size][idx%VectorT::Size];
    } else {
      ML_PRINT_ERROR("FloatingPointMatrix::linearIndexed(), illegal index", ML_BAD_INDEX, "Using index 0 instead");
    }
  }
  ML_CATCH_RETHROW;
  return v[0][0];
}

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

template <class VectorT, size_t size>
inline typename VectorT::ComponentType FloatingPointMatrix<VectorT,size>::linearIndexedConst(const size_t idx) const
{
  ML_TRACE_IN_TIME_CRITICAL("FloatingPointMatrix::linearIndexedConst()");
  
  typename VectorT::ComponentType retVal = v[0][0];
  ML_TRY
  {
    if (idx < ComponentCount) {
      retVal = v[idx/VectorT::Size][idx%VectorT::Size];
    } else {
      ML_PRINT_ERROR("FloatingPointMatrix::linearIndexedConst(), illegal index", ML_BAD_INDEX, "Using index 0 instead");
    }
  }
  ML_CATCH_RETHROW;
  return retVal;
}

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

template <class VectorT, size_t size>
inline typename VectorT::ComponentType FloatingPointMatrix<VectorT,size>::compAbsSum() const 
{
  ML_TRACE_IN_TIME_CRITICAL("FloatingPointMatrix::compAbsSum()");
  
  typename VectorT::ComponentType retVal = 0;
  for (size_t i=0;i<RowCount;i++) {
      for (size_t j=0;j<ColumnCount;j++) {
        retVal += MLAbs(v[i][j]);
      }
  }
  return retVal;
}

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

template <class VectorT, size_t size>
void FloatingPointMatrix<VectorT,size>::setValuesFromPtr(const ComponentType* const values)
{
  ML_TRACE_IN_TIME_CRITICAL("FloatingPointMatrix::setValuesFromPtr");
  ML_TRY
  {
    size_t n = 0;
    for (size_t i=0;i<RowCount;i++) {
      for (size_t j=0;j<ColumnCount;j++) {
        v[i][j] = values[n++];
      }
    }
  }
  ML_CATCH_RETHROW;
}

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

template <class VectorT, size_t size>
void FloatingPointMatrix<VectorT,size>::getValuesToPtr(ComponentType* values) const
{
  ML_TRACE_IN_TIME_CRITICAL("FloatingPointMatrix::getValuesFromPtr");
  ML_TRY
  {
    size_t n = 0;
    for (size_t i=0;i<RowCount;i++) {
      for (size_t j=0;j<ColumnCount;j++) {
        values[n++] = v[i][j];
      }
    }
  }
  ML_CATCH_RETHROW;
}

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

ML_LA_END_NAMESPACE


#endif // __mlFloatingPointVector_H