SimpleMatrix.h

#pragma once

#if defined(SimpleMatrix_RECURSES)
#error Recursive header files inclusion detected in SimpleMatrix.h
#else // defined(SimpleMatrix_RECURSES)

#define SimpleMatrix_RECURSES

#if !defined SimpleMatrix_h

#define SimpleMatrix_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/CEuclideanRing.h"
#include "DGtal/kernel/PointVector.h"
#include "DGtal/kernel/NumberTraits.h"

namespace DGtal
{

  // template class SimpleMatrix
  template <typename TComponent, DGtal::Dimension TM, DGtal::Dimension TN>
  class SimpleMatrix
  {

  public:
    typedef TComponent Component;
    static const DGtal::Dimension M = TM;
    static const DGtal::Dimension N = TN;
    
    typedef PointVector<N,Component> RowVector;
    typedef PointVector<M,Component> ColumnVector;

    typedef SimpleMatrix<Component,TM,TN> Self;

    BOOST_CONCEPT_ASSERT(( CEuclideanRing<TComponent> ));
    BOOST_STATIC_ASSERT(TM > 0 );
    BOOST_STATIC_ASSERT(TM > 0 );
    
    SimpleMatrix();

    SimpleMatrix ( const Self & other );

    // ----------------------- Standard services ------------------------------

    void clear();


    void constant(const Component &aScalar);

    void identity();

    RowVector row(const DGtal::Dimension i) const;

    ColumnVector column(const DGtal::Dimension j) const;

    void setComponent(const DGtal::Dimension i, const DGtal::Dimension j,
                      const Component & aValue);

    Component operator()(const DGtal::Dimension i, const DGtal::Dimension j) const;

    // ----------------------- SimpleMatrix computations ------------------------------


    bool operator==(const Self & aMatrix) const;

    template<typename TComponentOther>
    Self & operator=(const SimpleMatrix<TComponentOther, M, N>& aMatrix);

    Self  operator+(const Self & aMatrix) const;

    Self & operator+=(const Self & aMatrix);


    Self  operator-(const Self & aMatrix) const;

    Self & operator-=(const Self & aMatrix);

    Self  operator*(const Component & aScalar) const;
 
    Self & operator*=(const Component & aScalar);
 
    Self  operator/(const Component & aScalar) const;

    Self & operator/=(const Component & aScalar) ;
    
    SimpleMatrix<Component,TM,TM>  
    operator*(const SimpleMatrix<Component,N,M> & aMatrix) const;
    
   
    ColumnVector  operator*(const RowVector & aVector) const;
    
   
    SimpleMatrix<Component,TN,TM> transpose() const;


    Component cofactor(const DGtal::Dimension i,
                       const DGtal::Dimension j) const;
    
    
    Self cofactor() const;
     
    Component minorDeterminant(const DGtal::Dimension i, 
                               const DGtal::Dimension j) const;

   
    Component determinant() const;
    
    SimpleMatrix<Component,TM,TN> inverse() const;


    ~SimpleMatrix();

    // ----------------------- Interface --------------------------------------
  public:

    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;

    // ------------------------- Protected Datas ------------------------------
  private:
 
    
    // ------------------------- Private Datas --------------------------------
  private:
    
#ifdef CPP11_ARRAY

    std::array< Component, M*N>  myValues;

    std::array< Component, M*N>  myCofactorCoefs;
#else

    boost::array< Component, M*N>  myValues;

    boost::array< Component, M*N>  myCofactorCoefs;
#endif
    // ------------------------- Hidden services ------------------------------
  protected:

  }; // end of class SimpleMatrix

  template <typename T, DGtal::Dimension M, DGtal::Dimension N>
  std::ostream&
  operator<< ( std::ostream & out, const SimpleMatrix<T,M,N> & object );

} // namespace DGtal


// Includes inline functions.
#include "DGtal/kernel/SimpleMatrixSpecializations.h"
#include "DGtal/kernel/SimpleMatrix.ih"

//                                                                           //

#endif // !defined SimpleMatrix_h

#undef SimpleMatrix_RECURSES
#endif // else defined(SimpleMatrix_RECURSES)