tdm::operator-

Navigation

API > API/Plugins > API/Plugins/RigLogicLib

Overloads

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

namespace tdm  
{  
    template<dim_t R, dim_t C, typename T>  
    mat < R , C , T > tdm::operator-  
    (  
        const mat < R , C , T > & m  
    )  
}  
Copy full snippet

namespace tdm {     template<dim_t R, dim_t C, typename T>     mat < R , C , T > tdm::operator-     (         const mat < R , C , T > & m     ) }

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

namespace tdm  
{  
    template<dim_t L, typename T>  
    vec < L, T > tdm::operator-  
    (  
        vec < L, T > v  
    )  
}  
Copy full snippet

namespace tdm {     template<dim_t L, typename T>     vec < L, T > tdm::operator-     (         vec < L, T > v     ) }

tdm::operator-(const ang< T, TUnit > &, const ang< T, TUnit > &)

namespace tdm  
{  
    template<typename T, typename TUnit>  
    ang < T, TUnit > tdm::operator-  
    (  
        const ang < T, TUnit > & lhs,  
        const ang < T, TUnit > & rhs  
    )  
}  
Copy full snippet

namespace tdm {     template<typename T, typename TUnit>     ang < T, TUnit > tdm::operator-     (         const ang < T, TUnit > & lhs,         const ang < T, TUnit > & rhs     ) }

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

namespace tdm  
{  
    template<dim_t R, dim_t C, typename T>  
    mat < R , C , T > tdm::operator-  
    (  
        const mat < R , C , T > & lhs,  
        T rhs  
    )  
}  
Copy full snippet

namespace tdm {     template<dim_t R, dim_t C, typename T>     mat < R , C , T > tdm::operator-     (         const mat < R , C , T > & lhs,         T rhs     ) }

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

namespace tdm  
{  
    template<dim_t R, dim_t C, typename T>  
    mat < R , C , T > tdm::operator-  
    (  
        T lhs,  
        const mat < R , C , T > & rhs  
    )  
}  
Copy full snippet

namespace tdm {     template<dim_t R, dim_t C, typename T>     mat < R , C , T > tdm::operator-     (         T lhs,         const mat < R , C , T > & rhs     ) }

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

namespace tdm  
{  
    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  
    )  
}  
Copy full snippet

namespace tdm {     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     ) }

tdm::operator-(const quat< T > &, const quat< T > &)

namespace tdm  
{  
    template<typename T>  
    quat < T > tdm::operator-  
    (  
        const quat < T > & lhs,  
        const quat < T > & rhs  
    )  
}  
Copy full snippet

namespace tdm {     template<typename T>     quat < T > tdm::operator-     (         const quat < T > & lhs,         const quat < T > & rhs     ) }

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

namespace tdm  
{  
    template<dim_t L, typename T, typename U>  
    vec < L, T > tdm::operator-  
    (  
        const vec < L, T > & lhs,  
        const vec < L, U > & rhs  
    )  
}  
Copy full snippet

namespace tdm {     template<dim_t L, typename T, typename U>     vec < L, T > tdm::operator-     (         const vec < L, T > & lhs,         const vec < L, U > & rhs     ) }

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

namespace tdm  
{  
    template<dim_t L, typename T, typename U>  
    vec < L, T > tdm::operator-  
    (  
        const vec < L, T > & lhs,  
        U rhs  
    )  
}  
Copy full snippet

namespace tdm {     template<dim_t L, typename T, typename U>     vec < L, T > tdm::operator-     (         const vec < L, T > & lhs,         U rhs     ) }

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

namespace tdm  
{  
    template<dim_t L, typename T, typename U>  
    vec < L, T > tdm::operator-  
    (  
        T lhs,  
        const vec < L, U > & rhs  
    )  
}  
Copy full snippet

namespace tdm {     template<dim_t L, typename T, typename U>     vec < L, T > tdm::operator-     (         T lhs,         const vec < L, U > & rhs     ) }