Skip to content

Namespace linalg

Namespace List > linalg

Namespaces

Type Name
namespace aliases
namespace detail
namespace ostream_overloads

Classes

Type Name
struct converter <class T, class U>
struct converter< mat< T, 1, 1 >, identity_t > <class T>
struct converter< mat< T, 2, 2 >, identity_t > <class T>
struct converter< mat< T, 3, 3 >, identity_t > <class T>
struct converter< mat< T, 4, 4 >, identity_t > <class T>
struct converter< std::array< T, 1 >, vec< T, 1 > > <class T>
struct converter< std::array< T, 2 >, vec< T, 2 > > <class T>
struct converter< std::array< T, 3 >, vec< T, 3 > > <class T>
struct converter< std::array< T, 4 >, vec< T, 4 > > <class T>
struct converter< vec< T, 1 >, std::array< T, 1 > > <class T>
struct converter< vec< T, 2 >, std::array< T, 2 > > <class T>
struct converter< vec< T, 3 >, std::array< T, 3 > > <class T>
struct converter< vec< T, 4 >, std::array< T, 4 > > <class T>
struct identity_t
struct mat <class T, M, N>
struct mat< T, M, 1 > <class T, M>
struct mat< T, M, 2 > <class T, M>
struct mat< T, M, 3 > <class T, M>
struct mat< T, M, 4 > <class T, M>
struct vec <class T, M>
struct vec< T, 1 > <class T>
struct vec< T, 2 > <class T>
struct vec< T, 3 > <class T>
struct vec< T, 4 > <class T>

Public Types

Type Name
typedef typename detail::apply< F, void, A... >::type apply_t
enum fwd_axis
typedef typename detail::scalar_type< A >::type scalar_t
enum z_range

Public Attributes

Type Name
constexpr identity_t identity = {1}

Public Functions

