quaternion_functions.h

Go to the documentation of this file.

/* -*- C++ -*- ------------------------------------------------------------
 
Copyright (c) 2007 Jesse Anders and Demian Nave http://cmldev.net/

The Configurable Math Library (CML) is distributed under the terms of the
Boost Software License, v1.0 (see cml/LICENSE for details).

 *-----------------------------------------------------------------------*/
#ifndef quaternion_functions_h
#define quaternion_functions_h

#include <cml/mathlib/checking.h> // For CheckQuat()
#include <cml/mathlib/epsilon.h>
#include <cml/util.h> // For acos_safe()

namespace cml {

template<typename E, class AT, class OT, class CT>
inline typename quaternion<E,AT,OT,CT>::value_type
real(const quaternion<E,AT,OT,CT>& q)
{
    return q.real();
}

template<typename XprT>
inline typename et::QuaternionXpr<XprT>::value_type
real(const et::QuaternionXpr<XprT>& e)
{
    return e.real();
}

template<typename E, class AT, class OT, class CT>
inline typename quaternion<E,AT,OT,CT>::imaginary_type
imaginary(const quaternion<E,AT,OT,CT>& q)
{
    return q.imaginary();
}

template<typename XprT>
//inline typename et::QuaternionXpr<XprT>::temporary_type
inline typename et::QuaternionXpr<XprT>::imaginary_type
imaginary(const et::QuaternionXpr<XprT>& e)
{
    return e.imaginary();
}

template<typename E, class AT, class OT, class CT>
inline typename quaternion<E,AT,OT,CT>::value_type
norm(const quaternion<E,AT,OT,CT>& arg)
{
    return arg.length_squared();
}

template<typename XprT>
inline typename XprT::value_type
norm(QUATXPR_ARG_TYPE arg)
{
    return arg.length_squared();
}

template<typename E, class AT, class OT, class CT>
inline typename quaternion<E,AT,OT,CT>::value_type
length_squared(const quaternion<E,AT,OT,CT>& arg)
{
    return arg.length_squared();
}

template<typename XprT>
inline typename XprT::value_type
length_squared(QUATXPR_ARG_TYPE arg)
{
    return arg.length_squared();
}

template<typename E, class AT, class OT, class CT>
inline typename quaternion<E,AT,OT,CT>::value_type
length(const quaternion<E,AT,OT,CT>& arg)
{
    return arg.length();
}

template<typename XprT>
inline typename XprT::value_type
length(QUATXPR_ARG_TYPE arg)
{
    return arg.length();
}

template<typename E, class AT, class OT, class CT>
inline quaternion<E,AT,OT,CT>
normalize(const quaternion<E,AT,OT,CT>& arg)
{
    typename quaternion<E,AT,OT,CT>::temporary_type result(arg);
    result.normalize();
    return result;
}

template<typename XprT>
inline typename XprT::temporary_type
normalize(QUATXPR_ARG_TYPE arg)
{
    return arg.normalize();
}

template<typename E, class AT, class OT, class CT>
inline quaternion<E,AT,OT,CT>
identity(const quaternion<E,AT,OT,CT>& arg)
{
    typename quaternion<E,AT,OT,CT>::temporary_type result(arg);
    result.identity();
    return result;
}

template < class QuatT >
typename QuatT::temporary_type log(
    const QuatT& q,
    typename QuatT::value_type tolerance =
        epsilon<typename QuatT::value_type>::placeholder())
{
    detail::CheckQuat(q);

    return q.log();
}

template < class QuatT >
typename QuatT::temporary_type exp(
    const QuatT& q,
    typename QuatT::value_type tolerance =
        epsilon<typename QuatT::value_type>::placeholder())
{
    detail::CheckQuat(q);

    return q.exp();
}

} // namespace cml

#endif

// -------------------------------------------------------------------------
// vim:ft=cpp