tdm Namespace Reference

Namespaces
namespace	affine
namespace	impl
namespace	projective

Classes
struct	axis_angle
struct	mat
struct	vec

Typedefs
using	dim_t = std::size_t
template<typename T >
using	vec2 = vec< 2, T >
template<typename T >
using	vec3 = vec< 3, T >
template<typename T >
using	vec4 = vec< 4, T >
template<dim_t L>
using	ivec = vec< L, int >
using	ivec2 = ivec< 2 >
using	ivec3 = ivec< 3 >
using	ivec4 = ivec< 4 >
template<dim_t L>
using	fvec = vec< L, float >
using	fvec2 = fvec< 2 >
using	fvec3 = fvec< 3 >
using	fvec4 = fvec< 4 >
template<typename T >
using	mat2 = mat< 2, 2, T >
template<typename T >
using	mat3 = mat< 3, 3, T >
template<typename T >
using	mat4 = mat< 4, 4, T >
template<dim_t R, dim_t C>
using	imat = mat< R, C, int >
using	imat2 = imat< 2, 2 >
using	imat3 = imat< 3, 3 >
using	imat4 = imat< 4, 4 >
template<dim_t R, dim_t C>
using	fmat = mat< R, C, float >
using	fmat2 = fmat< 2, 2 >
using	fmat3 = fmat< 3, 3 >
using	fmat4 = fmat< 4, 4 >

Enumerations
enum class	handedness { left = -1 , right = 1 }