Type Name
apply_t< detail::std_abs, A > abs (const A & a)
apply_t< detail::std_acos, A > acos (const A & a)
constexpr mat< T, 1, 1 > adjugate (const mat< T, 1, 1 > &)
constexpr mat< T, 2, 2 > adjugate (const mat< T, 2, 2 > & a)
constexpr mat< T, 3, 3 > adjugate (const mat< T, 3, 3 > & a)
constexpr mat< T, 4, 4 > adjugate (const mat< T, 4, 4 > & a)
constexpr bool all (const A & a)
T angle (const vec< T, M > & a, const vec< T, M > & b)
constexpr bool any (const A & a)
constexpr apply_t< F, A... > apply (F func, const A &... args)
int argmax (const vec< T, M > & a)
int argmin (const vec< T, M > & a)
apply_t< detail::std_asin, A > asin (const A & a)
apply_t< detail::std_atan, A > atan (const A & a)
apply_t< detail::std_atan2, A, B > atan2 (const A & a, const B & b)
T * begin (vec< T, M > & a)
const T * begin (const vec< T, M > & a)
vec< T, M > * begin (mat< T, M, N > & a)
const vec< T, M > * begin (const mat< T, M, N > & a)
apply_t< detail::std_ceil, A > ceil (const A & a)
constexpr apply_t< detail::clamp, X, L, H > clamp (const X & x, const L & l, const H & h)
constexpr mat< T, N, N > comatrix (const mat< T, N, N > & a)
constexpr detail::any_compare< A, B >::type compare (const A & a, const B & b)
apply_t< detail::std_copysign, A, B > copysign (const A & a, const B & b)
apply_t< detail::std_cos, A > cos (const A & a)
apply_t< detail::std_cosh, A > cosh (const A & a)
constexpr T cross (const vec< T, 2 > & a, const vec< T, 2 > & b)
constexpr vec< T, 2 > cross (T a, const vec< T, 2 > & b)
constexpr vec< T, 2 > cross (const vec< T, 2 > & a, T b)
constexpr vec< T, 3 > cross (const vec< T, 3 > & a, const vec< T, 3 > & b)
constexpr T determinant (const mat< T, 1, 1 > & a)
constexpr T determinant (const mat< T, 2, 2 > & a)
constexpr T determinant (const mat< T, 3, 3 > & a)
constexpr T determinant (const mat< T, 4, 4 > & a)
constexpr vec< T, 1 > diagonal (const mat< T, 1, 1 > & a)
constexpr vec< T, 2 > diagonal (const mat< T, 2, 2 > & a)
constexpr vec< T, 3 > diagonal (const mat< T, 3, 3 > & a)
constexpr vec< T, 4 > diagonal (const mat< T, 4, 4 > & a)
T distance (const vec< T, M > & a, const vec< T, M > & b)
constexpr T distance2 (const vec< T, M > & a, const vec< T, M > & b)
constexpr T dot (const vec< T, M > & a, const vec< T, M > & b)
T * end (vec< T, M > & a)
const T * end (const vec< T, M > & a)
vec< T, M > * end (mat< T, M, N > & a)
const vec< T, M > * end (const mat< T, M, N > & a)
constexpr apply_t< detail::op_eq, A, B > equal (const A & a, const B & b)
apply_t< detail::std_exp, A > exp (const A & a)
apply_t< detail::std_floor, A > floor (const A & a)
apply_t< detail::std_fmod, A, B > fmod (const A & a, const B & b)
constexpr A fold (F f, A a, const vec< B, 1 > & b)
constexpr A fold (F f, A a, const vec< B, 2 > & b)
constexpr A fold (F f, A a, const vec< B, 3 > & b)
constexpr A fold (F f, A a, const vec< B, 4 > & b)
constexpr A fold (F f, A a, const mat< B, M, 1 > & b)
constexpr A fold (F f, A a, const mat< B, M, 2 > & b)
constexpr A fold (F f, A a, const mat< B, M, 3 > & b)
constexpr A fold (F f, A a, const mat< B, M, 4 > & b)
mat< T, 4, 4 > frustum_matrix (T x0, T x1, T y0, T y1, T n, T f, fwd_axis a=neg_z, z_range z=neg_one_to_one)
constexpr apply_t< detail::op_ge, A, B > gequal (const A & a, const B & b)
constexpr apply_t< detail::op_gt, A, B > greater (const A & a, const B & b)
constexpr mat< T, N, N > inverse (const mat< T, N, N > & a)
T length (const vec< T, M > & a)
constexpr T length2 (const vec< T, M > & a)
constexpr apply_t< detail::op_le, A, B > lequal (const A & a, const B & b)
constexpr apply_t< detail::lerp, A, B, T > lerp (const A & a, const B & b, const T & t)
constexpr apply_t< detail::op_lt, A, B > less (const A & a, const B & b)
apply_t< detail::std_log, A > log (const A & a)
apply_t< detail::std_log10, A > log10 (const A & a)
constexpr apply_t< F, A > map (const A & a, F func)
constexpr apply_t< detail::max, A, B > max (const A & a, const B & b)
constexpr scalar_t< A > maxelem (const A & a)
constexpr apply_t< detail::min, A, B > min (const A & a, const B & b)
constexpr scalar_t< A > minelem (const A & a)
constexpr vec< T, M > mul (const mat< T, M, 1 > & a, const vec< T, 1 > & b)
constexpr vec< T, M > mul (const mat< T, M, 2 > & a, const vec< T, 2 > & b)
constexpr vec< T, M > mul (const mat< T, M, 3 > & a, const vec< T, 3 > & b)
constexpr vec< T, M > mul (const mat< T, M, 4 > & a, const vec< T, 4 > & b)
constexpr mat< T, M, 1 > mul (const mat< T, M, N > & a, const mat< T, N, 1 > & b)
constexpr mat< T, M, 2 > mul (const mat< T, M, N > & a, const mat< T, N, 2 > & b)
constexpr mat< T, M, 3 > mul (const mat< T, M, N > & a, const mat< T, N, 3 > & b)
constexpr mat< T, M, 4 > mul (const mat< T, M, N > & a, const mat< T, N, 4 > & b)
constexpr vec< T, M > mul (const mat< T, M, N > & a, const mat< T, N, P > & b, const vec< T, P > & c)
constexpr mat< T, M, Q > mul (const mat< T, M, N > & a, const mat< T, N, P > & b, const mat< T, P, Q > & c)
constexpr vec< T, M > mul (const mat< T, M, N > & a, const mat< T, N, P > & b, const mat< T, P, Q > & c, const vec< T, Q > & d)
constexpr mat< T, M, R > mul (const mat< T, M, N > & a, const mat< T, N, P > & b, const mat< T, P, Q > & c, const mat< T, Q, R > & d)
constexpr apply_t< detail::op_ne, A, B > nequal (const A & a, const B & b)
vec< T, M > nlerp (const vec< T, M > & a, const vec< T, M > & b, T t)
vec< T, M > normalize (const vec< T, M > & a)
constexpr apply_t< detail::op_not, A > operator! (const A & a)
virtual constexpr auto operator!= (const A & a, const B & b) = 0
constexpr apply_t< detail::op_mod, A, B > operator% (const A & a, const B & b)
constexpr auto operator%= (A & a, const B & b)
constexpr apply_t< detail::op_int, A, B > operator& (const A & a, const B & b)
constexpr auto operator&= (A & a, const B & b)
constexpr apply_t< detail::op_mul, A, B > operator* (const A & a, const B & b)
constexpr auto operator*= (A & a, const B & b)
constexpr apply_t< detail::op_pos, A > operator+ (const A & a)
constexpr apply_t< detail::op_add, A, B > operator+ (const A & a, const B & b)
constexpr auto operator+= (A & a, const B & b)
constexpr apply_t< detail::op_neg, A > operator- (const A & a)
constexpr apply_t< detail::op_sub, A, B > operator- (const A & a, const B & b)
constexpr auto operator-= (A & a, const B & b)
constexpr apply_t< detail::op_div, A, B > operator/ (const A & a, const B & b)
constexpr auto operator/= (A & a, const B & b)
constexpr auto operator< (const A & a, const B & b)
constexpr apply_t< detail::op_lsh, A, B > operator<< (const A & a, const B & b)
constexpr auto operator<<= (A & a, const B & b)
virtual constexpr auto operator<= (const A & a, const B & b) = 0
virtual constexpr auto operator== (const A & a, const B & b) = 0
constexpr auto operator> (const A & a, const B & b)
virtual constexpr auto operator>= (const A & a, const B & b) = 0
constexpr apply_t< detail::op_rsh, A, B > operator>> (const A & a, const B & b)
constexpr auto operator>>= (A & a, const B & b)
constexpr apply_t< detail::op_xor, A, B > operator^ (const A & a, const B & b)
constexpr auto operator^= (A & a, const B & b)
constexpr apply_t< detail::op_un, A, B > operator| (const A & a, const B & b)
constexpr auto operator|= (A & a, const B & b)
constexpr apply_t< detail::op_cmp, A > operator~ (const A & a)
constexpr mat< T, M, 1 > outerprod (const vec< T, M > & a, const vec< T, 1 > & b)
constexpr mat< T, M, 2 > outerprod (const vec< T, M > & a, const vec< T, 2 > & b)
constexpr mat< T, M, 3 > outerprod (const vec< T, M > & a, const vec< T, 3 > & b)
constexpr mat< T, M, 4 > outerprod (const vec< T, M > & a, const vec< T, 4 > & b)
mat< T, 4, 4 > perspective_matrix (T fovy, T aspect, T n, T f, fwd_axis a=neg_z, z_range z=neg_one_to_one)
mat< T, 4, 4 > pose_matrix (const vec< T, 4 > & q, const vec< T, 3 > & p)
apply_t< detail::std_pow, A, B > pow (const A & a, const B & b)
constexpr scalar_t< A > product (const A & a)
T qangle (const vec< T, 4 > & q)
vec< T, 3 > qaxis (const vec< T, 4 > & q)
constexpr vec< T, 4 > qconj (const vec< T, 4 > & q)
vec< T, 4 > qexp (const vec< T, 4 > & q)
vec< T, 4 > qinv (const vec< T, 4 > & q)
vec< T, 4 > qlog (const vec< T, 4 > & q)
constexpr mat< T, 3, 3 > qmat (const vec< T, 4 > & q)
constexpr vec< T, 4 > qmul (const vec< T, 4 > & a, const vec< T, 4 > & b)
constexpr vec< T, 4 > qmul (const vec< T, 4 > & a, R... r)
vec< T, 4 > qnlerp (const vec< T, 4 > & a, const vec< T, 4 > & b, T t)
vec< T, 4 > qpow (const vec< T, 4 > & q, const T & p)
constexpr vec< T, 3 > qrot (const vec< T, 4 > & q, const vec< T, 3 > & v)
vec< T, 4 > qslerp (const vec< T, 4 > & a, const vec< T, 4 > & b, T t)
constexpr vec< T, 3 > qxdir (const vec< T, 4 > & q)
constexpr vec< T, 3 > qydir (const vec< T, 4 > & q)
constexpr vec< T, 3 > qzdir (const vec< T, 4 > & q)
vec< T, 2 > rot (T a, const vec< T, 2 > & v)
mat< T, 4, 4 > rotation_matrix (const vec< T, 4 > & rotation)
vec< T, 4 > rotation_quat (const vec< T, 3 > & axis, T angle)
vec< T, 4 > rotation_quat (const mat< T, 3, 3 > & m)
apply_t< detail::std_round, A > round (const A & a)
mat< T, 4, 4 > scaling_matrix (const vec< T, 3 > & scaling)
constexpr apply_t< detail::select, P, A, B > select (const P & p, const A & a, const B & b)
apply_t< detail::std_sin, A > sin (const A & a)
apply_t< detail::std_sinh, A > sinh (const A & a)
vec< T, M > slerp (const vec< T, M > & a, const vec< T, M > & b, T t)
apply_t< detail::std_sqrt, A > sqrt (const A & a)
constexpr mat< T, I1-I0, J1-J0 > submat (const mat< T, M, N > & a)
constexpr vec< T, I1-I0 > subvec (const vec< T, M > & a)
constexpr scalar_t< A > sum (const A & a)
constexpr vec< T, sizeof...(I)> swizzle (const vec< T, M > & a)
apply_t< detail::std_tan, A > tan (const A & a)
apply_t< detail::std_tanh, A > tanh (const A & a)
constexpr T trace (const mat< T, N, N > & a)
mat< T, 4, 4 > translation_matrix (const vec< T, 3 > & translation)
constexpr mat< T, M, 1 > transpose (const mat< T, 1, M > & m)
constexpr mat< T, M, 2 > transpose (const mat< T, 2, M > & m)
constexpr mat< T, M, 3 > transpose (const mat< T, 3, M > & m)
constexpr mat< T, M, 4 > transpose (const mat< T, 4, M > & m)
T uangle (const vec< T, M > & a, const vec< T, M > & b)
constexpr apply_t< F, A, B > zip (const A & a, const B & b, F func)

