vector.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef ANTKEEPER_MATH_VECTOR_HPP
#define ANTKEEPER_MATH_VECTOR_HPP
 
#include <algorithm>
#include <cstddef>
#include <cstring>
#include <cmath>
#include <concepts>
#include <format>
#include <iterator>
#include <limits>
#include <type_traits>
#include <utility>
 
namespace math {
 
template <class T, std::size_t N>
struct vector
{
    using element_type = T;
    
    static constexpr std::size_t element_count = N;
    
    element_type elements[N];
    
    
    template <class U, std::size_t... I>
    [[nodiscard]] inline constexpr vector<U, N> type_cast(std::index_sequence<I...>) const noexcept
    {
        return {static_cast<U>(elements[I])...};
    }
    
    template <class U>
    [[nodiscard]] inline constexpr explicit operator vector<U, N>() const noexcept
    {
        return type_cast<U>(std::make_index_sequence<N>{});
    }
    
    template <std::size_t M, std::size_t... I>
    [[nodiscard]] inline constexpr vector<T, M> size_cast(std::index_sequence<I...>) const noexcept
    {
        return {(I < N) ? elements[I] : T{0} ...};
    }
    
    template <std::size_t M>
    [[nodiscard]] inline constexpr explicit operator vector<T, M>() const noexcept
    {
        return size_cast<M>(std::make_index_sequence<M>{});
    }
    
    
    
    [[nodiscard]] inline constexpr element_type& operator[](std::size_t i) noexcept
    {
        return elements[i];
    }
    [[nodiscard]] inline constexpr const element_type& operator[](std::size_t i) const noexcept
    {
        return elements[i];
    }
    
    [[nodiscard]] inline constexpr element_type& front() noexcept
    {
        return elements[0];
    }
    [[nodiscard]] inline constexpr const element_type& front() const noexcept
    {
        return elements[0];
    }
    
    [[nodiscard]] inline constexpr element_type& back() noexcept
    {
        return elements[N - 1];
    }
    [[nodiscard]] inline constexpr const element_type& back() const noexcept
    {
        return elements[N - 1];
    }
    
    [[nodiscard]] inline constexpr element_type* data() noexcept
    {
        return elements;
    };
    [[nodiscard]] inline constexpr const element_type* data() const noexcept
    {
        return elements;
    };
    
    [[nodiscard]] inline constexpr element_type& x() noexcept
    {
        static_assert(N > 0, "Vector does not contain an x element.");
        return elements[0];
    }
    [[nodiscard]] inline constexpr const element_type& x() const noexcept
    {
        static_assert(N > 0, "Vector does not contain an x element.");
        return elements[0];
    }
    
    [[nodiscard]] inline constexpr element_type& y() noexcept
    {
        static_assert(N > 1, "Vector does not contain a y element.");
        return elements[1];
    }
    [[nodiscard]] inline constexpr const element_type& y() const noexcept
    {
        static_assert(N > 1, "Vector does not contain a y element.");
        return elements[1];
    }
    
    [[nodiscard]] inline constexpr element_type& z() noexcept
    {
        static_assert(N > 2, "Vector does not contain a z element.");
        return elements[2];
    }
    [[nodiscard]] inline constexpr const element_type& z() const noexcept
    {
        static_assert(N > 2, "Vector does not contain a z element.");
        return elements[2];
    }
    
    
    
    [[nodiscard]] inline constexpr element_type* begin() noexcept
    {
        return elements;
    }
    [[nodiscard]] inline constexpr const element_type* begin() const noexcept
    {
        return elements;
    }
    [[nodiscard]] inline constexpr const element_type* cbegin() const noexcept
    {
        return elements;
    }
    
    [[nodiscard]] inline constexpr element_type* end() noexcept
    {
        return elements + N;
    }
    [[nodiscard]] inline constexpr const element_type* end() const noexcept
    {
        return elements + N;
    }
    [[nodiscard]] inline constexpr const element_type* cend() const noexcept
    {
        return elements + N;
    }
    
    [[nodiscard]] inline constexpr std::reverse_iterator<element_type*> rbegin() noexcept
    {
        return std::reverse_iterator<element_type*>(elements + N);
    }
    [[nodiscard]] inline constexpr std::reverse_iterator<const element_type*> rbegin() const noexcept
    {
        return std::reverse_iterator<const element_type*>(elements + N);
    }
    [[nodiscard]] inline constexpr std::reverse_iterator<const element_type*> crbegin() const noexcept
    {
        return std::reverse_iterator<const element_type*>(elements + N);
    }
    
