ICRS Eurobot 2013
Dependencies: mbed mbed-rtos Servo QEI
VectorBinaryFunctions.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: VectorBinaryFunctions.h,v 1.17 2007-06-23 15:58:58 opetzold Exp $ 00022 */ 00023 00024 #ifndef TVMET_VECTOR_BINARY_FUNCTIONS_H 00025 #define TVMET_VECTOR_BINARY_FUNCTIONS_H 00026 00027 #include <tvmet/NumericTraits.h> 00028 #include <tvmet/Extremum.h> 00029 00030 namespace tvmet { 00031 00032 00033 /********************************************************* 00034 * PART I: DECLARATION 00035 *********************************************************/ 00036 00037 /* 00038 * binary_function(Vector<T1, Sz>, Vector<T1, Sz>) 00039 * binary_function(Vector<T, Sz>, XprVector<E>) 00040 * binary_function(XprVector<E>, Vector<T, Sz>) 00041 */ 00042 #define TVMET_DECLARE_MACRO(NAME) \ 00043 template<class T1, class T2, std::size_t Sz> \ 00044 inline \ 00045 XprVector< \ 00046 XprBinOp< \ 00047 Fcnl_##NAME<T1, T2>, \ 00048 VectorConstReference<T1, Sz>, \ 00049 VectorConstReference<T2, Sz> \ 00050 >, \ 00051 Sz \ 00052 > \ 00053 NAME(const Vector<T1, Sz>& lhs, \ 00054 const Vector<T2, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; \ 00055 \ 00056 template<class E, class T, std::size_t Sz> \ 00057 inline \ 00058 XprVector< \ 00059 XprBinOp< \ 00060 Fcnl_##NAME<typename E::value_type, T>, \ 00061 VectorConstReference<T, Sz>, \ 00062 XprVector<E, Sz> \ 00063 >, \ 00064 Sz \ 00065 > \ 00066 NAME(const XprVector<E, Sz>& lhs, \ 00067 const Vector<T, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; \ 00068 \ 00069 template<class E, class T, std::size_t Sz> \ 00070 inline \ 00071 XprVector< \ 00072 XprBinOp< \ 00073 Fcnl_##NAME<T, typename E::value_type>, \ 00074 VectorConstReference<T, Sz>, \ 00075 XprVector<E, Sz> \ 00076 >, \ 00077 Sz \ 00078 > \ 00079 NAME(const Vector<T, Sz>& lhs, \ 00080 const XprVector<E, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; 00081 00082 TVMET_DECLARE_MACRO(atan2) 00083 TVMET_DECLARE_MACRO(drem) 00084 TVMET_DECLARE_MACRO(fmod) 00085 TVMET_DECLARE_MACRO(hypot) 00086 TVMET_DECLARE_MACRO(jn) 00087 TVMET_DECLARE_MACRO(yn) 00088 TVMET_DECLARE_MACRO(pow) 00089 #if defined(TVMET_HAVE_COMPLEX) 00090 TVMET_DECLARE_MACRO(polar) 00091 #endif 00092 00093 #undef TVMET_DECLARE_MACRO 00094 00095 00096 /* 00097 * binary_function(Vector<T, Sz>, POD) 00098 */ 00099 #define TVMET_DECLARE_MACRO(NAME, TP) \ 00100 template<class T, std::size_t Sz> \ 00101 inline \ 00102 XprVector< \ 00103 XprBinOp< \ 00104 Fcnl_##NAME<T, TP >, \ 00105 VectorConstReference<T, Sz>, \ 00106 XprLiteral< TP > \ 00107 >, \ 00108 Sz \ 00109 > \ 00110 NAME(const Vector<T, Sz>& lhs, TP rhs) TVMET_CXX_ALWAYS_INLINE; 00111 00112 TVMET_DECLARE_MACRO(atan2, int) 00113 TVMET_DECLARE_MACRO(drem, int) 00114 TVMET_DECLARE_MACRO(fmod, int) 00115 TVMET_DECLARE_MACRO(hypot, int) 00116 TVMET_DECLARE_MACRO(jn, int) 00117 TVMET_DECLARE_MACRO(yn, int) 00118 TVMET_DECLARE_MACRO(pow, int) 00119 00120 #if defined(TVMET_HAVE_LONG_LONG) 00121 TVMET_DECLARE_MACRO(atan2, long long int) 00122 TVMET_DECLARE_MACRO(drem, long long int) 00123 TVMET_DECLARE_MACRO(fmod, long long int) 00124 TVMET_DECLARE_MACRO(hypot, long long int) 00125 TVMET_DECLARE_MACRO(jn, long long int) 00126 TVMET_DECLARE_MACRO(yn, long long int) 00127 TVMET_DECLARE_MACRO(pow, long long int) 00128 #endif // defined(TVMET_HAVE_LONG_LONG) 00129 00130 TVMET_DECLARE_MACRO(atan2, float) 00131 TVMET_DECLARE_MACRO(drem, float) 00132 TVMET_DECLARE_MACRO(fmod, float) 00133 TVMET_DECLARE_MACRO(hypot, float) 00134 TVMET_DECLARE_MACRO(jn, float) 00135 TVMET_DECLARE_MACRO(yn, float) 00136 TVMET_DECLARE_MACRO(pow, float) 00137 00138 TVMET_DECLARE_MACRO(atan2, double) 00139 TVMET_DECLARE_MACRO(drem, double) 00140 TVMET_DECLARE_MACRO(fmod, double) 00141 TVMET_DECLARE_MACRO(hypot, double) 00142 TVMET_DECLARE_MACRO(jn, double) 00143 TVMET_DECLARE_MACRO(yn, double) 00144 TVMET_DECLARE_MACRO(pow, double) 00145 00146 #if defined(TVMET_HAVE_LONG_DOUBLE) 00147 TVMET_DECLARE_MACRO(atan2, long double) 00148 TVMET_DECLARE_MACRO(drem, long double) 00149 TVMET_DECLARE_MACRO(fmod, long double) 00150 TVMET_DECLARE_MACRO(hypot, long double) 00151 TVMET_DECLARE_MACRO(jn, long double) 00152 TVMET_DECLARE_MACRO(yn, long double) 00153 TVMET_DECLARE_MACRO(pow, long double) 00154 #endif // defined(TVMET_HAVE_LONG_DOUBLE) 00155 00156 #undef TVMET_DECLARE_MACRO 00157 00158 00159 /* 00160 * complex support 00161 */ 00162 00163 #if defined(TVMET_HAVE_COMPLEX) && defined(TVMET_HAVE_COMPLEX_MATH1) 00164 template<class T, std::size_t Sz> 00165 XprVector< 00166 XprBinOp< 00167 Fcnl_pow<T, std::complex<T> >, 00168 VectorConstReference<T, Sz>, 00169 XprLiteral< std::complex<T> > 00170 >, 00171 Sz 00172 > 00173 pow(const Vector<T, Sz>& lhs, 00174 const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; 00175 00176 00177 template<class T, std::size_t Sz> 00178 XprVector< 00179 XprBinOp< 00180 Fcnl_pow<std::complex<T>, std::complex<T> >, 00181 VectorConstReference<std::complex<T>, Sz>, 00182 XprLiteral< std::complex<T> > 00183 >, 00184 Sz 00185 > 00186 pow(const Vector<std::complex<T>, Sz>& lhs, 00187 const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; 00188 00189 00190 template<class T, std::size_t Sz> 00191 XprVector< 00192 XprBinOp< 00193 Fcnl_pow<std::complex<T>, T>, 00194 VectorConstReference<std::complex<T>, Sz>, 00195 XprLiteral<T> 00196 >, 00197 Sz 00198 > 00199 pow(const Vector<std::complex<T>, Sz>& lhs, 00200 const T& rhs) TVMET_CXX_ALWAYS_INLINE; 00201 00202 00203 template<class T, std::size_t Sz> 00204 XprVector< 00205 XprBinOp< 00206 Fcnl_pow<std::complex<T>, int>, 00207 VectorConstReference<std::complex<T>, Sz>, 00208 XprLiteral<int> 00209 >, 00210 Sz 00211 > 00212 pow(const Vector<std::complex<T>, Sz>& lhs, 00213 int rhs) TVMET_CXX_ALWAYS_INLINE; 00214 00215 00216 template<class T, std::size_t Sz> 00217 XprVector< 00218 XprBinOp< 00219 Fcnl_polar<T, T>, 00220 VectorConstReference<T, Sz>, 00221 XprLiteral<T> 00222 >, 00223 Sz 00224 > 00225 polar(const Vector<T, Sz>& lhs, const T& rhs) TVMET_CXX_ALWAYS_INLINE; 00226 00227 #endif // defined(TVMET_HAVE_COMPLEX) && defined(TVMET_HAVE_COMPLEX_MATH1) 00228 00229 #if defined(TVMET_HAVE_COMPLEX) && defined(TVMET_HAVE_COMPLEX_MATH2) 00230 // to be written (atan2) 00231 #endif // defined(TVMET_HAVE_COMPLEX) && defined(TVMET_HAVE_COMPLEX_MATH2) 00232 00233 00234 /********************************************************* 00235 * PART II: IMPLEMENTATION 00236 *********************************************************/ 00237 00238 /* 00239 * binary_function(Vector<T1, Sz>, Vector<T1, Sz>) 00240 * binary_function(Vector<T, Sz>, XprVector<E>) 00241 * binary_function(XprVector<E>, Vector<T, Sz>) 00242 */ 00243 #define TVMET_IMPLEMENT_MACRO(NAME) \ 00244 template<class T1, class T2, std::size_t Sz> \ 00245 inline \ 00246 XprVector< \ 00247 XprBinOp< \ 00248 Fcnl_##NAME<T1, T2>, \ 00249 VectorConstReference<T1, Sz>, \ 00250 VectorConstReference<T2, Sz> \ 00251 >, \ 00252 Sz \ 00253 > \ 00254 NAME(const Vector<T1, Sz>& lhs, const Vector<T2, Sz>& rhs) { \ 00255 typedef XprBinOp < \ 00256 Fcnl_##NAME<T1, T2>, \ 00257 VectorConstReference<T1, Sz>, \ 00258 VectorConstReference<T2, Sz> \ 00259 > expr_type; \ 00260 return XprVector<expr_type, Sz>( \ 00261 expr_type(lhs.const_ref(), rhs.const_ref())); \ 00262 } \ 00263 \ 00264 template<class E, class T, std::size_t Sz> \ 00265 inline \ 00266 XprVector< \ 00267 XprBinOp< \ 00268 Fcnl_##NAME<typename E::value_type, T>, \ 00269 VectorConstReference<T, Sz>, \ 00270 XprVector<E, Sz> \ 00271 >, \ 00272 Sz \ 00273 > \ 00274 NAME(const XprVector<E, Sz>& lhs, const Vector<T, Sz>& rhs) { \ 00275 typedef XprBinOp< \ 00276 Fcnl_##NAME<typename E::value_type, T>, \ 00277 XprVector<E, Sz>, \ 00278 VectorConstReference<T, Sz> \ 00279 > expr_type; \ 00280 return XprVector<expr_type, Sz>( \ 00281 expr_type(lhs, rhs.const_ref())); \ 00282 } \ 00283 \ 00284 template<class E, class T, std::size_t Sz> \ 00285 inline \ 00286 XprVector< \ 00287 XprBinOp< \ 00288 Fcnl_##NAME<T, typename E::value_type>, \ 00289 VectorConstReference<T, Sz>, \ 00290 XprVector<E, Sz> \ 00291 >, \ 00292 Sz \ 00293 > \ 00294 NAME(const Vector<T, Sz>& lhs, const XprVector<E, Sz>& rhs) { \ 00295 typedef XprBinOp< \ 00296 Fcnl_##NAME<T, typename E::value_type>, \ 00297 VectorConstReference<T, Sz>, \ 00298 XprVector<E, Sz> \ 00299 > expr_type; \ 00300 return XprVector<expr_type, Sz>( \ 00301 expr_type(lhs.const_ref(), rhs)); \ 00302 } 00303 00304 TVMET_IMPLEMENT_MACRO(atan2) 00305 TVMET_IMPLEMENT_MACRO(drem) 00306 TVMET_IMPLEMENT_MACRO(fmod) 00307 TVMET_IMPLEMENT_MACRO(hypot) 00308 TVMET_IMPLEMENT_MACRO(jn) 00309 TVMET_IMPLEMENT_MACRO(yn) 00310 TVMET_IMPLEMENT_MACRO(pow) 00311 #if defined(TVMET_HAVE_COMPLEX) 00312 TVMET_IMPLEMENT_MACRO(polar) 00313 #endif 00314 00315 #undef TVMET_IMPLEMENT_MACRO 00316 00317 00318 /* 00319 * binary_function(Vector<T, Sz>, POD) 00320 */ 00321 #define TVMET_IMPLEMENT_MACRO(NAME, TP) \ 00322 template<class T, std::size_t Sz> \ 00323 inline \ 00324 XprVector< \ 00325 XprBinOp< \ 00326 Fcnl_##NAME<T, TP >, \ 00327 VectorConstReference<T, Sz>, \ 00328 XprLiteral< TP > \ 00329 >, \ 00330 Sz \ 00331 > \ 00332 NAME(const Vector<T, Sz>& lhs, TP rhs) { \ 00333 typedef XprBinOp< \ 00334 Fcnl_##NAME<T, TP >, \ 00335 VectorConstReference<T, Sz>, \ 00336 XprLiteral< TP > \ 00337 > expr_type; \ 00338 return XprVector<expr_type, Sz>( \ 00339 expr_type(lhs.const_ref(), XprLiteral< TP >(rhs))); \ 00340 } 00341 00342 TVMET_IMPLEMENT_MACRO(atan2, int) 00343 TVMET_IMPLEMENT_MACRO(drem, int) 00344 TVMET_IMPLEMENT_MACRO(fmod, int) 00345 TVMET_IMPLEMENT_MACRO(hypot, int) 00346 TVMET_IMPLEMENT_MACRO(jn, int) 00347 TVMET_IMPLEMENT_MACRO(yn, int) 00348 TVMET_IMPLEMENT_MACRO(pow, int) 00349 00350 #if defined(TVMET_HAVE_LONG_LONG) 00351 TVMET_IMPLEMENT_MACRO(atan2, long long int) 00352 TVMET_IMPLEMENT_MACRO(drem, long long int) 00353 TVMET_IMPLEMENT_MACRO(fmod, long long int) 00354 TVMET_IMPLEMENT_MACRO(hypot, long long int) 00355 TVMET_IMPLEMENT_MACRO(jn, long long int) 00356 TVMET_IMPLEMENT_MACRO(yn, long long int) 00357 TVMET_IMPLEMENT_MACRO(pow, long long int) 00358 #endif // defined(TVMET_HAVE_LONG_LONG) 00359 00360 TVMET_IMPLEMENT_MACRO(atan2, float) 00361 TVMET_IMPLEMENT_MACRO(drem, float) 00362 TVMET_IMPLEMENT_MACRO(fmod, float) 00363 TVMET_IMPLEMENT_MACRO(hypot, float) 00364 TVMET_IMPLEMENT_MACRO(jn, float) 00365 TVMET_IMPLEMENT_MACRO(yn, float) 00366 TVMET_IMPLEMENT_MACRO(pow, float) 00367 00368 TVMET_IMPLEMENT_MACRO(atan2, double) 00369 TVMET_IMPLEMENT_MACRO(drem, double) 00370 TVMET_IMPLEMENT_MACRO(fmod, double) 00371 TVMET_IMPLEMENT_MACRO(hypot, double) 00372 TVMET_IMPLEMENT_MACRO(jn, double) 00373 TVMET_IMPLEMENT_MACRO(yn, double) 00374 TVMET_IMPLEMENT_MACRO(pow, double) 00375 00376 #if defined(TVMET_HAVE_LONG_DOUBLE) 00377 TVMET_IMPLEMENT_MACRO(atan2, long double) 00378 TVMET_IMPLEMENT_MACRO(drem, long double) 00379 TVMET_IMPLEMENT_MACRO(fmod, long double) 00380 TVMET_IMPLEMENT_MACRO(hypot, long double) 00381 TVMET_IMPLEMENT_MACRO(jn, long double) 00382 TVMET_IMPLEMENT_MACRO(yn, long double) 00383 TVMET_IMPLEMENT_MACRO(pow, long double) 00384 #endif // defined(TVMET_HAVE_LONG_DOUBLE) 00385 00386 #undef TVMET_IMPLEMENT_MACRO 00387 00388 00389 /* 00390 * complex support 00391 */ 00392 00393 #if defined(TVMET_HAVE_COMPLEX) && defined(TVMET_HAVE_COMPLEX_MATH1) 00394 /** 00395 * \fn pow(const Vector<T, Sz>& lhs, const std::complex<T>& rhs) 00396 * \ingroup _binary_function 00397 */ 00398 template<class T, std::size_t Sz> 00399 inline 00400 XprVector< 00401 XprBinOp< 00402 Fcnl_pow<T, std::complex<T> >, 00403 VectorConstReference<T, Sz>, 00404 XprLiteral< std::complex<T> > 00405 >, 00406 Sz 00407 > 00408 pow(const Vector<T, Sz>& lhs, const std::complex<T>& rhs) { 00409 typedef XprBinOp< 00410 Fcnl_pow<T, std::complex<T> >, 00411 VectorConstReference<T, Sz>, 00412 XprLiteral< std::complex<T> > 00413 > expr_type; 00414 return XprVector<expr_type, Sz>( 00415 expr_type(lhs.const_ref(), XprLiteral< std::complex<T> >(rhs))); 00416 } 00417 00418 00419 /** 00420 * \fn pow(const Vector<std::complex<T>, Sz>& lhs, const std::complex<T>& rhs) 00421 * \ingroup _binary_function 00422 */ 00423 template<class T, std::size_t Sz> 00424 inline 00425 XprVector< 00426 XprBinOp< 00427 Fcnl_pow<std::complex<T>, std::complex<T> >, 00428 VectorConstReference<std::complex<T>, Sz>, 00429 XprLiteral< std::complex<T> > 00430 >, 00431 Sz 00432 > 00433 pow(const Vector<std::complex<T>, Sz>& lhs, const std::complex<T>& rhs) { 00434 typedef XprBinOp< 00435 Fcnl_pow<std::complex<T>, std::complex<T> >, 00436 VectorConstReference<std::complex<T>, Sz>, 00437 XprLiteral< std::complex<T> > 00438 > expr_type; 00439 return XprVector<expr_type, Sz>( 00440 expr_type(lhs.const_ref(), XprLiteral< std::complex<T> >(rhs))); 00441 } 00442 00443 00444 /** 00445 * \fn pow(const Vector<std::complex<T>, Sz>& lhs, const T& rhs) 00446 * \ingroup _binary_function 00447 */ 00448 template<class T, std::size_t Sz> 00449 inline 00450 XprVector< 00451 XprBinOp< 00452 Fcnl_pow<std::complex<T>, T>, 00453 VectorConstReference<std::complex<T>, Sz>, 00454 XprLiteral<T> 00455 >, 00456 Sz 00457 > 00458 pow(const Vector<std::complex<T>, Sz>& lhs, const T& rhs) { 00459 typedef XprBinOp< 00460 Fcnl_pow<std::complex<T>, T>, 00461 VectorConstReference<std::complex<T>, Sz>, 00462 XprLiteral<T> 00463 > expr_type; 00464 return XprVector<expr_type, Sz>( 00465 expr_type(lhs.const_ref(), XprLiteral<T>(rhs))); 00466 } 00467 00468 00469 /** 00470 * \fn pow(const Vector<std::complex<T>, Sz>& lhs, int rhs) 00471 * \ingroup _binary_function 00472 */ 00473 template<class T, std::size_t Sz> 00474 inline 00475 XprVector< 00476 XprBinOp< 00477 Fcnl_pow<std::complex<T>, int>, 00478 VectorConstReference<std::complex<T>, Sz>, 00479 XprLiteral<int> 00480 >, 00481 Sz 00482 > 00483 pow(const Vector<std::complex<T>, Sz>& lhs, int rhs) { 00484 typedef XprBinOp< 00485 Fcnl_pow<std::complex<T>, int>, 00486 VectorConstReference<std::complex<T>, Sz>, 00487 XprLiteral<int> 00488 > expr_type; 00489 return XprVector<expr_type, Sz>( 00490 expr_type(lhs.const_ref(), XprLiteral<int>(rhs))); 00491 } 00492 00493 00494 /** 00495 * \fn polar(const Vector<T, Sz>& lhs, const T& rhs) 00496 * \ingroup _binary_function 00497 */ 00498 template<class T, std::size_t Sz> 00499 inline 00500 XprVector< 00501 XprBinOp< 00502 Fcnl_polar<T, T>, 00503 VectorConstReference<T, Sz>, 00504 XprLiteral<T> 00505 >, 00506 Sz 00507 > 00508 polar(const Vector<T, Sz>& lhs, const T& rhs) { 00509 typedef XprBinOp< 00510 Fcnl_polar<T, T>, 00511 VectorConstReference<T, Sz>, 00512 XprLiteral<T> 00513 > expr_type; 00514 return XprVector<expr_type, Sz>( 00515 expr_type(lhs.const_ref(), XprLiteral<T>(rhs))); 00516 } 00517 #endif // defined(TVMET_HAVE_COMPLEX) && defined(TVMET_HAVE_COMPLEX_MATH1) 00518 00519 #if defined(TVMET_HAVE_COMPLEX) && defined(TVMET_HAVE_COMPLEX_MATH2) 00520 // to be written (atan2) 00521 #endif // defined(TVMET_HAVE_COMPLEX) && defined(TVMET_HAVE_COMPLEX_MATH2) 00522 00523 00524 } // namespace tvmet 00525 00526 #endif // TVMET_VECTOR_BINARY_FUNCTIONS_H 00527 00528 // Local Variables: 00529 // mode:C++ 00530 // tab-width:8 00531 // End:
Generated on Wed Jul 13 2022 18:28:37 by 1.7.2