DiagonalMatrix.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_DIAGONALMATRIX_H
#define MYRAMATH_DENSE_DIAGONALMATRIX_H

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

#include <myramath/dense/DiagonalMatrixRange.h>

#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 DiagonalMatrix;
template<class Number> class Matrix;
template<class Number> class MatrixRange;
template<class Number> class Vector;
template<class Number> class VectorRange;

template<class Number> class LIBPUBLIC DiagonalMatrix
  {
  public:

    typedef typename ReflectPrecision<Number>::type Precision;

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

    DiagonalMatrix();

    explicit DiagonalMatrix(int N);

    explicit DiagonalMatrix(const Expression<1,Number>& e);

    DiagonalMatrix(const DiagonalMatrix& that);

    void swap (DiagonalMatrix& that);

#ifdef MYRAMATH_ENABLE_CPP11
    DiagonalMatrix(DiagonalMatrix&& that);
#endif
    
    DiagonalMatrix& operator = (DiagonalMatrix that);

    explicit DiagonalMatrix(const CDiagonalMatrixRange<Number>& that);

    explicit DiagonalMatrix(InputStream& in);

    void write(OutputStream& out) const;

    const DiagonalMatrix<Number>& add_const() const;

   ~DiagonalMatrix();

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

    int size() const;

    int n_words() const;

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

    const CDiagonalMatrixRange<Number> range() const;
    const  DiagonalMatrixRange<Number> range()      ;

    operator const CDiagonalMatrixRange<Number> () const;
    operator const  DiagonalMatrixRange<Number> ()      ;

    const CDiagonalMatrixRange<Number> window(int n0, int n1) const;
    const  DiagonalMatrixRange<Number> window(int n0, int n1)      ;

    const Number& operator() (int n) const;
          Number& operator() (int n)      ;

    const Number& at(int n) const;
          Number& at(int n)      ;

    // ------------------------------------ Diagonal slicing.

    const CDiagonalMatrixRange<Number> first(int n) const;
    const  DiagonalMatrixRange<Number> first(int n)      ;
    
    const CDiagonalMatrixRange<Number> last(int n) const;
    const  DiagonalMatrixRange<Number> last(int n)      ;

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

    DiagonalMatrix& operator = (const CDiagonalMatrixRange<Number>& that);
    DiagonalMatrix& operator = (const Expression<1,Number>& that);

    void assign(const CDiagonalMatrixRange<Number>& that);
    void assign(const Expression<1,Number>& that);
    
    void operator += (const CDiagonalMatrixRange<Number>& that);
    void operator += (const Expression<1,Number>& that);

    void operator -= (const CDiagonalMatrixRange<Number>& that);
    void operator -= (const Expression<1,Number>& that);

    void operator *= (Number alpha);

    void operator /= (Number alpha);

    DiagonalMatrix<Number> operator -();

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

    static DiagonalMatrix<Number> identity(int N);

    static DiagonalMatrix<Number> random(int N);

    static DiagonalMatrix<Number> inertia(int N_plus, int N_minus);

    static DiagonalMatrix<Number> zeros(int N);

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

#ifdef MYRAMATH_ENABLE_CPP11
    static DiagonalMatrix<Number> fill(std::initializer_list<Number> list);
#endif

    static DiagonalMatrix<Number> linspace(Number x0, Number x1, int N);

    static DiagonalMatrix<Number> logspace(Precision x0, Precision x1, int N);

    static DiagonalMatrix<Number> evaluate(const Expression<1,Number>& e);

    Matrix<Number> make_Matrix() const;
    void make_Matrix(const MatrixRange<Number>& A) const;

    Vector<Number> make_Vector() const;
    void make_Vector(const VectorRange<Number>& x) const;
    
  private:

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

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

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

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

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

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

LIBPUBLIC DiagonalMatrix<NumberS> operator * (const CDiagonalMatrixRange<NumberS>& A, const CDiagonalMatrixRange<NumberS>& B);
LIBPUBLIC DiagonalMatrix<NumberD> operator * (const CDiagonalMatrixRange<NumberD>& A, const CDiagonalMatrixRange<NumberD>& B);
LIBPUBLIC DiagonalMatrix<NumberC> operator * (const CDiagonalMatrixRange<NumberC>& A, const CDiagonalMatrixRange<NumberC>& B);
LIBPUBLIC DiagonalMatrix<NumberZ> operator * (const CDiagonalMatrixRange<NumberZ>& A, const CDiagonalMatrixRange<NumberZ>& B);

LIBPUBLIC DiagonalMatrix<NumberC> make_complex(const CDiagonalMatrixRange<NumberS>& A);
LIBPUBLIC DiagonalMatrix<NumberZ> make_complex(const CDiagonalMatrixRange<NumberD>& A);

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

LIBPUBLIC DiagonalMatrix<NumberS> realpart(const CDiagonalMatrixRange<NumberC>& A);
LIBPUBLIC DiagonalMatrix<NumberD> realpart(const CDiagonalMatrixRange<NumberZ>& A);

LIBPUBLIC DiagonalMatrix<NumberS> imagpart(const CDiagonalMatrixRange<NumberC>& A);
LIBPUBLIC DiagonalMatrix<NumberD> imagpart(const CDiagonalMatrixRange<NumberZ>& A);

} // namespace myra

#endif