    [[nodiscard]] inline constexpr std::reverse_iterator<element_type*> rend() noexcept
    {
        return std::reverse_iterator<element_type*>(elements);
    }
    [[nodiscard]] inline constexpr std::reverse_iterator<const element_type*> rend() const noexcept
    {
        return std::reverse_iterator<const element_type*>(elements);
    }
    [[nodiscard]] inline constexpr std::reverse_iterator<const element_type*> crend() const noexcept
    {
        return std::reverse_iterator<const element_type*>(elements);
    }
    
    
    
    [[nodiscard]] inline constexpr std::size_t size() const noexcept
    {
        return N;
    };
    
    
    
    [[nodiscard]] inline static constexpr vector zero() noexcept
    {
        return {};
    }
    
    template <std::size_t... I>
    [[nodiscard]] inline static constexpr vector one(std::index_sequence<I...>) noexcept
    {
        //return {element_type{1}...};
        
        // MSVC bug workaround (I must be referenced for parameter pack expansion)
        return {(I ? element_type{1} : element_type{1})...};
    }
    
    [[nodiscard]] inline static constexpr vector one() noexcept
    {
        return one(std::make_index_sequence<N>{});
    }
    
    template <std::size_t... I>
    [[nodiscard]] inline static constexpr vector infinity(std::index_sequence<I...>) noexcept
    {
        //return {element_type{1}...};
        
        // MSVC bug workaround (I must be referenced for parameter pack expansion)
        return {(I ? std::numeric_limits<element_type>::infinity() : std::numeric_limits<element_type>::infinity())...};
    }
    
    [[nodiscard]] inline static constexpr vector infinity() noexcept
    {
        return infinity(std::make_index_sequence<N>{});
    }
    
};
 
namespace vector_types {
 
template <class T>
using vec2 = vector<T, 2>;
 
template <class T>
using vec3 = vector<T, 3>;
 
template <class T>
using vec4 = vector<T, 4>;
 
template <std::size_t N>
using bvec = vector<bool, N>;
using bvec2 = bvec<2>;
using bvec3 = bvec<3>;
using bvec4 = bvec<4>;
 
template <std::size_t N>
using ivec = vector<int, N>;
using ivec2 = ivec<2>;
using ivec3 = ivec<3>;
using ivec4 = ivec<4>;
 
template <std::size_t N>
using uvec = vector<unsigned int, N>;
using uvec2 = uvec<2>;
using uvec3 = uvec<3>;
using uvec4 = uvec<4>;
 
template <std::size_t N>
using fvec = vector<float, N>;
using fvec2 = fvec<2>;
using fvec3 = fvec<3>;
using fvec4 = fvec<4>;
 
template <std::size_t N>
using dvec = vector<double, N>;
using dvec2 = dvec<2>;
using dvec3 = dvec<3>;
using dvec4 = dvec<4>;
 
} // namespace vector_types
 
// Bring vector types into math namespace
using namespace vector_types;
 
// Bring vector types into math::types namespace
namespace types { using namespace math::vector_types; }
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> abs(const vector<T, N>& x);
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> add(const vector<T, N>& x, const vector<T, N>& y) noexcept;
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> add(const vector<T, N>& x, T y) noexcept;
 
template <std::size_t N>
[[nodiscard]] constexpr bool all(const vector<bool, N>& x) noexcept;
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] T angle(const vector<T, N>& from, const vector<T, N>& to);
 
template <std::size_t N>
[[nodiscard]] constexpr bool any(const vector<bool, N>& x) noexcept;
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> ceil(const vector<T, N>& x);
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> clamp(const vector<T, N>& x, const vector<T, N>& min, const vector<T, N>& max);
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> clamp(const vector<T, N>& x, T min, T max);
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] vector<T, N> clamp_length(const vector<T, N>& x, T max_length);
 
template <class T>
[[nodiscard]] constexpr vector<T, 3> cross(const vector<T, 3>& x, const vector<T, 3>& y) noexcept;
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] T distance(const vector<T, N>& p0, const vector<T, N>& p1);
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> div(const vector<T, N>& x, const vector<T, N>& y) noexcept;
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> div(const vector<T, N>& x, T y) noexcept;
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> div(T x, const vector<T, N>& y) noexcept;
 
