quatop_macros.h File Reference

Create unary and binary operators with macros. More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	CML_QUAT_QUAT_BINOP(_op_, _OpT_)
	Declare an operator taking two quaternion operands.
#define	CML_QUAT_QUATXPR_BINOP(_op_, _OpT_)
	Declare an operator taking a quaternion and a et::QuaternionXpr.
#define	CML_QUAT_SCALAR_BINOP(_op_, _OpT_)
	Declare an operator taking a quaternion and a scalar.
#define	CML_QUAT_UNIOP(_op_, _OpT_)
	Declare a unary operator taking a quaternion operand.
#define	CML_QUATXPR_QUAT_BINOP(_op_, _OpT_)
	Declare an operator taking an et::QuaternionXpr and a quaternion.
#define	CML_QUATXPR_QUATXPR_BINOP(_op_, _OpT_)
	Declare an operator taking two et::QuaternionXpr operands.
#define	CML_QUATXPR_SCALAR_BINOP(_op_, _OpT_)
	Declare an operator taking a et::QuaternionXpr and a scalar.
#define	CML_QUATXPR_UNIOP(_op_, _OpT_)
	Declare a unary operator taking a et::QuaternionXpr operand.
#define	CML_SCALAR_QUAT_BINOP(_op_, _OpT_)
	Declare an operator taking a scalar and a quaternion.
#define	CML_SCALAR_QUATXPR_BINOP(_op_, _OpT_)
	Declare an operator taking a scalar and a et::QuaternionXpr.

---

Detailed Description

Create unary and binary operators with macros.

These macros work just like those in cml/quaternion/vecop_macros.h.

Definition in file quatop_macros.h.

---

Define Documentation

#define CML_QUAT_QUAT_BINOP	(	_op_,
		_OpT_		)

Value:

template<typename E1, class AT1, typename E2, class AT2,                \
    class OT, class CT>                                                 \
inline et::QuaternionXpr<                                               \
    et::BinaryQuaternionOp<                                             \
        quaternion<E1,AT1,OT,CT>, quaternion<E2,AT2,OT,CT>,             \
        _OpT_ <E1,E2>                                                   \
    >                                                                   \
>                                                                       \
                                                                        \
_op_ (                                                                  \
        const quaternion<E1,AT1,OT,CT>& left,                           \
        const quaternion<E2,AT2,OT,CT>& right)                          \
{                                                                       \
    typedef et::BinaryQuaternionOp<                                     \
            quaternion<E1,AT1,OT,CT>, quaternion<E2,AT2,OT,CT>,         \
            _OpT_ <E1,E2>                                               \
        > ExprT;                                                        \
    return et::QuaternionXpr<ExprT>(ExprT(left,right));                 \
}

Declare an operator taking two quaternion operands.

Definition at line 54 of file quatop_macros.h.

#define CML_QUAT_QUATXPR_BINOP	(	_op_,
		_OpT_		)

Value:

template<typename E, class AT, class OT, class CT, class XprT>          \
inline et::QuaternionXpr<                                               \
    et::BinaryQuaternionOp<                                             \
        quaternion<E,AT,OT,CT>, XprT,                                   \
        _OpT_ <E, typename XprT::value_type>                            \
    >                                                                   \
>                                                                       \
                                                                        \
_op_ (                                                                  \
        const quaternion<E,AT,OT,CT>& left,                             \
        QUATXPR_ARG_TYPE right)                                         \
{                                                                       \
    typedef et::BinaryQuaternionOp<                                     \
            quaternion<E,AT,OT,CT>, XprT,                               \
            _OpT_ <E, typename XprT::value_type>                        \
        > ExprT;                                                        \
    return et::QuaternionXpr<ExprT>(ExprT(left,right.expression()));    \
}

Declare an operator taking a quaternion and a et::QuaternionXpr.

Definition at line 77 of file quatop_macros.h.

#define CML_QUAT_SCALAR_BINOP	(	_op_,
		_OpT_		)

Value:

template<typename E, class AT, class OT, class CT, typename ScalarT>    \
inline et::QuaternionXpr<                                               \
    et::BinaryQuaternionOp<                                             \
        quaternion<E,AT,OT,CT>, ScalarT,                                \
        _OpT_ <E,ScalarT>                                               \
    >                                                                   \
>                                                                       \
                                                                        \
_op_ (                                                                  \
        const quaternion<E,AT,OT,CT>& left,                             \
        SCALAR_ARG_TYPE right)                                          \
{                                                                       \
    typedef et::BinaryQuaternionOp<                                     \
            quaternion<E,AT,OT,CT>, ScalarT, _OpT_ <E,ScalarT>          \
        > ExprT;                                                        \
    return et::QuaternionXpr<ExprT>(ExprT(left,right));                 \
}

Declare an operator taking a quaternion and a scalar.

Definition at line 149 of file quatop_macros.h.

#define CML_QUAT_UNIOP	(	_op_,
		_OpT_		)

Value:

template<typename E, class AT, class OT, class CT>                      \
inline et::QuaternionXpr<                                               \
    et::UnaryQuaternionOp< quaternion<E,AT,OT,CT>, _OpT_ <E> >          \
>                                                                       \
                                                                        \
_op_ (const quaternion<E,AT,OT,CT>& arg)                                \
{                                                                       \
    typedef et::UnaryQuaternionOp<                                      \
            quaternion<E,AT,OT,CT>, _OpT_ <E>                           \
        > ExprT;                                                        \
    return et::QuaternionXpr<ExprT>(ExprT(arg));                        \
}

Declare a unary operator taking a quaternion operand.

Definition at line 21 of file quatop_macros.h.

#define CML_QUATXPR_QUAT_BINOP	(	_op_,
		_OpT_		)

Value:

