Namespace linalg
Namespace List > linalg
Namespaces
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