libmatricxx/src/matrix.hxx

/*! @file

    @id $Id$
*/
//       1         2         3         4         5         6         7         8
// 45678901234567890123456789012345678901234567890123456789012345678901234567890

#include <iostream>
#include <cstring>
#include <cassert>
#include <type_traits>

template<typename TYPE, size_t TROWS=0, size_t TCOLUMNS=0> class Matrix {

    //........................................................const.variables
  public:

    static const size_t ROWS = TROWS;
    static const size_t COLUMNS = TCOLUMNS;
    static const size_t SIZE = ROWS*COLUMNS;
    static const size_t MEM_SIZE = ROWS*COLUMNS*sizeof(TYPE);

    //...............................................................typedefs
  public: 

    /// @name Auxiliary Classes
    ///{

    /// Return One Row as Vector, internally used for element access
    /** Only used to access values:

        @code
        Matrix<int,4,4> m;
        m[2][2] = 1;
        @endcode */
    class RowVector {
      public:
        TYPE& operator[](size_t column) {
          return _v[column];
        }
      protected:
        friend class Matrix;
        RowVector() = delete; // forbidden
        RowVector(TYPE c[COLUMNS]): _v(c) {}
        TYPE *_v;
    };

    /// Same as RowVector, but in a constant environment.
    class ConstRowVector {
      public:
        const TYPE& operator[](size_t column) const {
          return _v[column];
        }
      protected:
        friend class Matrix;
        ConstRowVector() = delete; // forbidden
        ConstRowVector(const TYPE c[COLUMNS]): _v(c) {}
        const TYPE *_v;
    };
    
    ///}

    //................................................................methods
  public:

    /// @name construction
    ///{
    
    Matrix() {
      memset(_c, 0, MEM_SIZE);
    }
    
    template<typename ...ARGS>
        Matrix(ARGS...t): _c{std::forward<TYPE>(t)...} {
      static_assert(sizeof...(t)==SIZE, "variadic matrix initialisation requires correct array size");
    }
    
    Matrix(const Matrix& o) {
      memcpy(_c, o._c, MEM_SIZE);
    }

    ///}

    /// @name operators
    ///{
    
    Matrix& operator=(TYPE oc[ROWS][COLUMNS]) {
      memcpy(_c, oc, MEM_SIZE);
      return *this;
    }
    
    Matrix& operator=(const Matrix& o) {
      memcpy(_c, o._c, MEM_SIZE);
      return *this;
    }
    
    bool operator==(const Matrix& o) const {
      TYPE *to((TYPE*)(_c)+SIZE), *from((TYPE*)(o._c)+SIZE);
      while (to>(TYPE*)(_c)) if (*--to != *--from) return false;
      return true;
    }

    bool operator!=(const Matrix& o) const {
      return !operator==(o);
    }

    Matrix<TYPE, COLUMNS, ROWS> T() const {
      Matrix<TYPE, COLUMNS, ROWS> res;
      for (size_t row(0); row<ROWS; ++row)
        for (size_t column(0); column<COLUMNS; ++column)
          res(column, row) = operator()(row, column);
      return res;
    }
    
    Matrix operator-() const {
      Matrix res;
      for (TYPE *to((TYPE*)(res._c)+SIZE); to>(TYPE*)(_c); --to) *to = -*to;
      return res;
    }

    Matrix& operator+=(const Matrix& o) {
      TYPE *to((TYPE*)(_c)+SIZE), *from((TYPE*)(o._c)+SIZE);
      while (to>(TYPE*)(_c)) *--to += *--from;
      return *this;
    }

    Matrix& operator-=(const Matrix& o) {
      TYPE *to((TYPE*)(_c)+SIZE), *from((TYPE*)(o._c)+SIZE);
      while (to>(TYPE*)(_c)) *--to -= *--from;
      return *this;
    }

    ///}

    /// @name element access
    ///{

    TYPE& operator()(size_t row, size_t column) {
      assert(row<ROWS);
      assert(column<COLUMNS);
      return _c[row][column];
    }
    
    const TYPE& operator()(size_t row, size_t column) const {
      assert(row<ROWS);
      assert(column<COLUMNS);
      return _c[row][column];
    }
    
    RowVector operator[](size_t row) {
      assert(row<ROWS);
      return RowVector(_c[row]);
    }
    
    const ConstRowVector operator[](size_t row) const {
      assert(row<ROWS);
      return ConstRowVector(_c[row]);
    }
    
    ///}

    //..............................................................variables
  protected:
    
    TYPE _c[ROWS][COLUMNS];
    
};

