vmath.hpp

C++17 tiny vector math library

Requirements

• gcc >= 7
• clang >= 5.0
• msvc >= 2017

Installation

vmath.hpp is a header-only library. All you need to do is copy the headers files from headers directory into your project and include them:

#include "vmath.hpp/vmath.hpp"

Also, you can add the root repository directory to your cmake project:

add_subdirectory(external/vmath.hpp)
target_link_libraries(your_project_target vmath.hpp)

API

• Vector Types
• Matrix Types
• Vector Operators
• Matrix Operators
• Angle and Trigonometry Functions
• Exponential Functions
• Common Functions
• Geometric Functions
• Relational Functions
• Matrix Functions
• Units
• Cast
• Access
• Matrix Transform 3D
• Matrix Transform 2D
• Matrix Projections
• Vector Transform

Vector Types

template < typename T, size_t Size >
class vec_base;

template < typename T >
class vec_base<T, 2> {
public:
    T x{}, y{};

    vec_base() = default;
    constexpr explicit vec_base(T v);
    constexpr vec_base(T x, T y);
    constexpr explicit vec_base(const vec_base<T, 3>& xy);
    constexpr explicit vec_base(const vec_base<T, 4>& xy);
};

template < typename T >
class vec_base<T, 3> {
public:
    T x{}, y{}, z{};

    vec_base() = default;
    constexpr explicit vec_base(T v);
    constexpr vec_base(T x, T y, T z);
    constexpr vec_base(const vec_base<T, 2>& xy, T z);
    constexpr vec_base(T x, const vec_base<T, 2>& yz);
    constexpr explicit vec_base(const vec_base<T, 4>& xyz);
};

template < typename T >
class vec_base<T, 4> {
public:
    T x{}, y{}, z{}, w{};

    vec_base() = default;
    constexpr explicit vec_base(T v);
    constexpr vec_base(T x, T y, T z, T w);
    constexpr vec_base(const vec_base<T, 2>& xy, T z, T w);
    constexpr vec_base(T x, const vec_base<T, 2>& yz, T w);
    constexpr vec_base(T x, T y, const vec_base<T, 2>& zw);
    constexpr vec_base(const vec_base<T, 2>& xy, const vec_base<T, 2>& zw);
    constexpr vec_base(const vec_base<T, 3>& xyz, T w);
    constexpr vec_base(T x, const vec_base<T, 3>& yzw);
};

template < typename T, size_t Size >
class vec final : public vec_base<T, Size> {
public:
    using value_type = T;

    using pointer = value_type*;
    using const_pointer = const value_type*;

    using reference = value_type&;
    using const_reference = const value_type&;

    static constexpr size_t size = Size;

    void swap(vec& other) noexcept(is_nothrow_swappable_v<T>);

    constexpr reference at(size_t index);
    constexpr const_reference at(size_t index) const;

    constexpr reference operator[](size_t index) noexcept;
    constexpr const_reference operator[](size_t index) const noexcept;
};

using bool2 = vec<bool, 2>;
using bool3 = vec<bool, 3>;
using bool4 = vec<bool, 4>;

using int2 = vec<int, 2>;
using int3 = vec<int, 3>;
using int4 = vec<int, 4>;

using uint2 = vec<unsigned, 2>;
using uint3 = vec<unsigned, 3>;
using uint4 = vec<unsigned, 4>;

using float2 = vec<float, 2>;
using float3 = vec<float, 3>;
using float4 = vec<float, 4>;

using double2 = vec<double, 2>;
using double3 = vec<double, 3>;
using double4 = vec<double, 4>;

using size2 = vec<size_t, 2>;
using size3 = vec<size_t, 3>;
using size4 = vec<size_t, 4>;

using ptrdiff2 = vec<std::ptrdiff_t, 2>;
using ptrdiff3 = vec<std::ptrdiff_t, 3>;
using ptrdiff4 = vec<std::ptrdiff_t, 4>;

Matrix Types

template < typename T, size_t Size >
class mat_base;

template < typename T >
class mat_base<T, 2> {
public:
    using row_type = vec<T, 2>;

    row_type rows[2] = {
        {1, 0},
        {0, 1}};

    mat_base() = default;
    constexpr explicit mat_base(T v);

