Vector.h

Go to the documentation of this file.

// This file is part of the Peano project. For conditions of distribution and
// use, please see the copyright notice at www.peano-framework.org
#pragma once
 
#include "tarch/la/la.h"
#include "tarch/Assertions.h"
#include "tarch/accelerator/accelerator.h"
#include "tarch/compiler/CompilerSpecificSettings.h"
 
#include <string>
#include <bitset>
#include <sstream>
#include <initializer_list>
 
namespace tarch {
  namespace la {
    template <int Size, typename Scalar>
    struct Vector;
 
    template <typename NewScalarType, int Size, typename Scalar>
    tarch::la::Vector<Size,NewScalarType> convertScalar(const tarch::la::Vector<Size,Scalar>&  vector);
  }
}
 
template<int Size, typename Scalar>
std::string toString( const tarch::la::Vector<Size,Scalar>&  vector );
 
template <int Size, typename Scalar>
struct tarch::la::Vector {
  private:
    Scalar _values[Size];
 
  public:
    Vector() InlineMethod = default;
 
    Vector( const Scalar* values ) InlineMethod;
 
    Vector( std::initializer_list<Scalar> values );
 
    Vector( const std::bitset<Size>& values ) InlineMethod;
 
    Vector(const Scalar& initialValue);
 
    inline Vector<Size,Scalar>& operator= (const Vector<Size,Scalar>& toAssign) InlineMethod;
 
    Vector(const Vector<Size,Scalar>&  toCopy);
 
    int size() const;
 
    inline const Scalar& operator[] (int index) const InlineMethod {
#if defined(GPUOffloadingOff)
          assertion3 ( index >= 0, index, Size, ::toString(*this) );
          assertion4 ( index < Size, index, Size, ::toString(*this), "you may not take the indexth entry from a vector with only Size components" );
#endif
        return _values[index];
    }
 
    inline Scalar& operator[] (int index) InlineMethod {
#if defined(GPUOffloadingOff)
          assertion3 ( index >= 0, index, Size, ::toString(*this) );
          assertion3 ( index < Size, index, Size, ::toString(*this) );
#endif
        return _values[index];
    }
 
    inline const Scalar& operator() (int index) const InlineMethod {
#if defined(GPUOffloadingOff)
          assertion3 ( index >= 0, index, Size, ::toString(*this) );
          assertion3 ( index < Size, index, Size, ::toString(*this) );
#endif
        return _values[index];
    }
 
    inline Scalar& operator() (int index) InlineMethod {
#if defined(GPUOffloadingOff)
        assertion3 ( index >= 0, index, Size, ::toString(*this) );
        assertion3 ( index < Size, index, Size, ::toString(*this) );
#endif
       return _values[index];
     }
 
    Scalar* data() {
      return _values;
    }
 
    const Scalar * data() const {
      return _values;
    }
};
 
#include "tarch/la/Vector.cpph"
#include "tarch/la/VectorOperations.h"
#include "tarch/la/VectorScalarOperations.h"
#include "tarch/la/VectorVectorOperations.h"
#include "tarch/la/VectorSlice.h"