template<typename TYPE> class Matrix<TYPE, 0, 0> {

    //..............................................................constants
  public:

    const size_t ROWS;
    const size_t COLUMNS;
    const size_t SIZE;
    const size_t MEM_SIZE;

    //...............................................................typedefs
  public: 

    /// @name Auxiliary Classes
    ///{

    /// Return One Row as Vector, internally used for element access
    /** Only used to access values:

        @code
        Matrix<int,4,4> m;
        m[2][2] = 1;
        @endcode */
    class RowVector {
      public:
        TYPE& operator[](size_t column) {
          assert(column<_m.COLUMNS);
          return _v[column];
        }
      protected:
        friend class Matrix;
        RowVector() = delete; // forbidden
        RowVector(const Matrix& m, TYPE c[]): _m(m), _v(c) {}
        const Matrix& _m;
        TYPE *_v;
    };

    /// Same as RowVector, but in a constant environment.
    class ConstRowVector {
      public:
        const TYPE& operator[](size_t column) const {
          assert(column<_m.COLUMNS);
          return _v[column];
        }
      protected:
        friend class Matrix;
        ConstRowVector() = delete; // forbidden
        ConstRowVector(const Matrix& m, const TYPE c[]): _m(m), _v(c) {}
        const Matrix& _m;
        const TYPE *_v;
    };
    
    ///}

    //................................................................methods
  public:

    /// @name construction
    ///{
    
    Matrix(size_t rows, size_t columns):
        ROWS(rows),
        COLUMNS(columns),
        SIZE(rows*columns),
        MEM_SIZE(rows*columns*sizeof(TYPE)),
        _c(new TYPE[rows*columns]) {
      memset(_c, 0, MEM_SIZE);
    }
    
    template<typename ...ARGS>
        Matrix(size_t rows, size_t columns, ARGS...t):
            Matrix(rows, columns) {
      assert(sizeof...(t)==SIZE);
      copy_args(_c, t...);
    }

    Matrix(const Matrix& o): Matrix(o.ROWS, o.COLUMNS) {
      memcpy(_c, o._c, MEM_SIZE);
    }

    ///}

    /// @name destruction
    ///{

    ~Matrix() {
      delete[] _c;
    }
    
    ///}

    /// @name operators
    ///{
    
    Matrix& operator=(TYPE oc[]) {
      assert(sizeof(oc)==MEM_SIZE);
      memcpy(_c, oc, MEM_SIZE);
      return *this;
    }
    
    Matrix& operator=(const Matrix& o) {
      if (o.ROWS!=ROWS&&o.COLUMNS!=COLUMNS) {
        delete[] _c;
        ROWS = o.ROWS;
        COLUMNS = o.COLUMNS;
        SIZE = o.SIZE;
        MEM_SIZE = o.MEM_SIZE;
        _c = new TYPE[SIZE];
      }
      memcpy(_c, o._c, MEM_SIZE);
      return *this;
    }

    bool operator==(const Matrix& o) const {
      if (o.ROWS!=ROWS||o.COLUMNS!=COLUMNS) return false;
      TYPE *to((TYPE*)(_c)+SIZE), *from((TYPE*)(o._c)+SIZE);
      while (to>(TYPE*)(_c)) if (*--to != *--from) return false;
      return true;
    }

    bool operator!=(const Matrix& o) const {
      return !operator==(o);
    }

    Matrix T() const {
      Matrix res(COLUMNS, ROWS);
      for (size_t row(0); row<ROWS; ++row)
        for (size_t column(0); column<COLUMNS; ++column)
          res(column, row) = operator()(row, column);
      return res;
    }

    Matrix operator-() const {
      Matrix res(COLUMNS, ROWS);
      for (TYPE *to((TYPE*)(res._c)+SIZE); to>(TYPE*)(_c); --to) *to = -*to;
      return res;
    }

    Matrix& operator+=(const Matrix& o) {
      assert(o.ROWS==ROWS);
      assert(o.COLUMNS==COLUMNS);
      TYPE *to((TYPE*)(_c)+SIZE), *from((TYPE*)(o._c)+SIZE);
      while (to>(TYPE*)(_c)) *--to += *--from;
      return *this;
    }

    Matrix& operator-=(const Matrix& o) {
      assert(o.ROWS==ROWS);
      assert(o.COLUMNS==COLUMNS);
      TYPE *to((TYPE*)(_c)+SIZE), *from((TYPE*)(o._c)+SIZE);
      while (to>(TYPE*)(_c)) *--to -= *--from;
      return *this;
    }

    ///}

    /// @name element access
    ///{
    
    TYPE& operator()(size_t row, size_t column) {
      assert(row<ROWS);
      assert(column<COLUMNS);
      return *(_c+row*COLUMNS+column);
    }
    
    const TYPE& operator()(size_t row, size_t column) const {
      assert(row<ROWS);
      assert(column<COLUMNS);
      return *(_c+row*COLUMNS+column);
    }
    
    RowVector operator[](size_t row) {
      assert(row<ROWS);
      return RowVector(*this, _c+row*COLUMNS);
    }
    
    const ConstRowVector operator[](size_t row) const {
      assert(row<ROWS);
      return ConstRowVector(*this, _c+row*COLUMNS);
    }
    
    ///}

    //................................................................methods
  protected:

    void copy_args(TYPE*) {}
    template<typename ...ARGS>
        void copy_args(TYPE* to, TYPE t1, ARGS...t) {
      *to = t1;
      copy_args(++to, t...);
    }

    //..............................................................variables
  protected:
    
    TYPE* _c;
    
};

template<typename TYPE, size_t ROWS, size_t COLUMNS>
    Matrix<TYPE, ROWS, COLUMNS> operator+(const Matrix<TYPE, ROWS, COLUMNS>& m1, const Matrix<TYPE, ROWS, COLUMNS>& m2) {
  Matrix<TYPE, ROWS, COLUMNS> res(m1);
  return res+=m2;
}
                     
template<typename TYPE, size_t ROWS, size_t COLUMNS>
    std::ostream& operator<<(std::ostream& s, const Matrix<TYPE, ROWS, COLUMNS>& m) {
  for (size_t w = 0; w < m.ROWS; ++w) {
    for (size_t h = 0; h < m.COLUMNS;++h) {
      s<<m[w][h]<<' ';
    }
    s<<'\n';
  }
}