    constexpr mat_base(
        T m11, T m12,
        T m21, T m22);

    constexpr mat_base(
        const row_type& row0,
        const row_type& row1);

    constexpr explicit mat_base(const mat_base<T, 3>& other);
    constexpr explicit mat_base(const mat_base<T, 4>& other);
};

template < typename T >
class mat_base<T, 3> {
public:
    using row_type = vec<T, 3>;

    row_type rows[3] = {
        {1, 0, 0},
        {0, 1, 0},
        {0, 0, 1}};

    mat_base() = default;
    constexpr explicit mat_base(T v);

    constexpr mat_base(
        T m11, T m12, T m13,
        T m21, T m22, T m23,
        T m31, T m32, T m33);

    constexpr mat_base(
        const row_type& row0,
        const row_type& row1,
        const row_type& row2);

    constexpr explicit mat_base(const mat_base<T, 2>& other);
    constexpr explicit mat_base(const mat_base<T, 4>& other);
};

template < typename T >
class mat_base<T, 4> {
public:
    using row_type = vec<T, 4>;

    row_type rows[4] = {
        {1, 0, 0, 0},
        {0, 1, 0, 0},
        {0, 0, 1, 0},
        {0, 0, 0, 1}};

    mat_base() = default;
    constexpr explicit mat_base(T v);

    constexpr mat_base(
        T m11, T m12, T m13, T m14,
        T m21, T m22, T m23, T m24,
        T m31, T m32, T m33, T m34,
        T m41, T m42, T m43, T m44);

    constexpr mat_base(
        const row_type& row0,
        const row_type& row1,
        const row_type& row2,
        const row_type& row3);

    constexpr explicit mat_base(const mat_base<T, 2>& other);
    constexpr explicit mat_base(const mat_base<T, 3>& other);
};

template < typename T, size_t Size >
class mat final : public mat_base<T, Size> {
public:
    using row_type = vec<T, Size>;

    using pointer = row_type*;
    using const_pointer = const row_type*;

    using reference = row_type&;
    using const_reference = const row_type&;

    static constexpr size_t size = Size;

    void swap(mat& other) noexcept(is_nothrow_swappable_v<T>);

    constexpr reference at(size_t index);
    constexpr const_reference at(size_t index) const;

    constexpr reference operator[](size_t index) noexcept;
    constexpr const_reference operator[](size_t index) const noexcept;
};

using bool2x2 = mat<bool, 2>;
using bool3x3 = mat<bool, 3>;
using bool4x4 = mat<bool, 4>;

using int2x2 = mat<int, 2>;
using int3x3 = mat<int, 3>;
using int4x4 = mat<int, 4>;

using uint2x2 = mat<unsigned, 2>;
using uint3x3 = mat<unsigned, 3>;
using uint4x4 = mat<unsigned, 4>;

using float2x2 = mat<float, 2>;
using float3x3 = mat<float, 3>;
using float4x4 = mat<float, 4>;

using double2x2 = mat<double, 2>;
using double3x3 = mat<double, 3>;
using double4x4 = mat<double, 4>;

using size2x2 = mat<size_t, 2>;
using size3x3 = mat<size_t, 3>;
using size4x4 = mat<size_t, 4>;

using ptrdiff2x2 = mat<std::ptrdiff_t, 2>;
using ptrdiff3x3 = mat<std::ptrdiff_t, 3>;
using ptrdiff4x4 = mat<std::ptrdiff_t, 4>;

Vector Operators

// -operator

template < typename T, size_t Size >
constexpr vec<T, Size> operator-(const vec<T, Size>& xs);

// operator+

