Matrix.h

Go to the documentation of this file.

// ========================================================================= //
// This file is part of MyraMath, copyright (c) 2014-2019 by Ryan A Chilton  //
// and distributed by MyraCore, LLC. See LICENSE.txt for license terms.      //
// ========================================================================= //

#ifndef MYRAMATH_DENSE_MATRIX_H
#define MYRAMATH_DENSE_MATRIX_H

#include <myramath/utility/detail/LIBPUBLIC.h>
#include <myramath/utility/Number.h>

#include <myramath/dense/VectorRange.h>
#include <myramath/dense/MatrixRange.h>

#include <utility>
#include <vector>
#include <iosfwd>
#ifdef MYRAMATH_ENABLE_CPP11
#include <initializer_list>
#endif

namespace myra {

// Forward declarations.
class intCRange;
class InputStream;
class OutputStream;
template<int Arity, class Number> class Expression;
template<class Number> class Matrix;
template<class T> class Array1;
template<class T> class Array2;

template<class Number> class LIBPUBLIC Matrix
  {
  public:

    typedef std::pair< MatrixRange<Number>,  MatrixRange<Number> >  Pair;
    typedef std::pair<CMatrixRange<Number>, CMatrixRange<Number> > CPair;

    // ------------------------------------ Construction, serialization, value semantics.

    Matrix();

    explicit Matrix(int I, int J);
    explicit Matrix(std::pair<int,int> IJ);

    explicit Matrix(const Expression<2,Number>& e);
    
    Matrix(const Matrix& that);

    void swap(Matrix& that);

#ifdef MYRAMATH_ENABLE_CPP11
    Matrix(Matrix&& that);
#endif
    
    Matrix<Number>& operator = (Matrix that);

    explicit Matrix(const CMatrixRange<Number>& that);

    explicit Matrix(InputStream& in);

    void write(OutputStream& out) const;

    const Matrix<Number>& add_const() const;

   ~Matrix();

    // ------------------------------------ Size queries.

    std::pair<int,int> size() const;

    uint64_t n_words() const;

    // ------------------------------------ General slicing.

    CMatrixRange<Number> range() const;
     MatrixRange<Number> range()      ;

    operator const CMatrixRange<Number> () const;
    operator const  MatrixRange<Number> ()      ;

    CMatrixRange<Number> window(int i0, int i1, int j0, int j1) const;
     MatrixRange<Number> window(int i0, int i1, int j0, int j1)      ;

    Array2<CMatrixRange<Number> > windows(const intCRange& i, const intCRange& j) const;
    Array2< MatrixRange<Number> > windows(const intCRange& i, const intCRange& j)      ;

    CVectorRange<Number> vector(int j) const;
     VectorRange<Number> vector(int j)      ;

    const Number& operator () (int i, int j) const;
          Number& operator () (int i, int j)      ;

    const Number& at(int i, int j) const;
          Number& at(int i, int j)      ;

    // ------------------------------------ Row slicing.

    CMatrixRange<Number> row(int i) const;
     MatrixRange<Number> row(int i)      ;

    CMatrixRange<Number> rows(int i0, int i1) const;
     MatrixRange<Number> rows(int i0, int i1)      ;

    Array1<CMatrixRange<Number> > rows(const intCRange& i) const;
    Array1< MatrixRange<Number> > rows(const intCRange& i)      ;

    CMatrixRange<Number> top(int i) const;
     MatrixRange<Number> top(int i)      ;

    CMatrixRange<Number> cut_top(int i) const;
     MatrixRange<Number> cut_top(int i)      ;

    CPair split_top(int i) const;
     Pair split_top(int i)      ;

    CMatrixRange<Number> bottom(int i) const;
     MatrixRange<Number> bottom(int i)      ;

    CMatrixRange<Number> cut_bottom(int i) const;
     MatrixRange<Number> cut_bottom(int i)      ;

    CPair split_bottom(int i) const;
     Pair split_bottom(int i)      ;

    // ------------------------------------ Column slicing.

    CMatrixRange<Number> column(int j) const;
     MatrixRange<Number> column(int j)      ;

    CMatrixRange<Number> columns(int j0, int j1) const;
     MatrixRange<Number> columns(int j0, int j1)      ;

    Array1<CMatrixRange<Number> > columns(const intCRange& j) const;
    Array1< MatrixRange<Number> > columns(const intCRange& j)      ;

    CMatrixRange<Number> left(int j) const;
     MatrixRange<Number> left(int j)      ;

    CMatrixRange<Number> cut_left(int j) const;
     MatrixRange<Number> cut_left(int j)      ;

    CPair split_left(int j) const;
     Pair split_left(int j)      ;

    CMatrixRange<Number> right(int j) const;
     MatrixRange<Number> right(int j)      ;    

    CMatrixRange<Number> cut_right(int j) const;
     MatrixRange<Number> cut_right(int j)      ;    

    CPair split_right(int j) const;
     Pair split_right(int j)      ;

    // ------------------------------------ Manipulating numeric contents.

    // Functor f should have an operator(), that takes a Number and returns a Number.
    template<class Functor> void transform(const Functor& f)
      { this->range().transform(f); }

    // Functor f should have an operator(), that takes a Number and returns a Number.
    template<class Functor> void transform_triangle(const Functor& f, char uplo)
      { this->range().transform_triangle(f,uplo); }

    // Functor f should have an operator(), that takes a Number and returns a Number.
    template<class Functor> void transform_diagonal(const Functor& f)
      { this->range().transform_diagonal(f); }

    Matrix<Number>& operator = (const CMatrixRange<Number>& that);
    Matrix<Number>& operator = (const Expression<2,Number>& that);

    void assign(const CMatrixRange<Number>& that);
    void assign(const CMatrixRange<Number>& that, char op);
    void assign(const Expression<2,Number>& that);

    void operator += (const CMatrixRange<Number>& that);
    void operator += (const Expression<2,Number>& that);

    void operator -= (const CMatrixRange<Number>& that);
    void operator -= (const Expression<2,Number>& that);

    void operator *= (Number alpha);

    void operator /= (Number alpha);

    Matrix<Number> operator -();

    // ------------------------------------ Static generators.

    static Matrix<Number> identity(int IJ);

    static Matrix<Number> random(int I, int J);

    static Matrix<Number> zeros(int I, int J);

    static Matrix<Number> ones(int I, int J);

    static Matrix<Number> fill(int I, int J, Number c);

#ifdef MYRAMATH_ENABLE_CPP11
    static Matrix<Number> fill_cmajor(int I, int J, std::initializer_list<Number> list);  // list given in column-major order
    static Matrix<Number> fill_rmajor(int I, int J, std::initializer_list<Number> list);  // list given in row-major order (more legible)
#endif

    static Matrix<Number> evaluate(const Expression<2,Number>& e);

  private:

    // Implementation detail of constructors/assignment operators.
    void initialize(int in_I, int in_J);

    // Returns the offset to A(i,j) inside contents[]
    size_t offset(int i, int j) const;
  
    // Size members.
    int I;
    int J;
    
    // Numeric contents.
    typedef std::vector<Number> Contents;
    Contents contents;
    
  };

template<class Number> class ReflectNumber< Matrix<Number> >
  { public: typedef Number type; };

LIBPUBLIC Matrix<NumberS> operator + (const CMatrixRange<NumberS>& A, const CMatrixRange<NumberS>& B);
LIBPUBLIC Matrix<NumberD> operator + (const CMatrixRange<NumberD>& A, const CMatrixRange<NumberD>& B);
LIBPUBLIC Matrix<NumberC> operator + (const CMatrixRange<NumberC>& A, const CMatrixRange<NumberC>& B);
LIBPUBLIC Matrix<NumberZ> operator + (const CMatrixRange<NumberZ>& A, const CMatrixRange<NumberZ>& B);

LIBPUBLIC Matrix<NumberS> operator - (const CMatrixRange<NumberS>& A, const CMatrixRange<NumberS>& B);
LIBPUBLIC Matrix<NumberD> operator - (const CMatrixRange<NumberD>& A, const CMatrixRange<NumberD>& B);
LIBPUBLIC Matrix<NumberC> operator - (const CMatrixRange<NumberC>& A, const CMatrixRange<NumberC>& B);
LIBPUBLIC Matrix<NumberZ> operator - (const CMatrixRange<NumberZ>& A, const CMatrixRange<NumberZ>& B);

LIBPUBLIC Matrix<NumberS> operator * (NumberS alpha, const CMatrixRange<NumberS>& A);
LIBPUBLIC Matrix<NumberD> operator * (NumberD alpha, const CMatrixRange<NumberD>& A);
LIBPUBLIC Matrix<NumberC> operator * (NumberC alpha, const CMatrixRange<NumberC>& A);
LIBPUBLIC Matrix<NumberZ> operator * (NumberZ alpha, const CMatrixRange<NumberZ>& A);

LIBPUBLIC Matrix<NumberS> operator * (const CMatrixRange<NumberS>& A, NumberS alpha);
LIBPUBLIC Matrix<NumberD> operator * (const CMatrixRange<NumberD>& A, NumberD alpha);
LIBPUBLIC Matrix<NumberC> operator * (const CMatrixRange<NumberC>& A, NumberC alpha);
LIBPUBLIC Matrix<NumberZ> operator * (const CMatrixRange<NumberZ>& A, NumberZ alpha);

LIBPUBLIC Matrix<NumberC> make_complex(const CMatrixRange<NumberS>& A);
LIBPUBLIC Matrix<NumberZ> make_complex(const CMatrixRange<NumberD>& A);

LIBPUBLIC Matrix<NumberC> make_complex(const CMatrixRange<NumberS>& R, const CMatrixRange<NumberS>& I);
LIBPUBLIC Matrix<NumberZ> make_complex(const CMatrixRange<NumberD>& R, const CMatrixRange<NumberD>& I);

LIBPUBLIC Matrix<NumberS> realpart(const CMatrixRange<NumberS>& A);
LIBPUBLIC Matrix<NumberD> realpart(const CMatrixRange<NumberD>& A);
LIBPUBLIC Matrix<NumberS> realpart(const CMatrixRange<NumberC>& A);
LIBPUBLIC Matrix<NumberD> realpart(const CMatrixRange<NumberZ>& A);

LIBPUBLIC Matrix<NumberS> imagpart(const CMatrixRange<NumberC>& A);
LIBPUBLIC Matrix<NumberD> imagpart(const CMatrixRange<NumberZ>& A);

} // namespace myra

#endif