LowerMatrix.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_LOWERMATRIX_H
#define MYRAMATH_DENSE_LOWERMATRIX_H

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

#include <myramath/dense/LowerMatrixRange.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 InputStream;
class OutputStream;
template<int Arity, class Number> class Expression;
template<class Number> class LowerMatrix;
template<class Number> class Matrix;

template <class Number> class LIBPUBLIC LowerMatrix
  {
  public:

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

    LowerMatrix();

    explicit LowerMatrix(int N);

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

    void swap(LowerMatrix<Number>& that);

#ifdef MYRAMATH_ENABLE_CPP11
    LowerMatrix(LowerMatrix&& that);
#endif

    LowerMatrix& operator = (LowerMatrix that);

    explicit LowerMatrix(const CLowerMatrixRange<Number>& that);

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

    explicit LowerMatrix(InputStream& in);

    void write(OutputStream& out) const;

    const LowerMatrix<Number>& add_const() const;

   ~LowerMatrix();

    // ------------------------------------ Size queries.
   
    int size() const;

    uint64_t n_words() const;

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

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

    CLowerMatrixRange<Number> range() const;
     LowerMatrixRange<Number> range()      ;

    operator CLowerMatrixRange<Number> () const;
    operator  LowerMatrixRange<Number> ()      ;

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

    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)      ;

    // Optionally, the 'T'ranspose or 'H'ermitian of *this can be copied into the upper triangle.
    Matrix<Number> make_Matrix(char op = 'N') const;
    void make_Matrix(const MatrixRange<Number>& A, char op = 'N') const;

    // ------------------------------------ Lower triangular slicing.

    CMatrixRange<Number> range11 () const;
    CMatrixRange<Number> range21 () const;
    CMatrixRange<Number> range22t() const;

    MatrixRange<Number> range11 ();
    MatrixRange<Number> range21 ();
    MatrixRange<Number> range22t();

    // ------------------------------------ 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); }
    
    LowerMatrix& operator = (const CLowerMatrixRange<Number>& that);
    LowerMatrix& operator = (const Expression<2,Number>& that);

    LowerMatrix& operator = (const CMatrixRange<Number>& that);    

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

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

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

    void operator *= (Number alpha);

    void operator /= (Number alpha);

    LowerMatrix<Number> operator -();

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

    static LowerMatrix<Number> identity(int N);

    static LowerMatrix<Number> random(int N);

    static LowerMatrix<Number> zeros(int N);

    static LowerMatrix<Number> ones(int N);

    static LowerMatrix<Number> fill(int N, Number c);

#ifdef MYRAMATH_ENABLE_CPP11
    static LowerMatrix<Number> fill_cmajor(std::initializer_list<Number> list);
    static LowerMatrix<Number> fill_rmajor(std::initializer_list<Number> list);    
#endif

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

  private:

    // Implementation detail of constructors/assignment operators.
    void initialize(int in_N);

    // Reseats the internal range R back onto contents.
    void reseat();

    // Size member.
    int N;

    // Numeric contents.
    typedef std::vector<Number> Contents;
    Contents contents;

    // LowerMatrixRange<Number> structure, imposes layout upon contents.
    LowerMatrixRange<Number> R;

  };

// Specializing ReflectNumber<> for LowerMatrix<Number>
template<class Number> class ReflectNumber< LowerMatrix<Number> >
  { public: typedef Number type; };

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

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

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

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

LIBPUBLIC LowerMatrix<NumberC> make_complex(const CLowerMatrixRange<NumberS>& A);
LIBPUBLIC LowerMatrix<NumberZ> make_complex(const CLowerMatrixRange<NumberD>& A);

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

LIBPUBLIC LowerMatrix<NumberS> realpart(const CLowerMatrixRange<NumberC>& A);
LIBPUBLIC LowerMatrix<NumberD> realpart(const CLowerMatrixRange<NumberZ>& A);

LIBPUBLIC LowerMatrix<NumberS> imagpart(const CLowerMatrixRange<NumberC>& A);
LIBPUBLIC LowerMatrix<NumberD> imagpart(const CLowerMatrixRange<NumberZ>& A);

} // namespace myra

#endif