Dogcows Code - chaz/yoink/blob - src/moof/cml/quaternion/quatop_macros.h

   1 /* -*- C++ -*- ------------------------------------------------------------
   2
   3 Copyright (c) 2007 Jesse Anders and Demian Nave http://cmldev.net/
   4
   5 The Configurable Math Library (CML) is distributed under the terms of the
   6 Boost Software License, v1.0 (see cml/LICENSE for details).
   7
   8  *-----------------------------------------------------------------------*/
   9 /** @file
  10  *  @brief
  11  *
  12  * Create unary and binary operators with macros.
  13  *
  14  * These macros work just like those in cml/quaternion/vecop_macros.h.
  15  */
  16
  17 #ifndef quatop_macros_h
  18 #define quatop_macros_h
  19
  20 /** Declare a unary operator taking a quaternion operand. */
  21 #define CML_QUAT_UNIOP(_op_, _OpT_)                                     \
  22 template<typename E, class AT, class OT, class CT>                      \
  23 inline et::QuaternionXpr<                                               \
  24     et::UnaryQuaternionOp< quaternion<E,AT,OT,CT>, _OpT_ <E> >          \
  25 >                                                                       \
  26                                                                         \
  27 _op_ (const quaternion<E,AT,OT,CT>& arg)                                \
  28 {                                                                       \
  29     typedef et::UnaryQuaternionOp<                                      \
  30             quaternion<E,AT,OT,CT>, _OpT_ <E>                           \
  31         > ExprT;                                                        \
  32     return et::QuaternionXpr<ExprT>(ExprT(arg));                        \
  33 }
  34
  35
  36 /** Declare a unary operator taking a et::QuaternionXpr operand. */
  37 #define CML_QUATXPR_UNIOP(_op_, _OpT_)                                  \
  38 template<class XprT>                                                    \
  39 inline et::QuaternionXpr<                                               \
  40     et::UnaryQuaternionOp< XprT, _OpT_ <typename XprT::value_type> >    \
  41 >                                                                       \
  42                                                                         \
  43 _op_ (QUATXPR_ARG_TYPE arg)                                             \
  44 {                                                                       \
  45     typedef et::UnaryQuaternionOp<                                      \
  46         XprT, _OpT_ <typename XprT::value_type>                         \
  47         > ExprT;                                                        \
  48     return et::QuaternionXpr<ExprT>(ExprT(arg.expression()));           \
  49 }
  50
  51
  52
  53 /** Declare an operator taking two quaternion operands. */
  54 #define CML_QUAT_QUAT_BINOP(_op_, _OpT_)                                \
  55 template<typename E1, class AT1, typename E2, class AT2,                \
  56     class OT, class CT>                                                 \
  57 inline et::QuaternionXpr<                                               \
  58     et::BinaryQuaternionOp<                                             \
  59         quaternion<E1,AT1,OT,CT>, quaternion<E2,AT2,OT,CT>,             \
  60         _OpT_ <E1,E2>                                                   \
  61     >                                                                   \
  62 >                                                                       \
  63                                                                         \
  64 _op_ (                                                                  \
  65         const quaternion<E1,AT1,OT,CT>& left,                           \
  66         const quaternion<E2,AT2,OT,CT>& right)                          \
  67 {                                                                       \
  68     typedef et::BinaryQuaternionOp<                                     \
  69             quaternion<E1,AT1,OT,CT>, quaternion<E2,AT2,OT,CT>,         \
  70             _OpT_ <E1,E2>                                               \
  71         > ExprT;                                                        \
  72     return et::QuaternionXpr<ExprT>(ExprT(left,right));                 \
  73 }
  74
  75
  76 /** Declare an operator taking a quaternion and a et::QuaternionXpr. */
  77 #define CML_QUAT_QUATXPR_BINOP(_op_, _OpT_)                             \
  78 template<typename E, class AT, class OT, class CT, class XprT>          \
  79 inline et::QuaternionXpr<                                               \
  80     et::BinaryQuaternionOp<                                             \
  81         quaternion<E,AT,OT,CT>, XprT,                                   \
  82         _OpT_ <E, typename XprT::value_type>                            \
  83     >                                                                   \
  84 >                                                                       \
  85                                                                         \
  86 _op_ (                                                                  \
  87         const quaternion<E,AT,OT,CT>& left,                             \
  88         QUATXPR_ARG_TYPE right)                                         \
  89 {                                                                       \
  90     typedef et::BinaryQuaternionOp<                                     \
  91             quaternion<E,AT,OT,CT>, XprT,                               \
  92             _OpT_ <E, typename XprT::value_type>                        \
  93         > ExprT;                                                        \
  94     return et::QuaternionXpr<ExprT>(ExprT(left,right.expression()));    \
  95 }
  96
  97
  98 /** Declare an operator taking an et::QuaternionXpr and a quaternion. */
  99 #define CML_QUATXPR_QUAT_BINOP(_op_, _OpT_)                             \
 100 template<class XprT, typename E, class AT, class OT, class CT>          \
 101 inline et::QuaternionXpr<                                               \
 102     et::BinaryQuaternionOp<                                             \
 103         XprT, quaternion<E,AT,OT,CT>,                                   \
 104         _OpT_ <typename XprT::value_type, E>                            \
 105     >                                                                   \
 106 >                                                                       \
 107                                                                         \
 108 _op_ (                                                                  \
 109         QUATXPR_ARG_TYPE left,                                          \
 110         const quaternion<E,AT,OT,CT>& right)                            \
 111 {                                                                       \
 112     typedef et::BinaryQuaternionOp<                                     \
 113             XprT, quaternion<E,AT,OT,CT>,                               \
 114             _OpT_ <typename XprT::value_type, E>                        \
 115         > ExprT;                                                        \
 116     return et::QuaternionXpr<ExprT>(ExprT(left.expression(),right));    \
 117 }
 118
 119
 120 /** Declare an operator taking two et::QuaternionXpr operands. */
 121 #define CML_QUATXPR_QUATXPR_BINOP(_op_, _OpT_)                          \
 122 template<class XprT1, class XprT2>                                      \
 123 inline et::QuaternionXpr<                                               \
 124     et::BinaryQuaternionOp<                                             \
 125         XprT1, XprT2,                                                   \
 126         _OpT_ <                                                         \
 127             typename XprT1::value_type,                                 \
 128             typename XprT2::value_type                                  \
 129         >                                                               \
 130     >                                                                   \
 131 >                                                                       \
 132                                                                         \
 133 _op_ (                                                                  \
 134         QUATXPR_ARG_TYPE_N(1) left,                                     \
 135         QUATXPR_ARG_TYPE_N(2) right)                                    \
 136 {                                                                       \
 137     typedef et::BinaryQuaternionOp<                                     \
 138             XprT1, XprT2,                                               \
 139             _OpT_ <                                                     \
 140                 typename XprT1::value_type,                             \
 141                 typename XprT2::value_type>                             \
 142         > ExprT;                                                        \
 143     return et::QuaternionXpr<ExprT>(                                    \
 144             ExprT(left.expression(),right.expression()));               \
 145 }
 146
 147
 148 /** Declare an operator taking a quaternion and a scalar. */
 149 #define CML_QUAT_SCALAR_BINOP(_op_, _OpT_)                              \
 150 template<typename E, class AT, class OT, class CT, typename ScalarT>    \
 151 inline et::QuaternionXpr<                                               \
 152     et::BinaryQuaternionOp<                                             \
 153         quaternion<E,AT,OT,CT>, ScalarT,                                \
 154         _OpT_ <E,ScalarT>                                               \
 155     >                                                                   \
 156 >                                                                       \
 157                                                                         \
 158 _op_ (                                                                  \
 159         const quaternion<E,AT,OT,CT>& left,                             \
 160         SCALAR_ARG_TYPE right)                                          \
 161 {                                                                       \
 162     typedef et::BinaryQuaternionOp<                                     \
 163             quaternion<E,AT,OT,CT>, ScalarT, _OpT_ <E,ScalarT>          \
 164         > ExprT;                                                        \
 165     return et::QuaternionXpr<ExprT>(ExprT(left,right));                 \
 166 }
 167
 168
 169 /** Declare an operator taking a scalar and a quaternion. */
 170 #define CML_SCALAR_QUAT_BINOP(_op_, _OpT_)                              \
 171 template<typename ScalarT, typename E, class AT, class OT, class CT>    \
 172 inline et::QuaternionXpr<                                               \
 173     et::BinaryQuaternionOp<                                             \
 174         ScalarT, quaternion<E,AT,OT,CT>, _OpT_ <ScalarT,E>              \
 175     >                                                                   \
 176 >                                                                       \
 177                                                                         \
 178 _op_ (                                                                  \
 179         SCALAR_ARG_TYPE left,                                           \
 180         const quaternion<E,AT,OT,CT>& right)                            \
 181 {                                                                       \
 182     typedef et::BinaryQuaternionOp<                                     \
 183             ScalarT, quaternion<E,AT,OT,CT>, _OpT_ <ScalarT,E>          \
 184         > ExprT;                                                        \
 185     return et::QuaternionXpr<ExprT>(ExprT(left,right));                 \
 186 }
 187
 188
 189 /** Declare an operator taking a et::QuaternionXpr and a scalar. */
 190 #define CML_QUATXPR_SCALAR_BINOP(_op_, _OpT_)                           \
 191 template<class XprT, typename ScalarT>                                  \
 192 inline et::QuaternionXpr<                                               \
 193     et::BinaryQuaternionOp<                                             \
 194         XprT, ScalarT, _OpT_ <typename XprT::value_type,ScalarT>        \
 195     >                                                                   \
 196 >                                                                       \
 197                                                                         \
 198 _op_ (                                                                  \
 199         QUATXPR_ARG_TYPE left,                                          \
 200         SCALAR_ARG_TYPE right)                                          \
 201 {                                                                       \
 202     typedef et::BinaryQuaternionOp<                                     \
 203             XprT, ScalarT, _OpT_ <typename XprT::value_type,ScalarT>    \
 204         > ExprT;                                                        \
 205     return et::QuaternionXpr<ExprT>(ExprT(left.expression(),right));    \
 206 }
 207
 208
 209 /** Declare an operator taking a scalar and a et::QuaternionXpr. */
 210 #define CML_SCALAR_QUATXPR_BINOP(_op_, _OpT_)                           \
 211 template<typename ScalarT, class XprT>                                  \
 212 inline et::QuaternionXpr<                                               \
 213     et::BinaryQuaternionOp<                                             \
 214         ScalarT, XprT, _OpT_ <ScalarT, typename XprT::value_type>       \
 215     >                                                                   \
 216 >                                                                       \
 217                                                                         \
 218 _op_ (                                                                  \
 219         SCALAR_ARG_TYPE left,                                           \
 220         QUATXPR_ARG_TYPE right)                                         \
 221 {                                                                       \
 222     typedef et::BinaryQuaternionOp<                                     \
 223             ScalarT, XprT,                                              \
 224             _OpT_ <ScalarT, typename XprT::value_type>                  \
 225         > ExprT;                                                        \
 226     return et::QuaternionXpr<ExprT>(ExprT(left,right.expression()));    \
 227 }
 228
 229 #endif
 230
 231 // -------------------------------------------------------------------------
 232 // vim:ft=cpp