Thomas Branch
ICRS Eurobot 2013
Dependencies: mbed mbed-rtos Servo QEI
Embed:
(wiki syntax)
Show/hide line numbers
VectorFunctions.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: VectorFunctions.h,v 1.21 2007-06-23 15:59:00 opetzold Exp $ 00022 */ 00023 00024 #ifndef TVMET_XPR_VECTOR_FUNCTIONS_H 00025 #define TVMET_XPR_VECTOR_FUNCTIONS_H 00026 00027 namespace tvmet { 00028 00029 00030 /* forwards */ 00031 template<class T, std::size_t Sz> class Vector; 00032 00033 00034 /********************************************************* 00035 * PART I: DECLARATION 00036 *********************************************************/ 00037 00038 00039 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00040 * Vector arithmetic functions add, sub, mul and div 00041 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00042 00043 00044 /* 00045 * function(XprVector<E1, Sz>, XprVector<E2, Sz>) 00046 */ 00047 #define TVMET_DECLARE_MACRO(NAME) \ 00048 template<class E1, class E2, std::size_t Sz> \ 00049 XprVector< \ 00050 XprBinOp< \ 00051 Fcnl_##NAME<typename E1::value_type, typename E2::value_type>, \ 00052 XprVector<E1, Sz>, \ 00053 XprVector<E2, Sz> \ 00054 >, \ 00055 Sz \ 00056 > \ 00057 NAME (const XprVector<E1, Sz>& lhs, \ 00058 const XprVector<E2, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; 00059 00060 TVMET_DECLARE_MACRO(add) // per se element wise 00061 TVMET_DECLARE_MACRO(sub) // per se element wise 00062 TVMET_DECLARE_MACRO(mul) // per se element wise 00063 namespace element_wise { 00064 TVMET_DECLARE_MACRO(div) // not defined for vectors 00065 } 00066 00067 #undef TVMET_DECLARE_MACRO 00068 00069 00070 /* 00071 * function(XprVector<E, Sz>, POD) 00072 * function(POD, XprVector<E, Sz>) 00073 * Note: - operations +,-,*,/ are per se element wise 00074 */ 00075 #define TVMET_DECLARE_MACRO(NAME, POD) \ 00076 template<class E, std::size_t Sz> \ 00077 XprVector< \ 00078 XprBinOp< \ 00079 Fcnl_##NAME< typename E::value_type, POD >, \ 00080 XprVector<E, Sz>, \ 00081 XprLiteral< POD > \ 00082 >, \ 00083 Sz \ 00084 > \ 00085 NAME (const XprVector<E, Sz>& lhs, \ 00086 POD rhs) TVMET_CXX_ALWAYS_INLINE; \ 00087 \ 00088 template<class E, std::size_t Sz> \ 00089 XprVector< \ 00090 XprBinOp< \ 00091 Fcnl_##NAME< POD, typename E::value_type>, \ 00092 XprLiteral< POD >, \ 00093 XprVector<E, Sz> \ 00094 >, \ 00095 Sz \ 00096 > \ 00097 NAME (POD lhs, \ 00098 const XprVector<E, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; 00099 00100 TVMET_DECLARE_MACRO(add, int) 00101 TVMET_DECLARE_MACRO(sub, int) 00102 TVMET_DECLARE_MACRO(mul, int) 00103 TVMET_DECLARE_MACRO(div, int) 00104 00105 #if defined(TVMET_HAVE_LONG_LONG) 00106 TVMET_DECLARE_MACRO(add, long long int) 00107 TVMET_DECLARE_MACRO(sub, long long int) 00108 TVMET_DECLARE_MACRO(mul, long long int) 00109 TVMET_DECLARE_MACRO(div, long long int) 00110 #endif 00111 00112 TVMET_DECLARE_MACRO(add, float) 00113 TVMET_DECLARE_MACRO(sub, float) 00114 TVMET_DECLARE_MACRO(mul, float) 00115 TVMET_DECLARE_MACRO(div, float) 00116 00117 TVMET_DECLARE_MACRO(add, double) 00118 TVMET_DECLARE_MACRO(sub, double) 00119 TVMET_DECLARE_MACRO(mul, double) 00120 TVMET_DECLARE_MACRO(div, double) 00121 00122 #if defined(TVMET_HAVE_LONG_DOUBLE) 00123 TVMET_DECLARE_MACRO(add, long double) 00124 TVMET_DECLARE_MACRO(sub, long double) 00125 TVMET_DECLARE_MACRO(mul, long double) 00126 TVMET_DECLARE_MACRO(div, long double) 00127 #endif 00128 00129 #undef TVMET_DECLARE_MACRO 00130 00131 00132 #if defined(TVMET_HAVE_COMPLEX) 00133 /* 00134 * function(XprMatrix<E, Rows, Cols>, complex<T>) 00135 * function(complex<T>, XprMatrix<E, Rows, Cols>) 00136 * Note: - operations +,-,*,/ are per se element wise 00137 * \todo type promotion 00138 */ 00139 #define TVMET_DECLARE_MACRO(NAME) \ 00140 template<class E, std::size_t Sz, class T> \ 00141 XprVector< \ 00142 XprBinOp< \ 00143 Fcnl_##NAME< typename E::value_type, std::complex<T> >, \ 00144 XprVector<E, Sz>, \ 00145 XprLiteral< std::complex<T> > \ 00146 >, \ 00147 Sz \ 00148 > \ 00149 NAME (const XprVector<E, Sz>& lhs, \ 00150 const std::complex<T>& rhs) TVMET_CXX_ALWAYS_INLINE; \ 00151 \ 00152 template<class E, std::size_t Sz, class T> \ 00153 XprVector< \ 00154 XprBinOp< \ 00155 Fcnl_##NAME< std::complex<T>, typename E::value_type>, \ 00156 XprLiteral< std::complex<T> >, \ 00157 XprVector<E, Sz> \ 00158 >, \ 00159 Sz \ 00160 > \ 00161 NAME (const std::complex<T>& lhs, \ 00162 const XprVector<E, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; 00163 00164 TVMET_DECLARE_MACRO(add) 00165 TVMET_DECLARE_MACRO(sub) 00166 TVMET_DECLARE_MACRO(mul) 00167 TVMET_DECLARE_MACRO(div) 00168 00169 #undef TVMET_DECLARE_MACRO 00170 00171 #endif // defined(TVMET_HAVE_COMPLEX) 00172 00173 00174 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00175 * vector specific functions 00176 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00177 00178 00179 template<class E, std::size_t Sz> 00180 typename NumericTraits<typename E::value_type>::sum_type 00181 sum(const XprVector<E, Sz>& v) TVMET_CXX_ALWAYS_INLINE; 00182 00183 00184 template<class E, std::size_t Sz> 00185 typename NumericTraits<typename E::value_type>::sum_type 00186 product(const XprVector<E, Sz>& v) TVMET_CXX_ALWAYS_INLINE; 00187 00188 00189 template<class E1, class E2, std::size_t Sz> 00190 typename PromoteTraits< 00191 typename E1::value_type, 00192 typename E2::value_type 00193 >::value_type 00194 dot(const XprVector<E1, Sz>& lhs, 00195 const XprVector<E2, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; 00196 00197 00198 template<class T, class E, std::size_t Sz> 00199 typename PromoteTraits<T, typename E::value_type>::value_type 00200 dot(const Vector<T, Sz>& lhs, 00201 const XprVector<E, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; 00202 00203 00204 template<class E, class T, std::size_t Sz> 00205 typename PromoteTraits<T, typename E::value_type>::value_type 00206 dot(const XprVector<E, Sz>& lhs, 00207 const Vector<T, Sz>& rhs) TVMET_CXX_ALWAYS_INLINE; 00208 00209 00210 template<class E1, class E2> 00211 Vector< 00212 typename PromoteTraits< 00213 typename E1::value_type, 00214 typename E2::value_type 00215 >::value_type, 00216 3 00217 > 00218 cross(const XprVector<E1, 3>& lhs, 00219 const XprVector<E2, 3>& rhs) TVMET_CXX_ALWAYS_INLINE; 00220 00221 00222 template<class T, class E> 00223 Vector< 00224 typename PromoteTraits<T, typename E::value_type>::value_type, 3> 00225 cross(const Vector<T, 3>& lhs, 00226 const XprVector<E, 3>& rhs) TVMET_CXX_ALWAYS_INLINE; 00227 00228 00229 template<class E, class T> 00230 Vector< 00231 typename PromoteTraits<T, typename E::value_type>::value_type, 3> 00232 cross(const XprVector<E, 3>& lhs, 00233 const Vector<T, 3>& rhs) TVMET_CXX_ALWAYS_INLINE; 00234 00235 00236 template<class E, std::size_t Sz> 00237 typename NumericTraits<typename E::value_type>::sum_type 00238 norm1(const XprVector<E, Sz>& v) TVMET_CXX_ALWAYS_INLINE; 00239 00240 00241 template<class E, std::size_t Sz> 00242 typename NumericTraits<typename E::value_type>::sum_type 00243 norm2(const XprVector<E, Sz>& v) TVMET_CXX_ALWAYS_INLINE; 00244 00245 00246 template<class E, std::size_t Sz> 00247 XprVector< 00248 XprBinOp< 00249 Fcnl_div<typename E::value_type, typename E::value_type>, 00250 XprVector<E, Sz>, 00251 XprLiteral<typename E::value_type> 00252 >, 00253 Sz 00254 > 00255 normalize(const XprVector<E, Sz>& v) TVMET_CXX_ALWAYS_INLINE; 00256 00257 00258 /********************************************************* 00259 * PART II: IMPLEMENTATION 00260 *********************************************************/ 00261 00262 00263 /* 00264 * function(XprVector<E1, Sz>, XprVector<E2, Sz>) 00265 */ 00266 #define TVMET_IMPLEMENT_MACRO(NAME) \ 00267 template<class E1, class E2, std::size_t Sz> \ 00268 inline \ 00269 XprVector< \ 00270 XprBinOp< \ 00271 Fcnl_##NAME<typename E1::value_type, typename E2::value_type>, \ 00272 XprVector<E1, Sz>, \ 00273 XprVector<E2, Sz> \ 00274 >, \ 00275 Sz \ 00276 > \ 00277 NAME (const XprVector<E1, Sz>& lhs, const XprVector<E2, Sz>& rhs) { \ 00278 typedef XprBinOp< \ 00279 Fcnl_##NAME<typename E1::value_type, typename E2::value_type>, \ 00280 XprVector<E1, Sz>, \ 00281 XprVector<E2, Sz> \ 00282 > expr_type; \ 00283 return XprVector<expr_type, Sz>(expr_type(lhs, rhs)); \ 00284 } 00285 00286 TVMET_IMPLEMENT_MACRO(add) // per se element wise 00287 TVMET_IMPLEMENT_MACRO(sub) // per se element wise 00288 TVMET_IMPLEMENT_MACRO(mul) // per se element wise 00289 namespace element_wise { 00290 TVMET_IMPLEMENT_MACRO(div) // not defined for vectors 00291 } 00292 00293 #undef TVMET_IMPLEMENT_MACRO 00294 00295 00296 /* 00297 * function(XprVector<E, Sz>, POD) 00298 * function(POD, XprVector<E, Sz>) 00299 * Note: - operations +,-,*,/ are per se element wise 00300 */ 00301 #define TVMET_IMPLEMENT_MACRO(NAME, POD) \ 00302 template<class E, std::size_t Sz> \ 00303 inline \ 00304 XprVector< \ 00305 XprBinOp< \ 00306 Fcnl_##NAME< typename E::value_type, POD >, \ 00307 XprVector<E, Sz>, \ 00308 XprLiteral< POD > \ 00309 >, \ 00310 Sz \ 00311 > \ 00312 NAME (const XprVector<E, Sz>& lhs, POD rhs) { \ 00313 typedef XprBinOp< \ 00314 Fcnl_##NAME< typename E::value_type, POD >, \ 00315 XprVector<E, Sz>, \ 00316 XprLiteral< POD > \ 00317 > expr_type; \ 00318 return XprVector<expr_type, Sz>( \ 00319 expr_type(lhs, XprLiteral< POD >(rhs))); \ 00320 } \ 00321 \ 00322 template<class E, std::size_t Sz> \ 00323 inline \ 00324 XprVector< \ 00325 XprBinOp< \ 00326 Fcnl_##NAME< POD, typename E::value_type>, \ 00327 XprLiteral< POD >, \ 00328 XprVector<E, Sz> \ 00329 >, \ 00330 Sz \ 00331 > \ 00332 NAME (POD lhs, const XprVector<E, Sz>& rhs) { \ 00333 typedef XprBinOp< \ 00334 Fcnl_##NAME< POD, typename E::value_type>, \ 00335 XprLiteral< POD >, \ 00336 XprVector<E, Sz> \ 00337 > expr_type; \ 00338 return XprVector<expr_type, Sz>( \ 00339 expr_type(XprLiteral< POD >(lhs), rhs)); \ 00340 } 00341 00342 TVMET_IMPLEMENT_MACRO(add, int) 00343 TVMET_IMPLEMENT_MACRO(sub, int) 00344 TVMET_IMPLEMENT_MACRO(mul, int) 00345 TVMET_IMPLEMENT_MACRO(div, int) 00346 00347 #if defined(TVMET_HAVE_LONG_LONG) 00348 TVMET_IMPLEMENT_MACRO(add, long long int) 00349 TVMET_IMPLEMENT_MACRO(sub, long long int) 00350 TVMET_IMPLEMENT_MACRO(mul, long long int) 00351 TVMET_IMPLEMENT_MACRO(div, long long int) 00352 #endif 00353 00354 TVMET_IMPLEMENT_MACRO(add, float) 00355 TVMET_IMPLEMENT_MACRO(sub, float) 00356 TVMET_IMPLEMENT_MACRO(mul, float) 00357 TVMET_IMPLEMENT_MACRO(div, float) 00358 00359 TVMET_IMPLEMENT_MACRO(add, double) 00360 TVMET_IMPLEMENT_MACRO(sub, double) 00361 TVMET_IMPLEMENT_MACRO(mul, double) 00362 TVMET_IMPLEMENT_MACRO(div, double) 00363 00364 #if defined(TVMET_HAVE_LONG_DOUBLE) 00365 TVMET_IMPLEMENT_MACRO(add, long double) 00366 TVMET_IMPLEMENT_MACRO(sub, long double) 00367 TVMET_IMPLEMENT_MACRO(mul, long double) 00368 TVMET_IMPLEMENT_MACRO(div, long double) 00369 #endif 00370 00371 #undef TVMET_IMPLEMENT_MACRO 00372 00373 00374 #if defined(TVMET_HAVE_COMPLEX) 00375 /* 00376 * function(XprMatrix<E, Rows, Cols>, complex<T>) 00377 * function(complex<T>, XprMatrix<E, Rows, Cols>) 00378 * Note: - operations +,-,*,/ are per se element wise 00379 * \todo type promotion 00380 */ 00381 #define TVMET_IMPLEMENT_MACRO(NAME) \ 00382 template<class E, std::size_t Sz, class T> \ 00383 inline \ 00384 XprVector< \ 00385 XprBinOp< \ 00386 Fcnl_##NAME< typename E::value_type, std::complex<T> >, \ 00387 XprVector<E, Sz>, \ 00388 XprLiteral< std::complex<T> > \ 00389 >, \ 00390 Sz \ 00391 > \ 00392 NAME (const XprVector<E, Sz>& lhs, const std::complex<T>& rhs) { \ 00393 typedef XprBinOp< \ 00394 Fcnl_##NAME< typename E::value_type, std::complex<T> >, \ 00395 XprVector<E, Sz>, \ 00396 XprLiteral< std::complex<T> > \ 00397 > expr_type; \ 00398 return XprVector<expr_type, Sz>( \ 00399 expr_type(lhs, XprLiteral< std::complex<T> >(rhs))); \ 00400 } \ 00401 \ 00402 template<class E, std::size_t Sz, class T> \ 00403 inline \ 00404 XprVector< \ 00405 XprBinOp< \ 00406 Fcnl_##NAME< std::complex<T>, typename E::value_type>, \ 00407 XprLiteral< std::complex<T> >, \ 00408 XprVector<E, Sz> \ 00409 >, \ 00410 Sz \ 00411 > \ 00412 NAME (const std::complex<T>& lhs, const XprVector<E, Sz>& rhs) { \ 00413 typedef XprBinOp< \ 00414 Fcnl_##NAME< std::complex<T>, typename E::value_type>, \ 00415 XprLiteral< std::complex<T> >, \ 00416 XprVector<E, Sz> \ 00417 > expr_type; \ 00418 return XprVector<expr_type, Sz>( \ 00419 expr_type(XprLiteral< std::complex<T> >(lhs), rhs)); \ 00420 } 00421 00422 TVMET_IMPLEMENT_MACRO(add) 00423 TVMET_IMPLEMENT_MACRO(sub) 00424 TVMET_IMPLEMENT_MACRO(mul) 00425 TVMET_IMPLEMENT_MACRO(div) 00426 00427 #undef TVMET_IMPLEMENT_MACRO 00428 00429 #endif // defined(TVMET_HAVE_COMPLEX) 00430 00431 00432 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 00433 * vector specific functions 00434 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 00435 00436 00437 /** 00438 * \fn sum(const XprVector<E, Sz>& v) 00439 * \brief Compute the sum of the vector expression. 00440 * \ingroup _unary_function 00441 * 00442 * Simply compute the sum of the given vector as: 00443 * \f[ 00444 * \sum_{i = 0}^{Sz-1} v[i] 00445 * \f] 00446 */ 00447 template<class E, std::size_t Sz> 00448 inline 00449 typename NumericTraits<typename E::value_type>::sum_type 00450 sum(const XprVector<E, Sz>& v) { 00451 return meta::Vector<Sz>::sum(v); 00452 } 00453 00454 00455 /** 00456 * \fn product(const XprVector<E, Sz>& v) 00457 * \brief Compute the product of the vector elements. 00458 * \ingroup _unary_function 00459 * 00460 * Simply computer the product of the given vector expression as: 00461 * \f[ 00462 * \prod_{i = 0}^{Sz - 1} v[i] 00463 * \f] 00464 */ 00465 template<class E, std::size_t Sz> 00466 inline 00467 typename NumericTraits<typename E::value_type>::sum_type 00468 product(const XprVector<E, Sz>& v) { 00469 return meta::Vector<Sz>::product(v); 00470 } 00471 00472 00473 /** 00474 * \fn dot(const XprVector<E1, Sz>& lhs, const XprVector<E2, Sz>& rhs) 00475 * \brief Compute the dot/inner product 00476 * \ingroup _binary_function 00477 * 00478 * Compute the dot product as: 00479 * \f[ 00480 * \sum_{i = 0}^{Sz - 1} ( lhs[i] * rhs[i] ) 00481 * \f] 00482 * where lhs is a column vector and rhs is a row vector, both vectors 00483 * have the same dimension. 00484 */ 00485 template<class E1, class E2, std::size_t Sz> 00486 inline 00487 typename PromoteTraits< 00488 typename E1::value_type, 00489 typename E2::value_type 00490 >::value_type 00491 dot(const XprVector<E1, Sz>& lhs, const XprVector<E2, Sz>& rhs) { 00492 return meta::Vector<Sz>::dot(lhs, rhs); 00493 } 00494 00495 00496 /** 00497 * \fn dot(const Vector<T, Sz>& lhs, const XprVector<E, Sz>& rhs) 00498 * \brief Compute the dot/inner product 00499 * \ingroup _binary_function 00500 * 00501 * Compute the dot product as: 00502 * \f[ 00503 * \sum_{i = 0}^{Sz - 1} ( lhs[i] * rhs[i] ) 00504 * \f] 00505 * where lhs is a column vector and rhs is a row vector, both vectors 00506 * have the same dimension. 00507 */ 00508 template<class T, class E, std::size_t Sz> 00509 inline 00510 typename PromoteTraits<T, typename E::value_type>::value_type 00511 dot(const Vector<T, Sz>& lhs, const XprVector<E, Sz>& rhs) { 00512 return meta::Vector<Sz>::dot(lhs, rhs); 00513 } 00514 00515 00516 /** 00517 * \fn dot(const XprVector<E, Sz>& lhs, const Vector<T, Sz>& rhs) 00518 * \brief Compute the dot/inner product 00519 * \ingroup _binary_function 00520 * 00521 * Compute the dot product as: 00522 * \f[ 00523 * \sum_{i = 0}^{Sz - 1} ( lhs[i] * rhs[i] ) 00524 * \f] 00525 * where lhs is a column vector and rhs is a row vector, both vectors 00526 * have the same dimension. 00527 */ 00528 template<class E, class T, std::size_t Sz> 00529 inline 00530 typename PromoteTraits<T, typename E::value_type>::value_type 00531 dot(const XprVector<E, Sz>& lhs, const Vector<T, Sz>& rhs) { 00532 return meta::Vector<Sz>::dot(lhs, rhs); 00533 } 00534 00535 00536 /** 00537 * \fn cross(const XprVector<E1, 3>& lhs, const XprVector<E2, 3>& rhs) 00538 * \brief Compute the cross/outer product 00539 * \ingroup _binary_function 00540 * \note working only for vectors of size = 3 00541 * \todo Implement vector outer product as ET and MT, returning a XprVector 00542 */ 00543 template<class E1, class E2> 00544 inline 00545 Vector< 00546 typename PromoteTraits< 00547 typename E1::value_type, 00548 typename E2::value_type 00549 >::value_type, 00550 3 00551 > 00552 cross(const XprVector<E1, 3>& lhs, const XprVector<E2, 3>& rhs) { 00553 typedef typename PromoteTraits< 00554 typename E1::value_type, 00555 typename E2::value_type 00556 >::value_type value_type; 00557 return Vector<value_type, 3>(lhs(1)*rhs(2) - rhs(1)*lhs(2), 00558 rhs(0)*lhs(2) - lhs(0)*rhs(2), 00559 lhs(0)*rhs(1) - rhs(0)*lhs(1)); 00560 } 00561 00562 00563 /** 00564 * \fn cross(const XprVector<E, 3>& lhs, const Vector<T, 3>& rhs) 00565 * \brief Compute the cross/outer product 00566 * \ingroup _binary_function 00567 * \note working only for vectors of size = 3 00568 * \todo Implement vector outer product as ET and MT, returning a XprVector 00569 */ 00570 template<class E, class T> 00571 inline 00572 Vector< 00573 typename PromoteTraits<T, typename E::value_type>::value_type, 3> 00574 cross(const XprVector<E, 3>& lhs, const Vector<T, 3>& rhs) { 00575 typedef typename PromoteTraits< 00576 typename E::value_type, T>::value_type value_type; 00577 return Vector<value_type, 3>(lhs(1)*rhs(2) - rhs(1)*lhs(2), 00578 rhs(0)*lhs(2) - lhs(0)*rhs(2), 00579 lhs(0)*rhs(1) - rhs(0)*lhs(1)); 00580 } 00581 00582 00583 /** 00584 * \fn cross(const Vector<T, 3>& lhs, const XprVector<E, 3>& rhs) 00585 * \brief Compute the cross/outer product 00586 * \ingroup _binary_function 00587 * \note working only for vectors of size = 3 00588 * \todo Implement vector outer product as ET and MT, returning a XprVector 00589 */ 00590 template<class T1, class E2> 00591 inline 00592 Vector< 00593 typename PromoteTraits<T1, typename E2::value_type>::value_type, 3> 00594 cross(const Vector<T1, 3>& lhs, const XprVector<E2, 3>& rhs) { 00595 typedef typename PromoteTraits< 00596 typename E2::value_type, T1>::value_type value_type; 00597 return Vector<value_type, 3>(lhs(1)*rhs(2) - rhs(1)*lhs(2), 00598 rhs(0)*lhs(2) - lhs(0)*rhs(2), 00599 lhs(0)*rhs(1) - rhs(0)*lhs(1)); 00600 } 00601 00602 00603 /** 00604 * \fn norm1(const XprVector<E, Sz>& v) 00605 * \brief The \f$l_1\f$ norm of a vector expression. 00606 * \ingroup _unary_function 00607 * The norm of any vector is just the square root of the dot product of 00608 * a vector with itself, or 00609 * 00610 * \f[ 00611 * |Vector<T, Sz> v| = |v| = \sum_{i=0}^{Sz-1}\,|v[i]| 00612 * \f] 00613 */ 00614 template<class E, std::size_t Sz> 00615 inline 00616 typename NumericTraits<typename E::value_type>::sum_type 00617 norm1(const XprVector<E, Sz>& v) { 00618 return sum(abs(v)); 00619 } 00620 00621 00622 /** 00623 * \fn norm2(const XprVector<E, Sz>& v) 00624 * \brief The euklidian norm (or \f$l_2\f$ norm) of a vector expression. 00625 * \ingroup _unary_function 00626 * The norm of any vector is just the square root of the dot product of 00627 * a vector with itself, or 00628 * 00629 * \f[ 00630 * |Vector<T, Sz> v| = |v| = \sqrt{ \sum_{i=0}^{Sz-1}\,v[i]^2 } 00631 * \f] 00632 * 00633 * \note The internal cast for Vector<int> avoids warnings on sqrt. 00634 */ 00635 template<class E, std::size_t Sz> 00636 inline 00637 typename NumericTraits<typename E::value_type>::sum_type 00638 norm2(const XprVector<E, Sz>& v) { 00639 typedef typename E::value_type value_type; 00640 return static_cast<value_type>( std::sqrt(static_cast<value_type>(dot(v, v))) ); 00641 } 00642 00643 00644 /** 00645 * \fn normalize(const XprVector<E, Sz>& v) 00646 * \brief Normalize the given vector expression. 00647 * \ingroup _unary_function 00648 * \sa norm2 00649 * 00650 * using the equation: 00651 * \f[ 00652 * \frac{Vector<T, Sz> v}{\sqrt{ \sum_{i=0}^{Sz-1}\,v[i]^2 }} 00653 * \f] 00654 */ 00655 template<class E, std::size_t Sz> 00656 inline 00657 XprVector< 00658 XprBinOp< 00659 Fcnl_div<typename E::value_type, typename E::value_type>, 00660 XprVector<E, Sz>, 00661 XprLiteral<typename E::value_type> 00662 >, 00663 Sz 00664 > 00665 normalize(const XprVector<E, Sz>& v) { 00666 typedef typename E::value_type value_type; 00667 typedef XprBinOp< 00668 Fcnl_div<value_type, value_type>, 00669 XprVector<E, Sz>, 00670 XprLiteral<value_type> 00671 > expr_type; 00672 return XprVector<expr_type, Sz>( 00673 expr_type(v, XprLiteral< value_type >(norm2(v)))); 00674 } 00675 00676 00677 } // namespace tvmet 00678 00679 #endif // TVMET_XPR_VECTOR_FUNCTIONS_H 00680 00681 // Local Variables: 00682 // mode:C++ 00683 // tab-width:8 00684 // End:
Generated on Wed Jul 13 2022 18:28:37 by
1.7.2