Public Types Documentation

typedef apply_t

using linalg::apply_t = typedef typename detail::apply<F,void,A...>::type;

enum fwd_axis

enum linalg::fwd_axis {
    neg_z,
    pos_z
};

typedef scalar_t

using linalg::scalar_t = typedef typename detail::scalar_type<A>::type;

enum z_range

enum linalg::z_range {
    neg_one_to_one,
    zero_to_one
};

Public Attributes Documentation

variable identity

constexpr identity_t linalg::identity;

Public Functions Documentation

function abs

template<class A>
apply_t< detail::std_abs, A > linalg::abs (
    const A & a
)

function acos

template<class A>
apply_t< detail::std_acos, A > linalg::acos (
    const A & a
)

function adjugate

template<class T>
constexpr mat< T, 1, 1 > linalg::adjugate (
    const mat< T, 1, 1 > &
)

function adjugate

template<class T>
constexpr mat< T, 2, 2 > linalg::adjugate (
    const mat< T, 2, 2 > & a
)

function adjugate

template<class T>
constexpr mat< T, 3, 3 > linalg::adjugate (
    const mat< T, 3, 3 > & a
)

function adjugate

template<class T>
constexpr mat< T, 4, 4 > linalg::adjugate (
    const mat< T, 4, 4 > & a
)

