Vector.h

// Copyright (C) 2015 Technische Universitaet Muenchen
// This file is part of the Mamico project. For conditions of distribution
// and use, please see the copyright notice in Mamico's main folder, or at
// www5.in.tum.de/mamico
#ifndef _TARCH_LA_VECTOR_H_
#define _TARCH_LA_VECTOR_H_
#include "tarch/TarchDefinitions.h"
#include <cmath>
#include <iostream>
#include <type_traits>
 
namespace tarch {
namespace la {
template <int size, class T> class Vector;
}
} // namespace tarch

 
template <int size, class T> class tarch::la::Vector {
private:
  T _entries[size];
 
public:
  Vector() {}
 
  Vector(const T& t) {
    for (int i = 0; i < size; i++) {
      _entries[i] = t;
    }
  }

  Vector(const T& t0, const T& t1) {
    static_assert(size == 2, "ERROR Vector(t0,t1) only valid for 2D vectors!");
    _entries[0] = t0;
    _entries[1] = t1;
  }

  Vector(const T& t0, const T& t1, const T& t2) {
    static_assert(size == 3, "ERROR Vector(t0,t1,t2) only valid for 3D vectors!");
    _entries[0] = t0;
    _entries[1] = t1;
    _entries[2] = t2;
  }

  Vector(const Vector<size, T>& v) {
    for (int i = 0; i < size; i++) {
      _entries[i] = v[i];
    }
  }

  void assign(const T& t) {
    for (int i = 0; i < size; i++) {
      _entries[i] = t;
    }
  }

  Vector<size, T>& operator=(const Vector<size, T>& v) {
    for (int i = 0; i < size; i++) {
      _entries[i] = v[i];
    }
    return *this;
  }

  T& operator[](int i) {
#if (TARCH_DEBUG == TARCH_YES)
    if (i < 0 || i > size - 1) {
      std::cout << "ERROR Vector T& operator[]: i out of range!" << std::endl;
      exit(EXIT_FAILURE);
    }
#endif
    return _entries[i];
  }

  const T& operator[](int i) const {
#if (TARCH_DEBUG == TARCH_YES)
    if (i < 0 || i > size - 1) {
      std::cout << "ERROR Vector const T& operator[]: i out of range!" << std::endl;
      exit(EXIT_FAILURE);
    }
#endif
    return _entries[i];
  }

  Vector<size, T>& operator+=(const Vector<size, T>& v) {
    for (int i = 0; i < size; i++) {
      _entries[i] += v[i];
    }
    return *this;
  }

  Vector<size, T>& operator-=(const Vector<size, T>& v) {
    for (int i = 0; i < size; i++) {
      _entries[i] -= v[i];
    }
    return *this;
  }

  template <class convert_to_T> explicit operator Vector<size, convert_to_T>() const {
    Vector<size, convert_to_T> ans;
    for (unsigned int i = 0; i < size; i++) {
      ans[i] = static_cast<convert_to_T>(_entries[i]);
    }
    return ans;
  }
};
 
#include "VectorOperations.cpph"
#endif // _TARCH_LA_VECTOR_H_