Vector.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_VECTOR_H
#define MYRAMATH_DENSE_VECTOR_H

#include <myramath/MYRAMATH_EXPORT.h>
#include <myramath/utility/Number.h>

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

#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 Vector;
template<class T> class Array1;

template<class Number> class MYRAMATH_EXPORT Vector
  {
  public:

    typedef std::pair<CVectorRange<Number>, CVectorRange<Number> > CPair;
    typedef std::pair< VectorRange<Number>,  VectorRange<Number> >  Pair;
    typedef typename ReflectPrecision<Number>::type Precision;

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

    Vector();

    explicit Vector(int N);

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

    Vector(const Vector& that);

    void swap (Vector& that);

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

    Vector& operator = (Vector that);

    explicit Vector(const CVectorRange<Number>& that);

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

    explicit Vector(InputStream& in);

    void write(OutputStream& out) const;

    const Vector<Number>& add_const() const;

   ~Vector();

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

    int size() const;

    int n_words() const;

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

    CVectorRange<Number> range() const;
     VectorRange<Number> range()      ;

    operator CVectorRange<Number> () const;
    operator  VectorRange<Number> ()      ;

    CVectorRange<Number> window(int n0, int n1) const;
     VectorRange<Number> window(int n0, int n1)      ;

    Array1<CVectorRange<Number> > windows(const intCRange& n) const;
    Array1< VectorRange<Number> > windows(const intCRange& n)      ;

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

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

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

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

    // ------------------------------------ Vector slicing.

    CVectorRange<Number> first(int n) const;
     VectorRange<Number> first(int n)      ;

    CVectorRange<Number> cut_first(int n) const;
     VectorRange<Number> cut_first(int n)      ;

    CPair split_first(int n) const;
     Pair split_first(int n)      ;
    
    CVectorRange<Number> last(int n) const;
     VectorRange<Number> last(int n)      ;

    CVectorRange<Number> cut_last(int n) const;
     VectorRange<Number> cut_last(int n)      ;

    CPair split_last(int n) const;
     Pair split_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); }

    Vector& operator = (const CVectorRange<Number>& that);
    Vector& operator = (const Expression<1,Number>& that);

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

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

    void operator *= (Number alpha);

    void operator /= (Number alpha);

    Vector<Number> operator -();

    // ------------------------------------ Static generators.
    
    static Vector<Number> random(int N);

    static Vector<Number> zeros(int N);

    static Vector<Number> ones(int N);

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

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

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

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

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

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

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

MYRAMATH_EXPORT Vector<NumberS> operator + (const CVectorRange<NumberS>& a, const CVectorRange<NumberS>& b);
MYRAMATH_EXPORT Vector<NumberD> operator + (const CVectorRange<NumberD>& a, const CVectorRange<NumberD>& b);
MYRAMATH_EXPORT Vector<NumberC> operator + (const CVectorRange<NumberC>& a, const CVectorRange<NumberC>& b);
MYRAMATH_EXPORT Vector<NumberZ> operator + (const CVectorRange<NumberZ>& a, const CVectorRange<NumberZ>& b);

MYRAMATH_EXPORT Vector<NumberS> operator - (const CVectorRange<NumberS>& a, const CVectorRange<NumberS>& b);
MYRAMATH_EXPORT Vector<NumberD> operator - (const CVectorRange<NumberD>& a, const CVectorRange<NumberD>& b);
MYRAMATH_EXPORT Vector<NumberC> operator - (const CVectorRange<NumberC>& a, const CVectorRange<NumberC>& b);
MYRAMATH_EXPORT Vector<NumberZ> operator - (const CVectorRange<NumberZ>& a, const CVectorRange<NumberZ>& b);

MYRAMATH_EXPORT Vector<NumberS> operator * (NumberS alpha, const CVectorRange<NumberS>& a);
MYRAMATH_EXPORT Vector<NumberD> operator * (NumberD alpha, const CVectorRange<NumberD>& a);
MYRAMATH_EXPORT Vector<NumberC> operator * (NumberC alpha, const CVectorRange<NumberC>& a);
MYRAMATH_EXPORT Vector<NumberZ> operator * (NumberZ alpha, const CVectorRange<NumberZ>& a);

MYRAMATH_EXPORT Vector<NumberS> operator * (const CVectorRange<NumberS>& a, NumberS alpha);
MYRAMATH_EXPORT Vector<NumberD> operator * (const CVectorRange<NumberD>& a, NumberD alpha);
MYRAMATH_EXPORT Vector<NumberC> operator * (const CVectorRange<NumberC>& a, NumberC alpha);
MYRAMATH_EXPORT Vector<NumberZ> operator * (const CVectorRange<NumberZ>& a, NumberZ alpha);

MYRAMATH_EXPORT Vector<NumberC> make_complex(const CVectorRange<NumberS>& a);
MYRAMATH_EXPORT Vector<NumberZ> make_complex(const CVectorRange<NumberD>& a);

MYRAMATH_EXPORT Vector<NumberC> make_complex(const CVectorRange<NumberS>& r, const CVectorRange<NumberS>& i);
MYRAMATH_EXPORT Vector<NumberZ> make_complex(const CVectorRange<NumberD>& r, const CVectorRange<NumberD>& i);

MYRAMATH_EXPORT Vector<NumberS> realpart(const CVectorRange<NumberS>& a);
MYRAMATH_EXPORT Vector<NumberD> realpart(const CVectorRange<NumberD>& a);
MYRAMATH_EXPORT Vector<NumberS> realpart(const CVectorRange<NumberC>& a);
MYRAMATH_EXPORT Vector<NumberD> realpart(const CVectorRange<NumberZ>& a);

MYRAMATH_EXPORT Vector<NumberS> imagpart(const CVectorRange<NumberC>& a);
MYRAMATH_EXPORT Vector<NumberD> imagpart(const CVectorRange<NumberZ>& a);

} // namespace myra

#endif