function all

template<class A>
constexpr bool linalg::all (
    const A & a
)

function angle

template<class T, int M>
T linalg::angle (
    const vec< T, M > & a,
    const vec< T, M > & b
)

function any

template<class A>
constexpr bool linalg::any (
    const A & a
)

function apply

template<class F, class... A>
constexpr apply_t< F, A... > linalg::apply (
    F func,
    const A &... args
)

function argmax

template<class T, int M>
int linalg::argmax (
    const vec< T, M > & a
)

function argmin

template<class T, int M>
int linalg::argmin (
    const vec< T, M > & a
)

function asin

template<class A>
apply_t< detail::std_asin, A > linalg::asin (
    const A & a
)

function atan

template<class A>
apply_t< detail::std_atan, A > linalg::atan (
    const A & a
)

function atan2

template<class A, class B>
apply_t< detail::std_atan2, A, B > linalg::atan2 (
    const A & a,
    const B & b
)

function begin

template<class T, int M>
T * linalg::begin (
    vec< T, M > & a
)

function begin

template<class T, int M>
const T * linalg::begin (
    const vec< T, M > & a
)

function begin

template<class T, int M, int N>
vec< T, M > * linalg::begin (
    mat< T, M, N > & a
)

function begin

template<class T, int M, int N>
const vec< T, M > * linalg::begin (
    const mat< T, M, N > & a
)

function ceil

template<class A>
apply_t< detail::std_ceil, A > linalg::ceil (
    const A & a
)

function clamp

template<class X, class L, class H>
constexpr apply_t< detail::clamp, X, L, H > linalg::clamp (
    const X & x,
    const L & l,
    const H & h
)

function comatrix

template<class T, int N>
constexpr mat< T, N, N > linalg::comatrix (
    const mat< T, N, N > & a
)

function compare

template<class A, class B>
constexpr detail::any_compare< A, B >::type linalg::compare (
    const A & a,
    const B & b
)

function copysign

template<class A, class B>
apply_t< detail::std_copysign, A, B > linalg::copysign (
    const A & a,
    const B & b
)

function cos

template<class A>
apply_t< detail::std_cos, A > linalg::cos (
    const A & a
)

function cosh

template<class A>
apply_t< detail::std_cosh, A > linalg::cosh (
    const A & a
)

function cross

template<class T>
constexpr T linalg::cross (
    const vec< T, 2 > & a,
    const vec< T, 2 > & b
)

function cross

template<class T>
constexpr vec< T, 2 > linalg::cross (
    T a,
    const vec< T, 2 > & b
)

function cross

template<class T>
constexpr vec< T, 2 > linalg::cross (
    const vec< T, 2 > & a,
    T b
)

function cross

