VectorRange.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_VECTORRANGE_H
#define MYRAMATH_DENSE_VECTORRANGE_H

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

#include <iosfwd>
#include <utility>
#include <vector>

namespace myra {

// Forward declarations.
template<int Arity, class Number> class Expression;
template<class Number> class  MatrixRange;
template<class Number> class CMatrixRange;
template<class Number> class  VectorRange;
template<class Number> class CVectorRange;
template<class T> class Array1;
class OutputStream;
class intCRange;

template<class Number> class LIBPUBLIC VectorRange
  {
  public:

    Number* begin;
    int N;

    // Useful typedef.
    typedef std::pair<VectorRange<Number>, VectorRange<Number> > Pair;

    // ------------------------------------ Construction and range semantics.

    VectorRange();

    VectorRange(Number* in_begin, int in_N);

    void write(OutputStream& out) const;

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

    int size() const;

    int n_words() const; 

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

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

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

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

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

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

    Number& at(int n) const;

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

    VectorRange<Number> first(int n) const;

    VectorRange<Number> cut_first(int n) const;

    Pair split_first(int n) const;

    VectorRange<Number> last(int n) const;

    VectorRange<Number> cut_last(int n) const;

    Pair split_last(int n) const;

    // ------------------------------------ Mutating underlying contents.

    // Functor f should be a have an operator(), that takes a Number and returns a Number.
    template<class Functor> void transform(const Functor& f) const
      {
      for (int n = 0; n < N; ++n)
        *pointer(n) = f( *pointer(n) );
      }

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

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

    void operator /= (Number alpha) const;

    void zero() const;

  private:
  
    // Returns pointer to n'th entry.
    Number* pointer(int n) const;

    // Throws if that is not the same size as *this.
    void check_size(const CVectorRange<Number>& that) const;

    // Throws if S is not the same size as *this.
    void check_size(int S) const;
    
  };

template<class Number> class LIBPUBLIC CVectorRange
  {
  public:

    const Number* begin;
    int N;

    // Useful typedef.
    typedef std::pair<CVectorRange<Number>, CVectorRange<Number> > Pair;

    // ------------------------------------ Construction and range semantics.

    CVectorRange();

    CVectorRange(const Number* in_begin, int in_N);

    void write(OutputStream& out) const;

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

    int size() const;

    int n_words() const;

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

    VectorRange<Number> remove_const() const;

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

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

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

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

    const Number& at(int n) const;
 
    // ------------------------------------ Vector slicing.

    CVectorRange<Number> first(int n) const;

    CVectorRange<Number> cut_first(int n) const;

    Pair split_first(int n) const;

    CVectorRange<Number> last(int n) const;

    CVectorRange<Number> cut_last(int n) const;

    Pair split_last(int n) const;

  private:
    
    // Returns pointer to n'th entry.
    const Number* pointer(int n) const;
    
  };

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

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

LIBPUBLIC Array1<CVectorRange<NumberS> > add_const(const Array1<VectorRange<NumberS> >& ranges);
LIBPUBLIC Array1<CVectorRange<NumberD> > add_const(const Array1<VectorRange<NumberD> >& ranges);
LIBPUBLIC Array1<CVectorRange<NumberC> > add_const(const Array1<VectorRange<NumberC> >& ranges);
LIBPUBLIC Array1<CVectorRange<NumberZ> > add_const(const Array1<VectorRange<NumberZ> >& ranges);

LIBPUBLIC Array1<VectorRange<NumberS> > remove_const(const Array1<CVectorRange<NumberS> >& ranges);
LIBPUBLIC Array1<VectorRange<NumberD> > remove_const(const Array1<CVectorRange<NumberD> >& ranges);
LIBPUBLIC Array1<VectorRange<NumberC> > remove_const(const Array1<CVectorRange<NumberC> >& ranges);
LIBPUBLIC Array1<VectorRange<NumberZ> > remove_const(const Array1<CVectorRange<NumberZ> >& ranges);

LIBPUBLIC std::ostream& operator << (std::ostream& out, const CVectorRange<NumberS>& v);
LIBPUBLIC std::ostream& operator << (std::ostream& out, const CVectorRange<NumberD>& v);
LIBPUBLIC std::ostream& operator << (std::ostream& out, const CVectorRange<NumberC>& v);
LIBPUBLIC std::ostream& operator << (std::ostream& out, const CVectorRange<NumberZ>& v);

} // namespace myra

#endif