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( std::initializer_list<TComponent> values );
 
    SimpleMatrix ( const Self & other );
 
    SimpleMatrix &operator=( const Self & other ) = default;
 
    // ----------------------- 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);
 
 
    void swapRows( const DGtal::Dimension i1, const DGtal::Dimension i2 );
    
    // ----------------------- 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)