template<class T>
constexpr vec< T, 3 > linalg::cross (
    const vec< T, 3 > & a,
    const vec< T, 3 > & b
)

function determinant

template<class T>
constexpr T linalg::determinant (
    const mat< T, 1, 1 > & a
)

function determinant

template<class T>
constexpr T linalg::determinant (
    const mat< T, 2, 2 > & a
)

function determinant

template<class T>
constexpr T linalg::determinant (
    const mat< T, 3, 3 > & a
)

function determinant

template<class T>
constexpr T linalg::determinant (
    const mat< T, 4, 4 > & a
)

function diagonal

template<class T>
constexpr vec< T, 1 > linalg::diagonal (
    const mat< T, 1, 1 > & a
)

function diagonal

template<class T>
constexpr vec< T, 2 > linalg::diagonal (
    const mat< T, 2, 2 > & a
)

function diagonal

template<class T>
constexpr vec< T, 3 > linalg::diagonal (
    const mat< T, 3, 3 > & a
)

function diagonal

template<class T>
constexpr vec< T, 4 > linalg::diagonal (
    const mat< T, 4, 4 > & a
)

function distance

template<class T, int M>
T linalg::distance (
    const vec< T, M > & a,
    const vec< T, M > & b
)

function distance2

template<class T, int M>
constexpr T linalg::distance2 (
    const vec< T, M > & a,
    const vec< T, M > & b
)

function dot

template<class T, int M>
constexpr T linalg::dot (
    const vec< T, M > & a,
    const vec< T, M > & b
)

function end

template<class T, int M>
T * linalg::end (
    vec< T, M > & a
)

function end

template<class T, int M>
const T * linalg::end (
    const vec< T, M > & a
)

function end

template<class T, int M, int N>
vec< T, M > * linalg::end (
    mat< T, M, N > & a
)

function end

template<class T, int M, int N>
const vec< T, M > * linalg::end (
    const mat< T, M, N > & a
)

function equal

template<class A, class B>
constexpr apply_t< detail::op_eq, A, B > linalg::equal (
    const A & a,
    const B & b
)

function exp

template<class A>
apply_t< detail::std_exp, A > linalg::exp (
    const A & a
)

function floor

template<class A>
apply_t< detail::std_floor, A > linalg::floor (
    const A & a
)

function fmod

template<class A, class B>
apply_t< detail::std_fmod, A, B > linalg::fmod (
    const A & a,
    const B & b
)

function fold

template<class F, class A, class B>
constexpr A linalg::fold (
    F f,
    A a,
    const vec< B, 1 > & b
)

function fold

template<class F, class A, class B>
constexpr A linalg::fold (
    F f,
    A a,
    const vec< B, 2 > & b
)

function fold

template<class F, class A, class B>
constexpr A linalg::fold (
    F f,
    A a,
    const vec< B, 3 > & b
)

function fold

template<class F, class A, class B>
constexpr A linalg::fold (
    F f,
    A a,
    const vec< B, 4 > & b
)

function fold

template<class F, class A, class B, int M>
constexpr A linalg::fold (
    F f,
    A a,
    const mat< B, M, 1 > & b
)

function fold

template<class F, class A, class B, int M>
constexpr A linalg::fold (
    F f,
    A a,
    const mat< B, M, 2 > & b
)

function fold

template<class F, class A, class B, int M>
constexpr A linalg::fold (
    F f,
    A a,
    const mat< B, M, 3 > & b
)

function fold

template<class F, class A, class B, int M>
constexpr A linalg::fold (
    F f,
    A a,
    const mat< B, M, 4 > & b
)

function frustum_matrix

template<class T>
mat< T, 4, 4 > linalg::frustum_matrix (
    T x0,
    T x1,
    T y0,
    T y1,
    T n,
    T f,
    fwd_axis a=neg_z,
    z_range z=neg_one_to_one
)

function gequal

template<class A, class B>
constexpr apply_t< detail::op_ge, A, B > linalg::gequal (
    const A & a,
    const B & b
)

function greater

template<class A, class B>
constexpr apply_t< detail::op_gt, A, B > linalg::greater (
    const A & a,
    const B & b
)

function inverse

template<class T, int N>
constexpr mat< T, N, N > linalg::inverse (
    const mat< T, N, N > & a
)

function length

template<class T, int M>
T linalg::length (
    const vec< T, M > & a
)

function length2

template<class T, int M>
constexpr T linalg::length2 (
    const vec< T, M > & a
)

function lequal

template<class A, class B>
constexpr apply_t< detail::op_le, A, B > linalg::lequal (
    const A & a,
    const B & b
)

function lerp

template<class A, class B, class T>
constexpr apply_t< detail::lerp, A, B, T > linalg::lerp (
    const A & a,
    const B & b,
    const T & t
)

function less

