Shuto Naruse / Mbed 2 deprecated Eurobot2012_Primary

Eurobot2012_Primary

Dependencies:   mbed Eurobot_2012_Primary

tvmet/xpr/MatrixOperators.h@25:143b19c1fb05, 2012-10-17 (annotated)

Committer:
narshu
Date:
Wed Oct 17 22:22:28 2012 +0000
Revision:
25:143b19c1fb05
Commit before publishing;

Who changed what in which revision?

UserRevisionLine numberNew contents of line
narshu 25:143b19c1fb05 1 /*
narshu 25:143b19c1fb05 2 * Tiny Vector Matrix Library
narshu 25:143b19c1fb05 3 * Dense Vector Matrix Libary of Tiny size using Expression Templates
narshu 25:143b19c1fb05 4 *
narshu 25:143b19c1fb05 5 * Copyright (C) 2001 - 2007 Olaf Petzold <opetzold@users.sourceforge.net>
narshu 25:143b19c1fb05 6 *
narshu 25:143b19c1fb05 7 * This library is free software; you can redistribute it and/or
narshu 25:143b19c1fb05 8 * modify it under the terms of the GNU lesser General Public
narshu 25:143b19c1fb05 9 * License as published by the Free Software Foundation; either
narshu 25:143b19c1fb05 10 * version 2.1 of the License, or (at your option) any later version.
narshu 25:143b19c1fb05 11 *
narshu 25:143b19c1fb05 12 * This library is distributed in the hope that it will be useful,
narshu 25:143b19c1fb05 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
narshu 25:143b19c1fb05 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
narshu 25:143b19c1fb05 15 * lesser General Public License for more details.
narshu 25:143b19c1fb05 16 *
narshu 25:143b19c1fb05 17 * You should have received a copy of the GNU lesser General Public
narshu 25:143b19c1fb05 18 * License along with this library; if not, write to the Free Software
narshu 25:143b19c1fb05 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
narshu 25:143b19c1fb05 20 *
narshu 25:143b19c1fb05 21 * $Id: MatrixOperators.h,v 1.23 2007-06-23 15:59:00 opetzold Exp $
narshu 25:143b19c1fb05 22 */
narshu 25:143b19c1fb05 23
narshu 25:143b19c1fb05 24 #ifndef TVMET_XPR_MATRIX_OPERATORS_H
narshu 25:143b19c1fb05 25 #define TVMET_XPR_MATRIX_OPERATORS_H
narshu 25:143b19c1fb05 26
narshu 25:143b19c1fb05 27 namespace tvmet {
narshu 25:143b19c1fb05 28
narshu 25:143b19c1fb05 29
narshu 25:143b19c1fb05 30 /*********************************************************
narshu 25:143b19c1fb05 31 * PART I: DECLARATION
narshu 25:143b19c1fb05 32 *********************************************************/
narshu 25:143b19c1fb05 33
narshu 25:143b19c1fb05 34
narshu 25:143b19c1fb05 35 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++
narshu 25:143b19c1fb05 36 * Matrix arithmetic operators implemented by functions
narshu 25:143b19c1fb05 37 * add, sub, mul and div
narshu 25:143b19c1fb05 38 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
narshu 25:143b19c1fb05 39
narshu 25:143b19c1fb05 40
narshu 25:143b19c1fb05 41 /*
narshu 25:143b19c1fb05 42 * operator(const XprMatrix<E1, Rows1, Cols1>& lhs, const XprMatrix<E2, Cols1,Cols2>& rhs)
narshu 25:143b19c1fb05 43 *
narshu 25:143b19c1fb05 44 * Note: operations +,-,*,/ are per se element wise. Further more,
narshu 25:143b19c1fb05 45 * element wise operations make sense only for matrices of the same
narshu 25:143b19c1fb05 46 * size [varg].
narshu 25:143b19c1fb05 47 */
narshu 25:143b19c1fb05 48 #define TVMET_DECLARE_MACRO(NAME, OP) \
narshu 25:143b19c1fb05 49 template<class E1, std::size_t Rows1, std::size_t Cols1, \
narshu 25:143b19c1fb05 50 class E2> \
narshu 25:143b19c1fb05 51 XprMatrix< \
narshu 25:143b19c1fb05 52 XprBinOp< \
narshu 25:143b19c1fb05 53 Fcnl_##NAME<typename E1::value_type, typename E2::value_type>, \
narshu 25:143b19c1fb05 54 XprMatrix<E1, Rows1, Cols1>, \
narshu 25:143b19c1fb05 55 XprMatrix<E2, Rows1, Cols1> \
narshu 25:143b19c1fb05 56 >, \
narshu 25:143b19c1fb05 57 Rows1, Cols1 \
narshu 25:143b19c1fb05 58 > \
narshu 25:143b19c1fb05 59 operator OP (const XprMatrix<E1, Rows1, Cols1>& lhs, \
narshu 25:143b19c1fb05 60 const XprMatrix<E2, Rows1, Cols1>& rhs) TVMET_CXX_ALWAYS_INLINE;
narshu 25:143b19c1fb05 61
narshu 25:143b19c1fb05 62 TVMET_DECLARE_MACRO(add, +) // per se element wise
narshu 25:143b19c1fb05 63 TVMET_DECLARE_MACRO(sub, -) // per se element wise
narshu 25:143b19c1fb05 64 namespace element_wise {
narshu 25:143b19c1fb05 65 TVMET_DECLARE_MACRO(mul, *) // see as prod()
narshu 25:143b19c1fb05 66 TVMET_DECLARE_MACRO(div, /) // not defined for matrizes, must be element_wise
narshu 25:143b19c1fb05 67 }
narshu 25:143b19c1fb05 68 #undef TVMET_DECLARE_MACRO
narshu 25:143b19c1fb05 69
narshu 25:143b19c1fb05 70
narshu 25:143b19c1fb05 71 /*
narshu 25:143b19c1fb05 72 * operator(XprMatrix<E, Rows, Cols>, POD)
narshu 25:143b19c1fb05 73 * operator(POD, XprMatrix<E, Rows, Cols>)
narshu 25:143b19c1fb05 74 * Note: operations +,-,*,/ are per se element wise
narshu 25:143b19c1fb05 75 */
narshu 25:143b19c1fb05 76 #define TVMET_DECLARE_MACRO(NAME, OP, POD) \
narshu 25:143b19c1fb05 77 template<class E, std::size_t Rows, std::size_t Cols> \
narshu 25:143b19c1fb05 78 XprMatrix< \
narshu 25:143b19c1fb05 79 XprBinOp< \
narshu 25:143b19c1fb05 80 Fcnl_##NAME<typename E::value_type, POD >, \
narshu 25:143b19c1fb05 81 XprMatrix<E, Rows, Cols>, \
narshu 25:143b19c1fb05 82 XprLiteral< POD > \
narshu 25:143b19c1fb05 83 >, \
narshu 25:143b19c1fb05 84 Rows, Cols \
narshu 25:143b19c1fb05 85 > \
narshu 25:143b19c1fb05 86 operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
narshu 25:143b19c1fb05 87 POD rhs) TVMET_CXX_ALWAYS_INLINE; \
narshu 25:143b19c1fb05 88 \
narshu 25:143b19c1fb05 89 template<class E,std::size_t Rows, std::size_t Cols> \
narshu 25:143b19c1fb05 90 XprMatrix< \
narshu 25:143b19c1fb05 91 XprBinOp< \
narshu 25:143b19c1fb05 92 Fcnl_##NAME<POD, typename E::value_type>, \
narshu 25:143b19c1fb05 93 XprLiteral< POD >, \
narshu 25:143b19c1fb05 94 XprMatrix<E, Rows, Cols> \
narshu 25:143b19c1fb05 95 >, \
narshu 25:143b19c1fb05 96 Rows, Cols \
narshu 25:143b19c1fb05 97 > \
narshu 25:143b19c1fb05 98 operator OP (POD lhs, \
narshu 25:143b19c1fb05 99 const XprMatrix<E, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
narshu 25:143b19c1fb05 100
narshu 25:143b19c1fb05 101 TVMET_DECLARE_MACRO(add, +, int)
narshu 25:143b19c1fb05 102 TVMET_DECLARE_MACRO(sub, -, int)
narshu 25:143b19c1fb05 103 TVMET_DECLARE_MACRO(mul, *, int)
narshu 25:143b19c1fb05 104 TVMET_DECLARE_MACRO(div, /, int)
narshu 25:143b19c1fb05 105
narshu 25:143b19c1fb05 106 #if defined(TVMET_HAVE_LONG_LONG)
narshu 25:143b19c1fb05 107 TVMET_DECLARE_MACRO(add, +, long long int)
narshu 25:143b19c1fb05 108 TVMET_DECLARE_MACRO(sub, -, long long int)
narshu 25:143b19c1fb05 109 TVMET_DECLARE_MACRO(mul, *, long long int)
narshu 25:143b19c1fb05 110 TVMET_DECLARE_MACRO(div, /, long long int)
narshu 25:143b19c1fb05 111 #endif // defined(TVMET_HAVE_LONG_LONG)
narshu 25:143b19c1fb05 112
narshu 25:143b19c1fb05 113 TVMET_DECLARE_MACRO(add, +, float)
narshu 25:143b19c1fb05 114 TVMET_DECLARE_MACRO(sub, -, float)
narshu 25:143b19c1fb05 115 TVMET_DECLARE_MACRO(mul, *, float)
narshu 25:143b19c1fb05 116 TVMET_DECLARE_MACRO(div, /, float)
narshu 25:143b19c1fb05 117
narshu 25:143b19c1fb05 118 TVMET_DECLARE_MACRO(add, +, double)
narshu 25:143b19c1fb05 119 TVMET_DECLARE_MACRO(sub, -, double)
narshu 25:143b19c1fb05 120 TVMET_DECLARE_MACRO(mul, *, double)
narshu 25:143b19c1fb05 121 TVMET_DECLARE_MACRO(div, /, double)
narshu 25:143b19c1fb05 122
narshu 25:143b19c1fb05 123 #if defined(TVMET_HAVE_LONG_DOUBLE)
narshu 25:143b19c1fb05 124 TVMET_DECLARE_MACRO(add, +, long double)
narshu 25:143b19c1fb05 125 TVMET_DECLARE_MACRO(sub, -, long double)
narshu 25:143b19c1fb05 126 TVMET_DECLARE_MACRO(mul, *, long double)
narshu 25:143b19c1fb05 127 TVMET_DECLARE_MACRO(div, /, long double)
narshu 25:143b19c1fb05 128 #endif // defined(TVMET_HAVE_LONG_DOUBLE)
narshu 25:143b19c1fb05 129
narshu 25:143b19c1fb05 130 #undef TVMET_DECLARE_MACRO
narshu 25:143b19c1fb05 131
narshu 25:143b19c1fb05 132
narshu 25:143b19c1fb05 133 #if defined(TVMET_HAVE_COMPLEX)
narshu 25:143b19c1fb05 134 /*
narshu 25:143b19c1fb05 135 * operator(XprMatrix<E, Rows, Cols>, complex<>)
narshu 25:143b19c1fb05 136 * operator(complex<>, XprMatrix<E, Rows, Cols>)
narshu 25:143b19c1fb05 137 * Note: operations +,-,*,/ are per se element wise
narshu 25:143b19c1fb05 138 * \todo type promotion
narshu 25:143b19c1fb05 139 */
narshu 25:143b19c1fb05 140 #define TVMET_DECLARE_MACRO(NAME, OP) \
narshu 25:143b19c1fb05 141 template<class E, std::size_t Rows, std::size_t Cols, class T> \
narshu 25:143b19c1fb05 142 XprMatrix< \
narshu 25:143b19c1fb05 143 XprBinOp< \
narshu 25:143b19c1fb05 144 Fcnl_##NAME<typename E::value_type, std::complex<T> >, \
narshu 25:143b19c1fb05 145 XprMatrix<E, Rows, Cols>, \
narshu 25:143b19c1fb05 146 XprLiteral< std::complex<T> > \
narshu 25:143b19c1fb05 147 >, \
narshu 25:143b19c1fb05 148 Rows, Cols \
narshu 25:143b19c1fb05 149 > \
narshu 25:143b19c1fb05 150 operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
narshu 25:143b19c1fb05 151 const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
narshu 25:143b19c1fb05 152 \
narshu 25:143b19c1fb05 153 template<class E, std::size_t Rows, std::size_t Cols, class T> \
narshu 25:143b19c1fb05 154 XprMatrix< \
narshu 25:143b19c1fb05 155 XprBinOp< \
narshu 25:143b19c1fb05 156 Fcnl_##NAME<std::complex<T>, typename E::value_type>, \
narshu 25:143b19c1fb05 157 XprLiteral< std::complex<T> >, \
narshu 25:143b19c1fb05 158 XprMatrix<E, Rows, Cols> \
narshu 25:143b19c1fb05 159 >, \
narshu 25:143b19c1fb05 160 Rows, Cols \
narshu 25:143b19c1fb05 161 > \
narshu 25:143b19c1fb05 162 operator OP (const std::complex<T>& lhs, \
narshu 25:143b19c1fb05 163 const XprMatrix<E, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
narshu 25:143b19c1fb05 164
narshu 25:143b19c1fb05 165 TVMET_DECLARE_MACRO(add, +)
narshu 25:143b19c1fb05 166 TVMET_DECLARE_MACRO(sub, -)
narshu 25:143b19c1fb05 167 TVMET_DECLARE_MACRO(mul, *)
narshu 25:143b19c1fb05 168 TVMET_DECLARE_MACRO(div, /)
narshu 25:143b19c1fb05 169
narshu 25:143b19c1fb05 170 #undef TVMET_DECLARE_MACRO
narshu 25:143b19c1fb05 171
narshu 25:143b19c1fb05 172 #endif // defined(TVMET_HAVE_COMPLEX)
narshu 25:143b19c1fb05 173
narshu 25:143b19c1fb05 174
narshu 25:143b19c1fb05 175 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++
narshu 25:143b19c1fb05 176 * matrix specific operator*() = prod() operations
narshu 25:143b19c1fb05 177 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
narshu 25:143b19c1fb05 178
narshu 25:143b19c1fb05 179
narshu 25:143b19c1fb05 180 /**
narshu 25:143b19c1fb05 181 * \fn operator*(const XprMatrix<E1, Rows1, Cols1>& lhs, const XprMatrix<E2, Cols1, Cols2>& rhs)
narshu 25:143b19c1fb05 182 * \brief Evaluate the product of two XprMatrix.
narshu 25:143b19c1fb05 183 * \ingroup _binary_operator
narshu 25:143b19c1fb05 184 * \sa prod(XprMatrix<E1, Rows1, Cols1> lhs, XprMatrix<E2, Cols1, Cols2> rhs)
narshu 25:143b19c1fb05 185 */
narshu 25:143b19c1fb05 186 template<class E1, std::size_t Rows1, std::size_t Cols1,
narshu 25:143b19c1fb05 187 class E2, std::size_t Cols2>
narshu 25:143b19c1fb05 188 XprMatrix<
narshu 25:143b19c1fb05 189 XprMMProduct<
narshu 25:143b19c1fb05 190 XprMatrix<E1, Rows1, Cols1>, Rows1, Cols1, // M1(Rows1, Cols1)
narshu 25:143b19c1fb05 191 XprMatrix<E2, Cols1, Cols2>, Cols2 // M2(Cols1, Cols2)
narshu 25:143b19c1fb05 192 >,
narshu 25:143b19c1fb05 193 Rows1, Cols2
narshu 25:143b19c1fb05 194 >
narshu 25:143b19c1fb05 195 operator*(const XprMatrix<E1, Rows1, Cols1>& lhs,
narshu 25:143b19c1fb05 196 const XprMatrix<E2, Cols1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE;
narshu 25:143b19c1fb05 197
narshu 25:143b19c1fb05 198
narshu 25:143b19c1fb05 199 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++
narshu 25:143b19c1fb05 200 * matrix-vector specific prod( ... ) operators
narshu 25:143b19c1fb05 201 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
narshu 25:143b19c1fb05 202
narshu 25:143b19c1fb05 203
narshu 25:143b19c1fb05 204 /**
narshu 25:143b19c1fb05 205 * \fn operator*(const XprMatrix<E1, Rows, Cols>& lhs, const XprVector<E2, Cols>& rhs)
narshu 25:143b19c1fb05 206 * \brief Evaluate the product of XprMatrix and XprVector.
narshu 25:143b19c1fb05 207 * \ingroup _binary_operator
narshu 25:143b19c1fb05 208 * \sa prod(XprMatrix<E1, Rows, Cols> lhs, XprVector<E2, Cols> rhs)
narshu 25:143b19c1fb05 209 */
narshu 25:143b19c1fb05 210 template<class E1, std::size_t Rows, std::size_t Cols,
narshu 25:143b19c1fb05 211 class E2>
narshu 25:143b19c1fb05 212 XprVector<
narshu 25:143b19c1fb05 213 XprMVProduct<
narshu 25:143b19c1fb05 214 XprMatrix<E1, Rows, Cols>, Rows, Cols,
narshu 25:143b19c1fb05 215 XprVector<E2, Cols>
narshu 25:143b19c1fb05 216 >,
narshu 25:143b19c1fb05 217 Rows
narshu 25:143b19c1fb05 218 >
narshu 25:143b19c1fb05 219 operator*(const XprMatrix<E1, Rows, Cols>& lhs,
narshu 25:143b19c1fb05 220 const XprVector<E2, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
narshu 25:143b19c1fb05 221
narshu 25:143b19c1fb05 222
narshu 25:143b19c1fb05 223 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++
narshu 25:143b19c1fb05 224 * Matrix integer and compare operators
narshu 25:143b19c1fb05 225 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
narshu 25:143b19c1fb05 226
narshu 25:143b19c1fb05 227
narshu 25:143b19c1fb05 228 /*
narshu 25:143b19c1fb05 229 * operator(XprMatrix<>, XprMatrix<>)
narshu 25:143b19c1fb05 230 * Note: operations are per se element wise
narshu 25:143b19c1fb05 231 */
narshu 25:143b19c1fb05 232 #define TVMET_DECLARE_MACRO(NAME, OP) \
narshu 25:143b19c1fb05 233 template<class E1, std::size_t Rows, std::size_t Cols, \
narshu 25:143b19c1fb05 234 class E2> \
narshu 25:143b19c1fb05 235 XprMatrix< \
narshu 25:143b19c1fb05 236 XprBinOp< \
narshu 25:143b19c1fb05 237 Fcnl_##NAME<typename E1::value_type, typename E2::value_type>, \
narshu 25:143b19c1fb05 238 XprMatrix<E1, Rows, Cols>, \
narshu 25:143b19c1fb05 239 XprMatrix<E2, Rows, Cols> \
narshu 25:143b19c1fb05 240 >, \
narshu 25:143b19c1fb05 241 Rows, Cols \
narshu 25:143b19c1fb05 242 > \
narshu 25:143b19c1fb05 243 operator OP (const XprMatrix<E1, Rows, Cols>& lhs, \
narshu 25:143b19c1fb05 244 const XprMatrix<E2, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
narshu 25:143b19c1fb05 245
narshu 25:143b19c1fb05 246 // integer operators only, e.g used on double you will get an error
narshu 25:143b19c1fb05 247 namespace element_wise {
narshu 25:143b19c1fb05 248 TVMET_DECLARE_MACRO(mod, %)
narshu 25:143b19c1fb05 249 TVMET_DECLARE_MACRO(bitxor, ^)
narshu 25:143b19c1fb05 250 TVMET_DECLARE_MACRO(bitand, &)
narshu 25:143b19c1fb05 251 TVMET_DECLARE_MACRO(bitor, |)
narshu 25:143b19c1fb05 252 TVMET_DECLARE_MACRO(shl, <<)
narshu 25:143b19c1fb05 253 TVMET_DECLARE_MACRO(shr, >>)
narshu 25:143b19c1fb05 254 }
narshu 25:143b19c1fb05 255
narshu 25:143b19c1fb05 256 // necessary operators for eval functions
narshu 25:143b19c1fb05 257 TVMET_DECLARE_MACRO(greater, >)
narshu 25:143b19c1fb05 258 TVMET_DECLARE_MACRO(less, <)
narshu 25:143b19c1fb05 259 TVMET_DECLARE_MACRO(greater_eq, >=)
narshu 25:143b19c1fb05 260 TVMET_DECLARE_MACRO(less_eq, <=)
narshu 25:143b19c1fb05 261 TVMET_DECLARE_MACRO(eq, ==)
narshu 25:143b19c1fb05 262 TVMET_DECLARE_MACRO(not_eq, !=)
narshu 25:143b19c1fb05 263 TVMET_DECLARE_MACRO(and, &&)
narshu 25:143b19c1fb05 264 TVMET_DECLARE_MACRO(or, ||)
narshu 25:143b19c1fb05 265
narshu 25:143b19c1fb05 266 #undef TVMET_DECLARE_MACRO
narshu 25:143b19c1fb05 267
narshu 25:143b19c1fb05 268
narshu 25:143b19c1fb05 269 #if defined(TVMET_HAVE_COMPLEX)
narshu 25:143b19c1fb05 270 /*
narshu 25:143b19c1fb05 271 * operator(XprMatrix<E, Rows, Cols>, std::complex<>)
narshu 25:143b19c1fb05 272 * operator(std::complex<>, XprMatrix<E, Rows, Cols>)
narshu 25:143b19c1fb05 273 * Note: - per se element wise
narshu 25:143b19c1fb05 274 * - bit ops on complex<int> doesn't make sense, stay away
narshu 25:143b19c1fb05 275 * \todo type promotion
narshu 25:143b19c1fb05 276 */
narshu 25:143b19c1fb05 277 #define TVMET_DECLARE_MACRO(NAME, OP) \
narshu 25:143b19c1fb05 278 template<class E, std::size_t Rows, std::size_t Cols, class T> \
narshu 25:143b19c1fb05 279 XprMatrix< \
narshu 25:143b19c1fb05 280 XprBinOp< \
narshu 25:143b19c1fb05 281 Fcnl_##NAME<typename E::value_type, std::complex<T> >, \
narshu 25:143b19c1fb05 282 XprMatrix<E, Rows, Cols>, \
narshu 25:143b19c1fb05 283 XprLiteral< std::complex<T> > \
narshu 25:143b19c1fb05 284 >, \
narshu 25:143b19c1fb05 285 Rows, Cols \
narshu 25:143b19c1fb05 286 > \
narshu 25:143b19c1fb05 287 operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
narshu 25:143b19c1fb05 288 const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \
narshu 25:143b19c1fb05 289 \
narshu 25:143b19c1fb05 290 template<class E, std::size_t Rows, std::size_t Cols, class T> \
narshu 25:143b19c1fb05 291 XprMatrix< \
narshu 25:143b19c1fb05 292 XprBinOp< \
narshu 25:143b19c1fb05 293 Fcnl_##NAME<std::complex<T>, typename E::value_type>, \
narshu 25:143b19c1fb05 294 XprLiteral< std::complex<T> >, \
narshu 25:143b19c1fb05 295 XprMatrix<E, Rows, Cols> \
narshu 25:143b19c1fb05 296 >, \
narshu 25:143b19c1fb05 297 Rows, Cols \
narshu 25:143b19c1fb05 298 > \
narshu 25:143b19c1fb05 299 operator OP (const std::complex<T>& lhs, \
narshu 25:143b19c1fb05 300 const XprMatrix<E, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
narshu 25:143b19c1fb05 301
narshu 25:143b19c1fb05 302 // necessary operators for eval functions
narshu 25:143b19c1fb05 303 TVMET_DECLARE_MACRO(greater, >)
narshu 25:143b19c1fb05 304 TVMET_DECLARE_MACRO(less, <)
narshu 25:143b19c1fb05 305 TVMET_DECLARE_MACRO(greater_eq, >=)
narshu 25:143b19c1fb05 306 TVMET_DECLARE_MACRO(less_eq, <=)
narshu 25:143b19c1fb05 307 TVMET_DECLARE_MACRO(eq, ==)
narshu 25:143b19c1fb05 308 TVMET_DECLARE_MACRO(not_eq, !=)
narshu 25:143b19c1fb05 309 TVMET_DECLARE_MACRO(and, &&)
narshu 25:143b19c1fb05 310 TVMET_DECLARE_MACRO(or, ||)
narshu 25:143b19c1fb05 311
narshu 25:143b19c1fb05 312 #undef TVMET_DECLARE_MACRO
narshu 25:143b19c1fb05 313
narshu 25:143b19c1fb05 314 #endif // defined(TVMET_HAVE_COMPLEX)
narshu 25:143b19c1fb05 315
narshu 25:143b19c1fb05 316
narshu 25:143b19c1fb05 317 /*
narshu 25:143b19c1fb05 318 * operator(XprMatrix<E, Rows, Cols>, POD)
narshu 25:143b19c1fb05 319 * operator(POD, XprMatrix<E, Rows, Cols>)
narshu 25:143b19c1fb05 320 * Note: operations are per se element wise
narshu 25:143b19c1fb05 321 */
narshu 25:143b19c1fb05 322 #define TVMET_DECLARE_MACRO(NAME, OP, TP) \
narshu 25:143b19c1fb05 323 template<class E, std::size_t Rows, std::size_t Cols> \
narshu 25:143b19c1fb05 324 XprMatrix< \
narshu 25:143b19c1fb05 325 XprBinOp< \
narshu 25:143b19c1fb05 326 Fcnl_##NAME<typename E::value_type, TP >, \
narshu 25:143b19c1fb05 327 XprMatrix<E, Rows, Cols>, \
narshu 25:143b19c1fb05 328 XprLiteral< TP > \
narshu 25:143b19c1fb05 329 >, \
narshu 25:143b19c1fb05 330 Rows, Cols \
narshu 25:143b19c1fb05 331 > \
narshu 25:143b19c1fb05 332 operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
narshu 25:143b19c1fb05 333 TP rhs) TVMET_CXX_ALWAYS_INLINE; \
narshu 25:143b19c1fb05 334 \
narshu 25:143b19c1fb05 335 template<class E, std::size_t Rows, std::size_t Cols> \
narshu 25:143b19c1fb05 336 XprMatrix< \
narshu 25:143b19c1fb05 337 XprBinOp< \
narshu 25:143b19c1fb05 338 Fcnl_##NAME<TP, typename E::value_type>, \
narshu 25:143b19c1fb05 339 XprLiteral< TP >, \
narshu 25:143b19c1fb05 340 XprMatrix<E, Rows, Cols> \
narshu 25:143b19c1fb05 341 >, \
narshu 25:143b19c1fb05 342 Rows, Cols \
narshu 25:143b19c1fb05 343 > \
narshu 25:143b19c1fb05 344 operator OP (TP lhs, \
narshu 25:143b19c1fb05 345 const XprMatrix<E, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE;
narshu 25:143b19c1fb05 346
narshu 25:143b19c1fb05 347 // integer operators only, e.g used on double you will get an error
narshu 25:143b19c1fb05 348 namespace element_wise {
narshu 25:143b19c1fb05 349 TVMET_DECLARE_MACRO(mod, %, int)
narshu 25:143b19c1fb05 350 TVMET_DECLARE_MACRO(bitxor, ^, int)
narshu 25:143b19c1fb05 351 TVMET_DECLARE_MACRO(bitand, &, int)
narshu 25:143b19c1fb05 352 TVMET_DECLARE_MACRO(bitor, |, int)
narshu 25:143b19c1fb05 353 TVMET_DECLARE_MACRO(shl, <<, int)
narshu 25:143b19c1fb05 354 TVMET_DECLARE_MACRO(shr, >>, int)
narshu 25:143b19c1fb05 355 }
narshu 25:143b19c1fb05 356
narshu 25:143b19c1fb05 357 // necessary operators for eval functions
narshu 25:143b19c1fb05 358 TVMET_DECLARE_MACRO(greater, >, int)
narshu 25:143b19c1fb05 359 TVMET_DECLARE_MACRO(less, <, int)
narshu 25:143b19c1fb05 360 TVMET_DECLARE_MACRO(greater_eq, >=, int)
narshu 25:143b19c1fb05 361 TVMET_DECLARE_MACRO(less_eq, <=, int)
narshu 25:143b19c1fb05 362 TVMET_DECLARE_MACRO(eq, ==, int)
narshu 25:143b19c1fb05 363 TVMET_DECLARE_MACRO(not_eq, !=, int)
narshu 25:143b19c1fb05 364 TVMET_DECLARE_MACRO(and, &&, int)
narshu 25:143b19c1fb05 365 TVMET_DECLARE_MACRO(or, ||, int)
narshu 25:143b19c1fb05 366
narshu 25:143b19c1fb05 367 #if defined(TVMET_HAVE_LONG_LONG)
narshu 25:143b19c1fb05 368 // integer operators only
narshu 25:143b19c1fb05 369 namespace element_wise {
narshu 25:143b19c1fb05 370 TVMET_DECLARE_MACRO(mod, %, long long int)
narshu 25:143b19c1fb05 371 TVMET_DECLARE_MACRO(bitxor, ^, long long int)
narshu 25:143b19c1fb05 372 TVMET_DECLARE_MACRO(bitand, &, long long int)
narshu 25:143b19c1fb05 373 TVMET_DECLARE_MACRO(bitor, |, long long int)
narshu 25:143b19c1fb05 374 TVMET_DECLARE_MACRO(shl, <<, long long int)
narshu 25:143b19c1fb05 375 TVMET_DECLARE_MACRO(shr, >>, long long int)
narshu 25:143b19c1fb05 376 }
narshu 25:143b19c1fb05 377
narshu 25:143b19c1fb05 378 // necessary operators for eval functions
narshu 25:143b19c1fb05 379 TVMET_DECLARE_MACRO(greater, >, long long int)
narshu 25:143b19c1fb05 380 TVMET_DECLARE_MACRO(less, <, long long int)
narshu 25:143b19c1fb05 381 TVMET_DECLARE_MACRO(greater_eq, >=, long long int)
narshu 25:143b19c1fb05 382 TVMET_DECLARE_MACRO(less_eq, <=, long long int)
narshu 25:143b19c1fb05 383 TVMET_DECLARE_MACRO(eq, ==, long long int)
narshu 25:143b19c1fb05 384 TVMET_DECLARE_MACRO(not_eq, !=, long long int)
narshu 25:143b19c1fb05 385 TVMET_DECLARE_MACRO(and, &&, long long int)
narshu 25:143b19c1fb05 386 TVMET_DECLARE_MACRO(or, ||, long long int)
narshu 25:143b19c1fb05 387 #endif // defined(TVMET_HAVE_LONG_LONG)
narshu 25:143b19c1fb05 388
narshu 25:143b19c1fb05 389 // necessary operators for eval functions
narshu 25:143b19c1fb05 390 TVMET_DECLARE_MACRO(greater, >, float)
narshu 25:143b19c1fb05 391 TVMET_DECLARE_MACRO(less, <, float)
narshu 25:143b19c1fb05 392 TVMET_DECLARE_MACRO(greater_eq, >=, float)
narshu 25:143b19c1fb05 393 TVMET_DECLARE_MACRO(less_eq, <=, float)
narshu 25:143b19c1fb05 394 TVMET_DECLARE_MACRO(eq, ==, float)
narshu 25:143b19c1fb05 395 TVMET_DECLARE_MACRO(not_eq, !=, float)
narshu 25:143b19c1fb05 396 TVMET_DECLARE_MACRO(and, &&, float)
narshu 25:143b19c1fb05 397 TVMET_DECLARE_MACRO(or, ||, float)
narshu 25:143b19c1fb05 398
narshu 25:143b19c1fb05 399 // necessary operators for eval functions
narshu 25:143b19c1fb05 400 TVMET_DECLARE_MACRO(greater, >, double)
narshu 25:143b19c1fb05 401 TVMET_DECLARE_MACRO(less, <, double)
narshu 25:143b19c1fb05 402 TVMET_DECLARE_MACRO(greater_eq, >=, double)
narshu 25:143b19c1fb05 403 TVMET_DECLARE_MACRO(less_eq, <=, double)
narshu 25:143b19c1fb05 404 TVMET_DECLARE_MACRO(eq, ==, double)
narshu 25:143b19c1fb05 405 TVMET_DECLARE_MACRO(not_eq, !=, double)
narshu 25:143b19c1fb05 406 TVMET_DECLARE_MACRO(and, &&, double)
narshu 25:143b19c1fb05 407 TVMET_DECLARE_MACRO(or, ||, double)
narshu 25:143b19c1fb05 408
narshu 25:143b19c1fb05 409 #if defined(TVMET_HAVE_LONG_DOUBLE)
narshu 25:143b19c1fb05 410 // necessary operators for eval functions
narshu 25:143b19c1fb05 411 TVMET_DECLARE_MACRO(greater, >, long double)
narshu 25:143b19c1fb05 412 TVMET_DECLARE_MACRO(less, <, long double)
narshu 25:143b19c1fb05 413 TVMET_DECLARE_MACRO(greater_eq, >=, long double)
narshu 25:143b19c1fb05 414 TVMET_DECLARE_MACRO(less_eq, <=, long double)
narshu 25:143b19c1fb05 415 TVMET_DECLARE_MACRO(eq, ==, long double)
narshu 25:143b19c1fb05 416 TVMET_DECLARE_MACRO(not_eq, !=, long double)
narshu 25:143b19c1fb05 417 TVMET_DECLARE_MACRO(and, &&, long double)
narshu 25:143b19c1fb05 418 TVMET_DECLARE_MACRO(or, ||, long double)
narshu 25:143b19c1fb05 419 #endif // defined(TVMET_HAVE_LONG_DOUBLE)
narshu 25:143b19c1fb05 420
narshu 25:143b19c1fb05 421 #undef TVMET_DECLARE_MACRO
narshu 25:143b19c1fb05 422
narshu 25:143b19c1fb05 423
narshu 25:143b19c1fb05 424 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++
narshu 25:143b19c1fb05 425 * global unary operators
narshu 25:143b19c1fb05 426 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
narshu 25:143b19c1fb05 427
narshu 25:143b19c1fb05 428
narshu 25:143b19c1fb05 429 /*
narshu 25:143b19c1fb05 430 * unary_operator(const XprMatrix<E, Rows, Cols>& m)
narshu 25:143b19c1fb05 431 * Note: per se element wise
narshu 25:143b19c1fb05 432 */
narshu 25:143b19c1fb05 433 #define TVMET_DECLARE_MACRO(NAME, OP) \
narshu 25:143b19c1fb05 434 template <class E, std::size_t Rows, std::size_t Cols> \
narshu 25:143b19c1fb05 435 XprMatrix< \
narshu 25:143b19c1fb05 436 XprUnOp< \
narshu 25:143b19c1fb05 437 Fcnl_##NAME<typename E::value_type>, \
narshu 25:143b19c1fb05 438 XprMatrix<E, Rows, Cols> \
narshu 25:143b19c1fb05 439 >, \
narshu 25:143b19c1fb05 440 Rows, Cols \
narshu 25:143b19c1fb05 441 > \
narshu 25:143b19c1fb05 442 operator OP (const XprMatrix<E, Rows, Cols>& m) TVMET_CXX_ALWAYS_INLINE;
narshu 25:143b19c1fb05 443
narshu 25:143b19c1fb05 444 TVMET_DECLARE_MACRO(not, !)
narshu 25:143b19c1fb05 445 TVMET_DECLARE_MACRO(compl, ~)
narshu 25:143b19c1fb05 446 TVMET_DECLARE_MACRO(neg, -)
narshu 25:143b19c1fb05 447
narshu 25:143b19c1fb05 448 #undef TVMET_DECLARE_MACRO
narshu 25:143b19c1fb05 449
narshu 25:143b19c1fb05 450
narshu 25:143b19c1fb05 451 /*********************************************************
narshu 25:143b19c1fb05 452 * PART II: IMPLEMENTATION
narshu 25:143b19c1fb05 453 *********************************************************/
narshu 25:143b19c1fb05 454
narshu 25:143b19c1fb05 455
narshu 25:143b19c1fb05 456
narshu 25:143b19c1fb05 457 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++
narshu 25:143b19c1fb05 458 * Matrix arithmetic operators implemented by functions
narshu 25:143b19c1fb05 459 * add, sub, mul and div
narshu 25:143b19c1fb05 460 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
narshu 25:143b19c1fb05 461
narshu 25:143b19c1fb05 462
narshu 25:143b19c1fb05 463 /*
narshu 25:143b19c1fb05 464 * operator(const XprMatrix<E1, Rows1, Cols1>& lhs, const XprMatrix<E2, Cols1,Cols2>& rhs)
narshu 25:143b19c1fb05 465 *
narshu 25:143b19c1fb05 466 * Note: operations +,-,*,/ are per se element wise. Further more,
narshu 25:143b19c1fb05 467 * element wise operations make sense only for matrices of the same
narshu 25:143b19c1fb05 468 * size [varg].
narshu 25:143b19c1fb05 469 */
narshu 25:143b19c1fb05 470 #define TVMET_IMPLEMENT_MACRO(NAME, OP) \
narshu 25:143b19c1fb05 471 template<class E1, std::size_t Rows1, std::size_t Cols1, \
narshu 25:143b19c1fb05 472 class E2> \
narshu 25:143b19c1fb05 473 inline \
narshu 25:143b19c1fb05 474 XprMatrix< \
narshu 25:143b19c1fb05 475 XprBinOp< \
narshu 25:143b19c1fb05 476 Fcnl_##NAME<typename E1::value_type, typename E2::value_type>, \
narshu 25:143b19c1fb05 477 XprMatrix<E1, Rows1, Cols1>, \
narshu 25:143b19c1fb05 478 XprMatrix<E2, Rows1, Cols1> \
narshu 25:143b19c1fb05 479 >, \
narshu 25:143b19c1fb05 480 Rows1, Cols1 \
narshu 25:143b19c1fb05 481 > \
narshu 25:143b19c1fb05 482 operator OP (const XprMatrix<E1, Rows1, Cols1>& lhs, \
narshu 25:143b19c1fb05 483 const XprMatrix<E2, Rows1, Cols1>& rhs) { \
narshu 25:143b19c1fb05 484 return NAME (lhs, rhs); \
narshu 25:143b19c1fb05 485 }
narshu 25:143b19c1fb05 486
narshu 25:143b19c1fb05 487 TVMET_IMPLEMENT_MACRO(add, +) // per se element wise
narshu 25:143b19c1fb05 488 TVMET_IMPLEMENT_MACRO(sub, -) // per se element wise
narshu 25:143b19c1fb05 489 namespace element_wise {
narshu 25:143b19c1fb05 490 TVMET_IMPLEMENT_MACRO(mul, *) // see as prod()
narshu 25:143b19c1fb05 491 TVMET_IMPLEMENT_MACRO(div, /) // not defined for matrizes, must be element_wise
narshu 25:143b19c1fb05 492 }
narshu 25:143b19c1fb05 493 #undef TVMET_IMPLEMENT_MACRO
narshu 25:143b19c1fb05 494
narshu 25:143b19c1fb05 495
narshu 25:143b19c1fb05 496 /*
narshu 25:143b19c1fb05 497 * operator(XprMatrix<E, Rows, Cols>, POD)
narshu 25:143b19c1fb05 498 * operator(POD, XprMatrix<E, Rows, Cols>)
narshu 25:143b19c1fb05 499 * Note: operations +,-,*,/ are per se element wise
narshu 25:143b19c1fb05 500 */
narshu 25:143b19c1fb05 501 #define TVMET_IMPLEMENT_MACRO(NAME, OP, POD) \
narshu 25:143b19c1fb05 502 template<class E, std::size_t Rows, std::size_t Cols> \
narshu 25:143b19c1fb05 503 inline \
narshu 25:143b19c1fb05 504 XprMatrix< \
narshu 25:143b19c1fb05 505 XprBinOp< \
narshu 25:143b19c1fb05 506 Fcnl_##NAME<typename E::value_type, POD >, \
narshu 25:143b19c1fb05 507 XprMatrix<E, Rows, Cols>, \
narshu 25:143b19c1fb05 508 XprLiteral< POD > \
narshu 25:143b19c1fb05 509 >, \
narshu 25:143b19c1fb05 510 Rows, Cols \
narshu 25:143b19c1fb05 511 > \
narshu 25:143b19c1fb05 512 operator OP (const XprMatrix<E, Rows, Cols>& lhs, POD rhs) { \
narshu 25:143b19c1fb05 513 return NAME (lhs, rhs); \
narshu 25:143b19c1fb05 514 } \
narshu 25:143b19c1fb05 515 \
narshu 25:143b19c1fb05 516 template<class E,std::size_t Rows, std::size_t Cols> \
narshu 25:143b19c1fb05 517 inline \
narshu 25:143b19c1fb05 518 XprMatrix< \
narshu 25:143b19c1fb05 519 XprBinOp< \
narshu 25:143b19c1fb05 520 Fcnl_##NAME<POD, typename E::value_type>, \
narshu 25:143b19c1fb05 521 XprLiteral< POD >, \
narshu 25:143b19c1fb05 522 XprMatrix<E, Rows, Cols> \
narshu 25:143b19c1fb05 523 >, \
narshu 25:143b19c1fb05 524 Rows, Cols \
narshu 25:143b19c1fb05 525 > \
narshu 25:143b19c1fb05 526 operator OP (POD lhs, const XprMatrix<E, Rows, Cols>& rhs) { \
narshu 25:143b19c1fb05 527 return NAME (lhs, rhs); \
narshu 25:143b19c1fb05 528 }
narshu 25:143b19c1fb05 529
narshu 25:143b19c1fb05 530 TVMET_IMPLEMENT_MACRO(add, +, int)
narshu 25:143b19c1fb05 531 TVMET_IMPLEMENT_MACRO(sub, -, int)
narshu 25:143b19c1fb05 532 TVMET_IMPLEMENT_MACRO(mul, *, int)
narshu 25:143b19c1fb05 533 TVMET_IMPLEMENT_MACRO(div, /, int)
narshu 25:143b19c1fb05 534
narshu 25:143b19c1fb05 535 #if defined(TVMET_HAVE_LONG_LONG)
narshu 25:143b19c1fb05 536 TVMET_IMPLEMENT_MACRO(add, +, long long int)
narshu 25:143b19c1fb05 537 TVMET_IMPLEMENT_MACRO(sub, -, long long int)
narshu 25:143b19c1fb05 538 TVMET_IMPLEMENT_MACRO(mul, *, long long int)
narshu 25:143b19c1fb05 539 TVMET_IMPLEMENT_MACRO(div, /, long long int)
narshu 25:143b19c1fb05 540 #endif // defined(TVMET_HAVE_LONG_LONG)
narshu 25:143b19c1fb05 541
narshu 25:143b19c1fb05 542 TVMET_IMPLEMENT_MACRO(add, +, float)
narshu 25:143b19c1fb05 543 TVMET_IMPLEMENT_MACRO(sub, -, float)
narshu 25:143b19c1fb05 544 TVMET_IMPLEMENT_MACRO(mul, *, float)
narshu 25:143b19c1fb05 545 TVMET_IMPLEMENT_MACRO(div, /, float)
narshu 25:143b19c1fb05 546
narshu 25:143b19c1fb05 547 TVMET_IMPLEMENT_MACRO(add, +, double)
narshu 25:143b19c1fb05 548 TVMET_IMPLEMENT_MACRO(sub, -, double)
narshu 25:143b19c1fb05 549 TVMET_IMPLEMENT_MACRO(mul, *, double)
narshu 25:143b19c1fb05 550 TVMET_IMPLEMENT_MACRO(div, /, double)
narshu 25:143b19c1fb05 551
narshu 25:143b19c1fb05 552 #if defined(TVMET_HAVE_LONG_DOUBLE)
narshu 25:143b19c1fb05 553 TVMET_IMPLEMENT_MACRO(add, +, long double)
narshu 25:143b19c1fb05 554 TVMET_IMPLEMENT_MACRO(sub, -, long double)
narshu 25:143b19c1fb05 555 TVMET_IMPLEMENT_MACRO(mul, *, long double)
narshu 25:143b19c1fb05 556 TVMET_IMPLEMENT_MACRO(div, /, long double)
narshu 25:143b19c1fb05 557 #endif // defined(TVMET_HAVE_LONG_DOUBLE)
narshu 25:143b19c1fb05 558
narshu 25:143b19c1fb05 559 #undef TVMET_IMPLEMENT_MACRO
narshu 25:143b19c1fb05 560
narshu 25:143b19c1fb05 561
narshu 25:143b19c1fb05 562 #if defined(TVMET_HAVE_COMPLEX)
narshu 25:143b19c1fb05 563 /*
narshu 25:143b19c1fb05 564 * operator(XprMatrix<E, Rows, Cols>, complex<>)
narshu 25:143b19c1fb05 565 * operator(complex<>, XprMatrix<E, Rows, Cols>)
narshu 25:143b19c1fb05 566 * Note: operations +,-,*,/ are per se element wise
narshu 25:143b19c1fb05 567 * \todo type promotion
narshu 25:143b19c1fb05 568 */
narshu 25:143b19c1fb05 569 #define TVMET_IMPLEMENT_MACRO(NAME, OP) \
narshu 25:143b19c1fb05 570 template<class E, std::size_t Rows, std::size_t Cols, class T> \
narshu 25:143b19c1fb05 571 inline \
narshu 25:143b19c1fb05 572 XprMatrix< \
narshu 25:143b19c1fb05 573 XprBinOp< \
narshu 25:143b19c1fb05 574 Fcnl_##NAME<typename E::value_type, std::complex<T> >, \
narshu 25:143b19c1fb05 575 XprMatrix<E, Rows, Cols>, \
narshu 25:143b19c1fb05 576 XprLiteral< std::complex<T> > \
narshu 25:143b19c1fb05 577 >, \
narshu 25:143b19c1fb05 578 Rows, Cols \
narshu 25:143b19c1fb05 579 > \
narshu 25:143b19c1fb05 580 operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
narshu 25:143b19c1fb05 581 const std::complex<T>& rhs) { \
narshu 25:143b19c1fb05 582 return NAME (lhs, rhs); \
narshu 25:143b19c1fb05 583 } \
narshu 25:143b19c1fb05 584 \
narshu 25:143b19c1fb05 585 template<class E, std::size_t Rows, std::size_t Cols, class T> \
narshu 25:143b19c1fb05 586 inline \
narshu 25:143b19c1fb05 587 XprMatrix< \
narshu 25:143b19c1fb05 588 XprBinOp< \
narshu 25:143b19c1fb05 589 Fcnl_##NAME<std::complex<T>, typename E::value_type>, \
narshu 25:143b19c1fb05 590 XprLiteral< std::complex<T> >, \
narshu 25:143b19c1fb05 591 XprMatrix<E, Rows, Cols> \
narshu 25:143b19c1fb05 592 >, \
narshu 25:143b19c1fb05 593 Rows, Cols \
narshu 25:143b19c1fb05 594 > \
narshu 25:143b19c1fb05 595 operator OP (const std::complex<T>& lhs, \
narshu 25:143b19c1fb05 596 const XprMatrix<E, Rows, Cols>& rhs) { \
narshu 25:143b19c1fb05 597 return NAME (lhs, rhs); \
narshu 25:143b19c1fb05 598 }
narshu 25:143b19c1fb05 599
narshu 25:143b19c1fb05 600 TVMET_IMPLEMENT_MACRO(add, +)
narshu 25:143b19c1fb05 601 TVMET_IMPLEMENT_MACRO(sub, -)
narshu 25:143b19c1fb05 602 TVMET_IMPLEMENT_MACRO(mul, *)
narshu 25:143b19c1fb05 603 TVMET_IMPLEMENT_MACRO(div, /)
narshu 25:143b19c1fb05 604
narshu 25:143b19c1fb05 605 #undef TVMET_IMPLEMENT_MACRO
narshu 25:143b19c1fb05 606
narshu 25:143b19c1fb05 607 #endif // defined(TVMET_HAVE_COMPLEX)
narshu 25:143b19c1fb05 608
narshu 25:143b19c1fb05 609
narshu 25:143b19c1fb05 610 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++
narshu 25:143b19c1fb05 611 * matrix specific operator*() = prod() operations
narshu 25:143b19c1fb05 612 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
narshu 25:143b19c1fb05 613
narshu 25:143b19c1fb05 614
narshu 25:143b19c1fb05 615 /**
narshu 25:143b19c1fb05 616 * \fn operator*(const XprMatrix<E1, Rows1, Cols1>& lhs, const XprMatrix<E2, Cols1, Cols2>& rhs)
narshu 25:143b19c1fb05 617 * \brief Evaluate the product of two XprMatrix.
narshu 25:143b19c1fb05 618 * \ingroup _binary_operator
narshu 25:143b19c1fb05 619 * \sa prod(XprMatrix<E1, Rows1, Cols1> lhs, XprMatrix<E2, Cols1, Cols2> rhs)
narshu 25:143b19c1fb05 620 */
narshu 25:143b19c1fb05 621 template<class E1, std::size_t Rows1, std::size_t Cols1,
narshu 25:143b19c1fb05 622 class E2, std::size_t Cols2>
narshu 25:143b19c1fb05 623 inline
narshu 25:143b19c1fb05 624 XprMatrix<
narshu 25:143b19c1fb05 625 XprMMProduct<
narshu 25:143b19c1fb05 626 XprMatrix<E1, Rows1, Cols1>, Rows1, Cols1, // M1(Rows1, Cols1)
narshu 25:143b19c1fb05 627 XprMatrix<E2, Cols1, Cols2>, Cols2 // M2(Cols1, Cols2)
narshu 25:143b19c1fb05 628 >,
narshu 25:143b19c1fb05 629 Rows1, Cols2
narshu 25:143b19c1fb05 630 >
narshu 25:143b19c1fb05 631 operator*(const XprMatrix<E1, Rows1, Cols1>& lhs, const XprMatrix<E2, Cols1, Cols2>& rhs) {
narshu 25:143b19c1fb05 632 return prod(lhs, rhs);
narshu 25:143b19c1fb05 633 }
narshu 25:143b19c1fb05 634
narshu 25:143b19c1fb05 635
narshu 25:143b19c1fb05 636 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++
narshu 25:143b19c1fb05 637 * matrix-vector specific prod( ... ) operators
narshu 25:143b19c1fb05 638 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
narshu 25:143b19c1fb05 639
narshu 25:143b19c1fb05 640
narshu 25:143b19c1fb05 641 /**
narshu 25:143b19c1fb05 642 * \fn operator*(const XprMatrix<E1, Rows, Cols>& lhs, const XprVector<E2, Cols>& rhs)
narshu 25:143b19c1fb05 643 * \brief Evaluate the product of XprMatrix and XprVector.
narshu 25:143b19c1fb05 644 * \ingroup _binary_operator
narshu 25:143b19c1fb05 645 * \sa prod(XprMatrix<E1, Rows, Cols> lhs, XprVector<E2, Cols> rhs)
narshu 25:143b19c1fb05 646 */
narshu 25:143b19c1fb05 647 template<class E1, std::size_t Rows, std::size_t Cols,
narshu 25:143b19c1fb05 648 class E2>
narshu 25:143b19c1fb05 649 inline
narshu 25:143b19c1fb05 650 XprVector<
narshu 25:143b19c1fb05 651 XprMVProduct<
narshu 25:143b19c1fb05 652 XprMatrix<E1, Rows, Cols>, Rows, Cols,
narshu 25:143b19c1fb05 653 XprVector<E2, Cols>
narshu 25:143b19c1fb05 654 >,
narshu 25:143b19c1fb05 655 Rows
narshu 25:143b19c1fb05 656 >
narshu 25:143b19c1fb05 657 operator*(const XprMatrix<E1, Rows, Cols>& lhs, const XprVector<E2, Cols>& rhs) {
narshu 25:143b19c1fb05 658 return prod(lhs, rhs);
narshu 25:143b19c1fb05 659 }
narshu 25:143b19c1fb05 660
narshu 25:143b19c1fb05 661
narshu 25:143b19c1fb05 662 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++
narshu 25:143b19c1fb05 663 * Matrix integer and compare operators
narshu 25:143b19c1fb05 664 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
narshu 25:143b19c1fb05 665
narshu 25:143b19c1fb05 666
narshu 25:143b19c1fb05 667 /*
narshu 25:143b19c1fb05 668 * operator(XprMatrix<>, XprMatrix<>)
narshu 25:143b19c1fb05 669 * Note: operations are per se element wise
narshu 25:143b19c1fb05 670 */
narshu 25:143b19c1fb05 671 #define TVMET_IMPLEMENT_MACRO(NAME, OP) \
narshu 25:143b19c1fb05 672 template<class E1, std::size_t Rows, std::size_t Cols, \
narshu 25:143b19c1fb05 673 class E2> \
narshu 25:143b19c1fb05 674 inline \
narshu 25:143b19c1fb05 675 XprMatrix< \
narshu 25:143b19c1fb05 676 XprBinOp< \
narshu 25:143b19c1fb05 677 Fcnl_##NAME<typename E1::value_type, typename E2::value_type>, \
narshu 25:143b19c1fb05 678 XprMatrix<E1, Rows, Cols>, \
narshu 25:143b19c1fb05 679 XprMatrix<E2, Rows, Cols> \
narshu 25:143b19c1fb05 680 >, \
narshu 25:143b19c1fb05 681 Rows, Cols \
narshu 25:143b19c1fb05 682 > \
narshu 25:143b19c1fb05 683 operator OP (const XprMatrix<E1, Rows, Cols>& lhs, \
narshu 25:143b19c1fb05 684 const XprMatrix<E2, Rows, Cols>& rhs) { \
narshu 25:143b19c1fb05 685 typedef XprBinOp< \
narshu 25:143b19c1fb05 686 Fcnl_##NAME<typename E1::value_type, typename E2::value_type>, \
narshu 25:143b19c1fb05 687 XprMatrix<E1, Rows, Cols>, \
narshu 25:143b19c1fb05 688 XprMatrix<E2, Rows, Cols> \
narshu 25:143b19c1fb05 689 > expr_type; \
narshu 25:143b19c1fb05 690 return XprMatrix<expr_type, Rows, Cols>(expr_type(lhs, rhs)); \
narshu 25:143b19c1fb05 691 }
narshu 25:143b19c1fb05 692
narshu 25:143b19c1fb05 693 // integer operators only, e.g used on double you will get an error
narshu 25:143b19c1fb05 694 namespace element_wise {
narshu 25:143b19c1fb05 695 TVMET_IMPLEMENT_MACRO(mod, %)
narshu 25:143b19c1fb05 696 TVMET_IMPLEMENT_MACRO(bitxor, ^)
narshu 25:143b19c1fb05 697 TVMET_IMPLEMENT_MACRO(bitand, &)
narshu 25:143b19c1fb05 698 TVMET_IMPLEMENT_MACRO(bitor, |)
narshu 25:143b19c1fb05 699 TVMET_IMPLEMENT_MACRO(shl, <<)
narshu 25:143b19c1fb05 700 TVMET_IMPLEMENT_MACRO(shr, >>)
narshu 25:143b19c1fb05 701 }
narshu 25:143b19c1fb05 702
narshu 25:143b19c1fb05 703 // necessary operators for eval functions
narshu 25:143b19c1fb05 704 TVMET_IMPLEMENT_MACRO(greater, >)
narshu 25:143b19c1fb05 705 TVMET_IMPLEMENT_MACRO(less, <)
narshu 25:143b19c1fb05 706 TVMET_IMPLEMENT_MACRO(greater_eq, >=)
narshu 25:143b19c1fb05 707 TVMET_IMPLEMENT_MACRO(less_eq, <=)
narshu 25:143b19c1fb05 708 TVMET_IMPLEMENT_MACRO(eq, ==)
narshu 25:143b19c1fb05 709 TVMET_IMPLEMENT_MACRO(not_eq, !=)
narshu 25:143b19c1fb05 710 TVMET_IMPLEMENT_MACRO(and, &&)
narshu 25:143b19c1fb05 711 TVMET_IMPLEMENT_MACRO(or, ||)
narshu 25:143b19c1fb05 712
narshu 25:143b19c1fb05 713 #undef TVMET_IMPLEMENT_MACRO
narshu 25:143b19c1fb05 714
narshu 25:143b19c1fb05 715
narshu 25:143b19c1fb05 716 #if defined(TVMET_HAVE_COMPLEX)
narshu 25:143b19c1fb05 717 /*
narshu 25:143b19c1fb05 718 * operator(XprMatrix<E, Rows, Cols>, std::complex<>)
narshu 25:143b19c1fb05 719 * operator(std::complex<>, XprMatrix<E, Rows, Cols>)
narshu 25:143b19c1fb05 720 * Note: - per se element wise
narshu 25:143b19c1fb05 721 * - bit ops on complex<int> doesn't make sense, stay away
narshu 25:143b19c1fb05 722 * \todo type promotion
narshu 25:143b19c1fb05 723 */
narshu 25:143b19c1fb05 724 #define TVMET_IMPLEMENT_MACRO(NAME, OP) \
narshu 25:143b19c1fb05 725 template<class E, std::size_t Rows, std::size_t Cols, class T> \
narshu 25:143b19c1fb05 726 inline \
narshu 25:143b19c1fb05 727 XprMatrix< \
narshu 25:143b19c1fb05 728 XprBinOp< \
narshu 25:143b19c1fb05 729 Fcnl_##NAME<typename E::value_type, std::complex<T> >, \
narshu 25:143b19c1fb05 730 XprMatrix<E, Rows, Cols>, \
narshu 25:143b19c1fb05 731 XprLiteral< std::complex<T> > \
narshu 25:143b19c1fb05 732 >, \
narshu 25:143b19c1fb05 733 Rows, Cols \
narshu 25:143b19c1fb05 734 > \
narshu 25:143b19c1fb05 735 operator OP (const XprMatrix<E, Rows, Cols>& lhs, \
narshu 25:143b19c1fb05 736 const std::complex<T>& rhs) { \
narshu 25:143b19c1fb05 737 typedef XprBinOp< \
narshu 25:143b19c1fb05 738 Fcnl_##NAME<typename E::value_type, std::complex<T> >, \
narshu 25:143b19c1fb05 739 XprMatrix<E, Rows, Cols>, \
narshu 25:143b19c1fb05 740 XprLiteral< std::complex<T> > \
narshu 25:143b19c1fb05 741 > expr_type; \
narshu 25:143b19c1fb05 742 return XprMatrix<expr_type, Rows, Cols>( \
narshu 25:143b19c1fb05 743 expr_type(lhs, XprLiteral< std::complex<T> >(rhs))); \
narshu 25:143b19c1fb05 744 } \
narshu 25:143b19c1fb05 745 \
narshu 25:143b19c1fb05 746 template<class E, std::size_t Rows, std::size_t Cols, class T> \
narshu 25:143b19c1fb05 747 inline \
narshu 25:143b19c1fb05 748 XprMatrix< \
narshu 25:143b19c1fb05 749 XprBinOp< \
narshu 25:143b19c1fb05 750 Fcnl_##NAME<std::complex<T>, typename E::value_type>, \
narshu 25:143b19c1fb05 751 XprLiteral< std::complex<T> >, \
narshu 25:143b19c1fb05 752 XprMatrix<E, Rows, Cols> \
narshu 25:143b19c1fb05 753 >, \
narshu 25:143b19c1fb05 754 Rows, Cols \
narshu 25:143b19c1fb05 755 > \
narshu 25:143b19c1fb05 756 operator OP (const std::complex<T>& lhs, \
narshu 25:143b19c1fb05 757 const XprMatrix<E, Rows, Cols>& rhs) { \
narshu 25:143b19c1fb05 758 typedef XprBinOp< \
narshu 25:143b19c1fb05 759 Fcnl_##NAME< std::complex<T>, typename E::value_type>, \
narshu 25:143b19c1fb05 760 XprLiteral< std::complex<T> >, \
narshu 25:143b19c1fb05 761 XprMatrix<E, Rows, Cols> \
narshu 25:143b19c1fb05 762 > expr_type; \
narshu 25:143b19c1fb05 763 return XprMatrix<expr_type, Rows, Cols>( \
narshu 25:143b19c1fb05 764 expr_type(XprLiteral< std::complex<T> >(lhs), rhs)); \
narshu 25:143b19c1fb05 765 }
narshu 25:143b19c1fb05 766
narshu 25:143b19c1fb05 767 // necessary operators for eval functions
narshu 25:143b19c1fb05 768 TVMET_IMPLEMENT_MACRO(greater, >)
narshu 25:143b19c1fb05 769 TVMET_IMPLEMENT_MACRO(less, <)
narshu 25:143b19c1fb05 770 TVMET_IMPLEMENT_MACRO(greater_eq, >=)
narshu 25:143b19c1fb05 771 TVMET_IMPLEMENT_MACRO(less_eq, <=)
narshu 25:143b19c1fb05 772 TVMET_IMPLEMENT_MACRO(eq, ==)
narshu 25:143b19c1fb05 773 TVMET_IMPLEMENT_MACRO(not_eq, !=)
narshu 25:143b19c1fb05 774 TVMET_IMPLEMENT_MACRO(and, &&)
narshu 25:143b19c1fb05 775 TVMET_IMPLEMENT_MACRO(or, ||)
narshu 25:143b19c1fb05 776
narshu 25:143b19c1fb05 777 #undef TVMET_IMPLEMENT_MACRO
narshu 25:143b19c1fb05 778
narshu 25:143b19c1fb05 779 #endif // defined(TVMET_HAVE_COMPLEX)
narshu 25:143b19c1fb05 780
narshu 25:143b19c1fb05 781
narshu 25:143b19c1fb05 782 /*
narshu 25:143b19c1fb05 783 * operator(XprMatrix<E, Rows, Cols>, POD)
narshu 25:143b19c1fb05 784 * operator(POD, XprMatrix<E, Rows, Cols>)
narshu 25:143b19c1fb05 785 * Note: operations are per se element wise
narshu 25:143b19c1fb05 786 */
narshu 25:143b19c1fb05 787 #define TVMET_IMPLEMENT_MACRO(NAME, OP, TP) \
narshu 25:143b19c1fb05 788 template<class E, std::size_t Rows, std::size_t Cols> \
narshu 25:143b19c1fb05 789 inline \
narshu 25:143b19c1fb05 790 XprMatrix< \
narshu 25:143b19c1fb05 791 XprBinOp< \
narshu 25:143b19c1fb05 792 Fcnl_##NAME<typename E::value_type, TP >, \
narshu 25:143b19c1fb05 793 XprMatrix<E, Rows, Cols>, \
narshu 25:143b19c1fb05 794 XprLiteral< TP > \
narshu 25:143b19c1fb05 795 >, \
narshu 25:143b19c1fb05 796 Rows, Cols \
narshu 25:143b19c1fb05 797 > \
narshu 25:143b19c1fb05 798 operator OP (const XprMatrix<E, Rows, Cols>& lhs, TP rhs) { \
narshu 25:143b19c1fb05 799 typedef XprBinOp< \
narshu 25:143b19c1fb05 800 Fcnl_##NAME<typename E::value_type, TP >, \
narshu 25:143b19c1fb05 801 XprMatrix<E, Rows, Cols>, \
narshu 25:143b19c1fb05 802 XprLiteral< TP > \
narshu 25:143b19c1fb05 803 > expr_type; \
narshu 25:143b19c1fb05 804 return XprMatrix<expr_type, Rows, Cols>( \
narshu 25:143b19c1fb05 805 expr_type(lhs, XprLiteral< TP >(rhs))); \
narshu 25:143b19c1fb05 806 } \
narshu 25:143b19c1fb05 807 \
narshu 25:143b19c1fb05 808 template<class E, std::size_t Rows, std::size_t Cols> \
narshu 25:143b19c1fb05 809 inline \
narshu 25:143b19c1fb05 810 XprMatrix< \
narshu 25:143b19c1fb05 811 XprBinOp< \
narshu 25:143b19c1fb05 812 Fcnl_##NAME<TP, typename E::value_type>, \
narshu 25:143b19c1fb05 813 XprLiteral< TP >, \
narshu 25:143b19c1fb05 814 XprMatrix<E, Rows, Cols> \
narshu 25:143b19c1fb05 815 >, \
narshu 25:143b19c1fb05 816 Rows, Cols \
narshu 25:143b19c1fb05 817 > \
narshu 25:143b19c1fb05 818 operator OP (TP lhs, const XprMatrix<E, Rows, Cols>& rhs) { \
narshu 25:143b19c1fb05 819 typedef XprBinOp< \
narshu 25:143b19c1fb05 820 Fcnl_##NAME< TP, typename E::value_type>, \
narshu 25:143b19c1fb05 821 XprLiteral< TP >, \
narshu 25:143b19c1fb05 822 XprMatrix<E, Rows, Cols> \
narshu 25:143b19c1fb05 823 > expr_type; \
narshu 25:143b19c1fb05 824 return XprMatrix<expr_type, Rows, Cols>( \
narshu 25:143b19c1fb05 825 expr_type(XprLiteral< TP >(lhs), rhs)); \
narshu 25:143b19c1fb05 826 }
narshu 25:143b19c1fb05 827
narshu 25:143b19c1fb05 828
narshu 25:143b19c1fb05 829 // integer operators only, e.g used on double you will get an error
narshu 25:143b19c1fb05 830 namespace element_wise {
narshu 25:143b19c1fb05 831 TVMET_IMPLEMENT_MACRO(mod, %, int)
narshu 25:143b19c1fb05 832 TVMET_IMPLEMENT_MACRO(bitxor, ^, int)
narshu 25:143b19c1fb05 833 TVMET_IMPLEMENT_MACRO(bitand, &, int)
narshu 25:143b19c1fb05 834 TVMET_IMPLEMENT_MACRO(bitor, |, int)
narshu 25:143b19c1fb05 835 TVMET_IMPLEMENT_MACRO(shl, <<, int)
narshu 25:143b19c1fb05 836 TVMET_IMPLEMENT_MACRO(shr, >>, int)
narshu 25:143b19c1fb05 837 }
narshu 25:143b19c1fb05 838
narshu 25:143b19c1fb05 839 // necessary operators for eval functions
narshu 25:143b19c1fb05 840 TVMET_IMPLEMENT_MACRO(greater, >, int)
narshu 25:143b19c1fb05 841 TVMET_IMPLEMENT_MACRO(less, <, int)
narshu 25:143b19c1fb05 842 TVMET_IMPLEMENT_MACRO(greater_eq, >=, int)
narshu 25:143b19c1fb05 843 TVMET_IMPLEMENT_MACRO(less_eq, <=, int)
narshu 25:143b19c1fb05 844 TVMET_IMPLEMENT_MACRO(eq, ==, int)
narshu 25:143b19c1fb05 845 TVMET_IMPLEMENT_MACRO(not_eq, !=, int)
narshu 25:143b19c1fb05 846 TVMET_IMPLEMENT_MACRO(and, &&, int)
narshu 25:143b19c1fb05 847 TVMET_IMPLEMENT_MACRO(or, ||, int)
narshu 25:143b19c1fb05 848
narshu 25:143b19c1fb05 849 #if defined(TVMET_HAVE_LONG_LONG)
narshu 25:143b19c1fb05 850 // integer operators only
narshu 25:143b19c1fb05 851 namespace element_wise {
narshu 25:143b19c1fb05 852 TVMET_IMPLEMENT_MACRO(mod, %, long long int)
narshu 25:143b19c1fb05 853 TVMET_IMPLEMENT_MACRO(bitxor, ^, long long int)
narshu 25:143b19c1fb05 854 TVMET_IMPLEMENT_MACRO(bitand, &, long long int)
narshu 25:143b19c1fb05 855 TVMET_IMPLEMENT_MACRO(bitor, |, long long int)
narshu 25:143b19c1fb05 856 TVMET_IMPLEMENT_MACRO(shl, <<, long long int)
narshu 25:143b19c1fb05 857 TVMET_IMPLEMENT_MACRO(shr, >>, long long int)
narshu 25:143b19c1fb05 858 }
narshu 25:143b19c1fb05 859
narshu 25:143b19c1fb05 860 // necessary operators for eval functions
narshu 25:143b19c1fb05 861 TVMET_IMPLEMENT_MACRO(greater, >, long long int)
narshu 25:143b19c1fb05 862 TVMET_IMPLEMENT_MACRO(less, <, long long int)
narshu 25:143b19c1fb05 863 TVMET_IMPLEMENT_MACRO(greater_eq, >=, long long int)
narshu 25:143b19c1fb05 864 TVMET_IMPLEMENT_MACRO(less_eq, <=, long long int)
narshu 25:143b19c1fb05 865 TVMET_IMPLEMENT_MACRO(eq, ==, long long int)
narshu 25:143b19c1fb05 866 TVMET_IMPLEMENT_MACRO(not_eq, !=, long long int)
narshu 25:143b19c1fb05 867 TVMET_IMPLEMENT_MACRO(and, &&, long long int)
narshu 25:143b19c1fb05 868 TVMET_IMPLEMENT_MACRO(or, ||, long long int)
narshu 25:143b19c1fb05 869 #endif // defined(TVMET_HAVE_LONG_LONG)
narshu 25:143b19c1fb05 870
narshu 25:143b19c1fb05 871 // necessary operators for eval functions
narshu 25:143b19c1fb05 872 TVMET_IMPLEMENT_MACRO(greater, >, float)
narshu 25:143b19c1fb05 873 TVMET_IMPLEMENT_MACRO(less, <, float)
narshu 25:143b19c1fb05 874 TVMET_IMPLEMENT_MACRO(greater_eq, >=, float)
narshu 25:143b19c1fb05 875 TVMET_IMPLEMENT_MACRO(less_eq, <=, float)
narshu 25:143b19c1fb05 876 TVMET_IMPLEMENT_MACRO(eq, ==, float)
narshu 25:143b19c1fb05 877 TVMET_IMPLEMENT_MACRO(not_eq, !=, float)
narshu 25:143b19c1fb05 878 TVMET_IMPLEMENT_MACRO(and, &&, float)
narshu 25:143b19c1fb05 879 TVMET_IMPLEMENT_MACRO(or, ||, float)
narshu 25:143b19c1fb05 880
narshu 25:143b19c1fb05 881 // necessary operators for eval functions
narshu 25:143b19c1fb05 882 TVMET_IMPLEMENT_MACRO(greater, >, double)
narshu 25:143b19c1fb05 883 TVMET_IMPLEMENT_MACRO(less, <, double)
narshu 25:143b19c1fb05 884 TVMET_IMPLEMENT_MACRO(greater_eq, >=, double)
narshu 25:143b19c1fb05 885 TVMET_IMPLEMENT_MACRO(less_eq, <=, double)
narshu 25:143b19c1fb05 886 TVMET_IMPLEMENT_MACRO(eq, ==, double)
narshu 25:143b19c1fb05 887 TVMET_IMPLEMENT_MACRO(not_eq, !=, double)
narshu 25:143b19c1fb05 888 TVMET_IMPLEMENT_MACRO(and, &&, double)
narshu 25:143b19c1fb05 889 TVMET_IMPLEMENT_MACRO(or, ||, double)
narshu 25:143b19c1fb05 890
narshu 25:143b19c1fb05 891 #if defined(TVMET_HAVE_LONG_DOUBLE)
narshu 25:143b19c1fb05 892 // necessary operators for eval functions
narshu 25:143b19c1fb05 893 TVMET_IMPLEMENT_MACRO(greater, >, long double)
narshu 25:143b19c1fb05 894 TVMET_IMPLEMENT_MACRO(less, <, long double)
narshu 25:143b19c1fb05 895 TVMET_IMPLEMENT_MACRO(greater_eq, >=, long double)
narshu 25:143b19c1fb05 896 TVMET_IMPLEMENT_MACRO(less_eq, <=, long double)
narshu 25:143b19c1fb05 897 TVMET_IMPLEMENT_MACRO(eq, ==, long double)
narshu 25:143b19c1fb05 898 TVMET_IMPLEMENT_MACRO(not_eq, !=, long double)
narshu 25:143b19c1fb05 899 TVMET_IMPLEMENT_MACRO(and, &&, long double)
narshu 25:143b19c1fb05 900 TVMET_IMPLEMENT_MACRO(or, ||, long double)
narshu 25:143b19c1fb05 901 #endif // defined(TVMET_HAVE_LONG_DOUBLE)
narshu 25:143b19c1fb05 902
narshu 25:143b19c1fb05 903 #undef TVMET_IMPLEMENT_MACRO
narshu 25:143b19c1fb05 904
narshu 25:143b19c1fb05 905
narshu 25:143b19c1fb05 906 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++
narshu 25:143b19c1fb05 907 * global unary operators
narshu 25:143b19c1fb05 908 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
narshu 25:143b19c1fb05 909
narshu 25:143b19c1fb05 910
narshu 25:143b19c1fb05 911 /*
narshu 25:143b19c1fb05 912 * unary_operator(const XprMatrix<E, Rows, Cols>& m)
narshu 25:143b19c1fb05 913 * Note: per se element wise
narshu 25:143b19c1fb05 914 */
narshu 25:143b19c1fb05 915 #define TVMET_IMPLEMENT_MACRO(NAME, OP) \
narshu 25:143b19c1fb05 916 template <class E, std::size_t Rows, std::size_t Cols> \
narshu 25:143b19c1fb05 917 inline \
narshu 25:143b19c1fb05 918 XprMatrix< \
narshu 25:143b19c1fb05 919 XprUnOp< \
narshu 25:143b19c1fb05 920 Fcnl_##NAME<typename E::value_type>, \
narshu 25:143b19c1fb05 921 XprMatrix<E, Rows, Cols> \
narshu 25:143b19c1fb05 922 >, \
narshu 25:143b19c1fb05 923 Rows, Cols \
narshu 25:143b19c1fb05 924 > \
narshu 25:143b19c1fb05 925 operator OP (const XprMatrix<E, Rows, Cols>& m) { \
narshu 25:143b19c1fb05 926 typedef XprUnOp< \
narshu 25:143b19c1fb05 927 Fcnl_##NAME<typename E::value_type>, \
narshu 25:143b19c1fb05 928 XprMatrix<E, Rows, Cols> \
narshu 25:143b19c1fb05 929 > expr_type; \
narshu 25:143b19c1fb05 930 return XprMatrix<expr_type, Rows, Cols>(expr_type(m)); \
narshu 25:143b19c1fb05 931 }
narshu 25:143b19c1fb05 932
narshu 25:143b19c1fb05 933 TVMET_IMPLEMENT_MACRO(not, !)
narshu 25:143b19c1fb05 934 TVMET_IMPLEMENT_MACRO(compl, ~)
narshu 25:143b19c1fb05 935 TVMET_IMPLEMENT_MACRO(neg, -)
narshu 25:143b19c1fb05 936
narshu 25:143b19c1fb05 937 #undef TVMET_IMPLEMENT_MACRO
narshu 25:143b19c1fb05 938
narshu 25:143b19c1fb05 939
narshu 25:143b19c1fb05 940 } // namespace tvmet
narshu 25:143b19c1fb05 941
narshu 25:143b19c1fb05 942 #endif // TVMET_XPR_MATRIX_OPERATORS_H
narshu 25:143b19c1fb05 943
narshu 25:143b19c1fb05 944 // Local Variables:
narshu 25:143b19c1fb05 945 // mode:C++
narshu 25:143b19c1fb05 946 // tab-width:8
narshu 25:143b19c1fb05 947 // End: