00001
00002
00003
00004
00005
00006
00007
00008
00017 #ifndef quatop_macros_h
00018 #define quatop_macros_h
00019
00021 #define CML_QUAT_UNIOP(_op_, _OpT_) \
00022 template<typename E, class AT, class OT, class CT> \
00023 inline et::QuaternionXpr< \
00024 et::UnaryQuaternionOp< quaternion<E,AT,OT,CT>, _OpT_ <E> > \
00025 > \
00026 \
00027 _op_ (const quaternion<E,AT,OT,CT>& arg) \
00028 { \
00029 typedef et::UnaryQuaternionOp< \
00030 quaternion<E,AT,OT,CT>, _OpT_ <E> \
00031 > ExprT; \
00032 return et::QuaternionXpr<ExprT>(ExprT(arg)); \
00033 }
00034
00035
00037 #define CML_QUATXPR_UNIOP(_op_, _OpT_) \
00038 template<class XprT> \
00039 inline et::QuaternionXpr< \
00040 et::UnaryQuaternionOp< XprT, _OpT_ <typename XprT::value_type> > \
00041 > \
00042 \
00043 _op_ (QUATXPR_ARG_TYPE arg) \
00044 { \
00045 typedef et::UnaryQuaternionOp< \
00046 XprT, _OpT_ <typename XprT::value_type> \
00047 > ExprT; \
00048 return et::QuaternionXpr<ExprT>(ExprT(arg.expression())); \
00049 }
00050
00051
00052
00054 #define CML_QUAT_QUAT_BINOP(_op_, _OpT_) \
00055 template<typename E1, class AT1, typename E2, class AT2, \
00056 class OT, class CT> \
00057 inline et::QuaternionXpr< \
00058 et::BinaryQuaternionOp< \
00059 quaternion<E1,AT1,OT,CT>, quaternion<E2,AT2,OT,CT>, \
00060 _OpT_ <E1,E2> \
00061 > \
00062 > \
00063 \
00064 _op_ ( \
00065 const quaternion<E1,AT1,OT,CT>& left, \
00066 const quaternion<E2,AT2,OT,CT>& right) \
00067 { \
00068 typedef et::BinaryQuaternionOp< \
00069 quaternion<E1,AT1,OT,CT>, quaternion<E2,AT2,OT,CT>, \
00070 _OpT_ <E1,E2> \
00071 > ExprT; \
00072 return et::QuaternionXpr<ExprT>(ExprT(left,right)); \
00073 }
00074
00075
00077 #define CML_QUAT_QUATXPR_BINOP(_op_, _OpT_) \
00078 template<typename E, class AT, class OT, class CT, class XprT> \
00079 inline et::QuaternionXpr< \
00080 et::BinaryQuaternionOp< \
00081 quaternion<E,AT,OT,CT>, XprT, \
00082 _OpT_ <E, typename XprT::value_type> \
00083 > \
00084 > \
00085 \
00086 _op_ ( \
00087 const quaternion<E,AT,OT,CT>& left, \
00088 QUATXPR_ARG_TYPE right) \
00089 { \
00090 typedef et::BinaryQuaternionOp< \
00091 quaternion<E,AT,OT,CT>, XprT, \
00092 _OpT_ <E, typename XprT::value_type> \
00093 > ExprT; \
00094 return et::QuaternionXpr<ExprT>(ExprT(left,right.expression())); \
00095 }
00096
00097
00099 #define CML_QUATXPR_QUAT_BINOP(_op_, _OpT_) \
00100 template<class XprT, typename E, class AT, class OT, class CT> \
00101 inline et::QuaternionXpr< \
00102 et::BinaryQuaternionOp< \
00103 XprT, quaternion<E,AT,OT,CT>, \
00104 _OpT_ <typename XprT::value_type, E> \
00105 > \
00106 > \
00107 \
00108 _op_ ( \
00109 QUATXPR_ARG_TYPE left, \
00110 const quaternion<E,AT,OT,CT>& right) \
00111 { \
00112 typedef et::BinaryQuaternionOp< \
00113 XprT, quaternion<E,AT,OT,CT>, \
00114 _OpT_ <typename XprT::value_type, E> \
00115 > ExprT; \
00116 return et::QuaternionXpr<ExprT>(ExprT(left.expression(),right)); \
00117 }
00118
00119
00121 #define CML_QUATXPR_QUATXPR_BINOP(_op_, _OpT_) \
00122 template<class XprT1, class XprT2> \
00123 inline et::QuaternionXpr< \
00124 et::BinaryQuaternionOp< \
00125 XprT1, XprT2, \
00126 _OpT_ < \
00127 typename XprT1::value_type, \
00128 typename XprT2::value_type \
00129 > \
00130 > \
00131 > \
00132 \
00133 _op_ ( \
00134 QUATXPR_ARG_TYPE_N(1) left, \
00135 QUATXPR_ARG_TYPE_N(2) right) \
00136 { \
00137 typedef et::BinaryQuaternionOp< \
00138 XprT1, XprT2, \
00139 _OpT_ < \
00140 typename XprT1::value_type, \
00141 typename XprT2::value_type> \
00142 > ExprT; \
00143 return et::QuaternionXpr<ExprT>( \
00144 ExprT(left.expression(),right.expression())); \
00145 }
00146
00147
00149 #define CML_QUAT_SCALAR_BINOP(_op_, _OpT_) \
00150 template<typename E, class AT, class OT, class CT, typename ScalarT> \
00151 inline et::QuaternionXpr< \
00152 et::BinaryQuaternionOp< \
00153 quaternion<E,AT,OT,CT>, ScalarT, \
00154 _OpT_ <E,ScalarT> \
00155 > \
00156 > \
00157 \
00158 _op_ ( \
00159 const quaternion<E,AT,OT,CT>& left, \
00160 SCALAR_ARG_TYPE right) \
00161 { \
00162 typedef et::BinaryQuaternionOp< \
00163 quaternion<E,AT,OT,CT>, ScalarT, _OpT_ <E,ScalarT> \
00164 > ExprT; \
00165 return et::QuaternionXpr<ExprT>(ExprT(left,right)); \
00166 }
00167
00168
00170 #define CML_SCALAR_QUAT_BINOP(_op_, _OpT_) \
00171 template<typename ScalarT, typename E, class AT, class OT, class CT> \
00172 inline et::QuaternionXpr< \
00173 et::BinaryQuaternionOp< \
00174 ScalarT, quaternion<E,AT,OT,CT>, _OpT_ <ScalarT,E> \
00175 > \
00176 > \
00177 \
00178 _op_ ( \
00179 SCALAR_ARG_TYPE left, \
00180 const quaternion<E,AT,OT,CT>& right) \
00181 { \
00182 typedef et::BinaryQuaternionOp< \
00183 ScalarT, quaternion<E,AT,OT,CT>, _OpT_ <ScalarT,E> \
00184 > ExprT; \
00185 return et::QuaternionXpr<ExprT>(ExprT(left,right)); \
00186 }
00187
00188
00190 #define CML_QUATXPR_SCALAR_BINOP(_op_, _OpT_) \
00191 template<class XprT, typename ScalarT> \
00192 inline et::QuaternionXpr< \
00193 et::BinaryQuaternionOp< \
00194 XprT, ScalarT, _OpT_ <typename XprT::value_type,ScalarT> \
00195 > \
00196 > \
00197 \
00198 _op_ ( \
00199 QUATXPR_ARG_TYPE left, \
00200 SCALAR_ARG_TYPE right) \
00201 { \
00202 typedef et::BinaryQuaternionOp< \
00203 XprT, ScalarT, _OpT_ <typename XprT::value_type,ScalarT> \
00204 > ExprT; \
00205 return et::QuaternionXpr<ExprT>(ExprT(left.expression(),right)); \
00206 }
00207
00208
00210 #define CML_SCALAR_QUATXPR_BINOP(_op_, _OpT_) \
00211 template<typename ScalarT, class XprT> \
00212 inline et::QuaternionXpr< \
00213 et::BinaryQuaternionOp< \
00214 ScalarT, XprT, _OpT_ <ScalarT, typename XprT::value_type> \
00215 > \
00216 > \
00217 \
00218 _op_ ( \
00219 SCALAR_ARG_TYPE left, \
00220 QUATXPR_ARG_TYPE right) \
00221 { \
00222 typedef et::BinaryQuaternionOp< \
00223 ScalarT, XprT, \
00224 _OpT_ <ScalarT, typename XprT::value_type> \
00225 > ExprT; \
00226 return et::QuaternionXpr<ExprT>(ExprT(left,right.expression())); \
00227 }
00228
00229 #endif
00230
00231
00232
