vector.hpp

#ifndef TOPAZ_CORE_VECTOR_HPP
#define TOPAZ_CORE_VECTOR_HPP
#include <concepts>
#include <array>
#include <type_traits>
#include <algorithm>
 
namespace tz
{
    template<typename T, int N>
    requires std::integral<T> || std::floating_point<T>
    struct vector
    {
        static constexpr vector<T, N> zero()
        {
            return vector<T, N>::filled(T{0});
        }
 
        static constexpr vector<T, N> filled(T t)
        {
            std::array<T, N> values;
            std::fill(values.begin(), values.end(), t);
            return {values};
        }
 
        template<typename... Ts>
        requires(
            sizeof...(Ts) <= N
            && sizeof...(Ts) > 1
            && std::is_convertible_v<std::tuple_element_t<0, std::tuple<Ts...>>, T>)
        constexpr vector(Ts&&... ts) :
        arr({ std::forward<Ts>(ts)... }) {}
        constexpr vector(std::array<T, N> data): arr(data){}
        vector() = default;
        vector(const vector<T, N>& cpy) = default;
        vector(vector<T, N>&& move) = default;
        vector& operator=(const vector<T, N>& rhs) = default;
        vector& operator=(vector<T, N>&& rhs) = default;
 
        const T& operator[](std::size_t idx) const;
        T& operator[](std::size_t idx);
 
        // Multiply vector by scalar
        vector<T, N>& operator*=(T scalar);
        vector<T, N>& operator/=(T scalar);
        vector<T, N> operator*(T scalar) const{auto cpy = *this; return cpy *= scalar;}
        vector<T, N> operator/(T scalar) const{auto cpy = *this; return cpy /= scalar;}
 
        vector<T, N>& operator+=(const vector<T, N>& rhs);
        vector<T, N>& operator-=(const vector<T, N>& rhs);
        vector<T, N>& operator*=(const vector<T, N>& rhs);
        vector<T, N>& operator/=(const vector<T, N>& rhs);
 
        vector<T, N> operator+(const vector<T, N>& rhs) const{auto cpy = *this; return cpy += rhs;}
        vector<T, N> operator-(const vector<T, N>& rhs) const{auto cpy = *this; return cpy -= rhs;}
        vector<T, N> operator*(const vector<T, N>& rhs) const{auto cpy = *this; return cpy *= rhs;}
        vector<T, N> operator/(const vector<T, N>& rhs) const{auto cpy = *this; return cpy /= rhs;}
 
        template<typename C>
        operator vector<C, N>() const requires(std::is_convertible_v<T, C>)
        {
            std::array<C, N> arr;
            std::transform(this->arr.begin(), this->arr.end(), arr.begin(), [](const T& t)->C{return static_cast<C>(t);});
            return {arr};
        }
 
        T length() const;
        T dot(const vector<T, N>& rhs) const;
        vector<T, N> cross(const vector<T, N>& rhs) const requires(N == 3);
 
        bool operator==(const vector<T, N>& rhs) const = default;
    private:
        std::array<T, N> arr;
    };
 
    using v2i = vector<int, 2>;
    using v3i = vector<int, 3>;
    using v4i = vector<int, 4>;
    using v2u = vector<unsigned int, 2>;
    using v3u = vector<unsigned int, 3>;
    using v4u = vector<unsigned int, 4>;
    using v2f = vector<float, 2>;
    using v3f = vector<float, 3>;
    using v4f = vector<float, 4>;
    using v2d = vector<double, 2>;
    using v3d = vector<double, 3>;
    using v4d = vector<double, 4>;
}
 
#endif // TOPAZ_CORE_VECTOR_HPP