template<class A, class B>
constexpr apply_t< detail::op_lt, A, B > linalg::less (
    const A & a,
    const B & b
)

function log

template<class A>
apply_t< detail::std_log, A > linalg::log (
    const A & a
)

function log10

template<class A>
apply_t< detail::std_log10, A > linalg::log10 (
    const A & a
)

function map

template<class A, class F>
constexpr apply_t< F, A > linalg::map (
    const A & a,
    F func
)

function max

template<class A, class B>
constexpr apply_t< detail::max, A, B > linalg::max (
    const A & a,
    const B & b
)

function maxelem

template<class A>
constexpr scalar_t< A > linalg::maxelem (
    const A & a
)

function min

template<class A, class B>
constexpr apply_t< detail::min, A, B > linalg::min (
    const A & a,
    const B & b
)

function minelem

template<class A>
constexpr scalar_t< A > linalg::minelem (
    const A & a
)

function mul

template<class T, int M>
constexpr vec< T, M > linalg::mul (
    const mat< T, M, 1 > & a,
    const vec< T, 1 > & b
)

function mul

template<class T, int M>
constexpr vec< T, M > linalg::mul (
    const mat< T, M, 2 > & a,
    const vec< T, 2 > & b
)

function mul

template<class T, int M>
constexpr vec< T, M > linalg::mul (
    const mat< T, M, 3 > & a,
    const vec< T, 3 > & b
)

function mul

template<class T, int M>
constexpr vec< T, M > linalg::mul (
    const mat< T, M, 4 > & a,
    const vec< T, 4 > & b
)

function mul

template<class T, int M, int N>
constexpr mat< T, M, 1 > linalg::mul (
    const mat< T, M, N > & a,
    const mat< T, N, 1 > & b
)

function mul

template<class T, int M, int N>
constexpr mat< T, M, 2 > linalg::mul (
    const mat< T, M, N > & a,
    const mat< T, N, 2 > & b
)

function mul

template<class T, int M, int N>
constexpr mat< T, M, 3 > linalg::mul (
    const mat< T, M, N > & a,
    const mat< T, N, 3 > & b
)

function mul

template<class T, int M, int N>
constexpr mat< T, M, 4 > linalg::mul (
    const mat< T, M, N > & a,
    const mat< T, N, 4 > & b
)

function mul

template<class T, int M, int N, int P>
constexpr vec< T, M > linalg::mul (
    const mat< T, M, N > & a,
    const mat< T, N, P > & b,
    const vec< T, P > & c
)

function mul

template<class T, int M, int N, int P, int Q>
constexpr mat< T, M, Q > linalg::mul (
    const mat< T, M, N > & a,
    const mat< T, N, P > & b,
    const mat< T, P, Q > & c
)

function mul

template<class T, int M, int N, int P, int Q>
constexpr vec< T, M > linalg::mul (
    const mat< T, M, N > & a,
    const mat< T, N, P > & b,
    const mat< T, P, Q > & c,
    const vec< T, Q > & d
)

function mul

template<class T, int M, int N, int P, int Q, int R>
constexpr mat< T, M, R > linalg::mul (
    const mat< T, M, N > & a,
    const mat< T, N, P > & b,
    const mat< T, P, Q > & c,
    const mat< T, Q, R > & d
)

function nequal

template<class A, class B>
constexpr apply_t< detail::op_ne, A, B > linalg::nequal (
    const A & a,
    const B & b
)

function nlerp

template<class T, int M>
vec< T, M > linalg::nlerp (
    const vec< T, M > & a,
    const vec< T, M > & b,
    T t
)

function normalize

template<class T, int M>
vec< T, M > linalg::normalize (
    const vec< T, M > & a
)

function operator!

template<class A>
constexpr apply_t< detail::op_not, A > linalg::operator! (
    const A & a
)

function operator!=

template<class A, class B>
virtual constexpr auto linalg::operator!= (
    const A & a,
    const B & b
) = 0

function operator%

template<class A, class B>
constexpr apply_t< detail::op_mod, A, B > linalg::operator% (
    const A & a,
    const B & b
)

function operator%=

template<class A, class B>
constexpr auto linalg::operator%= (
    A & a,
    const B & b
)

function operator&

template<class A, class B>
constexpr apply_t< detail::op_int, A, B > linalg::operator& (
    const A & a,
    const B & b
)

function operator&=

template<class A, class B>
constexpr auto linalg::operator&= (
    A & a,
    const B & b
)

function operator*

template<class A, class B>
constexpr apply_t< detail::op_mul, A, B > linalg::operator* (
    const A & a,
    const B & b
)

function operator*=

template<class A, class B>
constexpr auto linalg::operator*= (
    A & a,
    const B & b
)

function operator+

template<class A>
constexpr apply_t< detail::op_pos, A > linalg::operator+ (
    const A & a
)