template < typename T, size_t Size >
constexpr vec<T, Size> operator+(const vec<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr vec<T, Size> operator+(T x, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr vec<T, Size> operator+(const vec<T, Size>& xs, const vec<T, Size>& ys);

// operator+=

template < typename T, size_t Size >
constexpr vec<T, Size>& operator+=(vec<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr vec<T, Size>& operator+=(vec<T, Size>& xs, const vec<T, Size>& ys);

// operator-

template < typename T, size_t Size >
constexpr vec<T, Size> operator-(const vec<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr vec<T, Size> operator-(T x, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr vec<T, Size> operator-(const vec<T, Size>& xs, const vec<T, Size>& ys);

// operator-=

template < typename T, size_t Size >
constexpr vec<T, Size>& operator-=(vec<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr vec<T, Size>& operator-=(vec<T, Size>& xs, const vec<T, Size>& ys);

// operator*

template < typename T, size_t Size >
constexpr vec<T, Size> operator*(const vec<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr vec<T, Size> operator*(T x, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr vec<T, Size> operator*(const vec<T, Size>& xs, const vec<T, Size>& ys);

// operator*=

template < typename T, size_t Size >
constexpr vec<T, Size>& operator*=(vec<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr vec<T, Size>& operator*=(vec<T, Size>& xs, const vec<T, Size>& ys);

// operator/

template < typename T, size_t Size >
constexpr vec<T, Size> operator/(const vec<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr vec<T, Size> operator/(T x, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr vec<T, Size> operator/(const vec<T, Size>& xs, const vec<T, Size>& ys);

// operator/=

template < typename T, size_t Size >
constexpr vec<T, Size>& operator/=(vec<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr vec<T, Size>& operator/=(vec<T, Size>& xs, const vec<T, Size>& ys);

// operator==

template < typename T, size_t Size >
constexpr bool operator==(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr bool operator!=(const vec<T, Size>& xs, const vec<T, Size>& ys);

// operator<

template < typename T, size_t Size >
constexpr bool operator<(const vec<T, Size>& xs, const vec<T, Size>& ys);

Matrix Operators

// -operator

template < typename T, size_t Size >
constexpr mat<T, Size> operator-(const mat<T, Size>& xs);

// operator+

template < typename T, size_t Size >
constexpr mat<T, Size> operator+(const mat<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr mat<T, Size> operator+(T x, const mat<T, Size>& ys);

template < typename T, size_t Size >
constexpr mat<T, Size> operator+(const mat<T, Size>& xs, const mat<T, Size>& ys);

// operator+=

template < typename T, size_t Size >
constexpr mat<T, Size>& operator+=(mat<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr mat<T, Size>& operator+=(mat<T, Size>& xs, const mat<T, Size>& ys);

// operator-

template < typename T, size_t Size >
constexpr mat<T, Size> operator-(const mat<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr mat<T, Size> operator-(T x, const mat<T, Size>& ys);

template < typename T, size_t Size >
constexpr mat<T, Size> operator-(const mat<T, Size>& xs, const mat<T, Size>& ys);

// operator-=

template < typename T, size_t Size >
constexpr mat<T, Size>& operator-=(mat<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr mat<T, Size>& operator-=(mat<T, Size>& xs, const mat<T, Size>& ys);

// operator*

template < typename T, size_t Size >
constexpr mat<T, Size> operator*(const mat<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr mat<T, Size> operator*(T x, const mat<T, Size>& ys);

template < typename T, size_t Size >
constexpr vec<T, Size> operator*(const vec<T, Size>& xs, const mat<T, Size>& ys);

template < typename T, size_t Size >
constexpr mat<T, Size> operator*(const mat<T, Size>& xs, const mat<T, Size>& ys);

// operator*=

template < typename T, size_t Size >
constexpr mat<T, Size>& operator*=(mat<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr vec<T, Size>& operator*=(vec<T, Size>& xs, const mat<T, Size>& ys);

template < typename T, size_t Size >
constexpr mat<T, Size>& operator*=(mat<T, Size>& xs, const mat<T, Size>& ys);

// operator/

template < typename T, size_t Size >
constexpr mat<T, Size> operator/(const mat<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr mat<T, Size> operator/(T x, const mat<T, Size>& ys);

template < typename T, size_t Size >
constexpr mat<T, Size> operator/(const mat<T, Size>& xs, const mat<T, Size>& ys);

// operator/=

template < typename T, size_t Size >
constexpr mat<T, Size>& operator/=(mat<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr mat<T, Size>& operator/=(mat<T, Size>& xs, const mat<T, Size>& ys);

// operator==

template < typename T, size_t Size >
constexpr bool operator==(const mat<T, Size>& xs, const mat<T, Size>& ys);

template < typename T, size_t Size >
constexpr bool operator!=(const mat<T, Size>& xs, const mat<T, Size>& ys);

// operator<

template < typename T, size_t Size >
constexpr bool operator<(const mat<T, Size>& xs, const mat<T, Size>& ys);

Angle and Trigonometry Functions

// Scalar

template < floating_point T >
constexpr T radians(T degrees) noexcept;

template < floating_point T >
constexpr T degrees(T radians) noexcept;

template < floating_point T >
T sin(T x) noexcept;

template < floating_point T >
T cos(T x) noexcept;

template < floating_point T >
T tan(T x) noexcept;

template < floating_point T >
T asin(T x) noexcept;

template < floating_point T >
T acos(T x) noexcept;

template < floating_point T >
T atan(T x) noexcept;

template < floating_point T >
T atan2(T y, T x) noexcept;

template < floating_point T >
T sinh(T x) noexcept;

template < floating_point T >
T cosh(T x) noexcept;

template < floating_point T >
T tanh(T x) noexcept;

template < floating_point T >
T asinh(T x) noexcept;

template < floating_point T >
T acosh(T x) noexcept;

template < floating_point T >
T atanh(T x) noexcept;

// Vector

template < typename T, size_t Size >
constexpr vec<T, Size> radians(const vec<T, Size>& degrees);

template < typename T, size_t Size >
constexpr vec<T, Size> degrees(const vec<T, Size>& radians);

template < typename T, size_t Size >
vec<T, Size> sin(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> cos(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> tan(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> asin(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> acos(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> atan(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> atan2(const vec<T, Size>& ys, const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> sinh(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> cosh(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> tanh(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> asinh(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> acosh(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> atanh(const vec<T, Size>& xs);

Exponential Functions

// Scalar

template < floating_point T >
T pow(T x, T y) noexcept;

template < floating_point T >
T exp(T x) noexcept;

template < floating_point T >
T log(T x) noexcept;

template < floating_point T >
T exp2(T x) noexcept;

template < floating_point T >
T log2(T x) noexcept;

template < floating_point T >
T sqrt(T x) noexcept;

template < floating_point T >
T rsqrt(T x) noexcept;

// Vector

template < typename T, size_t Size >
vec<T, Size> pow(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T, size_t Size >
vec<T, Size> exp(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> log(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> exp2(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> log2(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> sqrt(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> rsqrt(const vec<T, Size>& xs);

Common Functions

// Scalar

template < arithmetic T >
constexpr T abs(T x) noexcept;

template < arithmetic T >
constexpr T sign(T x) noexcept;

template < floating_point T >
constexpr T reciprocal(T x) noexcept;

template < floating_point T >
T floor(T x) noexcept;

template < floating_point T >
T trunc(T x) noexcept;

template < floating_point T >
T round(T x) noexcept;

template < floating_point T >
T ceil(T x) noexcept;

template < floating_point T >
T fract(T x) noexcept;

template < floating_point T >
T fmod(T x, T y) noexcept;

template < floating_point T >
T modf(T x, T* y) noexcept;

template < arithmetic T >
constexpr T min(T x, T y) noexcept;

template < arithmetic T >
constexpr T max(T x, T y) noexcept;

template < arithmetic T >
constexpr T clamp(T x, T min_x, T max_x) noexcept;

template < arithmetic T >
constexpr T saturate(T x) noexcept;

template < floating_point T >
constexpr T lerp(T x, T y, T a) noexcept;

template < floating_point T >
constexpr T step(T edge, T x) noexcept;

template < floating_point T >
constexpr T smoothstep(T edge0, T edge1, T x) noexcept;

template < arithmetic T >
bool isnan(T x) noexcept;

template < arithmetic T >
bool isinf(T x) noexcept;

template < arithmetic T >
bool isfinite(T x) noexcept;

template < floating_point T >
T fma(T x, T y, T z) noexcept;

template < floating_point T >
T frexp(T x, int* exp) noexcept;

template < floating_point T >
T ldexp(T x, int exp) noexcept;

// Vector

template < typename T, size_t Size >
constexpr vec<T, Size> abs(const vec<T, Size>& xs);

template < typename T, size_t Size >
constexpr vec<T, Size> sign(const vec<T, Size>& xs);

template < typename T, size_t Size >
constexpr vec<T, Size> reciprocal(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> floor(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> trunc(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> round(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> ceil(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> fract(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> fmod(const vec<T, Size>& xs, T y);

template < typename T, size_t Size >
vec<T, Size> fmod(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T, size_t Size >
vec<T, Size> modf(const vec<T, Size>& xs, vec<T, Size>* is);

template < typename T, size_t Size >
constexpr T min(const vec<T, Size>& xs);

template < typename T, size_t Size >
constexpr vec<T, Size> min(const vec<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr vec<T, Size> min(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr T max(const vec<T, Size>& xs);

template < typename T, size_t Size >
constexpr vec<T, Size> max(const vec<T, Size>& xs, T y);

template < typename T, size_t Size >
constexpr vec<T, Size> max(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr vec<T, Size> clamp(const vec<T, Size>& xs, T min_x, T max_x);

template < typename T, size_t Size >
constexpr vec<T, Size> clamp(const vec<T, Size>& xs, const vec<T, Size>& min_xs, const vec<T, Size>& max_xs);

template < typename T, size_t Size >
constexpr vec<T, Size> saturate(const vec<T, Size>& xs);

template < typename T, size_t Size >
constexpr vec<T, Size> lerp(const vec<T, Size>& xs, const vec<T, Size>& ys, T a);

template < typename T, size_t Size >
constexpr vec<T, Size> lerp(const vec<T, Size>& xs, const vec<T, Size>& ys, const vec<T, Size>& as);

template < typename T, size_t Size >
constexpr vec<T, Size> step(T edge, const vec<T, Size>& xs);

template < typename T, size_t Size >
constexpr vec<T, Size> step(const vec<T, Size>& edges, const vec<T, Size>& xs);

template < typename T, size_t Size >
constexpr vec<T, Size> smoothstep(T edge0, T edge1, const vec<T, Size>& xs);

template < typename T, size_t Size >
constexpr vec<T, Size> smoothstep(const vec<T, Size>& edges0, const vec<T, Size>& edges1, const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<bool, Size> isnan(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<bool, Size> isinf(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<bool, Size> isfinite(const vec<T, Size>& xs);

template < typename T, size_t Size >
vec<T, Size> fma(const vec<T, Size>& as, const vec<T, Size>& bs, const vec<T, Size>& cs);

template < typename T, size_t Size >
vec<T, Size> frexp(const vec<T, Size>& xs, vec<int, Size>* exps);

template < typename T, size_t Size >
vec<T, Size> ldexp(const vec<T, Size>& xs, const vec<int, Size>& exps);

Geometric Functions

// Scalar

template < arithmetic T >
constexpr T dot(T x, T y) noexcept;

template < arithmetic T >
constexpr T length(T x) noexcept;

template < arithmetic T >
constexpr T length2(T x) noexcept;

template < arithmetic T >
constexpr T distance(T x, T y) noexcept;

template < arithmetic T >
constexpr T distance2(T x, T y) noexcept;

template < floating_point T >
T normalize(T x) noexcept;

template < floating_point T >
constexpr T faceforward(T n, T i, T nref) noexcept;

template < floating_point T >
constexpr T reflect(T i, T n) noexcept;

template < floating_point T >
T refract(T i, T n, T eta) noexcept;

// Vector

template < typename T, size_t Size >
constexpr T dot(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T, size_t Size >
T length(const vec<T, Size>& xs);

template < typename T, size_t Size >
constexpr T length2(const vec<T, Size>& xs);

template < typename T, size_t Size >
T distance(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr T distance2(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T >
constexpr T cross(const vec<T, 2>& xs, const vec<T, 2>& ys);

template < typename T >
constexpr vec<T, 3> cross(const vec<T, 3>& xs, const vec<T, 3>& ys);

template < typename T, size_t Size >
vec<T, Size> normalize(const vec<T, Size>& xs);

template < typename T, size_t Size >
constexpr vec<T, Size> faceforward(const vec<T, Size>& n, const vec<T, Size>& i, const vec<T, Size>& nref);

template < typename T, size_t Size >
constexpr vec<T, Size> reflect(const vec<T, Size>& i, const vec<T, Size>& n);

template < typename T, size_t Size >
vec<T, Size> refract(const vec<T, Size>& i, const vec<T, Size>& n, T eta);

Relational Functions

// Scalar

template < arithmetic T >
constexpr bool less(T x, T y) noexcept;

template < arithmetic T >
constexpr bool less_equal(T x, T y) noexcept;

template < arithmetic T >
constexpr bool greater(T x, T y) noexcept;

template < arithmetic T >
constexpr bool greater_equal(T x, T y) noexcept;

template < arithmetic T >
constexpr bool equal_to(T x, T y) noexcept;

template < arithmetic T >
constexpr bool equal_to(T x, T y, T epsilon) noexcept;

template < arithmetic T >
constexpr bool not_equal_to(T x, T y) noexcept;

template < arithmetic T >
constexpr bool not_equal_to(T x, T y, T epsilon) noexcept;

template < arithmetic T >
constexpr bool any(T x) noexcept;

template < arithmetic T >
constexpr bool all(T x) noexcept;

// Vector

template < typename T, size_t Size >
constexpr vec<bool, Size> less(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr vec<bool, Size> less_equal(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr vec<bool, Size> greater(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr vec<bool, Size> greater_equal(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr vec<bool, Size> equal_to(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr vec<bool, Size> equal_to(const vec<T, Size>& xs, const vec<T, Size>& ys, T epsilon);

template < typename T, size_t Size >
constexpr vec<bool, Size> not_equal_to(const vec<T, Size>& xs, const vec<T, Size>& ys);

template < typename T, size_t Size >
constexpr vec<bool, Size> not_equal_to(const vec<T, Size>& xs, const vec<T, Size>& ys, T epsilon);

template < typename T, size_t Size >
constexpr bool any(const vec<T, Size>& xs);

template < typename T, size_t Size >
constexpr bool all(const vec<T, Size>& xs);

Matrix Functions

template < typename T >
constexpr mat<T, 2> transpose(const mat<T, 2>& m);

template < typename T >
constexpr mat<T, 3> transpose(const mat<T, 3>& m);

template < typename T >
constexpr mat<T, 4> transpose(const mat<T, 4>& m);

template < typename T >
constexpr T determinant(const mat<T, 2>& m);

template < typename T >
constexpr T determinant(const mat<T, 3>& m);

template < typename T >
constexpr T determinant(const mat<T, 4>& m);

template < typename T >
constexpr mat<T, 2> inverse(const mat<T, 2>& m);

template < typename T >
constexpr mat<T, 3> inverse(const mat<T, 3>& m);

template < typename T >
constexpr mat<T, 4> inverse(const mat<T, 4>& m);

Units

template < typename T > inline constexpr vec<T, 2> zero2;
template < typename T > inline constexpr vec<T, 3> zero3;
template < typename T > inline constexpr vec<T, 4> zero4;

template < typename T > inline constexpr vec<T, 2> unit2;
template < typename T > inline constexpr vec<T, 3> unit3;
template < typename T > inline constexpr vec<T, 4> unit4;

template < typename T > inline constexpr vec<T, 2> unit2_x;
template < typename T > inline constexpr vec<T, 2> unit2_y;

template < typename T > inline constexpr vec<T, 3> unit3_x;
template < typename T > inline constexpr vec<T, 3> unit3_y;
template < typename T > inline constexpr vec<T, 3> unit3_z;

template < typename T > inline constexpr vec<T, 4> unit4_x;
template < typename T > inline constexpr vec<T, 4> unit4_y;
template < typename T > inline constexpr vec<T, 4> unit4_z;
template < typename T > inline constexpr vec<T, 4> unit4_w;

template < typename T > inline constexpr mat<T, 2> zero2x2;
template < typename T > inline constexpr mat<T, 3> zero3x3;
template < typename T > inline constexpr mat<T, 4> zero4x4;

template < typename T > inline constexpr mat<T, 2> unit2x2;
template < typename T > inline constexpr mat<T, 3> unit3x3;
template < typename T > inline constexpr mat<T, 4> unit4x4;

template < typename T > inline constexpr mat<T, 2> identity2x2;
template < typename T > inline constexpr mat<T, 3> identity3x3;
template < typename T > inline constexpr mat<T, 4> identity4x4;

Cast

template < arithmetic To, arithmetic From >
constexpr To cast_to(From x) noexcept;

template < typename To, typename From, size_t Size >
constexpr vec<To, Size> cast_to(const vec<From, Size>& v);

template < typename To, typename From, size_t Size >
constexpr mat<To, Size> cast_to(const mat<From, Size>& m);

Access

template < typename T, size_t Size >
constexpr T component(const vec<T, Size>& v, size_t index);

template < typename T, size_t Size >
constexpr vec<T, Size> component(vec<T, Size> v, size_t index, T x);

template < typename T, size_t Size >
constexpr vec<T, Size> row(const mat<T, Size>& m, size_t index);

template < typename T, size_t Size >
constexpr mat<T, Size> row(mat<T, Size> m, size_t index, const vec<T, Size>& v);

template < typename T, size_t Size >
constexpr vec<T, Size> column(const mat<T, Size>& m, size_t index);

template < typename T, size_t Size >
constexpr mat<T, Size> column(const mat<T, Size>& m, size_t index, const vec<T, Size>& v);

Matrix Transform 3D

template < typename T >
constexpr mat<T, 4> translate(const vec<T, 3>& v);

template < typename T >
constexpr mat<T, 4> translate(const mat<T, 4>& m, const vec<T, 3>& v);

template < typename T >
mat<T, 4> rotate(T angle, const vec<T, 3>& axis);

template < typename T >
mat<T, 4> rotate(const mat<T, 4>& m, T angle, const vec<T, 3>& axis);

template < typename T >
constexpr mat<T, 4> scale(const vec<T, 3>& v);

template < typename T >
constexpr mat<T, 4> scale(const mat<T, 4>& m, const vec<T, 3>& v);

template < typename T >
mat<T, 4> look_at_lh(const vec<T, 3>& eye, const vec<T, 3>& at, const vec<T, 3>& up);

template < typename T >
mat<T, 4> look_at_rh(const vec<T, 3>& eye, const vec<T, 3>& at, const vec<T, 3>& up);

Matrix Transform 2D

template < typename T >
constexpr mat<T, 3> translate(const vec<T, 2>& v);

template < typename T >
constexpr mat<T, 3> translate(const mat<T, 3>& m, const vec<T, 2>& v);

template < typename T >
mat<T, 3> rotate(T angle);

template < typename T >
mat<T, 3> rotate(const mat<T, 3>& m, T angle);

template < typename T >
constexpr mat<T, 3> scale(const vec<T, 2>& v);

template < typename T >
constexpr mat<T, 3> scale(const mat<T, 3>& m, const vec<T, 2>& v);

template < typename T >
constexpr mat<T, 3> shear(const vec<T, 2>& v);

template < typename T >
constexpr mat<T, 3> shear(const mat<T, 3>& m, const vec<T, 2>& v);

template < typename T >
constexpr mat<T, 3> shear_x(T y);

template < typename T >
constexpr mat<T, 3> shear_x(const mat<T, 3>& m, T y);

template < typename T >
constexpr mat<T, 3> shear_y(T x);

template < typename T >
constexpr mat<T, 3> shear_y(const mat<T, 3>& m, T x);

Matrix Projections

template < typename T >
mat<T, 4> orthographic_lh_zo(T left, T right, T bottom, T top, T znear, T zfar);

template < typename T >
mat<T, 4> orthographic_lh_no(T left, T right, T bottom, T top, T znear, T zfar);

template < typename T >
mat<T, 4> orthographic_rh_zo(T left, T right, T bottom, T top, T znear, T zfar);

template < typename T >
mat<T, 4> orthographic_rh_no(T left, T right, T bottom, T top, T znear, T zfar);

template < typename T >
mat<T, 4> perspective_lh_zo(T fov, T aspect, T znear, T zfar);

template < typename T >
mat<T, 4> perspective_lh_no(T fov, T aspect, T znear, T zfar);

template < typename T >
mat<T, 4> perspective_rh_zo(T fov, T aspect, T znear, T zfar);

template < typename T >
mat<T, 4> perspective_rh_no(T fov, T aspect, T znear, T zfar);

Vector Transform

template < typename T, size_t Size >
T angle(const vec<T, Size>& x, const vec<T, Size>& y);

template < typename T >
vec<T, 2> rotate(const vec<T, 2>& v, T angle);

template < typename T >
vec<T, 3> rotate(const vec<T, 3>& v, T angle, const vec<T, 3>& normal);

template < typename T >
vec<T, 4> rotate(const vec<T, 4>& v, T angle, const vec<T, 3>& normal);

License (MIT)