mlFloatingPointMatrix.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2012, 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_FLOATING_POINT_MATRIX_H
#define ML_FLOATING_POINT_MATRIX_H

 
//------------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "mlLinearAlgebraSystem.h"
 
#include <mlPrintTemplateErrors.h>
 
//------------------------------------------------------------------------
// Put all code 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 = static_cast<int>(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 \e 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.
  // \p idx has to be smaller than ComponentCount. Other idx values must be avoided by the caller,
  // as they lead to an error post and the return of the 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,
  // as they lead to an error post and the return of the value at index 0.
  ComponentType linearIndexedConst(const size_t idx) const;
 
  // Returns the sum of all absolute 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
{
  if (i >= size){
    printTemplateError("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)
{
  if (i >= size){
    printTemplateError("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)
{
  if (idx < ComponentCount) {
    return v[idx/VectorT::Size][idx%VectorT::Size];
  } else {
    printTemplateError("FloatingPointMatrix::linearIndexed(), illegal index", ML_BAD_INDEX, "Using index 0 instead");
  }
  return v[0][0];
}
 
//-----------------------------------------------------------------------------------
 
template <class VectorT, size_t size>
inline typename VectorT::ComponentType FloatingPointMatrix<VectorT,size>::linearIndexedConst(const size_t idx) const
{
  typename VectorT::ComponentType retVal = v[0][0];
  if (idx < ComponentCount) {
    retVal = v[idx/VectorT::Size][idx%VectorT::Size];
  } else {
    printTemplateError("FloatingPointMatrix::linearIndexedConst(), illegal index", ML_BAD_INDEX, "Using index 0 instead");
  }
  return retVal;
}
 
//-----------------------------------------------------------------------------------
 
template <class VectorT, size_t size>
inline typename VectorT::ComponentType FloatingPointMatrix<VectorT,size>::compAbsSum() const
{
  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)
{
  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++];
    }
  }
}
 
//-----------------------------------------------------------------------------------
 
template <class VectorT, size_t size>
void FloatingPointMatrix<VectorT,size>::getValuesToPtr(ComponentType* values) const
{
  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_LA_END_NAMESPACE
 
 
#endif // __mlFloatingPointVector_H