#include <cstddef>
#include <utility>
#include <array>
#include <type_traits>

template <typename T, std::size_t... I>
class VecImpl {
	public:
		using type = T;
		static constexpr std::size_t size_ = sizeof... (I);

		template <typename... Args, class X = std::enable_if_t<sizeof...(Args) == size_ && (std::is_convertible_v<Args, T> && ...)>>
		constexpr VecImpl (Args&&... args) : data {{ std::forward <Args> (args)... }} {
		}

		constexpr VecImpl (const VecImpl&) = default;
		constexpr VecImpl (VecImpl&&) = default;
		VecImpl& operator = (const VecImpl&) = default;
		VecImpl& operator = (VecImpl&&) = default;

		static constexpr std::size_t size () { return size_; }

		const T& operator [] (std::size_t i) const { return data [i]; }
		T& operator [] (std::size_t i) { return data [i]; }

		std::array<T, size_> data;
};

namespace Helper {
	template <typename T, typename I>
	struct GetVecImpl;

	template <typename T, std::size_t... I>
	struct GetVecImpl<T, std::index_sequence<I...>> {
		using type = VecImpl<T, I...>;
	};
}

template <typename T, std::size_t N>
using Vec = typename Helper::GetVecImpl<T, std::make_index_sequence<N>>::type;

template <typename U, typename T, std::size_t... I>
constexpr VecImpl<U, I...> vec_cast (const VecImpl<T, I...>& v) {
  return { static_cast<U> (v.data [I]) ... };
}


// Operatoren

template<typename T, typename U, std::size_t... I>
auto operator +(const VecImpl<T, I...>& a, const VecImpl<U, I...>& b) -> VecImpl<decltype(a.data [0] + b.data [0]), I...> {
	return { (a.data [I] + b.data [I])... };
}

template<typename T, typename U, std::size_t... I>
auto operator -(const VecImpl<T, I...>& a, const VecImpl<U, I...>& b) -> VecImpl<decltype(a.data [0] - b.data [0]), I...> {
	return { (a.data [I] - b.data [I])... };
}

template<typename T, typename U, std::size_t... I>
auto operator *(const VecImpl<T, I...>& a, const VecImpl<U, I...>& b) -> VecImpl<decltype(a.data [0] * b.data [0]), I...> {
	return { (a.data [I] * b.data [I])... };
}

template<typename T, typename U, std::size_t... I>
auto operator /(const VecImpl<T, I...>& a, const VecImpl<U, I...>& b) -> VecImpl<decltype(a.data [0] / b.data [0]), I...> {
	return { (a.data [I] / b.data [I])... };
}

int main () {
	Vec<float, 3> a { 0.f, 1.f, 2.f }, b { 3.f, 4.f, 5.f };

	Vec<float, 3> c { a + b };

	Vec<double, 3> d { vec_cast<double> (a) };
}