math vector

#include <iostream>
#include <vector>
using namespace std;
template <typename T>
class MathVector {
private:
    vector<T> data;

public:
    MathVector(size_t n) {
        data.resize(n);
    }

    template <typename Iter>
    MathVector(Iter first, Iter last) {
        while (first != last) {
            data.push_back(*first);
            ++first;
        }
    }

    size_t Dimension() const {
        return data.size();
    }
    T& operator[] (size_t i) {
        return data[i];
    }
    const T& operator [] (size_t i) const {
        return data[i];
    }

};
template <typename T>
ostream& operator << (ostream& out, const MathVector<T>& v) {
    out << '(';
    for (size_t i = 0; i != v.Dimension(); ++i) {
        if (i > 0)
            out << ", ";
        out << v[i];
    }
    out << ')';
    return out;
}
template <typename T>
MathVector<T>& operator *= (MathVector<T>& v, const T& scalar) {
    for (size_t i = 0; i != v.Dimension(); ++i)
        v[i] *= scalar;
    return v;
}
template <typename T>
MathVector<T> operator * (const MathVector<T>& v, const T& scalar) {
    MathVector<T> tmp = v;
    tmp *= scalar;
    return tmp;
}
template <typename T>
MathVector<T>& operator += (MathVector<T>& self, const MathVector<T>& other) {
    for (size_t i = 0; i != self.Dimension(); ++i)
        self[i] += other[i];
    return self;
}
template <typename T>
MathVector<T> operator + (const MathVector<T>& self, const MathVector<T>& other) {
    MathVector<T> tmp = self;
    tmp += other;
    return tmp;
}
template <typename T>
MathVector<T> operator * (const T& scalar, const MathVector<T>& v) {
    MathVector<T> tmp = v * scalar;
    return tmp;
}
template <typename T>
MathVector<T>& operator -= (MathVector<T>& self, const MathVector<T>& other) {
    for (size_t i = 0; i != self.Dimension(); ++i)
        self[i] -= other[i];
    return self;
}
template <typename T>
MathVector<T> operator - (const MathVector<T>& self, const MathVector<T>& other) {
    MathVector<T> tmp = self;
    tmp -= other;
    return tmp;
}
template <typename T>
MathVector<T> operator - (const MathVector<T>& self) {
    MathVector<T> tmp = self;
    tmp *= -1;
    return tmp;
}