Functions
template<typename T >
vec3< T >	cross (const vec3< T > &lhs, const vec3< T > &rhs)
template<dim_t L, typename T >
T	dot (const vec< L, T > &lhs, const vec< L, T > &rhs)
template<dim_t L, typename T >
vec< L, T >	negate (vec< L, T > v)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	negate (const mat< R, C, T > &m)
template<dim_t L, typename T >
std::enable_if< std::is_floating_point< T >::value, T >::type	length (const vec< L, T > &v)
template<dim_t L, typename T >
std::enable_if< std::is_floating_point< T >::value, vec< L, T > >::type	normalize (vec< L, T > v)
template<dim_t R, dim_t C, typename T >
mat< C, R, T >	transpose (const mat< R, C, T > &m)
template<dim_t N, typename T >
T	determinant (const mat< N, N, T > &m)
template<dim_t N, typename T >
mat< N, N, T >	inverse (const mat< N, N, T > &m)
template<dim_t N, typename T >
T	trace (const mat< N, N, T > &m)
template<dim_t R, dim_t C, typename T >
bool	operator== (const mat< R, C, T > &lhs, const mat< R, C, T > &rhs)
template<dim_t R, dim_t C, typename T >
bool	operator!= (const mat< R, C, T > &lhs, const mat< R, C, T > &rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	operator+ (const mat< R, C, T > &m)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	operator- (const mat< R, C, T > &m)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	operator+ (const mat< R, C, T > &lhs, T rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	operator+ (T lhs, const mat< R, C, T > &rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	operator+ (const mat< R, C, T > &lhs, const mat< R, C, T > &rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	operator- (const mat< R, C, T > &lhs, T rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	operator- (T lhs, const mat< R, C, T > &rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	operator- (const mat< R, C, T > &lhs, const mat< R, C, T > &rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	operator* (const mat< R, C, T > &lhs, T rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	operator* (T lhs, const mat< R, C, T > &rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >::row_type	operator* (const typename mat< R, C, T >::column_type &lhs, const mat< R, C, T > &rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >::column_type	operator* (const mat< R, C, T > &lhs, const typename mat< R, C, T >::row_type &rhs)
template<dim_t R, dim_t S, dim_t C, typename T >
mat< R, C, T >	operator* (const mat< R, S, T > &lhs, const mat< S, C, T > &rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	operator/ (const mat< R, C, T > &lhs, T rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	operator/ (T lhs, const mat< R, C, T > &rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >::row_type	operator/ (const typename mat< R, C, T >::column_type &lhs, const mat< R, C, T > &rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >::column_type	operator/ (const mat< R, C, T > &lhs, const typename mat< R, C, T >::row_type &rhs)
template<dim_t R, dim_t C, typename T >
mat< R, C, T >	operator/ (const mat< R, C, T > &lhs, const mat< R, C, T > &rhs)
constexpr double	pi ()
template<typename T >
std::enable_if< std::is_floating_point< T >::value, T >::type	degrees (T radians)
template<typename T >
std::enable_if< std::is_floating_point< T >::value, T >::type	radians (T degrees)
template<typename T >
mat4< T >	rotate (const vec3< T > &axis, T radians, handedness h=handedness::right)
template<typename T >
mat4< T >	rotate (const mat4< T > &m, const vec3< T > &axis, T radians, handedness h=handedness::right)
template<typename T >
mat4< T >	rotate (T xRadians, T yRadians, T zRadians, handedness h=handedness::right)
template<typename T >
mat4< T >	rotate (const mat4< T > &m, T xRadians, T yRadians, T zRadians, handedness h=handedness::right)
template<typename T >
mat4< T >	rotate (const vec3< T > &radians, handedness h=handedness::right)
template<typename T >
mat4< T >	rotate (const mat4< T > &m, const vec3< T > &radians, handedness h=handedness::right)
template<dim_t L, typename T >
mat< L+1, L+1, T >	scale (const vec< L, T > &factors)
template<dim_t L, typename T >
mat< L+1, L+1, T >	scale (const mat< L+1, L+1, T > &m, const vec< L, T > &factors)
template<dim_t L, typename T >
mat< L+1, L+1, T >	scale (T factor)
template<dim_t L, typename T >
mat< L, L, T >	scale (const mat< L, L, T > &m, T factor)
template<dim_t L, typename T >
mat< L+1, L+1, T >	translate (const vec< L, T > &position)
template<dim_t L, typename T >
mat< L+1, L+1, T >	translate (const mat< L+1, L+1, T > &m, const vec< L, T > &position)
template<typename T >
axis_angle< T >	xyz2AxisAngle (T xRadians, T yRadians, T zRadians, handedness h=handedness::right)
template<typename T >
axis_angle< T >	xyz2AxisAngle (const vec3< T > &radians, handedness h=handedness::right)
template<dim_t L, typename T >
bool	operator== (const vec< L, T > &lhs, const vec< L, T > &rhs)
template<dim_t L, typename T >
bool	operator!= (const vec< L, T > &lhs, const vec< L, T > &rhs)
template<dim_t L, typename T >
vec< L, T >	operator+ (const vec< L, T > &v)
template<dim_t L, typename T >
vec< L, T >	operator- (vec< L, T > v)
template<dim_t L, typename T , typename U >
vec< L, T >	operator+ (const vec< L, T > &lhs, const vec< L, U > &rhs)
template<dim_t L, typename T , typename U >
vec< L, T >	operator+ (const vec< L, T > &lhs, U rhs)
template<dim_t L, typename T , typename U >
vec< L, T >	operator+ (T lhs, const vec< L, U > &rhs)
template<dim_t L, typename T , typename U >
vec< L, T >	operator- (const vec< L, T > &lhs, const vec< L, U > &rhs)
template<dim_t L, typename T , typename U >
vec< L, T >	operator- (const vec< L, T > &lhs, U rhs)
template<dim_t L, typename T , typename U >
vec< L, T >	operator- (T lhs, const vec< L, U > &rhs)
template<dim_t L, typename T , typename U >
vec< L, T >	operator* (const vec< L, T > &lhs, const vec< L, U > &rhs)
template<dim_t L, typename T , typename U >
std::enable_if< std::is_arithmetic< U >::value, vec< L, T > >::type	operator* (const vec< L, T > &lhs, U rhs)
template<dim_t L, typename T , typename U >
std::enable_if< std::is_arithmetic< T >::value, vec< L, T > >::type	operator* (T lhs, const vec< L, U > &rhs)
template<dim_t L, typename T , typename U >
vec< L, T >	operator/ (const vec< L, T > &lhs, const vec< L, U > &rhs)
template<dim_t L, typename T , typename U >
std::enable_if< std::is_arithmetic< U >::value, vec< L, T > >::type	operator/ (const vec< L, T > &lhs, U rhs)
template<dim_t L, typename T , typename U >
std::enable_if< std::is_arithmetic< T >::value, vec< L, T > >::type	operator/ (T lhs, const vec< L, U > &rhs)

Typedef Documentation

dim_t

using tdm::dim_t = typedef std::size_t

fmat

template<dim_t R, dim_t C>

using tdm::fmat = typedef mat<R, C, float>

fmat2

using tdm::fmat2 = typedef fmat<2, 2>

fmat3

using tdm::fmat3 = typedef fmat<3, 3>

fmat4

using tdm::fmat4 = typedef fmat<4, 4>

fvec

template<dim_t L>

using tdm::fvec = typedef vec<L, float>

fvec2

using tdm::fvec2 = typedef fvec<2>

fvec3

using tdm::fvec3 = typedef fvec<3>

fvec4

using tdm::fvec4 = typedef fvec<4>

imat

template<dim_t R, dim_t C>

using tdm::imat = typedef mat<R, C, int>

imat2

using tdm::imat2 = typedef imat<2, 2>

imat3

using tdm::imat3 = typedef imat<3, 3>

imat4

using tdm::imat4 = typedef imat<4, 4>

ivec

template<dim_t L>

using tdm::ivec = typedef vec<L, int>

ivec2

using tdm::ivec2 = typedef ivec<2>

ivec3

using tdm::ivec3 = typedef ivec<3>

ivec4

using tdm::ivec4 = typedef ivec<4>

mat2

template<typename T >

using tdm::mat2 = typedef mat<2, 2, T>

mat3

template<typename T >

using tdm::mat3 = typedef mat<3, 3, T>

mat4

template<typename T >

using tdm::mat4 = typedef mat<4, 4, T>

vec2

template<typename T >

using tdm::vec2 = typedef vec<2, T>

vec3

template<typename T >

using tdm::vec3 = typedef vec<3, T>

vec4

template<typename T >

using tdm::vec4 = typedef vec<4, T>

Enumeration Type Documentation

handedness

enum class tdm::handedness

strong

Enumerator
left
right

                      {
    left = -1,
    right = 1
};

Function Documentation

cross()

template<typename T >

vec3< T > tdm::cross ( const vec3< T > &  lhs, const vec3< T > &  rhs  )

inline

                                                             {
    return vec3<T>{
        lhs[1] * rhs[2] - lhs[2] * rhs[1],
        lhs[2] * rhs[0] - lhs[0] * rhs[2],
        lhs[0] * rhs[1] - lhs[1] * rhs[0]
    };
}

degrees()

template<typename T >

std::enable_if< std::is_floating_point< T >::value, T >::type tdm::degrees ( T  radians )

inline

                                                                                     {
    static constexpr const auto c = static_cast<T>(180.0 / pi());
    return c * radians;
}

References pi(), and radians().

Referenced by radians(), dnac::RotateCommand::RotateCommand(), dnac::RotateCommand::Impl::rotateNeutralJoints(), and dnac::RotateCommand::setRotation().

determinant()

template<dim_t N, typename T >

T tdm::determinant ( const mat< N, N, T > &  m )

inline

                                            {
    return impl::determinant(m, N);
}

References tdm::impl::determinant().

Referenced by inverse().

dot()

template<dim_t L, typename T >

T tdm::dot ( const vec< L, T > &  lhs, const vec< L, T > &  rhs  )

inline

                                                         {
    return (lhs * rhs).sum();
}

Referenced by dnac::Triangle::getBarycentricCoords().

inverse()

template<dim_t N, typename T >

mat< N, N, T > tdm::inverse ( const mat< N, N, T > &  m )

inline

                                                   {
    T det = determinant(m);
    if (det == T{}) {
        return {};
    }
 
    mat<N, N, T> adj = impl::adjoint(m);
    mat<N, N, T> inv;
    for (dim_t row{}; row < m.rows(); ++row) {
        for (dim_t col{}; col < m.columns(); ++col) {
            inv(row, col) = adj(row, col) / det;
        }
    }
    return inv;
}

References tdm::impl::adjoint(), and determinant().

Referenced by dnac::extractRotationMatrix(), operator/(), and tdm::mat< R, C, T >::operator/=().

length()

template<dim_t L, typename T >

std::enable_if< std::is_floating_point< T >::value, T >::type tdm::length ( const vec< L, T > &  v )

inline

                                                                                             {
    return v.length();
}

References tdm::vec< L, T >::length().

Referenced by trio::StringConverter< wchar_t >::from(), and dnac::CalculateMeshLowerLODsCommand::Impl::getMeshName().

negate() [1/2]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::negate ( const mat< R, C, T > &  m )

inline

                                                  {
    return m.negate();
}

negate() [2/2]

template<dim_t L, typename T >

vec< L, T > tdm::negate ( vec< L, T >  v )

inline

                                     {
    return v.negate();
}

References tdm::vec< L, T >::negate().

normalize()

template<dim_t L, typename T >

std::enable_if< std::is_floating_point< T >::value, vec< L, T > >::type tdm::normalize ( vec< L, T >  v )

inline

                                                                                                  {
    v.normalize();
    return v;
}

References tdm::vec< L, T >::normalize().

operator!=() [1/2]

template<dim_t R, dim_t C, typename T >

bool tdm::operator!= ( const mat< R, C, T > &  lhs, const mat< R, C, T > &  rhs  )

inline

                                                                         {
    return !(lhs == rhs);
}

operator!=() [2/2]

template<dim_t L, typename T >

bool tdm::operator!= ( const vec< L, T > &  lhs, const vec< L, T > &  rhs  )

inline

                                                                   {
    return !(lhs == rhs);
}

operator*() [1/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T >::column_type tdm::operator* ( const mat< R, C, T > &  lhs, const typename mat< R, C, T >::row_type &  rhs  )

inline

                                                                                                                     {
    using column_type = typename mat<R, C, T>::column_type;
    using value_type = typename column_type::value_type;
    column_type ret;
    rhs.apply([&ret, &lhs](value_type value, dim_t ci) {
            ret += (lhs.column(ci) * column_type{value});
        });
    return ret;
}

References tdm::vec< L, T >::apply(), and tdm::mat< R, C, T >::column().

operator*() [2/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::operator* ( const mat< R, C, T > &  lhs, T  rhs  )

inline

                                                              {
    return mat<R, C, T>(lhs) *= rhs;
}

operator*() [3/8]

template<dim_t R, dim_t S, dim_t C, typename T >

mat< R, C, T > tdm::operator* ( const mat< R, S, T > &  lhs, const mat< S, C, T > &  rhs  )

inline

                                                                                {
    using row_type = typename mat<R, C, T>::row_type;
    mat<R, C, T> ret;
    ret.apply([&lhs, &rhs](row_type& row, dim_t ri) {
            row = (lhs[ri] * rhs);
        });
    return ret;
}

References tdm::mat< R, C, T >::apply().

operator*() [4/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T >::row_type tdm::operator* ( const typename mat< R, C, T >::column_type &  lhs, const mat< R, C, T > &  rhs  )

inline

                                                                                                                     {
    using row_type = typename mat<R, C, T>::row_type;
    row_type ret;
    rhs.apply([&ret, &lhs](const row_type& row, dim_t ri) {
            ret += (row * row_type{lhs[ri]});
        });
    return ret;
}

References tdm::mat< R, C, T >::apply().

operator*() [5/8]

template<dim_t L, typename T , typename U >

vec< L, T > tdm::operator* ( const vec< L, T > &  lhs, const vec< L, U > &  rhs  )

inline

                                                                       {
    return vec<L, T>(lhs) *= rhs;
}

operator*() [6/8]

template<dim_t L, typename T , typename U >

std::enable_if< std::is_arithmetic< U >::value, vec< L, T > >::type tdm::operator* ( const vec< L, T > &  lhs, U  rhs  )

inline

                                                                                                              {
    return vec<L, T>(lhs) *= rhs;
}

operator*() [7/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::operator* ( T  lhs, const mat< R, C, T > &  rhs  )

inline

                                                              {
    return mat<R, C, T>(rhs) *= lhs;
}

operator*() [8/8]

template<dim_t L, typename T , typename U >

std::enable_if< std::is_arithmetic< T >::value, vec< L, T > >::type tdm::operator* ( T  lhs, const vec< L, U > &  rhs  )

inline

                                                                                                              {
    return vec<L, T>(lhs) *= rhs;
}

operator+() [1/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::operator+ ( const mat< R, C, T > &  lhs, const mat< R, C, T > &  rhs  )

inline

                                                                                {
    return mat<R, C, T>(lhs) += rhs;
}

operator+() [2/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::operator+ ( const mat< R, C, T > &  lhs, T  rhs  )

inline

                                                              {
    return mat<R, C, T>(lhs) += rhs;
}

operator+() [3/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::operator+ ( const mat< R, C, T > &  m )

inline

                                                     {
    return m;
}

operator+() [4/8]

template<dim_t L, typename T , typename U >

vec< L, T > tdm::operator+ ( const vec< L, T > &  lhs, const vec< L, U > &  rhs  )

inline

                                                                       {
    return vec<L, T>(lhs) += rhs;
}

operator+() [5/8]

template<dim_t L, typename T , typename U >

vec< L, T > tdm::operator+ ( const vec< L, T > &  lhs, U  rhs  )

inline

                                                        {
    return vec<L, T>(lhs) += rhs;
}

operator+() [6/8]

template<dim_t L, typename T >

vec< L, T > tdm::operator+ ( const vec< L, T > &  v )

inline

                                               {
    return v;
}

operator+() [7/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::operator+ ( T  lhs, const mat< R, C, T > &  rhs  )

inline

                                                              {
    return mat<R, C, T>(lhs) += rhs;
}

operator+() [8/8]

template<dim_t L, typename T , typename U >

vec< L, T > tdm::operator+ ( T  lhs, const vec< L, U > &  rhs  )

inline

                                                        {
    return vec<L, T>(lhs) += rhs;
}

operator-() [1/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::operator- ( const mat< R, C, T > &  lhs, const mat< R, C, T > &  rhs  )

inline

                                                                                {
    return mat<R, C, T>(lhs) -= rhs;
}

operator-() [2/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::operator- ( const mat< R, C, T > &  lhs, T  rhs  )

inline

                                                              {
    return mat<R, C, T>(lhs) -= rhs;
}

operator-() [3/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::operator- ( const mat< R, C, T > &  m )

inline

                                                     {
    mat<R, C, T> ret{m};
    ret.negate();
    return ret;
}

operator-() [4/8]

template<dim_t L, typename T , typename U >

vec< L, T > tdm::operator- ( const vec< L, T > &  lhs, const vec< L, U > &  rhs  )

inline

                                                                       {
    return vec<L, T>(lhs) -= rhs;
}

operator-() [5/8]

template<dim_t L, typename T , typename U >

vec< L, T > tdm::operator- ( const vec< L, T > &  lhs, U  rhs  )

inline

                                                        {
    return vec<L, T>(lhs) -= rhs;
}

operator-() [6/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::operator- ( T  lhs, const mat< R, C, T > &  rhs  )

inline

                                                              {
    return mat<R, C, T>(lhs) -= rhs;
}

operator-() [7/8]

template<dim_t L, typename T , typename U >

vec< L, T > tdm::operator- ( T  lhs, const vec< L, U > &  rhs  )

inline

                                                        {
    return vec<L, T>(lhs) -= rhs;
}

operator-() [8/8]

template<dim_t L, typename T >

vec< L, T > tdm::operator- ( vec< L, T >  v )

inline

                                        {
    return v.negate();
}

References tdm::vec< L, T >::negate().

operator/() [1/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::operator/ ( const mat< R, C, T > &  lhs, const mat< R, C, T > &  rhs  )

inline

                                                                                {
    return mat<R, C, T>(lhs) /= rhs;
}

operator/() [2/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T >::column_type tdm::operator/ ( const mat< R, C, T > &  lhs, const typename mat< R, C, T >::row_type &  rhs  )

inline

                                                                                                                     {
    return (inverse(lhs) * rhs);
}

References inverse().

operator/() [3/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::operator/ ( const mat< R, C, T > &  lhs, T  rhs  )

inline

                                                              {
    return mat<R, C, T>(lhs) /= rhs;
}

operator/() [4/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T >::row_type tdm::operator/ ( const typename mat< R, C, T >::column_type &  lhs, const mat< R, C, T > &  rhs  )

inline

                                                                                                                     {
    return (lhs * inverse(rhs));
}

References inverse().

operator/() [5/8]

template<dim_t L, typename T , typename U >

vec< L, T > tdm::operator/ ( const vec< L, T > &  lhs, const vec< L, U > &  rhs  )

inline

                                                                       {
    return vec<L, T>(lhs) /= rhs;
}

operator/() [6/8]

template<dim_t L, typename T , typename U >

std::enable_if< std::is_arithmetic< U >::value, vec< L, T > >::type tdm::operator/ ( const vec< L, T > &  lhs, U  rhs  )

inline

                                                                                                              {
    return vec<L, T>(lhs) /= rhs;
}

operator/() [7/8]

template<dim_t R, dim_t C, typename T >

mat< R, C, T > tdm::operator/ ( T  lhs, const mat< R, C, T > &  rhs  )

inline

                                                              {
    using row_type = typename mat<R, C, T>::row_type;
    mat<R, C, T> tmp{rhs};
    tmp.apply([lhs](row_type& row, dim_t  /*unused*/) {
            row = lhs / row;
        });
    return tmp;
}

References tdm::mat< R, C, T >::apply().

operator/() [8/8]

template<dim_t L, typename T , typename U >

std::enable_if< std::is_arithmetic< T >::value, vec< L, T > >::type tdm::operator/ ( T  lhs, const vec< L, U > &  rhs  )

inline

                                                                                                              {
    return vec<L, T>(lhs) /= rhs;
}

operator==() [1/2]

template<dim_t R, dim_t C, typename T >

bool tdm::operator== ( const mat< R, C, T > &  lhs, const mat< R, C, T > &  rhs  )

inline

                                                                         {
    using row_type = typename mat<R, C, T>::row_type;
    bool retval = true;
    lhs.apply([&rhs, &retval](const row_type& row, dim_t ri) {
            retval = retval && (row == rhs[ri]);
        });
    return retval;
}

References tdm::mat< R, C, T >::apply().

operator==() [2/2]

template<dim_t L, typename T >

bool tdm::operator== ( const vec< L, T > &  lhs, const vec< L, T > &  rhs  )

inline

                                                                   {
    bool equal = true;
    lhs.apply([&equal, &rhs](const T& v, dim_t i) {
            equal = equal && (v == rhs[i]);
        });
    return equal;
}

References tdm::vec< L, T >::apply().

pi()

constexpr double tdm::pi ( )

inlineconstexpr

                             {
    return 3.14159265358979323846;
}

Referenced by degrees(), dnac::extractRotationVector(), and radians().

radians()

template<typename T >

std::enable_if< std::is_floating_point< T >::value, T >::type tdm::radians ( T  degrees )

inline

                                                                                     {
    static constexpr const auto c = static_cast<T>(pi() / 180.0);
    return c * degrees;
}

References degrees(), and pi().

Referenced by degrees(), dnac::RotateCommand::Impl::getRotationTransformationMatrix(), and dnac::RotateCommand::Impl::rotateNeutralJoints().

trace()

template<dim_t N, typename T >

T tdm::trace ( const mat< N, N, T > &  m )

inline

                                      {
    T trace{0};
    for (dim_t row{}; row < m.rows(); ++row) {
        trace += m(row, row);
    }
    return trace;
}

References trace().

Referenced by trace().

transpose()

template<dim_t R, dim_t C, typename T >

mat< C, R, T > tdm::transpose ( const mat< R, C, T > &  m )

inline

                                                     {
    using row_type = typename mat<C, R, T>::row_type;
    mat<C, R, T> ret;
    ret.apply([&m](row_type& row, dim_t i) {
            row = m.column(i);
        });
    return ret;
}

References tdm::mat< R, C, T >::apply().

Referenced by tdm::mat< R, C, T >::fromColumns(), and tdm::mat< R, C, T >::transpose().