template <class T, std::size_t N>
[[nodiscard]] constexpr T dot(const vector<T, N>& x, const vector<T, N>& y) noexcept;
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<bool, N> equal(const vector<T, N>& x, const vector<T, N>& y) noexcept;
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> floor(const vector<T, N>& x);
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> fma(const vector<T, N>& x, const vector<T, N>& y, const vector<T, N>& z);
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> fma(const vector<T, N>& x, T y, T z);
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> fract(const vector<T, N>& x);
 
template<std::size_t I, class T, std::size_t N>
[[nodiscard]] constexpr T& get(math::vector<T, N>& v) noexcept;
template<std::size_t I, class T, std::size_t N>
[[nodiscard]] constexpr T&& get(math::vector<T, N>&& v) noexcept;
template<std::size_t I, class T, std::size_t N>
[[nodiscard]] constexpr const T& get(const math::vector<T, N>& v) noexcept;
template<std::size_t I, class T, std::size_t N>
[[nodiscard]] constexpr const T&& get(const math::vector<T, N>&& v) noexcept;
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<bool, N> greater_than(const vector<T, N>& x, const vector<T, N>& y) noexcept;
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<bool, N> greater_than_equal(const vector<T, N>& x, const vector<T, N>& y) noexcept;
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] T inv_length(const vector<T, N>& x);
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] T length(const vector<T, N>& x);
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<bool, N> less_than(const vector<T, N>& x, const vector<T, N>& y) noexcept;
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<bool, N> less_than_equal(const vector<T, N>& x, const vector<T, N>& y) noexcept;
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> max(const vector<T, N>& x, const vector<T, N>& y);
 
template <class T, std::size_t N>
[[nodiscard]] constexpr T max(const vector<T, N>& x);
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> min(const vector<T, N>& x, const vector<T, N>& y);
 
template <class T, std::size_t N>
[[nodiscard]] constexpr T min(const vector<T, N>& x);
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> mod(const vector<T, N>& x, const vector<T, N>& y);
template <std::floating_point T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> mod(const vector<T, N>& x, T y);
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> mul(const vector<T, N>& x, const vector<T, N>& y) noexcept;
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> mul(const vector<T, N>& x, T y) noexcept;
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> negate(const vector<T, N>& x) noexcept;
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] vector<T, N> normalize(const vector<T, N>& x);
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<bool, N> logical_not(const vector<T, N>& x) noexcept;
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<bool, N> not_equal(const vector<T, N>& x, const vector<T, N>& y) noexcept;
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] vector<T, N> pow(const vector<T, N>& x, const vector<T, N>& y);
template <std::floating_point T, std::size_t N>
[[nodiscard]] vector<T, N> pow(const vector<T, N>& x, T y);
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> round(const vector<T, N>& x);
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> sign(const vector<T, N>& x);
 
template <std::floating_point T>
[[nodiscard]] T signed_angle(const vector<T, 3>& x, const vector<T, 3>& y, const vector<T, 3>& n);
 
template <class T, std::size_t N>
[[nodiscard]] constexpr T sqr_distance(const vector<T, N>& p0, const vector<T, N>& p1) noexcept;
 
template <class T, std::size_t N>
[[nodiscard]] constexpr T sqr_length(const vector<T, N>& x) noexcept;
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] vector<T, N> sqrt(const vector<T, N>& x);
 
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> sub(const vector<T, N>& x, const vector<T, N>& y) noexcept;
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> sub(const vector<T, N>& x, T y) noexcept;
template <class T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> sub(T x, const vector<T, N>& y) noexcept;
 
template <class T, std::size_t N>
[[nodiscard]] constexpr T sum(const vector<T, N>& x) noexcept;
 
template <std::size_t... Indices, class T, std::size_t N>
[[nodiscard]] constexpr vector<T, sizeof...(Indices)> swizzle(const vector<T, N>& x) noexcept;
 
template <class T>
[[nodiscard]] constexpr T triple(const vector<T, 3>& x, const vector<T, 3>& y, const vector<T, 3>& z) noexcept;
 
