Vector.h

#pragma once
 
#include <array>
#include <cmath>
#include <functional>
#include <numeric>
 
namespace spark::math::details
{
    template <template <typename> typename Impl, typename T, std::size_t N>
    class Vector
    {
    public:
        explicit constexpr Vector(std::array<std::reference_wrapper<T>, N> values)
            : m_values(values) {}
 
        constexpr bool operator==(const Vector& other) const noexcept
        {
            for (std::size_t i = 0; i < m_values.size(); i++)
                if (m_values[i].get() != other.m_values[i].get())
                    return false;
            return true;
        }
 
        constexpr bool operator!=(const Vector& other) const noexcept
        {
            return !operator==(other);
        }
 
        constexpr Impl<T> operator+(const Impl<T>& other) const noexcept
        {
            Impl<T> result;
            for (std::size_t i = 0; i < N; ++i)
                result.m_values[i].get() = m_values[i] + other.m_values[i];
            return result;
        }
 
        constexpr Impl<T> operator-(const Impl<T>& other) const noexcept
        {
            Impl<T> result;
            for (std::size_t i = 0; i < N; ++i)
                result.m_values[i].get() = m_values[i] - other.m_values[i];
            return result;
        }
 
        constexpr Impl<T> operator*(const Impl<T>& other) const noexcept
        {
            Impl<T> result;
            for (std::size_t i = 0; i < N; ++i)
                result.m_values[i].get() = m_values[i] * other.m_values[i];
            return result;
        }
 
        constexpr Impl<T> operator/(const Impl<T>& other) const noexcept
        {
            Impl<T> result;
            for (std::size_t i = 0; i < N; ++i)
                result.m_values[i].get() = m_values[i] / other.m_values[i];
            return result;
        }
 
        constexpr Impl<T> operator*(const T& value) const noexcept
        {
            Impl<T> result;
            for (std::size_t i = 0; i < N; ++i)
                result.m_values[i].get() = m_values[i] * value;
            return result;
        }
 
        constexpr Impl<T> operator/(const T& value) const noexcept
        {
            Impl<T> result;
            for (std::size_t i = 0; i < N; ++i)
                result.m_values[i].get() = m_values[i] / value;
            return result;
        }
 
        constexpr Impl<T>& operator+=(const Vector& other) noexcept
        {
            for (std::size_t i = 0; i < N; ++i)
                m_values[i] += other.m_values[i];
            return static_cast<Impl<T>&>(*this);
        }
 
        constexpr Impl<T>& operator-=(const Vector& other) noexcept
        {
            for (std::size_t i = 0; i < N; ++i)
                m_values[i] -= other.m_values[i];
            return static_cast<Impl<T>&>(*this);
        }
 
        constexpr Impl<T>& operator*=(const Vector& other) noexcept
        {
            for (std::size_t i = 0; i < N; ++i)
                m_values[i] *= other.m_values[i];
            return static_cast<Impl<T>&>(*this);
        }
 
        constexpr Impl<T>& operator/=(const T& value) noexcept
        {
            for (std::size_t i = 0; i < N; ++i)
                m_values[i] /= value;
            return static_cast<Impl<T>&>(*this);
        }
 
        constexpr Impl<T> operator-() const noexcept
        {
            Impl<T> result;
            for (std::size_t i = 0; i < N; ++i)
                result.m_values[i].get() = -m_values[i];
            return result;
        }
 
        [[nodiscard]] constexpr T norm() const noexcept
        {
            static_assert(std::is_floating_point_v<T>, "The norm can only be computed for floating point types.");
 
            T value {};
            for (std::size_t i = 0; i < N; ++i)
                value += m_values[i].get() * m_values[i].get();
            return std::sqrt(value);
        }
 
        [[nodiscard]] constexpr Impl<T> normalized() const noexcept
        {
            return *this / norm();
        }
 
        [[nodiscard]] constexpr T dot(const Impl<T>& other) const noexcept
        {
            T value {};
            for (std::size_t i = 0; i < N; ++i)
                value += m_values[i].get() * other.m_values[i].get();
            return value;
        }
 
        friend constexpr void swap(Vector& lhs, Vector& rhs) noexcept
        {
            for (std::size_t i = 0; i < N; ++i)
            {
                T temp = lhs.m_values[i];
                lhs.m_values[i].get() = rhs.m_values[i].get();
                rhs.m_values[i].get() = temp;
            }
        }
 
    private:
        std::array<std::reference_wrapper<T>, N> m_values;
    };
}