Skip to content

Namespace linalg::detail

Namespace List > linalg > detail

Classes

Type Name
struct any_compare <class A, class B>
struct any_compare< mat< T, M, 1 >, mat< T, M, 1 > > <class T, M>
struct any_compare< mat< T, M, 2 >, mat< T, M, 2 > > <class T, M>
struct any_compare< mat< T, M, 3 >, mat< T, M, 3 > > <class T, M>
struct any_compare< mat< T, M, 4 >, mat< T, M, 4 > > <class T, M>
struct any_compare< vec< T, 1 >, vec< T, 1 > > <class T>
struct any_compare< vec< T, 2 >, vec< T, 2 > > <class T>
struct any_compare< vec< T, 3 >, vec< T, 3 > > <class T>
struct any_compare< vec< T, 4 >, vec< T, 4 > > <class T>
struct apply <class F, class Void, T>
struct apply< F, scalars_t< >, mat< A, M, N > > <class F, M, N, class A>
struct apply< F, scalars_t< >, mat< A, M, N >, mat< B, M, N > > <class F, M, N, class A, class B>
struct apply< F, scalars_t< >, vec< A, M > > <class F, M, class A>
struct apply< F, scalars_t< >, vec< A, M >, vec< B, M > > <class F, M, class A, class B>
struct apply< F, scalars_t< >, vec< A, M >, vec< B, M >, vec< C, M > > <class F, M, class A, class B, class C>
struct apply< F, scalars_t< A >, A, mat< B, M, N > > <class F, M, N, class A, class B>
struct apply< F, scalars_t< A >, A, vec< B, M > > <class F, M, class A, class B>
struct apply< F, scalars_t< A >, A, vec< B, M >, vec< C, M > > <class F, M, class A, class B, class C>
struct apply< F, scalars_t< A, B >, A, B, vec< C, M > > <class F, M, class A, class B, class C>
struct apply< F, scalars_t< A, C >, A, vec< B, M >, C > <class F, M, class A, class B, class C>
struct apply< F, scalars_t< A... >, A... > <class F, A>
struct apply< F, scalars_t< B >, mat< A, M, N >, B > <class F, M, N, class A, class B>
struct apply< F, scalars_t< B >, vec< A, M >, B > <class F, M, class A, class B>
struct apply< F, scalars_t< B >, vec< A, M >, B, vec< C, M > > <class F, M, class A, class B, class C>
struct apply< F, scalars_t< B, C >, vec< A, M >, B, C > <class F, M, class A, class B, class C>
struct apply< F, scalars_t< C >, vec< A, M >, vec< B, M >, C > <class F, M, class A, class B, class C>
struct clamp
struct empty
struct getter <I>
struct getter< 0 > <>
struct getter< 1 > <>
struct getter< 2 > <>
struct getter< 3 > <>
struct lerp
struct make_seq_impl <A, N>
struct make_seq_impl< A, 0 > <A>
struct make_seq_impl< A, 1 > <A>
struct make_seq_impl< A, 2 > <A>
struct make_seq_impl< A, 3 > <A>
struct make_seq_impl< A, 4 > <A>
struct max
struct min
struct op_add
struct op_and
struct op_cmp
struct op_div
struct op_eq
struct op_ge
struct op_gt
struct op_int
struct op_le
struct op_lsh
struct op_lt
struct op_mod
struct op_mul
struct op_ne
struct op_neg
struct op_not
struct op_or
struct op_pos
struct op_rsh
struct op_sub
struct op_un
struct op_xor
struct ord <class T>
struct scalar_type <class A>
struct scalar_type< mat< T, M, N > > <class T, M, N>
struct scalar_type< vec< T, M > > <class T, M>
struct scalars <T>
struct scalars< T, U... > <class T, U>
struct scalars<> <>
struct select
struct seq <I>
struct std_abs
struct std_acos
struct std_asin
struct std_atan
struct std_atan2
struct std_ceil
struct std_copysign
struct std_cos
struct std_cosh
struct std_exp
struct std_floor
struct std_fmod
struct std_log
struct std_log10
struct std_pow
struct std_round
struct std_sin
struct std_sinh
struct std_sqrt
struct std_tan
struct std_tanh

Public Types

Type Name
typedef typename std::enable_if<!std::is_same< T, U >::value, decltype(converter< T, U >{}(std::declval< U >()))>::type conv_t
typedef typename make_seq_impl< A, B-A >::type make_seq
typedef decltype(std::declval< F >()(std::declval< T >()...)) ret_t
typedef typename scalars< T... >::type scalars_t

Public Functions

Type Name
constexpr bool operator!= (const ord< T > & o, std::nullptr_t)
constexpr bool operator< (const ord< T > & o, std::nullptr_t)
constexpr bool operator<= (const ord< T > & o, std::nullptr_t)
constexpr bool operator== (const ord< T > & o, std::nullptr_t)
constexpr bool operator> (const ord< T > & o, std::nullptr_t)
constexpr bool operator>= (const ord< T > & o, std::nullptr_t)
vec< T, sizeof...(I)> constexpr swizzle (const vec< T, M > & v, seq< I... >)
mat< T, sizeof...(I), sizeof...(J)> constexpr swizzle (const mat< T, M, N > & m, seq< I... > i, seq< J... >)

Public Types Documentation

typedef conv_t

using linalg::detail::conv_t = typedef typename std::enable_if<!std::is_same<T,U>::value, decltype(converter<T,U>{}(std::declval<U>()))>::type;

typedef make_seq

using linalg::detail::make_seq = typedef typename make_seq_impl<A,B-A>::type;

typedef ret_t

using linalg::detail::ret_t = typedef decltype(std::declval<F>()(std::declval<T>()...));

typedef scalars_t

using linalg::detail::scalars_t = typedef typename scalars<T...>::type;

Public Functions Documentation

function operator!=

template<class T>
constexpr bool linalg::detail::operator!= (
    const ord< T > & o,
    std::nullptr_t
)

function operator<

template<class T>
constexpr bool linalg::detail::operator< (
    const ord< T > & o,
    std::nullptr_t
)

function operator<=

template<class T>
constexpr bool linalg::detail::operator<= (
    const ord< T > & o,
    std::nullptr_t
)

function operator==

template<class T>
constexpr bool linalg::detail::operator== (
    const ord< T > & o,
    std::nullptr_t
)

function operator>

template<class T>
constexpr bool linalg::detail::operator> (
    const ord< T > & o,
    std::nullptr_t
)

function operator>=

template<class T>
constexpr bool linalg::detail::operator>= (
    const ord< T > & o,
    std::nullptr_t
)

function swizzle

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

function swizzle

template<class T, int M, int N, int... I, int... J>
mat< T, sizeof...(I), sizeof...(J)> constexpr linalg::detail::swizzle (
    const mat< T, M, N > & m,
    seq< I... > i,
    seq< J... >
)

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