#ifndef VECTOR_H
#define VECTOR_H
// Vector.h 

#include <vector>
#include <math.h>
#include <initializer_list>

namespace Math
{
  template<typename T=double>
  class Vector
  {
  public:
    using iterator = typename std::vector<T>::iterator;
    using const_iterator = typename std::vector<T>::const_iterator;

    Vector(size_t size=0);
    Vector(std::initializer_list<T> list);
    Vector(const Vector<T>& v);
    Vector(Vector<T>&& v);
    void push_back(const T& t);
    iterator begin();
    iterator end();
    const_iterator begin() const;
    const_iterator end() const;
    Vector& operator=(const Vector<T>& v);
    Vector& operator=(Vector<T>&& v);
    void operator+=(const Vector<T>& v);
    Vector operator+(const Vector<T>& v);
    void operator-=(const Vector<T>& v);
    Vector operator-(const Vector<T>& v);
    T& operator[](size_t pos);
    T operator[](size_t pos) const;
    bool operator==(const Vector<T>& v) const;
    bool operator!=(const Vector<T>& v) const;
    size_t size() const;
    T EuclidianSize() const;
    T MaxCompSize() const;
    operator std::vector<T>();
  private:
    std::vector<T> vec_;
  };

  template<typename T>
  inline typename Vector<T>::iterator Vector<T>::begin() { return vec_.begin(); }

  template<typename T>
  inline typename Vector<T>::iterator Vector<T>::end() { return vec_.end(); }

  template<typename T>
  inline typename Vector<T>::const_iterator Vector<T>::begin() const { return vec_.begin(); }

  template<typename T>
  inline typename Vector<T>::const_iterator Vector<T>::end() const { return vec_.end(); }

  template<typename T>
  Vector<T>::Vector(size_t size) : vec_(size) {}

  template<typename T>
  Vector<T>::Vector(std::initializer_list<T> list) : vec_(list) {}

  template<typename T>
  Vector<T>::Vector(const Vector<T>& v) : vec_(v.vec_) {}

  template<typename T>
  Vector<T>::Vector(Vector<T>&& v) : vec_(std::move(v.vec_)) {}

  template<typename T>
  void Vector<T>::push_back(const T& t)
  {
    vec_.push_back(t);
  }

  template<typename T>
  Vector<T>& Vector<T>::operator=(const Vector<T>& v)
  {
    if (this == &v) return *this;
    for (auto elem : v)
      vec_.push_back(elem);
  }

  template<typename T>
  Vector<T>& Vector<T>::operator=(Vector<T>&& v)
  {
    if (this == &v) return *this;
    vec_ = std::move(v.vec_);
    return *this;
  }

  template<typename T>
  void Vector<T>::operator+=(const Vector<T>& v)
  {
    if (size() != v.size())
      throw(std::exception("unequal vector sizes"));
    for (size_t i = 0; i < size(); ++i)
      vec_[i] += v.vec_[i];
  }

  template<typename T>
  Vector<T> Vector<T>::operator+(const Vector<T>& v)
  {
    Vector temp = *this;
    temp += v;
    return temp;
  }

  template<typename T>
  void Vector<T>::operator-=(const Vector<T>& v)
  {
    if (size() != v.size())
      throw(std::exception("unequal vector sizes"));
    for (size_t i = 0; i < size(); ++i)
      vec_[i] -= v.vec_[i];
  }

  template<typename T>
  Vector<T> Vector<T>::operator-(const Vector<T>& v)
  {
    Vector temp = *this;
    temp -= v;
    return temp;
  }

  template<typename T>
  T& Vector<T>::operator[](size_t pos)
  {
    if (pos < 0 || size() <= pos)
      throw std::exception("index out of range");
    return vec_[pos];
  }

  template<typename T>
  T Vector<T>::operator[](size_t pos) const
  {
    if (pos < 0 || size() <= pos)
      throw std::exception("index out of range");
    return vec_[pos];
  }

  template<typename T>
  bool Vector<T>::operator==(const Vector<T>& v) const
  {
    return vec_ == v.vec_;
  }

  template<typename T>
  bool Vector<T>::operator!=(const Vector<T>& v) const
  {
    return vec_ != v.vec_;
  }

  template<typename T>
  Vector<T> operator*(T scale, const Vector<T>& v)
  {
    Vector<T> temp;
    for (auto elem : v)
      temp.push_back(scale*elem);
    return temp;
  }

  template<typename T>
  Vector<T> operator*(const Vector<T>& v, T scale)
  {
    Vector<T> temp;
    for (auto elem : v)
      temp.push_back(scale*elem);
    return temp;
  }

  template<typename T>
  size_t Vector<T>::size() const
  {
    return vec_.size();
  }

  template<typename T>
  T Vector<T>::EuclidianSize() const
  {
    T size = 0;
    for (auto elem : *this)
      size += elem*elem;
    return std::sqrt(size);
  }

  template<typename T>
  T Vector<T>::MaxCompSize() const
  {
    T size = 0;
    for (auto elem : *this)
      if (std::abs(elem) > size)
        size = elem;
    return size;
  }

  template<typename T>
  void show(const Vector<T>& vec)
  {
    std::cout << "\n  ";
    for (size_t i = 0; i < vec.size() - 1; ++i)
      std::cout << vec[i] << ", ";
    std::cout << vec[vec.size() - 1] << "\n";
  }
}
#endif