function operator+

template<class A, class B>
constexpr apply_t< detail::op_add, A, B > linalg::operator+ (
    const A & a,
    const B & b
)

function operator+=

template<class A, class B>
constexpr auto linalg::operator+= (
    A & a,
    const B & b
)

function operator-

template<class A>
constexpr apply_t< detail::op_neg, A > linalg::operator- (
    const A & a
)

function operator-

template<class A, class B>
constexpr apply_t< detail::op_sub, A, B > linalg::operator- (
    const A & a,
    const B & b
)

function operator-=

template<class A, class B>
constexpr auto linalg::operator-= (
    A & a,
    const B & b
)

function operator/

template<class A, class B>
constexpr apply_t< detail::op_div, A, B > linalg::operator/ (
    const A & a,
    const B & b
)

function operator/=

template<class A, class B>
constexpr auto linalg::operator/= (
    A & a,
    const B & b
)

function operator<

template<class A, class B>
constexpr auto linalg::operator< (
    const A & a,
    const B & b
)

function operator<<

template<class A, class B>
constexpr apply_t< detail::op_lsh, A, B > linalg::operator<< (
    const A & a,
    const B & b
)

function operator<<=

template<class A, class B>
constexpr auto linalg::operator<<= (
    A & a,
    const B & b
)

function operator<=

template<class A, class B>
virtual constexpr auto linalg::operator<= (
    const A & a,
    const B & b
) = 0

function operator==

template<class A, class B>
virtual constexpr auto linalg::operator== (
    const A & a,
    const B & b
) = 0

function operator>

template<class A, class B>
constexpr auto linalg::operator> (
    const A & a,
    const B & b
)

function operator>=

template<class A, class B>
virtual constexpr auto linalg::operator>= (
    const A & a,
    const B & b
) = 0

function operator>>

template<class A, class B>
constexpr apply_t< detail::op_rsh, A, B > linalg::operator>> (
    const A & a,
    const B & b
)

function operator>>=

template<class A, class B>
constexpr auto linalg::operator>>= (
    A & a,
    const B & b
)

function operator^

template<class A, class B>
constexpr apply_t< detail::op_xor, A, B > linalg::operator^ (
    const A & a,
    const B & b
)

function operator^=

template<class A, class B>
constexpr auto linalg::operator^= (
    A & a,
    const B & b
)

function operator|

template<class A, class B>
constexpr apply_t< detail::op_un, A, B > linalg::operator| (
    const A & a,
    const B & b
)

function operator|=

template<class A, class B>
constexpr auto linalg::operator|= (
    A & a,
    const B & b
)

function operator~

template<class A>
constexpr apply_t< detail::op_cmp, A > linalg::operator~ (
    const A & a
)

function outerprod

template<class T, int M>
constexpr mat< T, M, 1 > linalg::outerprod (
    const vec< T, M > & a,
    const vec< T, 1 > & b
)

function outerprod

template<class T, int M>
constexpr mat< T, M, 2 > linalg::outerprod (
    const vec< T, M > & a,
    const vec< T, 2 > & b
)

function outerprod

template<class T, int M>
constexpr mat< T, M, 3 > linalg::outerprod (
    const vec< T, M > & a,
    const vec< T, 3 > & b
)

function outerprod

template<class T, int M>
constexpr mat< T, M, 4 > linalg::outerprod (
    const vec< T, M > & a,
    const vec< T, 4 > & b
)

function perspective_matrix

template<class T>
mat< T, 4, 4 > linalg::perspective_matrix (
    T fovy,
    T aspect,
    T n,
    T f,
    fwd_axis a=neg_z,
    z_range z=neg_one_to_one
)

function pose_matrix

template<class T>
mat< T, 4, 4 > linalg::pose_matrix (
    const vec< T, 4 > & q,
    const vec< T, 3 > & p
)

function pow

template<class A, class B>
apply_t< detail::std_pow, A, B > linalg::pow (
    const A & a,
    const B & b
)

function product

template<class A>
constexpr scalar_t< A > linalg::product (
    const A & a
)

function qangle

template<class T>
T linalg::qangle (
    const vec< T, 4 > & q
)

function qaxis

template<class T>
vec< T, 3 > linalg::qaxis (
    const vec< T, 4 > & q
)

function qconj

template<class T>
constexpr vec< T, 4 > linalg::qconj (
    const vec< T, 4 > & q
)

function qexp

template<class T>
vec< T, 4 > linalg::qexp (
    const vec< T, 4 > & q
)

function qinv

template<class T>
vec< T, 4 > linalg::qinv (
    const vec< T, 4 > & q
)

function qlog

template<class T>
vec< T, 4 > linalg::qlog (
    const vec< T, 4 > & q
)

function qmat

