#include <iostream>
#include <algorithm> // for min()
#include <array>
using namespace std;

template<size_t Dim, typename Type = double>
class mathvector
{
public:
  explicit mathvector(array<Type, Dim> const& values) : content_(values) {}
  mathvector() : content_{} {} // zero-initialize

  // --------------------------------------------------
  mathvector& operator*=(Type scalar)
  {
    for (auto& el : content_) el *= scalar;
    return *this;
  }

  // --------------------------------------------------
  mathvector& operator+=(mathvector const& other)
  {
    for (size_t i(0); i < Dim; ++i) content_[i] += other.content_[i];
    return *this;
  }

  // --------------------------------------------------
  template<size_t Dim2>
  mathvector<Dim2, Type> convert() const
  {
    array<Type, Dim2> newbie{};
    constexpr size_t borne(min(Dim, Dim2));
    for (size_t i(0); i < borne; ++i) newbie[i] = content_[i];
    return mathvector<Dim2, Type>(newbie);
    // return newbie; // only possible with non-explicit constructor
  }

  // --------------------------------------------------
  void display(ostream& out) const
  {
    out << '(';
    if (Dim > 0) {
      constexpr size_t last(Dim - 1);
      for (size_t i(0); i < last; ++i) out << content_[i] << ", ";
      out << content_[last];
    }
    out << ')';
  }
  
  // --------------------------------------------------
private:
  array<Type, Dim> content_;
};

// ======================================================================
template<size_t Dim, typename Type>
mathvector<Dim, Type> operator*(Type const& scalar,
                                mathvector<Dim, Type> vect)
{ return vect *= scalar; }
  
// ======================================================================
template<size_t Dim, typename Type>
mathvector<Dim, Type> operator+(mathvector<Dim, Type>        vect1,
                                mathvector<Dim, Type> const& vect2)
{ return vect1 += vect2; }

// ======================================================================
template<size_t Dim, typename Type>
ostream& operator<<(ostream& out, mathvector<Dim, Type> const& vect)
{
  vect.display(out);
  return out;
}

// ======================================================================
int main()
{
  mathvector<2> v1({3.4, 4.5});

  mathvector<4, int> v2({3, 4, 5, 6});

  // implicit instantiation cannot work here
  mathvector<3, int>    v3(v2.convert<3>());
  mathvector<4, double> v4(v1.convert<4>());

  cout << v1 << endl;
  cout << v2 << endl;
  cout << v3 << endl;
  cout << v4 << endl;

  cout << -2 * v2 << endl;
  cout << v3 + v3 << endl;
  
  return 0;
}