This is the Tiny Vector Matrix Expression Templates library found at http://tvmet.sourceforge.net. It is the fastest and most compact matrix lib out there (for < 10x10 matricies). I have done some minor tweaks to make it compile for mbed. For examples and hints on how to use, see: http://tvmet.sourceforge.net/usage.html
Dependents: Eurobot_2012_Secondary
MatrixOperators.h
00001 /* 00002 * Tiny Vector Matrix Library 00003 * Dense Vector Matrix Libary of Tiny size using Expression Templates 00004 * 00005 * Copyright (C) 2001 - 2007 Olaf Petzold <opetzold@users.sourceforge.net> 00006 * 00007 * This library is free software; you can redistribute it and/or 00008 * modify it under the terms of the GNU lesser General Public 00009 * License as published by the Free Software Foundation; either 00010 * version 2.1 of the License, or (at your option) any later version. 00011 * 00012 * This library is distributed in the hope that it will be useful, 00013 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00015 * lesser General Public License for more details. 00016 * 00017 * You should have received a copy of the GNU lesser General Public 00018 * License along with this library; if not, write to the Free Software 00019 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 00020 * 00021 * $Id: MatrixOperators.h,v 1.37 2007-06-23 15:58:58 opetzold Exp $ 00022 */ 00023 00024 #ifndef TVMET_MATRIX_OPERATORS_H 00025 #define TVMET_MATRIX_OPERATORS_H 00026 00027 namespace tvmet { 00028 00029 00030 /********************************************************* 00031 * PART I: DECLARATION 00032 *********************************************************/ 00033 00034 00035 template<class T, std::size_t Rows, std::size_t Cols> 00036 std::ostream& operator<<(std::ostream& os, 00037 const Matrix<T, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; 00038 00039 00040 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00041 * Member operators (arithmetic and bit ops) 00042 *++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00043 00044 00045 /* 00046 * update_operator(Matrix<T1, Rows, Cols>, Matrix<T2, Rows, Cols>) 00047 * update_operator(Matrix<T1, Rows, Cols>, XprMatrix<E, Rows, Cols> rhs) 00048 * Note: per se element wise 00049 * \todo: the operator*= can have element wise mul oder product, decide! 00050 */ 00051 #define TVMET_DECLARE_MACRO(NAME, OP) \ 00052 template<class T1, class T2, std::size_t Rows, std::size_t Cols> \ 00053 Matrix<T1, Rows, Cols>& \ 00054 operator OP (Matrix<T1, Rows, Cols>& lhs, \ 00055 const Matrix<T2, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \ 00056 \ 00057 template<class T, class E, std::size_t Rows, std::size_t Cols> \ 00058 Matrix<T, Rows, Cols>& \ 00059 operator OP (Matrix<T, Rows, Cols>& lhs, \ 00060 const XprMatrix<E, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; 00061 00062 TVMET_DECLARE_MACRO(add_eq, +=) // per se element wise 00063 TVMET_DECLARE_MACRO(sub_eq, -=) // per se element wise 00064 namespace element_wise { 00065 TVMET_DECLARE_MACRO(mul_eq, *=) // see note 00066 TVMET_DECLARE_MACRO(div_eq, /=) // not defined for vectors 00067 } 00068 00069 // integer operators only, e.g used on double you wil get an error 00070 namespace element_wise { 00071 TVMET_DECLARE_MACRO(mod_eq, %=) 00072 TVMET_DECLARE_MACRO(xor_eq, ^=) 00073 TVMET_DECLARE_MACRO(and_eq, &=) 00074 TVMET_DECLARE_MACRO(or_eq, |=) 00075 TVMET_DECLARE_MACRO(shl_eq, <<=) 00076 TVMET_DECLARE_MACRO(shr_eq, >>=) 00077 } 00078 00079 #undef TVMET_DECLARE_MACRO 00080 00081 00082 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00083 * Matrix arithmetic operators implemented by functions 00084 * add, sub, mul and div 00085 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00086 00087 00088 /* 00089 * operator(Matrix<T1, Rows, Cols>, Matrix<T2, Rows, Cols>) 00090 * operator(XprMatrix<E, Rows, Cols>, Matrix<T, Rows, Cols>) 00091 * operator(Matrix<T, Rows, Cols>, XprMatrix<E, Rows, Cols>) 00092 * Note: per se element wise 00093 */ 00094 #define TVMET_DECLARE_MACRO(NAME, OP) \ 00095 template<class T1, class T2, std::size_t Rows, std::size_t Cols> \ 00096 XprMatrix< \ 00097 XprBinOp< \ 00098 Fcnl_##NAME<T1, T2>, \ 00099 MatrixConstReference<T1, Rows, Cols>, \ 00100 MatrixConstReference<T2, Rows, Cols> \ 00101 >, \ 00102 Rows, Cols \ 00103 > \ 00104 operator OP (const Matrix<T1, Rows, Cols>& lhs, \ 00105 const Matrix<T2, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \ 00106 \ 00107 template<class E, class T, std::size_t Rows, std::size_t Cols> \ 00108 XprMatrix< \ 00109 XprBinOp< \ 00110 Fcnl_##NAME<typename E::value_type, T>, \ 00111 XprMatrix<E, Rows, Cols>, \ 00112 MatrixConstReference<T, Rows, Cols> \ 00113 >, \ 00114 Rows, Cols \ 00115 > \ 00116 operator OP (const XprMatrix<E, Rows, Cols>& lhs, \ 00117 const Matrix<T, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \ 00118 \ 00119 template<class T, class E, std::size_t Rows, std::size_t Cols> \ 00120 XprMatrix< \ 00121 XprBinOp< \ 00122 Fcnl_##NAME<typename E::value_type, T>, \ 00123 MatrixConstReference<T, Rows, Cols>, \ 00124 XprMatrix<E, Rows, Cols> \ 00125 >, \ 00126 Rows, Cols \ 00127 > \ 00128 operator OP (const Matrix<T, Rows, Cols>& lhs, \ 00129 const XprMatrix<E, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; 00130 00131 TVMET_DECLARE_MACRO(add, +) // per se element wise 00132 TVMET_DECLARE_MACRO(sub, -) // per se element wise 00133 namespace element_wise { 00134 TVMET_DECLARE_MACRO(mul, *) // see as prod() 00135 TVMET_DECLARE_MACRO(div, /) // not defined for matrizes 00136 } 00137 #undef TVMET_DECLARE_MACRO 00138 00139 00140 /* 00141 * operator(Matrix<T, Rows, Cols>, POD) 00142 * operator(POD, Matrix<T, Rows, Cols>) 00143 * Note: operations +,-,*,/ are per se element wise 00144 */ 00145 #define TVMET_DECLARE_MACRO(NAME, OP, POD) \ 00146 template<class T, std::size_t Rows, std::size_t Cols> \ 00147 XprMatrix< \ 00148 XprBinOp< \ 00149 Fcnl_##NAME<T, POD >, \ 00150 MatrixConstReference<T, Rows, Cols>, \ 00151 XprLiteral<POD > \ 00152 >, \ 00153 Rows, Cols \ 00154 > \ 00155 operator OP (const Matrix<T, Rows, Cols>& lhs, \ 00156 POD rhs) TVMET_CXX_ALWAYS_INLINE; \ 00157 \ 00158 template<class T, std::size_t Rows, std::size_t Cols> \ 00159 XprMatrix< \ 00160 XprBinOp< \ 00161 Fcnl_##NAME< POD, T>, \ 00162 XprLiteral< POD >, \ 00163 MatrixConstReference<T, Rows, Cols> \ 00164 >, \ 00165 Rows, Cols \ 00166 > \ 00167 operator OP (POD lhs, \ 00168 const Matrix<T, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; 00169 00170 TVMET_DECLARE_MACRO(add, +, int) 00171 TVMET_DECLARE_MACRO(sub, -, int) 00172 TVMET_DECLARE_MACRO(mul, *, int) 00173 TVMET_DECLARE_MACRO(div, /, int) 00174 00175 #if defined(TVMET_HAVE_LONG_LONG) 00176 TVMET_DECLARE_MACRO(add, +, long long int) 00177 TVMET_DECLARE_MACRO(sub, -, long long int) 00178 TVMET_DECLARE_MACRO(mul, *, long long int) 00179 TVMET_DECLARE_MACRO(div, /, long long int) 00180 #endif // defined(TVMET_HAVE_LONG_LONG) 00181 00182 TVMET_DECLARE_MACRO(add, +, float) 00183 TVMET_DECLARE_MACRO(sub, -, float) 00184 TVMET_DECLARE_MACRO(mul, *, float) 00185 TVMET_DECLARE_MACRO(div, /, float) 00186 00187 TVMET_DECLARE_MACRO(add, +, double) 00188 TVMET_DECLARE_MACRO(sub, -, double) 00189 TVMET_DECLARE_MACRO(mul, *, double) 00190 TVMET_DECLARE_MACRO(div, /, double) 00191 00192 #if defined(TVMET_HAVE_LONG_DOUBLE) 00193 TVMET_DECLARE_MACRO(add, +, long double) 00194 TVMET_DECLARE_MACRO(sub, -, long double) 00195 TVMET_DECLARE_MACRO(mul, *, long double) 00196 TVMET_DECLARE_MACRO(div, /, long double) 00197 #endif // defined(TVMET_HAVE_LONG_DOUBLE) 00198 00199 #undef TVMET_DECLARE_MACRO 00200 00201 00202 #if defined(TVMET_HAVE_COMPLEX) 00203 /* 00204 * operator(Matrix<T, Rows, Cols>, complex<T>) 00205 * operator(complex<T>, Matrix<T, Rows, Cols>) 00206 * Note: operations +,-,*,/ are per se element wise 00207 * \todo type promotion 00208 */ 00209 #define TVMET_DECLARE_MACRO(NAME, OP) \ 00210 template<class T, std::size_t Rows, std::size_t Cols> \ 00211 XprMatrix< \ 00212 XprBinOp< \ 00213 Fcnl_##NAME< std::complex<T>, std::complex<T> >, \ 00214 MatrixConstReference< std::complex<T>, Rows, Cols>, \ 00215 XprLiteral<std::complex<T> > \ 00216 >, \ 00217 Rows, Cols \ 00218 > \ 00219 operator OP (const Matrix< std::complex<T>, Rows, Cols>& lhs, \ 00220 const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \ 00221 \ 00222 template<class T, std::size_t Rows, std::size_t Cols> \ 00223 XprMatrix< \ 00224 XprBinOp< \ 00225 Fcnl_##NAME< std::complex<T>, std::complex<T> >, \ 00226 XprLiteral< std::complex<T> >, \ 00227 MatrixConstReference< std::complex<T>, Rows, Cols> \ 00228 >, \ 00229 Rows, Cols \ 00230 > \ 00231 operator OP (const std::complex<T>& lhs, \ 00232 const Matrix< std::complex<T>, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; 00233 00234 TVMET_DECLARE_MACRO(add, +) 00235 TVMET_DECLARE_MACRO(sub, -) 00236 TVMET_DECLARE_MACRO(mul, *) 00237 TVMET_DECLARE_MACRO(div, /) 00238 00239 #undef TVMET_DECLARE_MACRO 00240 00241 #endif // defined(TVMET_HAVE_COMPLEX) 00242 00243 00244 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00245 * matrix specific operator*() = prod() operations 00246 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00247 00248 00249 template<class T1, std::size_t Rows1, std::size_t Cols1, 00250 class T2, std::size_t Cols2> 00251 XprMatrix< 00252 XprMMProduct< 00253 MatrixConstReference<T1, Rows1, Cols1>, Rows1, Cols1, 00254 MatrixConstReference<T2, Cols1, Cols2>, Cols2 00255 >, 00256 Rows1, Cols2 00257 > 00258 operator*(const Matrix<T1, Rows1, Cols1>& lhs, 00259 const Matrix<T2, Cols1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE; 00260 00261 00262 template<class E1, std::size_t Rows1, std::size_t Cols1, 00263 class T2, std::size_t Cols2> 00264 XprMatrix< 00265 XprMMProduct< 00266 XprMatrix<E1, Rows1, Cols1>, Rows1, Cols1, 00267 MatrixConstReference<T2, Cols1, Cols2>, Cols2 00268 >, 00269 Rows1, Cols2 00270 > 00271 operator*(const XprMatrix<E1, Rows1, Cols1>& lhs, 00272 const Matrix<T2, Cols1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE; 00273 00274 00275 template<class T1, std::size_t Rows1, std::size_t Cols1, 00276 class E2, std::size_t Cols2> 00277 XprMatrix< 00278 XprMMProduct< 00279 MatrixConstReference<T1, Rows1, Cols1>, Rows1, Cols1, 00280 XprMatrix<E2, Cols1, Cols2>, Cols2 00281 >, 00282 Rows1, Cols2 00283 > 00284 operator*(const Matrix<T1, Rows1, Cols1>& lhs, 00285 const XprMatrix<E2, Cols1, Cols2>& rhs) TVMET_CXX_ALWAYS_INLINE; 00286 00287 00288 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00289 * matrix-vector specific prod( ... ) operators 00290 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00291 00292 00293 template<class T1, std::size_t Rows, std::size_t Cols, class T2> 00294 XprVector< 00295 XprMVProduct< 00296 MatrixConstReference<T1, Rows, Cols>, Rows, Cols, 00297 VectorConstReference<T2, Cols> 00298 >, 00299 Rows 00300 > 00301 operator*(const Matrix<T1, Rows, Cols>& lhs, 00302 const Vector<T2, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; 00303 00304 00305 template<class T1, class E2, std::size_t Rows, std::size_t Cols> 00306 XprVector< 00307 XprMVProduct< 00308 MatrixConstReference<T1, Rows, Cols>, Rows, Cols, 00309 XprVector<E2, Cols> 00310 >, 00311 Rows 00312 > 00313 operator*(const Matrix<T1, Rows, Cols>& lhs, 00314 const XprVector<E2, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; 00315 00316 00317 template<class E1, class T2, std::size_t Rows, std::size_t Cols> 00318 XprVector< 00319 XprMVProduct< 00320 XprMatrix<E1, Rows, Cols>, Rows, Cols, 00321 VectorConstReference<T2, Cols> 00322 >, 00323 Rows 00324 > 00325 operator*(const XprMatrix<E1, Rows, Cols>& lhs, 00326 const Vector<T2, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; 00327 00328 00329 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00330 * Matrix integer and compare operators 00331 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00332 00333 00334 /* 00335 * operator(Matrix<T1, Rows, Cols>, Matrix<T2, Rows, Cols>) 00336 * operator(XprMatrix<E>, Matrix<T, Rows, Cols>) 00337 * operator(Matrix<T, Rows, Cols>, XprMatrix<E>) 00338 * Note: operations are per se element wise 00339 */ 00340 #define TVMET_DECLARE_MACRO(NAME, OP) \ 00341 template<class T1, std::size_t Rows, std::size_t Cols, \ 00342 class T2> \ 00343 XprMatrix< \ 00344 XprBinOp< \ 00345 Fcnl_##NAME<T1, T2>, \ 00346 MatrixConstReference<T1, Rows, Cols>, \ 00347 MatrixConstReference<T2, Rows, Cols> \ 00348 >, \ 00349 Rows, Cols \ 00350 > \ 00351 operator OP (const Matrix<T1, Rows, Cols>& lhs, \ 00352 const Matrix<T2, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \ 00353 \ 00354 template<class E, \ 00355 class T, std::size_t Rows, std::size_t Cols> \ 00356 XprMatrix< \ 00357 XprBinOp< \ 00358 Fcnl_##NAME<typename E::value_type, T>, \ 00359 XprMatrix<E, Rows, Cols>, \ 00360 MatrixConstReference<T, Rows, Cols> \ 00361 >, \ 00362 Rows, Cols \ 00363 > \ 00364 operator OP (const XprMatrix<E, Rows, Cols>& lhs, \ 00365 const Matrix<T, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; \ 00366 \ 00367 template<class T, std::size_t Rows, std::size_t Cols, \ 00368 class E> \ 00369 XprMatrix< \ 00370 XprBinOp< \ 00371 Fcnl_##NAME<typename E::value_type, T>, \ 00372 MatrixConstReference<T, Rows, Cols>, \ 00373 XprMatrix<E, Rows, Cols> \ 00374 >, \ 00375 Rows, Cols \ 00376 > \ 00377 operator OP (const Matrix<T, Rows, Cols>& lhs, \ 00378 const XprMatrix<E, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; 00379 00380 // integer operators only, e.g used on double you wil get an error 00381 namespace element_wise { 00382 TVMET_DECLARE_MACRO(mod, %) 00383 TVMET_DECLARE_MACRO(bitxor, ^) 00384 TVMET_DECLARE_MACRO(bitand, &) 00385 TVMET_DECLARE_MACRO(bitor, |) 00386 TVMET_DECLARE_MACRO(shl, <<) 00387 TVMET_DECLARE_MACRO(shr, >>) 00388 } 00389 00390 // necessary operators for eval functions 00391 TVMET_DECLARE_MACRO(greater, >) 00392 TVMET_DECLARE_MACRO(less, <) 00393 TVMET_DECLARE_MACRO(greater_eq, >=) 00394 TVMET_DECLARE_MACRO(less_eq, <=) 00395 TVMET_DECLARE_MACRO(eq, ==) 00396 TVMET_DECLARE_MACRO(not_eq, !=) 00397 TVMET_DECLARE_MACRO(and, &&) 00398 TVMET_DECLARE_MACRO(or, ||) 00399 00400 #undef TVMET_DECLARE_MACRO 00401 00402 00403 #if defined(TVMET_HAVE_COMPLEX) 00404 /* 00405 * operator(Matrix<T, Rows, Cols>, complex<T>) 00406 * operator(complex<T>, Matrix<T, Rows, Cols>) 00407 * Note: - per se element wise 00408 * - bit ops on complex<int> doesn't make sense, stay away 00409 * \todo type promotion 00410 */ 00411 #define TVMET_DECLARE_MACRO(NAME, OP) \ 00412 template<class T, std::size_t Rows, std::size_t Cols> \ 00413 XprMatrix< \ 00414 XprBinOp< \ 00415 Fcnl_##NAME< std::complex<T>, std::complex<T> >, \ 00416 MatrixConstReference< std::complex<T>, Rows, Cols>, \ 00417 XprLiteral<std::complex<T> > \ 00418 >, \ 00419 Rows, Cols \ 00420 > \ 00421 operator OP (const Matrix< std::complex<T>, Rows, Cols>& lhs, \ 00422 const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \ 00423 \ 00424 template<class T, std::size_t Rows, std::size_t Cols> \ 00425 XprMatrix< \ 00426 XprBinOp< \ 00427 Fcnl_##NAME< std::complex<T>, std::complex<T> >, \ 00428 XprLiteral< std::complex<T> >, \ 00429 MatrixConstReference< std::complex<T>, Rows, Cols> \ 00430 >, \ 00431 Rows, Cols \ 00432 > \ 00433 operator OP (const std::complex<T>& lhs, \ 00434 const Matrix< std::complex<T>, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; 00435 00436 // necessary operators for eval functions 00437 TVMET_DECLARE_MACRO(greater, >) 00438 TVMET_DECLARE_MACRO(less, <) 00439 TVMET_DECLARE_MACRO(greater_eq, >=) 00440 TVMET_DECLARE_MACRO(less_eq, <=) 00441 TVMET_DECLARE_MACRO(eq, ==) 00442 TVMET_DECLARE_MACRO(not_eq, !=) 00443 TVMET_DECLARE_MACRO(and, &&) 00444 TVMET_DECLARE_MACRO(or, ||) 00445 00446 #undef TVMET_DECLARE_MACRO 00447 00448 #endif // defined(TVMET_HAVE_COMPLEX) 00449 00450 00451 /* 00452 * operator(Matrix<T, Rows, Cols>, POD) 00453 * operator(POD, Matrix<T, Rows, Cols>) 00454 * Note: operations are per se element wise 00455 */ 00456 #define TVMET_DECLARE_MACRO(NAME, OP, TP) \ 00457 template<class T, std::size_t Rows, std::size_t Cols> \ 00458 XprMatrix< \ 00459 XprBinOp< \ 00460 Fcnl_##NAME<T, TP >, \ 00461 MatrixConstReference<T, Rows, Cols>, \ 00462 XprLiteral<TP > \ 00463 >, \ 00464 Rows, Cols \ 00465 > \ 00466 operator OP (const Matrix<T, Rows, Cols>& lhs, TP rhs) TVMET_CXX_ALWAYS_INLINE; \ 00467 \ 00468 template<class T, std::size_t Rows, std::size_t Cols> \ 00469 XprMatrix< \ 00470 XprBinOp< \ 00471 Fcnl_##NAME< TP, T>, \ 00472 XprLiteral< TP >, \ 00473 MatrixConstReference<T, Rows, Cols> \ 00474 >, \ 00475 Rows, Cols \ 00476 > \ 00477 operator OP (TP lhs, const Matrix<T, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; 00478 00479 // integer operators only, e.g used on double you wil get an error 00480 namespace element_wise { 00481 TVMET_DECLARE_MACRO(mod, %, int) 00482 TVMET_DECLARE_MACRO(bitxor, ^, int) 00483 TVMET_DECLARE_MACRO(bitand, &, int) 00484 TVMET_DECLARE_MACRO(bitor, |, int) 00485 TVMET_DECLARE_MACRO(shl, <<, int) 00486 TVMET_DECLARE_MACRO(shr, >>, int) 00487 } 00488 00489 // necessary operators for eval functions 00490 TVMET_DECLARE_MACRO(greater, >, int) 00491 TVMET_DECLARE_MACRO(less, <, int) 00492 TVMET_DECLARE_MACRO(greater_eq, >=, int) 00493 TVMET_DECLARE_MACRO(less_eq, <=, int) 00494 TVMET_DECLARE_MACRO(eq, ==, int) 00495 TVMET_DECLARE_MACRO(not_eq, !=, int) 00496 TVMET_DECLARE_MACRO(and, &&, int) 00497 TVMET_DECLARE_MACRO(or, ||, int) 00498 00499 #if defined(TVMET_HAVE_LONG_LONG) 00500 // integer operators only 00501 namespace element_wise { 00502 TVMET_DECLARE_MACRO(mod, %, long long int) 00503 TVMET_DECLARE_MACRO(bitxor, ^, long long int) 00504 TVMET_DECLARE_MACRO(bitand, &, long long int) 00505 TVMET_DECLARE_MACRO(bitor, |, long long int) 00506 TVMET_DECLARE_MACRO(shl, <<, long long int) 00507 TVMET_DECLARE_MACRO(shr, >>, long long int) 00508 } 00509 00510 // necessary operators for eval functions 00511 TVMET_DECLARE_MACRO(greater, >, long long int) 00512 TVMET_DECLARE_MACRO(less, <, long long int) 00513 TVMET_DECLARE_MACRO(greater_eq, >=, long long int) 00514 TVMET_DECLARE_MACRO(less_eq, <=, long long int) 00515 TVMET_DECLARE_MACRO(eq, ==, long long int) 00516 TVMET_DECLARE_MACRO(not_eq, !=, long long int) 00517 TVMET_DECLARE_MACRO(and, &&, long long int) 00518 TVMET_DECLARE_MACRO(or, ||, long long int) 00519 #endif // defined(TVMET_HAVE_LONG_LONG) 00520 00521 // necessary operators for eval functions 00522 TVMET_DECLARE_MACRO(greater, >, float) 00523 TVMET_DECLARE_MACRO(less, <, float) 00524 TVMET_DECLARE_MACRO(greater_eq, >=, float) 00525 TVMET_DECLARE_MACRO(less_eq, <=, float) 00526 TVMET_DECLARE_MACRO(eq, ==, float) 00527 TVMET_DECLARE_MACRO(not_eq, !=, float) 00528 TVMET_DECLARE_MACRO(and, &&, float) 00529 TVMET_DECLARE_MACRO(or, ||, float) 00530 00531 // necessary operators for eval functions 00532 TVMET_DECLARE_MACRO(greater, >, double) 00533 TVMET_DECLARE_MACRO(less, <, double) 00534 TVMET_DECLARE_MACRO(greater_eq, >=, double) 00535 TVMET_DECLARE_MACRO(less_eq, <=, double) 00536 TVMET_DECLARE_MACRO(eq, ==, double) 00537 TVMET_DECLARE_MACRO(not_eq, !=, double) 00538 TVMET_DECLARE_MACRO(and, &&, double) 00539 TVMET_DECLARE_MACRO(or, ||, double) 00540 00541 #if defined(TVMET_HAVE_LONG_DOUBLE) 00542 // necessary operators for eval functions 00543 TVMET_DECLARE_MACRO(greater, >, long double) 00544 TVMET_DECLARE_MACRO(less, <, long double) 00545 TVMET_DECLARE_MACRO(greater_eq, >=, long double) 00546 TVMET_DECLARE_MACRO(less_eq, <=, long double) 00547 TVMET_DECLARE_MACRO(eq, ==, long double) 00548 TVMET_DECLARE_MACRO(not_eq, !=, long double) 00549 TVMET_DECLARE_MACRO(and, &&, long double) 00550 TVMET_DECLARE_MACRO(or, ||, long double) 00551 #endif // defined(TVMET_HAVE_LONG_DOUBLE) 00552 00553 #undef TVMET_DECLARE_MACRO 00554 00555 00556 00557 00558 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00559 * global unary operators 00560 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00561 00562 00563 /* 00564 * unary_operator(Matrix<T, Rows, Cols>) 00565 * Note: per se element wise 00566 */ 00567 #define TVMET_DECLARE_MACRO(NAME, OP) \ 00568 template <class T, std::size_t Rows, std::size_t Cols> \ 00569 XprMatrix< \ 00570 XprUnOp< \ 00571 Fcnl_##NAME<T>, \ 00572 MatrixConstReference<T, Rows, Cols> \ 00573 >, \ 00574 Rows, Cols \ 00575 > \ 00576 operator OP (const Matrix<T, Rows, Cols>& rhs) TVMET_CXX_ALWAYS_INLINE; 00577 00578 TVMET_DECLARE_MACRO(not, !) 00579 TVMET_DECLARE_MACRO(compl, ~) 00580 TVMET_DECLARE_MACRO(neg, -) 00581 #undef TVMET_DECLARE_MACRO 00582 00583 00584 /********************************************************* 00585 * PART II: IMPLEMENTATION 00586 *********************************************************/ 00587 00588 00589 /** 00590 * \fn operator<<(std::ostream& os, const Matrix<T, Rows, Cols>& rhs) 00591 * \brief Overload operator for i/o 00592 * \ingroup _binary_operator 00593 */ 00594 template<class T, std::size_t Rows, std::size_t Cols> 00595 inline 00596 std::ostream& operator<<(std::ostream& os, const Matrix<T, Rows, Cols>& rhs) { 00597 return rhs.print_on(os); 00598 } 00599 00600 00601 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00602 * Member operators (arithmetic and bit ops) 00603 *++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00604 00605 00606 /* 00607 * update_operator(Matrix<T1, Rows, Cols>, Matrix<T2, Rows, Cols>) 00608 * update_operator(Matrix<T1, Rows, Cols>, XprMatrix<E, Rows, Cols> rhs) 00609 * Note: per se element wise 00610 * \todo: the operator*= can have element wise mul oder product, decide! 00611 */ 00612 #define TVMET_IMPLEMENT_MACRO(NAME, OP) \ 00613 template<class T1, class T2, std::size_t Rows, std::size_t Cols> \ 00614 inline \ 00615 Matrix<T1, Rows, Cols>& \ 00616 operator OP (Matrix<T1, Rows, Cols>& lhs, const Matrix<T2, Rows, Cols>& rhs) { \ 00617 return lhs.M_##NAME(rhs); \ 00618 } \ 00619 \ 00620 template<class T, class E, std::size_t Rows, std::size_t Cols> \ 00621 inline \ 00622 Matrix<T, Rows, Cols>& \ 00623 operator OP (Matrix<T, Rows, Cols>& lhs, const XprMatrix<E, Rows, Cols>& rhs) { \ 00624 return lhs.M_##NAME(rhs); \ 00625 } 00626 00627 TVMET_IMPLEMENT_MACRO(add_eq, +=) // per se element wise 00628 TVMET_IMPLEMENT_MACRO(sub_eq, -=) // per se element wise 00629 namespace element_wise { 00630 TVMET_IMPLEMENT_MACRO(mul_eq, *=) // see note 00631 TVMET_IMPLEMENT_MACRO(div_eq, /=) // not defined for vectors 00632 } 00633 00634 // integer operators only, e.g used on double you wil get an error 00635 namespace element_wise { 00636 TVMET_IMPLEMENT_MACRO(mod_eq, %=) 00637 TVMET_IMPLEMENT_MACRO(xor_eq, ^=) 00638 TVMET_IMPLEMENT_MACRO(and_eq, &=) 00639 TVMET_IMPLEMENT_MACRO(or_eq, |=) 00640 TVMET_IMPLEMENT_MACRO(shl_eq, <<=) 00641 TVMET_IMPLEMENT_MACRO(shr_eq, >>=) 00642 } 00643 00644 #undef TVMET_IMPLEMENT_MACRO 00645 00646 00647 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00648 * Matrix arithmetic operators implemented by functions 00649 * add, sub, mul and div 00650 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00651 00652 00653 /* 00654 * operator(Matrix<T1, Rows, Cols>, Matrix<T2, Rows, Cols>) 00655 * operator(XprMatrix<E, Rows, Cols>, Matrix<T, Rows, Cols>) 00656 * operator(Matrix<T, Rows, Cols>, XprMatrix<E, Rows, Cols>) 00657 * Note: per se element wise 00658 */ 00659 #define TVMET_IMPLEMENT_MACRO(NAME, OP) \ 00660 template<class T1, class T2, std::size_t Rows, std::size_t Cols> \ 00661 inline \ 00662 XprMatrix< \ 00663 XprBinOp< \ 00664 Fcnl_##NAME<T1, T2>, \ 00665 MatrixConstReference<T1, Rows, Cols>, \ 00666 MatrixConstReference<T2, Rows, Cols> \ 00667 >, \ 00668 Rows, Cols \ 00669 > \ 00670 operator OP (const Matrix<T1, Rows, Cols>& lhs, const Matrix<T2, Rows, Cols>& rhs) { \ 00671 return NAME(lhs, rhs); \ 00672 } \ 00673 \ 00674 template<class E, class T, std::size_t Rows, std::size_t Cols> \ 00675 inline \ 00676 XprMatrix< \ 00677 XprBinOp< \ 00678 Fcnl_##NAME<typename E::value_type, T>, \ 00679 XprMatrix<E, Rows, Cols>, \ 00680 MatrixConstReference<T, Rows, Cols> \ 00681 >, \ 00682 Rows, Cols \ 00683 > \ 00684 operator OP (const XprMatrix<E, Rows, Cols>& lhs, const Matrix<T, Rows, Cols>& rhs) { \ 00685 return NAME(lhs, rhs); \ 00686 } \ 00687 \ 00688 template<class T, class E, std::size_t Rows, std::size_t Cols> \ 00689 inline \ 00690 XprMatrix< \ 00691 XprBinOp< \ 00692 Fcnl_##NAME<typename E::value_type, T>, \ 00693 MatrixConstReference<T, Rows, Cols>, \ 00694 XprMatrix<E, Rows, Cols> \ 00695 >, \ 00696 Rows, Cols \ 00697 > \ 00698 operator OP (const Matrix<T, Rows, Cols>& lhs, const XprMatrix<E, Rows, Cols>& rhs) { \ 00699 return NAME(lhs, rhs); \ 00700 } 00701 00702 TVMET_IMPLEMENT_MACRO(add, +) // per se element wise 00703 TVMET_IMPLEMENT_MACRO(sub, -) // per se element wise 00704 namespace element_wise { 00705 TVMET_IMPLEMENT_MACRO(mul, *) // see as prod() 00706 TVMET_IMPLEMENT_MACRO(div, /) // not defined for matrizes 00707 } 00708 #undef TVMET_IMPLEMENT_MACRO 00709 00710 00711 /* 00712 * operator(Matrix<T, Rows, Cols>, POD) 00713 * operator(POD, Matrix<T, Rows, Cols>) 00714 * Note: operations +,-,*,/ are per se element wise 00715 */ 00716 #define TVMET_IMPLEMENT_MACRO(NAME, OP, POD) \ 00717 template<class T, std::size_t Rows, std::size_t Cols> \ 00718 inline \ 00719 XprMatrix< \ 00720 XprBinOp< \ 00721 Fcnl_##NAME<T, POD >, \ 00722 MatrixConstReference<T, Rows, Cols>, \ 00723 XprLiteral<POD > \ 00724 >, \ 00725 Rows, Cols \ 00726 > \ 00727 operator OP (const Matrix<T, Rows, Cols>& lhs, POD rhs) { \ 00728 return NAME (lhs, rhs); \ 00729 } \ 00730 \ 00731 template<class T, std::size_t Rows, std::size_t Cols> \ 00732 inline \ 00733 XprMatrix< \ 00734 XprBinOp< \ 00735 Fcnl_##NAME< POD, T>, \ 00736 XprLiteral< POD >, \ 00737 MatrixConstReference<T, Rows, Cols> \ 00738 >, \ 00739 Rows, Cols \ 00740 > \ 00741 operator OP (POD lhs, const Matrix<T, Rows, Cols>& rhs) { \ 00742 return NAME (lhs, rhs); \ 00743 } 00744 00745 TVMET_IMPLEMENT_MACRO(add, +, int) 00746 TVMET_IMPLEMENT_MACRO(sub, -, int) 00747 TVMET_IMPLEMENT_MACRO(mul, *, int) 00748 TVMET_IMPLEMENT_MACRO(div, /, int) 00749 00750 #if defined(TVMET_HAVE_LONG_LONG) 00751 TVMET_IMPLEMENT_MACRO(add, +, long long int) 00752 TVMET_IMPLEMENT_MACRO(sub, -, long long int) 00753 TVMET_IMPLEMENT_MACRO(mul, *, long long int) 00754 TVMET_IMPLEMENT_MACRO(div, /, long long int) 00755 #endif // defined(TVMET_HAVE_LONG_LONG) 00756 00757 TVMET_IMPLEMENT_MACRO(add, +, float) 00758 TVMET_IMPLEMENT_MACRO(sub, -, float) 00759 TVMET_IMPLEMENT_MACRO(mul, *, float) 00760 TVMET_IMPLEMENT_MACRO(div, /, float) 00761 00762 TVMET_IMPLEMENT_MACRO(add, +, double) 00763 TVMET_IMPLEMENT_MACRO(sub, -, double) 00764 TVMET_IMPLEMENT_MACRO(mul, *, double) 00765 TVMET_IMPLEMENT_MACRO(div, /, double) 00766 00767 #if defined(TVMET_HAVE_LONG_DOUBLE) 00768 TVMET_IMPLEMENT_MACRO(add, +, long double) 00769 TVMET_IMPLEMENT_MACRO(sub, -, long double) 00770 TVMET_IMPLEMENT_MACRO(mul, *, long double) 00771 TVMET_IMPLEMENT_MACRO(div, /, long double) 00772 #endif // defined(TVMET_HAVE_LONG_DOUBLE) 00773 00774 #undef TVMET_IMPLEMENT_MACRO 00775 00776 00777 #if defined(TVMET_HAVE_COMPLEX) 00778 /* 00779 * operator(Matrix<T, Rows, Cols>, complex<T>) 00780 * operator(complex<T>, Matrix<T, Rows, Cols>) 00781 * Note: operations +,-,*,/ are per se element wise 00782 * \todo type promotion 00783 */ 00784 #define TVMET_IMPLEMENT_MACRO(NAME, OP) \ 00785 template<class T, std::size_t Rows, std::size_t Cols> \ 00786 inline \ 00787 XprMatrix< \ 00788 XprBinOp< \ 00789 Fcnl_##NAME< std::complex<T>, std::complex<T> >, \ 00790 MatrixConstReference< std::complex<T>, Rows, Cols>, \ 00791 XprLiteral<std::complex<T> > \ 00792 >, \ 00793 Rows, Cols \ 00794 > \ 00795 operator OP (const Matrix< std::complex<T>, Rows, Cols>& lhs, \ 00796 const std::complex<T>& rhs) { \ 00797 return NAME (lhs, rhs); \ 00798 } \ 00799 \ 00800 template<class T, std::size_t Rows, std::size_t Cols> \ 00801 inline \ 00802 XprMatrix< \ 00803 XprBinOp< \ 00804 Fcnl_##NAME< std::complex<T>, std::complex<T> >, \ 00805 XprLiteral< std::complex<T> >, \ 00806 MatrixConstReference< std::complex<T>, Rows, Cols> \ 00807 >, \ 00808 Rows, Cols \ 00809 > \ 00810 operator OP (const std::complex<T>& lhs, \ 00811 const Matrix< std::complex<T>, Rows, Cols>& rhs) { \ 00812 return NAME (lhs, rhs); \ 00813 } 00814 00815 TVMET_IMPLEMENT_MACRO(add, +) 00816 TVMET_IMPLEMENT_MACRO(sub, -) 00817 TVMET_IMPLEMENT_MACRO(mul, *) 00818 TVMET_IMPLEMENT_MACRO(div, /) 00819 00820 #undef TVMET_IMPLEMENT_MACRO 00821 00822 #endif // defined(TVMET_HAVE_COMPLEX) 00823 00824 00825 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00826 * matrix specific operator*() = prod() operations 00827 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00828 00829 00830 /** 00831 * \fn operator*(const Matrix<T1, Rows1, Cols1>& lhs, const Matrix<T2, Cols1, Cols2>& rhs) 00832 * \brief multiply two Matrices. 00833 * \ingroup _binary_operator 00834 * \note The rows2 has to be equal to cols1. 00835 * \sa prod(const Matrix<T1, Rows1, Cols1>& lhs, const Matrix<T2, Cols1, Cols2>& rhs) 00836 */ 00837 template<class T1, std::size_t Rows1, std::size_t Cols1, 00838 class T2, std::size_t Cols2> 00839 inline 00840 XprMatrix< 00841 XprMMProduct< 00842 MatrixConstReference<T1, Rows1, Cols1>, Rows1, Cols1, 00843 MatrixConstReference<T2, Cols1, Cols2>, Cols2 00844 >, 00845 Rows1, Cols2 00846 > 00847 operator*(const Matrix<T1, Rows1, Cols1>& lhs, const Matrix<T2, Cols1, Cols2>& rhs) { 00848 return prod(lhs, rhs); 00849 } 00850 00851 00852 /** 00853 * \fn operator*(const XprMatrix<E1, Rows1, Cols1>& lhs, const Matrix<T2, Cols1, Cols2>& rhs) 00854 * \brief Evaluate the product of XprMatrix and Matrix. 00855 * \ingroup _binary_operator 00856 * \sa prod(const XprMatrix<E1, Rows1, Cols1>& lhs, const Matrix<T2, Cols1, Cols2>& rhs) 00857 */ 00858 template<class E1, std::size_t Rows1, std::size_t Cols1, 00859 class T2, std::size_t Cols2> 00860 inline 00861 XprMatrix< 00862 XprMMProduct< 00863 XprMatrix<E1, Rows1, Cols1>, Rows1, Cols1, 00864 MatrixConstReference<T2, Cols1, Cols2>, Cols2 00865 >, 00866 Rows1, Cols2 00867 > 00868 operator*(const XprMatrix<E1, Rows1, Cols1>& lhs, const Matrix<T2, Cols1, Cols2>& rhs) { 00869 return prod(lhs, rhs); 00870 } 00871 00872 00873 /** 00874 * \fn operator*(const Matrix<T1, Rows1, Cols1>& lhs, const XprMatrix<E2, Cols1, Cols2>& rhs) 00875 * \brief Evaluate the product of Matrix and XprMatrix. 00876 * \ingroup _binary_operator 00877 * \sa prod(const Matrix<T, Rows1, Cols1>& lhs, const XprMatrix<E, Cols1, Cols2>& rhs) 00878 */ 00879 template<class T1, std::size_t Rows1, std::size_t Cols1, 00880 class E2, std::size_t Cols2> 00881 inline 00882 XprMatrix< 00883 XprMMProduct< 00884 MatrixConstReference<T1, Rows1, Cols1>, Rows1, Cols1, 00885 XprMatrix<E2, Cols1, Cols2>, Cols2 00886 >, 00887 Rows1, Cols2 00888 > 00889 operator*(const Matrix<T1, Rows1, Cols1>& lhs, const XprMatrix<E2, Cols1, Cols2>& rhs) { 00890 return prod(lhs, rhs); 00891 } 00892 00893 00894 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00895 * matrix-vector specific prod( ... ) operators 00896 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00897 00898 00899 /** 00900 * \fn operator*(const Matrix<T1, Rows, Cols>& lhs, const Vector<T2, Cols>& rhs) 00901 * \brief multiply a Matrix with a Vector. 00902 * \ingroup _binary_operator 00903 * \note The length of the Vector has to be equal to the number of Columns. 00904 * \sa prod(const Matrix<T1, Rows, Cols>& m, const Vector<T2, Cols>& v) 00905 */ 00906 template<class T1, std::size_t Rows, std::size_t Cols, class T2> 00907 inline 00908 XprVector< 00909 XprMVProduct< 00910 MatrixConstReference<T1, Rows, Cols>, Rows, Cols, 00911 VectorConstReference<T2, Cols> 00912 >, 00913 Rows 00914 > 00915 operator*(const Matrix<T1, Rows, Cols>& lhs, const Vector<T2, Cols>& rhs) { 00916 return prod(lhs, rhs); 00917 } 00918 00919 00920 /** 00921 * \fn operator*(const Matrix<T1, Rows, Cols>& lhs, const XprVector<E2, Cols>& rhs) 00922 * \brief Function for the matrix-vector-product 00923 * \ingroup _binary_operator 00924 * \sa prod(const Matrix<T, Rows, Cols>& lhs, const XprVector<E, Cols>& rhs) 00925 */ 00926 template<class T1, class E2, std::size_t Rows, std::size_t Cols> 00927 inline 00928 XprVector< 00929 XprMVProduct< 00930 MatrixConstReference<T1, Rows, Cols>, Rows, Cols, 00931 XprVector<E2, Cols> 00932 >, 00933 Rows 00934 > 00935 operator*(const Matrix<T1, Rows, Cols>& lhs, const XprVector<E2, Cols>& rhs) { 00936 return prod(lhs, rhs); 00937 } 00938 00939 00940 /** 00941 * \fn operator*(const XprMatrix<E1, Rows, Cols>& lhs, const Vector<T2, Cols>& rhs) 00942 * \brief Compute the product of an XprMatrix with a Vector. 00943 * \ingroup _binary_operator 00944 * \sa prod(const XprMatrix<E, Rows, Cols>& lhs, const Vector<T, Cols>& rhs) 00945 */ 00946 template<class E1, class T2, std::size_t Rows, std::size_t Cols> 00947 inline 00948 XprVector< 00949 XprMVProduct< 00950 XprMatrix<E1, Rows, Cols>, Rows, Cols, 00951 VectorConstReference<T2, Cols> 00952 >, 00953 Rows 00954 > 00955 operator*(const XprMatrix<E1, Rows, Cols>& lhs, const Vector<T2, Cols>& rhs) { 00956 return prod(lhs, rhs); 00957 } 00958 00959 00960 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00961 * Matrix integer and compare operators 00962 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00963 00964 00965 /* 00966 * operator(Matrix<T1, Rows, Cols>, Matrix<T2, Rows, Cols>) 00967 * operator(XprMatrix<E>, Matrix<T, Rows, Cols>) 00968 * operator(Matrix<T, Rows, Cols>, XprMatrix<E>) 00969 * Note: operations are per se element wise 00970 */ 00971 #define TVMET_IMPLEMENT_MACRO(NAME, OP) \ 00972 template<class T1, std::size_t Rows, std::size_t Cols, \ 00973 class T2> \ 00974 inline \ 00975 XprMatrix< \ 00976 XprBinOp< \ 00977 Fcnl_##NAME<T1, T2>, \ 00978 MatrixConstReference<T1, Rows, Cols>, \ 00979 MatrixConstReference<T2, Rows, Cols> \ 00980 >, \ 00981 Rows, Cols \ 00982 > \ 00983 operator OP (const Matrix<T1, Rows, Cols>& lhs, \ 00984 const Matrix<T2, Rows, Cols>& rhs) { \ 00985 typedef XprBinOp < \ 00986 Fcnl_##NAME<T1, T2>, \ 00987 MatrixConstReference<T1, Rows, Cols>, \ 00988 MatrixConstReference<T2, Rows, Cols> \ 00989 > expr_type; \ 00990 return XprMatrix<expr_type, Rows, Cols>(expr_type(lhs.const_ref(), rhs.const_ref())); \ 00991 } \ 00992 \ 00993 template<class E, \ 00994 class T, std::size_t Rows, std::size_t Cols> \ 00995 inline \ 00996 XprMatrix< \ 00997 XprBinOp< \ 00998 Fcnl_##NAME<typename E::value_type, T>, \ 00999 XprMatrix<E, Rows, Cols>, \ 01000 MatrixConstReference<T, Rows, Cols> \ 01001 >, \ 01002 Rows, Cols \ 01003 > \ 01004 operator OP (const XprMatrix<E, Rows, Cols>& lhs, const Matrix<T, Rows, Cols>& rhs) { \ 01005 typedef XprBinOp< \ 01006 Fcnl_##NAME<typename E::value_type, T>, \ 01007 XprMatrix<E, Rows, Cols>, \ 01008 MatrixConstReference<T, Rows, Cols> \ 01009 > expr_type; \ 01010 return XprMatrix<expr_type, Rows, Cols>(expr_type(lhs, rhs.const_ref())); \ 01011 } \ 01012 \ 01013 template<class T, std::size_t Rows, std::size_t Cols, \ 01014 class E> \ 01015 inline \ 01016 XprMatrix< \ 01017 XprBinOp< \ 01018 Fcnl_##NAME<typename E::value_type, T>, \ 01019 MatrixConstReference<T, Rows, Cols>, \ 01020 XprMatrix<E, Rows, Cols> \ 01021 >, \ 01022 Rows, Cols \ 01023 > \ 01024 operator OP (const Matrix<T, Rows, Cols>& lhs, const XprMatrix<E, Rows, Cols>& rhs) { \ 01025 typedef XprBinOp< \ 01026 Fcnl_##NAME<T, typename E::value_type>, \ 01027 MatrixConstReference<T, Rows, Cols>, \ 01028 XprMatrix<E, Rows, Cols> \ 01029 > expr_type; \ 01030 return XprMatrix<expr_type, Rows, Cols>(expr_type(lhs.const_ref(), rhs)); \ 01031 } 01032 01033 // integer operators only, e.g used on double you wil get an error 01034 namespace element_wise { 01035 TVMET_IMPLEMENT_MACRO(mod, %) 01036 TVMET_IMPLEMENT_MACRO(bitxor, ^) 01037 TVMET_IMPLEMENT_MACRO(bitand, &) 01038 TVMET_IMPLEMENT_MACRO(bitor, |) 01039 TVMET_IMPLEMENT_MACRO(shl, <<) 01040 TVMET_IMPLEMENT_MACRO(shr, >>) 01041 } 01042 01043 // necessary operators for eval functions 01044 TVMET_IMPLEMENT_MACRO(greater, >) 01045 TVMET_IMPLEMENT_MACRO(less, <) 01046 TVMET_IMPLEMENT_MACRO(greater_eq, >=) 01047 TVMET_IMPLEMENT_MACRO(less_eq, <=) 01048 TVMET_IMPLEMENT_MACRO(eq, ==) 01049 TVMET_IMPLEMENT_MACRO(not_eq, !=) 01050 TVMET_IMPLEMENT_MACRO(and, &&) 01051 TVMET_IMPLEMENT_MACRO(or, ||) 01052 01053 #undef TVMET_IMPLEMENT_MACRO 01054 01055 01056 #if defined(TVMET_HAVE_COMPLEX) 01057 /* 01058 * operator(Matrix<T, Rows, Cols>, complex<T>) 01059 * operator(complex<T>, Matrix<T, Rows, Cols>) 01060 * Note: - per se element wise 01061 * - bit ops on complex<int> doesn't make sense, stay away 01062 * \todo type promotion 01063 */ 01064 #define TVMET_IMPLEMENT_MACRO(NAME, OP) \ 01065 template<class T, std::size_t Rows, std::size_t Cols> \ 01066 inline \ 01067 XprMatrix< \ 01068 XprBinOp< \ 01069 Fcnl_##NAME< std::complex<T>, std::complex<T> >, \ 01070 MatrixConstReference< std::complex<T>, Rows, Cols>, \ 01071 XprLiteral<std::complex<T> > \ 01072 >, \ 01073 Rows, Cols \ 01074 > \ 01075 operator OP (const Matrix< std::complex<T>, Rows, Cols>& lhs, \ 01076 const std::complex<T>& rhs) { \ 01077 typedef XprBinOp< \ 01078 Fcnl_##NAME< std::complex<T>, std::complex<T> >, \ 01079 MatrixConstReference< std::complex<T>, Rows, Cols>, \ 01080 XprLiteral< std::complex<T> > \ 01081 > expr_type; \ 01082 return XprMatrix<expr_type, Rows, Cols>( \ 01083 expr_type(lhs.const_ref(), XprLiteral< std::complex<T> >(rhs))); \ 01084 } \ 01085 \ 01086 template<class T, std::size_t Rows, std::size_t Cols> \ 01087 inline \ 01088 XprMatrix< \ 01089 XprBinOp< \ 01090 Fcnl_##NAME< std::complex<T>, std::complex<T> >, \ 01091 XprLiteral< std::complex<T> >, \ 01092 MatrixConstReference< std::complex<T>, Rows, Cols> \ 01093 >, \ 01094 Rows, Cols \ 01095 > \ 01096 operator OP (const std::complex<T>& lhs, \ 01097 const Matrix< std::complex<T>, Rows, Cols>& rhs) { \ 01098 typedef XprBinOp< \ 01099 Fcnl_##NAME< std::complex<T>, std::complex<T> >, \ 01100 XprLiteral< std::complex<T> >, \ 01101 MatrixConstReference<T, Rows, Cols> \ 01102 > expr_type; \ 01103 return XprMatrix<expr_type, Rows, Cols>( \ 01104 expr_type(XprLiteral< std::complex<T> >(lhs), rhs.const_ref())); \ 01105 } 01106 01107 // necessary operators for eval functions 01108 TVMET_IMPLEMENT_MACRO(greater, >) 01109 TVMET_IMPLEMENT_MACRO(less, <) 01110 TVMET_IMPLEMENT_MACRO(greater_eq, >=) 01111 TVMET_IMPLEMENT_MACRO(less_eq, <=) 01112 TVMET_IMPLEMENT_MACRO(eq, ==) 01113 TVMET_IMPLEMENT_MACRO(not_eq, !=) 01114 TVMET_IMPLEMENT_MACRO(and, &&) 01115 TVMET_IMPLEMENT_MACRO(or, ||) 01116 01117 #undef TVMET_IMPLEMENT_MACRO 01118 01119 #endif // defined(TVMET_HAVE_COMPLEX) 01120 01121 01122 /* 01123 * operator(Matrix<T, Rows, Cols>, POD) 01124 * operator(POD, Matrix<T, Rows, Cols>) 01125 * Note: operations are per se element wise 01126 */ 01127 #define TVMET_IMPLEMENT_MACRO(NAME, OP, TP) \ 01128 template<class T, std::size_t Rows, std::size_t Cols> \ 01129 inline \ 01130 XprMatrix< \ 01131 XprBinOp< \ 01132 Fcnl_##NAME<T, TP >, \ 01133 MatrixConstReference<T, Rows, Cols>, \ 01134 XprLiteral<TP > \ 01135 >, \ 01136 Rows, Cols \ 01137 > \ 01138 operator OP (const Matrix<T, Rows, Cols>& lhs, TP rhs) { \ 01139 typedef XprBinOp< \ 01140 Fcnl_##NAME<T, TP >, \ 01141 MatrixConstReference<T, Rows, Cols>, \ 01142 XprLiteral< TP > \ 01143 > expr_type; \ 01144 return XprMatrix<expr_type, Rows, Cols>( \ 01145 expr_type(lhs.const_ref(), XprLiteral< TP >(rhs))); \ 01146 } \ 01147 \ 01148 template<class T, std::size_t Rows, std::size_t Cols> \ 01149 inline \ 01150 XprMatrix< \ 01151 XprBinOp< \ 01152 Fcnl_##NAME< TP, T>, \ 01153 XprLiteral< TP >, \ 01154 MatrixConstReference<T, Rows, Cols> \ 01155 >, \ 01156 Rows, Cols \ 01157 > \ 01158 operator OP (TP lhs, const Matrix<T, Rows, Cols>& rhs) { \ 01159 typedef XprBinOp< \ 01160 Fcnl_##NAME< TP, T>, \ 01161 XprLiteral< TP >, \ 01162 MatrixConstReference<T, Rows, Cols> \ 01163 > expr_type; \ 01164 return XprMatrix<expr_type, Rows, Cols>( \ 01165 expr_type(XprLiteral< TP >(lhs), rhs.const_ref())); \ 01166 } 01167 01168 // integer operators only, e.g used on double you wil get an error 01169 namespace element_wise { 01170 TVMET_IMPLEMENT_MACRO(mod, %, int) 01171 TVMET_IMPLEMENT_MACRO(bitxor, ^, int) 01172 TVMET_IMPLEMENT_MACRO(bitand, &, int) 01173 TVMET_IMPLEMENT_MACRO(bitor, |, int) 01174 TVMET_IMPLEMENT_MACRO(shl, <<, int) 01175 TVMET_IMPLEMENT_MACRO(shr, >>, int) 01176 } 01177 01178 // necessary operators for eval functions 01179 TVMET_IMPLEMENT_MACRO(greater, >, int) 01180 TVMET_IMPLEMENT_MACRO(less, <, int) 01181 TVMET_IMPLEMENT_MACRO(greater_eq, >=, int) 01182 TVMET_IMPLEMENT_MACRO(less_eq, <=, int) 01183 TVMET_IMPLEMENT_MACRO(eq, ==, int) 01184 TVMET_IMPLEMENT_MACRO(not_eq, !=, int) 01185 TVMET_IMPLEMENT_MACRO(and, &&, int) 01186 TVMET_IMPLEMENT_MACRO(or, ||, int) 01187 01188 #if defined(TVMET_HAVE_LONG_LONG) 01189 // integer operators only 01190 namespace element_wise { 01191 TVMET_IMPLEMENT_MACRO(mod, %, long long int) 01192 TVMET_IMPLEMENT_MACRO(bitxor, ^, long long int) 01193 TVMET_IMPLEMENT_MACRO(bitand, &, long long int) 01194 TVMET_IMPLEMENT_MACRO(bitor, |, long long int) 01195 TVMET_IMPLEMENT_MACRO(shl, <<, long long int) 01196 TVMET_IMPLEMENT_MACRO(shr, >>, long long int) 01197 } 01198 01199 // necessary operators for eval functions 01200 TVMET_IMPLEMENT_MACRO(greater, >, long long int) 01201 TVMET_IMPLEMENT_MACRO(less, <, long long int) 01202 TVMET_IMPLEMENT_MACRO(greater_eq, >=, long long int) 01203 TVMET_IMPLEMENT_MACRO(less_eq, <=, long long int) 01204 TVMET_IMPLEMENT_MACRO(eq, ==, long long int) 01205 TVMET_IMPLEMENT_MACRO(not_eq, !=, long long int) 01206 TVMET_IMPLEMENT_MACRO(and, &&, long long int) 01207 TVMET_IMPLEMENT_MACRO(or, ||, long long int) 01208 #endif // defined(TVMET_HAVE_LONG_LONG) 01209 01210 // necessary operators for eval functions 01211 TVMET_IMPLEMENT_MACRO(greater, >, float) 01212 TVMET_IMPLEMENT_MACRO(less, <, float) 01213 TVMET_IMPLEMENT_MACRO(greater_eq, >=, float) 01214 TVMET_IMPLEMENT_MACRO(less_eq, <=, float) 01215 TVMET_IMPLEMENT_MACRO(eq, ==, float) 01216 TVMET_IMPLEMENT_MACRO(not_eq, !=, float) 01217 TVMET_IMPLEMENT_MACRO(and, &&, float) 01218 TVMET_IMPLEMENT_MACRO(or, ||, float) 01219 01220 // necessary operators for eval functions 01221 TVMET_IMPLEMENT_MACRO(greater, >, double) 01222 TVMET_IMPLEMENT_MACRO(less, <, double) 01223 TVMET_IMPLEMENT_MACRO(greater_eq, >=, double) 01224 TVMET_IMPLEMENT_MACRO(less_eq, <=, double) 01225 TVMET_IMPLEMENT_MACRO(eq, ==, double) 01226 TVMET_IMPLEMENT_MACRO(not_eq, !=, double) 01227 TVMET_IMPLEMENT_MACRO(and, &&, double) 01228 TVMET_IMPLEMENT_MACRO(or, ||, double) 01229 01230 #if defined(TVMET_HAVE_LONG_DOUBLE) 01231 // necessary operators for eval functions 01232 TVMET_IMPLEMENT_MACRO(greater, >, long double) 01233 TVMET_IMPLEMENT_MACRO(less, <, long double) 01234 TVMET_IMPLEMENT_MACRO(greater_eq, >=, long double) 01235 TVMET_IMPLEMENT_MACRO(less_eq, <=, long double) 01236 TVMET_IMPLEMENT_MACRO(eq, ==, long double) 01237 TVMET_IMPLEMENT_MACRO(not_eq, !=, long double) 01238 TVMET_IMPLEMENT_MACRO(and, &&, long double) 01239 TVMET_IMPLEMENT_MACRO(or, ||, long double) 01240 #endif // defined(TVMET_HAVE_LONG_DOUBLE) 01241 01242 #undef TVMET_IMPLEMENT_MACRO 01243 01244 01245 01246 01247 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 01248 * global unary operators 01249 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 01250 01251 01252 /* 01253 * unary_operator(Matrix<T, Rows, Cols>) 01254 * Note: per se element wise 01255 */ 01256 #define TVMET_IMPLEMENT_MACRO(NAME, OP) \ 01257 template <class T, std::size_t Rows, std::size_t Cols> \ 01258 inline \ 01259 XprMatrix< \ 01260 XprUnOp< \ 01261 Fcnl_##NAME<T>, \ 01262 MatrixConstReference<T, Rows, Cols> \ 01263 >, \ 01264 Rows, Cols \ 01265 > \ 01266 operator OP (const Matrix<T, Rows, Cols>& rhs) { \ 01267 typedef XprUnOp< \ 01268 Fcnl_##NAME<T>, \ 01269 MatrixConstReference<T, Rows, Cols> \ 01270 > expr_type; \ 01271 return XprMatrix<expr_type, Rows, Cols>(expr_type(rhs.const_ref())); \ 01272 } 01273 01274 TVMET_IMPLEMENT_MACRO(not, !) 01275 TVMET_IMPLEMENT_MACRO(compl, ~) 01276 TVMET_IMPLEMENT_MACRO(neg, -) 01277 #undef TVMET_IMPLEMENT_MACRO 01278 01279 01280 } // namespace tvmet 01281 01282 #endif // TVMET_MATRIX_OPERATORS_H 01283 01284 // Local Variables: 01285 // mode:C++ 01286 // tab-width:8 01287 // End:
Generated on Tue Jul 12 2022 19:00:11 by 1.7.2