template<class T>
constexpr mat< T, 3, 3 > linalg::qmat (
    const vec< T, 4 > & q
)

function qmul

template<class T>
constexpr vec< T, 4 > linalg::qmul (
    const vec< T, 4 > & a,
    const vec< T, 4 > & b
)

function qmul

template<class T, class... R>
constexpr vec< T, 4 > linalg::qmul (
    const vec< T, 4 > & a,
    R... r
)

function qnlerp

template<class T>
vec< T, 4 > linalg::qnlerp (
    const vec< T, 4 > & a,
    const vec< T, 4 > & b,
    T t
)

function qpow

template<class T>
vec< T, 4 > linalg::qpow (
    const vec< T, 4 > & q,
    const T & p
)

function qrot

template<class T>
constexpr vec< T, 3 > linalg::qrot (
    const vec< T, 4 > & q,
    const vec< T, 3 > & v
)

function qslerp

template<class T>
vec< T, 4 > linalg::qslerp (
    const vec< T, 4 > & a,
    const vec< T, 4 > & b,
    T t
)

function qxdir

template<class T>
constexpr vec< T, 3 > linalg::qxdir (
    const vec< T, 4 > & q
)

function qydir

template<class T>
constexpr vec< T, 3 > linalg::qydir (
    const vec< T, 4 > & q
)

function qzdir

template<class T>
constexpr vec< T, 3 > linalg::qzdir (
    const vec< T, 4 > & q
)

function rot

template<class T>
vec< T, 2 > linalg::rot (
    T a,
    const vec< T, 2 > & v
)

function rotation_matrix

template<class T>
mat< T, 4, 4 > linalg::rotation_matrix (
    const vec< T, 4 > & rotation
)

function rotation_quat

template<class T>
vec< T, 4 > linalg::rotation_quat (
    const vec< T, 3 > & axis,
    T angle
)

function rotation_quat

template<class T>
vec< T, 4 > linalg::rotation_quat (
    const mat< T, 3, 3 > & m
)

function round

template<class A>
apply_t< detail::std_round, A > linalg::round (
    const A & a
)

function scaling_matrix

template<class T>
mat< T, 4, 4 > linalg::scaling_matrix (
    const vec< T, 3 > & scaling
)

function select

template<class P, class A, class B>
constexpr apply_t< detail::select, P, A, B > linalg::select (
    const P & p,
    const A & a,
    const B & b
)

function sin

template<class A>
apply_t< detail::std_sin, A > linalg::sin (
    const A & a
)

function sinh

template<class A>
apply_t< detail::std_sinh, A > linalg::sinh (
    const A & a
)

function slerp

template<class T, int M>
vec< T, M > linalg::slerp (
    const vec< T, M > & a,
    const vec< T, M > & b,
    T t
)

function sqrt

template<class A>
apply_t< detail::std_sqrt, A > linalg::sqrt (
    const A & a
)

function submat

template<int I0, int J0, int I1, int J1, class T, int M, int N>
constexpr mat< T, I1-I0, J1-J0 > linalg::submat (
    const mat< T, M, N > & a
)

function subvec

template<int I0, int I1, class T, int M>
constexpr vec< T, I1-I0 > linalg::subvec (
    const vec< T, M > & a
)

function sum

template<class A>
constexpr scalar_t< A > linalg::sum (
    const A & a
)

function swizzle

template<int... I, class T, int M>
constexpr vec< T, sizeof...(I)> linalg::swizzle (
    const vec< T, M > & a
)

function tan

template<class A>
apply_t< detail::std_tan, A > linalg::tan (
    const A & a
)

function tanh

template<class A>
apply_t< detail::std_tanh, A > linalg::tanh (
    const A & a
)

function trace

template<class T, int N>
constexpr T linalg::trace (
    const mat< T, N, N > & a
)

function translation_matrix

template<class T>
mat< T, 4, 4 > linalg::translation_matrix (
    const vec< T, 3 > & translation
)

function transpose

template<class T, int M>
constexpr mat< T, M, 1 > linalg::transpose (
    const mat< T, 1, M > & m
)

function transpose

template<class T, int M>
constexpr mat< T, M, 2 > linalg::transpose (
    const mat< T, 2, M > & m
)

function transpose

template<class T, int M>
constexpr mat< T, M, 3 > linalg::transpose (
    const mat< T, 3, M > & m
)

function transpose

template<class T, int M>
constexpr mat< T, M, 4 > linalg::transpose (
    const mat< T, 4, M > & m
)

function uangle

template<class T, int M>
T linalg::uangle (
    const vec< T, M > & a,
    const vec< T, M > & b
)

function zip

template<class A, class B, class F>
constexpr apply_t< F, A, B > linalg::zip (
    const A & a,
    const B & b,
    F func
)

The documentation for this class was generated from the following file common/linalg.hpp