template<class XprT, typename E, class AT, class OT, class CT>          \
inline et::QuaternionXpr<                                               \
    et::BinaryQuaternionOp<                                             \
        XprT, quaternion<E,AT,OT,CT>,                                   \
        _OpT_ <typename XprT::value_type, E>                            \
    >                                                                   \
>                                                                       \
                                                                        \
_op_ (                                                                  \
        QUATXPR_ARG_TYPE left,                                          \
        const quaternion<E,AT,OT,CT>& right)                            \
{                                                                       \
    typedef et::BinaryQuaternionOp<                                     \
            XprT, quaternion<E,AT,OT,CT>,                               \
            _OpT_ <typename XprT::value_type, E>                        \
        > ExprT;                                                        \
    return et::QuaternionXpr<ExprT>(ExprT(left.expression(),right));    \
}

Declare an operator taking an et::QuaternionXpr and a quaternion.

Definition at line 99 of file quatop_macros.h.

#define CML_QUATXPR_QUATXPR_BINOP	(	_op_,
		_OpT_		)

Value:

template<class XprT1, class XprT2>                                      \
inline et::QuaternionXpr<                                               \
    et::BinaryQuaternionOp<                                             \
        XprT1, XprT2,                                                   \
        _OpT_ <                                                         \
            typename XprT1::value_type,                                 \
            typename XprT2::value_type                                  \
        >                                                               \
    >                                                                   \
>                                                                       \
                                                                        \
_op_ (                                                                  \
        QUATXPR_ARG_TYPE_N(1) left,                                     \
        QUATXPR_ARG_TYPE_N(2) right)                                    \
{                                                                       \
    typedef et::BinaryQuaternionOp<                                     \
            XprT1, XprT2,                                               \
            _OpT_ <                                                     \
                typename XprT1::value_type,                             \
                typename XprT2::value_type>                             \
        > ExprT;                                                        \
    return et::QuaternionXpr<ExprT>(                                    \
            ExprT(left.expression(),right.expression()));               \
}

Declare an operator taking two et::QuaternionXpr operands.

Definition at line 121 of file quatop_macros.h.

#define CML_QUATXPR_SCALAR_BINOP	(	_op_,
		_OpT_		)

Value:

template<class XprT, typename ScalarT>                                  \
inline et::QuaternionXpr<                                               \
    et::BinaryQuaternionOp<                                             \
        XprT, ScalarT, _OpT_ <typename XprT::value_type,ScalarT>        \
    >                                                                   \
>                                                                       \
                                                                        \
_op_ (                                                                  \
        QUATXPR_ARG_TYPE left,                                          \
        SCALAR_ARG_TYPE right)                                          \
{                                                                       \
    typedef et::BinaryQuaternionOp<                                     \
            XprT, ScalarT, _OpT_ <typename XprT::value_type,ScalarT>    \
        > ExprT;                                                        \
    return et::QuaternionXpr<ExprT>(ExprT(left.expression(),right));    \
}

Declare an operator taking a et::QuaternionXpr and a scalar.

Definition at line 190 of file quatop_macros.h.

#define CML_QUATXPR_UNIOP	(	_op_,
		_OpT_		)

Value:

template<class XprT>                                                    \
inline et::QuaternionXpr<                                               \
    et::UnaryQuaternionOp< XprT, _OpT_ <typename XprT::value_type> >    \
>                                                                       \
                                                                        \
_op_ (QUATXPR_ARG_TYPE arg)                                             \
{                                                                       \
    typedef et::UnaryQuaternionOp<                                      \
        XprT, _OpT_ <typename XprT::value_type>                         \
        > ExprT;                                                        \
    return et::QuaternionXpr<ExprT>(ExprT(arg.expression()));           \
}

Declare a unary operator taking a et::QuaternionXpr operand.

Definition at line 37 of file quatop_macros.h.

#define CML_SCALAR_QUAT_BINOP	(	_op_,
		_OpT_		)

Value:

template<typename ScalarT, typename E, class AT, class OT, class CT>    \
inline et::QuaternionXpr<                                               \
    et::BinaryQuaternionOp<                                             \
        ScalarT, quaternion<E,AT,OT,CT>, _OpT_ <ScalarT,E>              \
    >                                                                   \
>                                                                       \
                                                                        \
_op_ (                                                                  \
        SCALAR_ARG_TYPE left,                                           \
        const quaternion<E,AT,OT,CT>& right)                            \
{                                                                       \
    typedef et::BinaryQuaternionOp<                                     \
            ScalarT, quaternion<E,AT,OT,CT>, _OpT_ <ScalarT,E>          \
        > ExprT;                                                        \
    return et::QuaternionXpr<ExprT>(ExprT(left,right));                 \
}

Declare an operator taking a scalar and a quaternion.

Definition at line 170 of file quatop_macros.h.

#define CML_SCALAR_QUATXPR_BINOP	(	_op_,
		_OpT_		)

Value:

template<typename ScalarT, class XprT>                                  \
inline et::QuaternionXpr<                                               \
    et::BinaryQuaternionOp<                                             \
        ScalarT, XprT, _OpT_ <ScalarT, typename XprT::value_type>       \
    >                                                                   \
>                                                                       \
                                                                        \
_op_ (                                                                  \
        SCALAR_ARG_TYPE left,                                           \
        QUATXPR_ARG_TYPE right)                                         \
{                                                                       \
    typedef et::BinaryQuaternionOp<                                     \
            ScalarT, XprT,                                              \
            _OpT_ <ScalarT, typename XprT::value_type>                  \
        > ExprT;                                                        \
    return et::QuaternionXpr<ExprT>(ExprT(left,right.expression()));    \
}

Declare an operator taking a scalar and a et::QuaternionXpr.

Definition at line 210 of file quatop_macros.h.