template <std::floating_point T, std::size_t N>
[[nodiscard]] constexpr vector<T, N> trunc(const vector<T, N>& x);
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> abs(const vector<T, N>& x, std::index_sequence<I...>)
{
    return {std::abs(x[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> abs(const vector<T, N>& x)
{
    return abs(x, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> add(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>) noexcept
{
    return {(x[I] + y[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> add(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return add(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> add(const vector<T, N>& x, T y, std::index_sequence<I...>) noexcept
{
    return {(x[I] + y)...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> add(const vector<T, N>& x, T y) noexcept
{
    return add(x, y, std::make_index_sequence<N>{});
}
 
template <std::size_t N, std::size_t... I>
inline constexpr bool all(const vector<bool, N>& x, std::index_sequence<I...>) noexcept
{
    return (x[I] && ...);
}
 
template <std::size_t N>
inline constexpr bool all(const vector<bool, N>& x) noexcept
{
    return all(x, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N>
T angle(const vector<T, N>& from, const vector<T, N>& to)
{
    return std::acos(std::min<T>(std::max<T>(dot(from, to), T{-1}), T{1}));
}
 
template <std::size_t N, std::size_t... I>
inline constexpr bool any(const vector<bool, N>& x, std::index_sequence<I...>) noexcept
{
    return (x[I] || ...);
}
 
template <std::size_t N>
inline constexpr bool any(const vector<bool, N>& x) noexcept
{
    return any(x, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> ceil(const vector<T, N>& x, std::index_sequence<I...>)
{
    return {std::ceil(x[I])...};
}
 
template <std::floating_point T, std::size_t N>
inline constexpr vector<T, N> ceil(const vector<T, N>& x)
{
    return ceil(x, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> clamp(const vector<T, N>& x, const vector<T, N>& min_val, const vector<T, N>& max_val, std::index_sequence<I...>)
{
    return {std::min<T>(max_val[I], std::max<T>(min_val[I], x[I]))...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> clamp(const vector<T, N>& x, const vector<T, N>& min, const vector<T, N>& max)
{
    return clamp(x, min, max, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> clamp(const vector<T, N>& x, T min, T max, std::index_sequence<I...>)
{
    return {std::min<T>(max, std::max<T>(min, x[I]))...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> clamp(const vector<T, N>& x, T min, T max)
{
    return clamp(x, min, max, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N>
vector<T, N> clamp_length(const vector<T, N>& x, T max_length)
{
    const auto length2 = sqr_length(x);
    return (length2 > max_length * max_length) ? (x * (max_length / std::sqrt(length2))) : x;
}
 
template <class T>
inline constexpr vector<T, 3> cross(const vector<T, 3>& x, const vector<T, 3>& y) noexcept
{
    return
    {
        x[1] * y[2] - x[2] * y[1],
        x[2] * y[0] - x[0] * y[2],
        x[0] * y[1] - x[1] * y[0]
    };
}
 
template <std::floating_point T, std::size_t N>
inline T distance(const vector<T, N>& p0, const vector<T, N>& p1)
{
    return length(sub(p0, p1));
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> div(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>) noexcept
{
    return {(x[I] / y[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> div(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return div(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> div(const vector<T, N>& x, T y, std::index_sequence<I...>) noexcept
{
    return {(x[I] / y)...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> div(const vector<T, N>& x, T y) noexcept
{
    return div(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> div(T x, const vector<T, N>& y, std::index_sequence<I...>) noexcept
{
    return {(x / y[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> div(T x, const vector<T, N>& y) noexcept
{
    return div(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr T dot(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>) noexcept
{
    return ((x[I] * y[I]) + ...);
}
 
template <class T, std::size_t N>
inline constexpr T dot(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return dot(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<bool, N> equal(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>) noexcept
{
    return {(x[I] == y[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<bool, N> equal(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return equal(x, y, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> floor(const vector<T, N>& x, std::index_sequence<I...>)
{
    return {std::floor(x[I])...};
}
 
template <std::floating_point T, std::size_t N>
inline constexpr vector<T, N> floor(const vector<T, N>& x)
{
    return floor(x, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> fma(const vector<T, N>& x, const vector<T, N>& y, const vector<T, N>& z, std::index_sequence<I...>)
{
    return {std::fma(x[I], y[I], z[I])...};
}
 
template <std::floating_point T, std::size_t N>
inline constexpr vector<T, N> fma(const vector<T, N>& x, const vector<T, N>& y, const vector<T, N>& z)
{
    return fma(x, y, z, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> fma(const vector<T, N>& x, T y, T z, std::index_sequence<I...>)
{
    return {std::fma(x[I], y, z)...};
}
 
template <std::floating_point T, std::size_t N>
inline constexpr vector<T, N> fma(const vector<T, N>& x, T y, T z)
{
    return fma(x, y, z, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> fract(const vector<T, N>& x, std::index_sequence<I...>)
{
    return {x[I] - std::floor(x[I])...};
}
 
template <std::floating_point T, std::size_t N>
inline constexpr vector<T, N> fract(const vector<T, N>& x)
{
    return fract(x, std::make_index_sequence<N>{});
}
 
template<std::size_t I, class T, std::size_t N>
inline constexpr T& get(math::vector<T, N>& v) noexcept
{
    static_assert(I < N);
    return v.elements[I];
}
 
template<std::size_t I, class T, std::size_t N>
inline constexpr T&& get(math::vector<T, N>&& v) noexcept
{
    static_assert(I < N);
    return std::move(v.elements[I]);
}
 
template<std::size_t I, class T, std::size_t N>
inline constexpr const T& get(const math::vector<T, N>& v) noexcept
{
    static_assert(I < N);
    return v.elements[I];
}
 
template<std::size_t I, class T, std::size_t N>
inline constexpr const T&& get(const math::vector<T, N>&& v) noexcept
{
    static_assert(I < N);
    return std::move(v.elements[I]);
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<bool, N> greater_than(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>) noexcept
{
    return {(x[I] > y[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<bool, N> greater_than(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return greater_than(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<bool, N> greater_than_equal(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>) noexcept
{
    return {(x[I] >= y[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<bool, N> greater_than_equal(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return greater_than_equal(x, y, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N>
inline T inv_length(const vector<T, N>& x)
{
    return T{1} / length(x);
}
 
template <std::floating_point T, std::size_t N>
inline T length(const vector<T, N>& x)
{
    return std::sqrt(sqr_length(x));
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<bool, N> less_than(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>) noexcept
{
    return {(x[I] < y[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<bool, N> less_than(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return less_than(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<bool, N> less_than_equal(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>) noexcept
{
    return {(x[I] <= y[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<bool, N> less_than_equal(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return less_than_equal(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> max(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>)
{
    return {std::max<T>(x[I], y[I])...};
}
 
template <class T, std::size_t N>
constexpr vector<T, N> max(const vector<T, N>& x, const vector<T, N>& y)
{
    return max(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N>
inline constexpr T max(const vector<T, N>& x)
{
    return *std::max_element(x.elements, x.elements + N);
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> min(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>)
{
    return {std::min<T>(x[I], y[I])...};
}
 
template <class T, std::size_t N>
constexpr vector<T, N> min(const vector<T, N>& x, const vector<T, N>& y)
{
    return min(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N>
inline constexpr T min(const vector<T, N>& x)
{
    return *std::min_element(x.elements, x.elements + N);
}
 
template <std::floating_point T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> mod(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>)
{
    return {std::fmod(x[I], y[I])...};
}
 
template <std::floating_point T, std::size_t N>
inline constexpr vector<T, N> mod(const vector<T, N>& x, const vector<T, N>& y)
{
    return mod(x, y, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> mod(const vector<T, N>& x, T y, std::index_sequence<I...>)
{
    return {std::fmod(x[I], y)...};
}
 
template <std::floating_point T, std::size_t N>
inline constexpr vector<T, N> mod(const vector<T, N>& x, T y)
{
    return mod(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> mul(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>) noexcept
{
    return {(x[I] * y[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> mul(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return mul(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> mul(const vector<T, N>& x, T y, std::index_sequence<I...>) noexcept
{
    return {(x[I] * y)...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> mul(const vector<T, N>& x, T y) noexcept
{
    return mul(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> negate(const vector<T, N>& x, std::index_sequence<I...>) noexcept
{
    return {(-x[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> negate(const vector<T, N>& x) noexcept
{
    return negate(x, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N>
inline vector<T, N> normalize(const vector<T, N>& x)
{
    return mul(x, inv_length(x));
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<bool, N> logical_not(const vector<T, N>& x, std::index_sequence<I...>) noexcept
{
    return {!x[I]...};
}
 
template <class T, std::size_t N>
inline constexpr vector<bool, N> logical_not(const vector<T, N>& x) noexcept
{
    return logical_not(x, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<bool, N> not_equal(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>) noexcept
{
    return {(x[I] != y[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<bool, N> not_equal(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return not_equal(x, y, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N, std::size_t... I>
inline vector<T, N> pow(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>)
{
    return {std::pow(x[I], y[I])...};
}
 
template <std::floating_point T, std::size_t N>
inline vector<T, N> pow(const vector<T, N>& x, const vector<T, N>& y)
{
    return pow(x, y, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N, std::size_t... I>
inline vector<T, N> pow(const vector<T, N>& x, T y, std::index_sequence<I...>)
{
    return {std::pow(x[I], y)...};
}
 
template <std::floating_point T, std::size_t N>
inline vector<T, N> pow(const vector<T, N>& x, T y)
{
    return pow(x, y, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> round(const vector<T, N>& x, std::index_sequence<I...>)
{
    return {std::round(x[I])...};
}
 
template <std::floating_point T, std::size_t N>
inline constexpr vector<T, N> round(const vector<T, N>& x)
{
    return round(x, std::make_index_sequence<N>{});
}
 
template <std::floating_point T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> sign(const vector<T, N>& x, std::index_sequence<I...>)
{
    return {std::copysign(T{1}, x[I])...};
}
 
template <std::floating_point T, std::size_t N>
inline constexpr vector<T, N> sign(const vector<T, N>& x)
{
    return sign(x, std::make_index_sequence<N>{});
}
 
template <std::floating_point T>
T signed_angle(const vector<T, 3>& from, const vector<T, 3>& to, const vector<T, 3>& axis)
{
    return std::atan2(triple(axis, from, to), dot(from, to));
}
 
template <class T, std::size_t N>
inline constexpr T sqr_distance(const vector<T, N>& p0, const vector<T, N>& p1) noexcept
{
    return sqr_length(sub(p0, p1));
}
 
template <class T, std::size_t N>
inline constexpr T sqr_length(const vector<T, N>& x) noexcept
{
    return dot(x, x);
}
 
template <std::floating_point T, std::size_t N, std::size_t... I>
inline vector<T, N> sqrt(const vector<T, N>& x, std::index_sequence<I...>)
{
    return {std::sqrt(x[I])...};
}
 
template <std::floating_point T, std::size_t N>
inline vector<T, N> sqrt(const vector<T, N>& x, const vector<T, N>& y)
{
    return sqrt(x, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> sub(const vector<T, N>& x, const vector<T, N>& y, std::index_sequence<I...>) noexcept
{
    return {(x[I] - y[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> sub(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return sub(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> sub(const vector<T, N>& x, T y, std::index_sequence<I...>) noexcept
{
    return {(x[I] - y)...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> sub(const vector<T, N>& x, T y) noexcept
{
    return sub(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> sub(T x, const vector<T, N>& y, std::index_sequence<I...>) noexcept
{
    return {(x - y[I])...};
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N> sub(T x, const vector<T, N>& y) noexcept
{
    return sub(x, y, std::make_index_sequence<N>{});
}
 
template <class T, std::size_t N, std::size_t... I>
inline constexpr T sum(const vector<T, N>& x, std::index_sequence<I...>) noexcept
{
    return (x[I] + ...);
}
 
template <class T, std::size_t N>
inline constexpr T sum(const vector<T, N>& x) noexcept
{
    return sum(x, std::make_index_sequence<N>{});
}
 
template <std::size_t... Indices, class T, std::size_t N>
inline constexpr vector<T, sizeof...(Indices)> swizzle(const vector<T, N>& x) noexcept
{
    return {x[Indices]...};
}
 
template <class T>
inline constexpr T triple(const vector<T, 3>& x, const vector<T, 3>& y, const vector<T, 3>& z) noexcept
{
    return dot(x, cross(y, z));
}
 
template <std::floating_point T, std::size_t N, std::size_t... I>
inline constexpr vector<T, N> trunc(const vector<T, N>& x, std::index_sequence<I...>)
{
    return {std::trunc(x[I])...};
}
 
template <std::floating_point T, std::size_t N>
inline constexpr vector<T, N> trunc(const vector<T, N>& x)
{
    return trunc(x, std::make_index_sequence<N>{});
}
 
namespace operators {
 
template <class T, std::size_t N>
[[nodiscard]] inline constexpr vector<T, N> operator+(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return add(x, y);
}
 
template <class T, std::size_t N>
[[nodiscard]] inline constexpr vector<T, N> operator+(const vector<T, N>& x, T y) noexcept
{
    return add(x, y);
}
template <class T, std::size_t N>
[[nodiscard]] inline constexpr vector<T, N> operator+(T x, const vector<T, N>& y) noexcept
{
    return add(y, x);
}
 
template <class T, std::size_t N>
[[nodiscard]] inline constexpr vector<T, N> operator/(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return div(x, y);
}
 
template <class T, std::size_t N>
[[nodiscard]] inline constexpr vector<T, N> operator/(const vector<T, N>& x, T y) noexcept
{
    return div(x, y);
}
 
template <class T, std::size_t N>
[[nodiscard]] inline constexpr vector<T, N> operator/(T x, const vector<T, N>& y) noexcept
{
    return div(x, y);
}
 
template <class T, std::size_t N>
[[nodiscard]] inline constexpr vector<T, N> operator*(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return mul(x, y);
}
 
template <class T, std::size_t N>
[[nodiscard]] inline constexpr vector<T, N> operator*(const vector<T, N>& x, T y) noexcept
{
    return mul(x, y);
}
template <class T, std::size_t N>
[[nodiscard]] inline constexpr vector<T, N> operator*(T x, const vector<T, N>& y) noexcept
{
    return mul(y, x);
}
 
template <class T, std::size_t N>
[[nodiscard]] inline constexpr vector<T, N> operator-(const vector<T, N>& x) noexcept
{
    return negate(x);
}
 
template <class T, std::size_t N>
[[nodiscard]] inline constexpr vector<T, N> operator-(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return sub(x, y);
}
 
template <class T, std::size_t N>
[[nodiscard]] inline constexpr vector<T, N> operator-(const vector<T, N>& x, T y) noexcept
{
    return sub(x, y);
}
 
template <class T, std::size_t N>
[[nodiscard]] inline constexpr vector<T, N> operator-(T x, const vector<T, N>& y) noexcept
{
    return sub(x, y);
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N>& operator+=(vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return (x = x + y);
}
template <class T, std::size_t N>
inline constexpr vector<T, N>& operator+=(vector<T, N>& x, T y) noexcept
{
    return (x = x + y);
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N>& operator-=(vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return (x = x - y);
}
template <class T, std::size_t N>
inline constexpr vector<T, N>& operator-=(vector<T, N>& x, T y) noexcept
{
    return (x = x - y);
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N>& operator*=(vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return (x = x * y);
}
template <class T, std::size_t N>
inline constexpr vector<T, N>& operator*=(vector<T, N>& x, T y) noexcept
{
    return (x = x * y);
}
 
template <class T, std::size_t N>
inline constexpr vector<T, N>& operator/=(vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return (x = x / y);
}
template <class T, std::size_t N>
inline constexpr vector<T, N>& operator/=(vector<T, N>& x, T y) noexcept
{
    return (x = x / y);
}
 
template <class T, std::size_t N>
inline constexpr bool operator==(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    // if consteval
    // {
        for (std::size_t i = 0; i < N; ++i)
        {
            if (x[i] != y[i])
            {
                return false;
            }
        }
        
        return true;
    // }
    // else
    // {
        // !std::memcmp(x.data(), y.data(), N * sizeof(T));
    // }
}
 
template <class T, std::size_t N>
inline constexpr bool operator!=(const vector<T, N>& x, const vector<T, N>& y) noexcept
{
    return !(x == y);
}
 
} // namespace operators
 
} // namespace math
 
// Bring vector operators into global namespace
using namespace math::operators;
 
namespace std
{
    template<class T, std::size_t N>
    struct tuple_size<math::vector<T, N>>
    {
        static constexpr std::size_t value = math::vector<T, N>::element_count;
    };
    
    template<std::size_t I, class T, std::size_t N>
    struct tuple_element<I, math::vector<T, N>>
    {
        using type = math::vector<T, N>::element_type;
    };
    
    template <class T, std::size_t N>
    struct formatter<math::vector<T, N>>: formatter<T>
    {
        auto format(const math::vector<T, N>& t, format_context& fc) const
        {
            auto&& out = fc.out();
            format_to(out, "{{");
            
            for (std::size_t i = 0; i < N; ++i)
            {
                formatter<T>::format(t[i], fc);
                if (i < N - 1)
                {
                    format_to(out, ", ");
                }
            }
            
            return format_to(out, "}}");
        }
    };
}
 
// Ensure vectors are POD types
static_assert(std::is_standard_layout_v<math::fvec3>);
static_assert(std::is_trivial_v<math::fvec3>);
 
#endif // ANTKEEPER_MATH_VECTOR_HPP