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/accelerator/accelerator.h"
#include "tarch/Assertions.h"
#include "tarch/compiler/CompilerSpecificSettings.h"
#include "tarch/la/la.h"
 
#include <bitset>
#include <initializer_list>
#include <sstream>
#include <string>
 
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
    );
  } // namespace la
} // namespace tarch

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) {
    #pragma unroll
    for (int i = 0; i < Size; i++) {
        _values[i] = toAssign._values[i];
    }
    return *this;
  };

  Vector(const Vector<Size, Scalar>& toCopy) InlineMethod
  = default;
 
//#pragma unroll
//    for (int i = 0; i < Size; i++) _values[i] = toCopy._values[i];
//  }

  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/VectorSlice.h"
#include "tarch/la/VectorVectorOperations.h"