matrix.h

Go to the documentation of this file.

/* Copyright (C) 2000-2013 CEA
 *
 * This software and supporting documentation were developed by
 *     bioPICSEL
 *     CEA/DSV/I²BM/MIRCen/LMN, Batiment 61,
 *     18, route du Panorama
 *     92265 Fontenay-aux-Roses
 *     France
 */

#ifndef PRIMATOLOGIST_MATH_MATRIX_H
#define PRIMATOLOGIST_MATH_MATRIX_H

#include <cartodata/volume/volume.h>                    // carto::VolumeRef
#include <cartobase/type/string_conversion.h>           // carto::toString
#include <exception>                                    // std::logic_error
#include <string>                                       // std::string
#include <vector>                                       // std::vector

namespace aims {
namespace math {

  //==========================================================================
  //   MATRIX TYPEDEFS
  //==========================================================================
  template <typename T> class MatrixBase;
  typedef MatrixBase<float>   Matrix;
  typedef MatrixBase<double>  MatrixD;
  typedef MatrixBase<float>   Vector;
  typedef MatrixBase<double>  VectorD;

  //==========================================================================
  //   UTILITY FUNCTIONS
  //==========================================================================
  template <typename T>
  MatrixBase<T> asMatrix( carto::VolumeRef<T> & volume );

  //==========================================================================
  //   BASE CLASS FOR MATRICES
  //==========================================================================
  template <typename T>
  class MatrixBase: public carto::VolumeRef<T>
  {
  public:
    //------------------------------------------------------------------------
    //   CONSTRUCTOR / DESTRUCTOR / COPY
    //------------------------------------------------------------------------
    MatrixBase( int nrow = 1, int ncol = 1 );
    template <typename U>
    MatrixBase( const carto::VolumeRef<U> & volume );
    template <typename U>
    MatrixBase( const std::vector<U> & vector );
    ~MatrixBase();
    template <typename U>
    MatrixBase<T> & operator= ( const carto::VolumeRef<U> & matrix );
    template <typename U>
    MatrixBase<T> & operator= ( const std::vector<U> & vector );
    //------------------------------------------------------------------------
    //   CONVERSIONS
    //------------------------------------------------------------------------
    template <typename U>
    operator MatrixBase<U>() const;
    //------------------------------------------------------------------------
    //   MATRIX OPERATIONS
    //------------------------------------------------------------------------
    template <typename U>
    MatrixBase<T> & operator*= ( const MatrixBase<U> & );
    MatrixBase<T> & transpose();
    MatrixBase<T> & invert();
    double trace() const;
    //------------------------------------------------------------------------
    //   SIZE
    //------------------------------------------------------------------------
    int nrow() const;
    int ncol() const;
    int size() const;

    //------------------------------------------------------------------------
    //   PRIVATE SHARED MEMORY CONSTRUCTOR
    //------------------------------------------------------------------------
    friend MatrixBase<T> asMatrix<>( carto::VolumeRef<T> & );
  private:
    MatrixBase( carto::VolumeRef<T> & );
  };

  //==========================================================================
  //   MATRIX OPERATIONS
  //==========================================================================
  template <typename T, typename U>
  MatrixBase<typename carto::volumeutil::multiplies<T,U>::result_type>
  operator* ( const MatrixBase<T> & a, const MatrixBase<U> & b );
  template <typename T>
  MatrixBase<T> transpose( const MatrixBase<T> & );
  template <typename T>
  MatrixBase<T> invert( const MatrixBase<T> & );

  //==========================================================================
  //   OVERLOAD OPERATORS
  //==========================================================================
  template <typename T, typename U>
  bool operator== ( const MatrixBase<T> & vol, const MatrixBase<U> & other );
  template <typename T, typename U>
  bool operator!= ( const MatrixBase<T> & vol, const MatrixBase<U> & other );
  template <typename T>
  MatrixBase<T> operator- ( const MatrixBase<T> & vol );
  template <typename T, typename U>
  MatrixBase<typename carto::volumeutil::plus<T,U>::result_type >
  operator+ ( const MatrixBase<T> & vol, const U & value );
  template <typename T, typename U>
  MatrixBase<typename carto::volumeutil::minus<T,U>::result_type >
  operator- ( const MatrixBase<T> & vol, const U & value );
  template <typename T, typename U>
  MatrixBase<typename carto::volumeutil::multiplies<T,U>::result_type >
  operator* ( const MatrixBase<T> & vol, const U & value );
  template <typename T, typename U>
  MatrixBase<typename carto::volumeutil::divides<T,U>::result_type >
  operator/ ( const MatrixBase<T> & vol, const U & value );
  // Scalar + Matrix
  template <typename T, typename U>
  MatrixBase<typename carto::volumeutil::plus<U,T>::result_type >
  operator+ ( const U & value, const MatrixBase<T> & vol );
  // Scalar - Matrix
  template <typename T, typename U>
  MatrixBase<typename carto::volumeutil::minus<U,T>::result_type >
  operator- ( const U & value, const MatrixBase<T> & vol );
  // Scalar * Matrix
  template <typename T, typename U>
  MatrixBase<typename carto::volumeutil::multiplies<U,T>::result_type >
  operator* ( const U & value, const MatrixBase<T> & vol );
  // Scalar / Matrix
  template <typename T, typename U>
  MatrixBase<typename carto::volumeutil::divides<U,T>::result_type >
  operator/ ( const U & value, const MatrixBase<T> & vol );
  // Matrix + Matrix
  template <typename T, typename U>
  MatrixBase<typename carto::volumeutil::plus<T,U>::result_type >
  operator+ ( const MatrixBase<T> & vol, const MatrixBase<U> & other );
  // Matrix - Matrix
  template <typename T, typename U>
  MatrixBase<typename carto::volumeutil::minus<T,U>::result_type >
  operator- ( const MatrixBase<T> & vol, const MatrixBase<U> & other );

  //==========================================================================
  //   STREAM / WRITE
  //==========================================================================
  template <typename T>
  std::ostream & operator<< ( std::ostream & out,
                              const MatrixBase<T> & matrix );
  template <typename T>
  void write( const MatrixBase<T> & matrix, const std::string & file );

  //==========================================================================
  //   EXCEPTION CLASS
  //==========================================================================
  class incompatible_matrix_exception: public std::logic_error
  {
  public:
    incompatible_matrix_exception( int nrow, int ncol ):
      std::logic_error( std::string("[aims::math::MatrixBase] Matrices "
        "should have compatible numbers of rows and columns for a matrix "
        "product. (") + carto::toString(ncol) + std::string(" and ") +
        carto::toString(nrow) + std::string(").") )
    {}
  };

} // namespace math
} // namespace aims

#endif // PRIMATOLOGIST_MATH_MATRIX_H