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"
#include <array>

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;

                typedef Dimension Index;
                typedef Component Scalar;

    BOOST_CONCEPT_ASSERT(( concepts::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();
    inline void setIdentity() { identity(); }

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

                inline Index rows() const { return M; }

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

                inline Index cols() const { return N; }

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

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

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

    // ----------------------- 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:

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

    std::array< Component, M*N>  myCofactorCoefs;
    
    // ------------------------- 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 );


  template <typename TComponent, DGtal::Dimension TM, DGtal::Dimension TN>
  SimpleMatrix<TComponent, TM, TN>
  operator* ( const TComponent& scalar, const SimpleMatrix<TComponent, TM, TN>& matrix);

} // namespace DGtal


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

//                                                                           //

#endif // !defined SimpleMatrix_h

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