tdm::operator*

Navigation

API > API/Plugins > API/Plugins/RigLogicLib

Overloads

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

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

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

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

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

namespace tdm {     template<typename T, typename TUnit>     ang < T, TUnit > tdm::operator*     (         T 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 typename mat< R, C, T >::column_type &, const mat< R, C, T > &)

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

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

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

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

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

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

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

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

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 quat< T > &, T)

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

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

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

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

namespace tdm {     template<typename T>     quat < T > tdm::operator*     (         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>  
    std::enable_if< std::is_arithmetic< U >::value, vec < L, T > >::type tdm::operator*  
    (  
        const vec < L, T > & lhs,  
        U rhs  
    )  
}  
Copy full snippet

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

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

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

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