Shuto Naruse
/
Eurobot2012_Secondary
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Fork of
Eurobot_2012_Secondary
by 
Shuto Naruse
Embed:
(wiki syntax)
Show/hide line numbers
VectorEval.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: VectorEval.h,v 1.18 2007-06-23 15:58:58 opetzold Exp $ 00022 */ 00023 00024 #ifndef TVMET_VECTOR_EVAL_H 00025 #define TVMET_VECTOR_EVAL_H 00026 00027 namespace tvmet { 00028 00029 00030 /******************************************************************** 00031 * functions all_elements/any_elements 00032 ********************************************************************/ 00033 00034 00035 /** 00036 * \fn bool all_elements(const XprVector<E, Sz>& e) 00037 * \brief check on statements for all elements 00038 * \ingroup _unary_function 00039 * This is for use with boolean operators like 00040 * \par Example: 00041 * \code 00042 * all_elements(vector > 0) { 00043 * // true branch 00044 * } else { 00045 * // false branch 00046 * } 00047 * \endcode 00048 * \sa \ref compare 00049 */ 00050 template<class E, std::size_t Sz> 00051 inline 00052 bool all_elements(const XprVector<E, Sz>& e) { 00053 return meta::Vector<Sz>::all_elements(e); 00054 } 00055 00056 00057 /** 00058 * \fn bool any_elements(const XprVector<E, Sz>& e) 00059 * \brief check on statements for any elements 00060 * \ingroup _unary_function 00061 * This is for use with boolean operators like 00062 * \par Example: 00063 * \code 00064 * any_elements(vector > 0) { 00065 * // true branch 00066 * } else { 00067 * // false branch 00068 * } 00069 * \endcode 00070 * \sa \ref compare 00071 */ 00072 template<class E, std::size_t Sz> 00073 inline 00074 bool any_elements(const XprVector<E, Sz>& e) { 00075 return meta::Vector<Sz>::any_elements(e); 00076 } 00077 00078 00079 /* 00080 * trinary evaluation functions with vectors and xpr of 00081 * XprVector<E1, Sz> ? Vector<T2, Sz> : Vector<T3, Sz> 00082 * XprVector<E1, Sz> ? Vector<T2, Sz> : XprVector<E3, Sz> 00083 * XprVector<E1, Sz> ? XprVector<E2, Sz> : Vector<T3, Sz> 00084 * XprVector<E1, Sz> ? XprVector<E2, Sz> : XprVector<E3, Sz> 00085 */ 00086 00087 /** 00088 * eval(const XprVector<E1, Sz>& e1, const Vector<T2, Sz>& v2, const Vector<T3, Sz>& v3) 00089 * \brief Evals the vector expressions. 00090 * \ingroup _trinary_function 00091 * This eval is for the a?b:c syntax, since it's not allowed to overload 00092 * these operators. 00093 */ 00094 template<class E1, class T2, class T3, std::size_t Sz> 00095 inline 00096 XprVector< 00097 XprEval< 00098 XprVector<E1, Sz>, 00099 VectorConstReference<T2, Sz>, 00100 VectorConstReference<T3, Sz> 00101 >, 00102 Sz 00103 > 00104 eval(const XprVector<E1, Sz>& e1, const Vector<T2, Sz>& v2, const Vector<T3, Sz>& v3) { 00105 typedef XprEval< 00106 XprVector<E1, Sz>, 00107 VectorConstReference<T2, Sz>, 00108 VectorConstReference<T3, Sz> 00109 > expr_type; 00110 return XprVector<expr_type, Sz>( 00111 expr_type(e1, v2.const_ref(), v3.const_ref())); 00112 } 00113 00114 00115 /** 00116 * eval(const XprVector<E1, Sz>& e1, const Vector<T2, Sz>& v2, const XprVector<E3, Sz>& e3) 00117 * \brief Evals the vector expressions. 00118 * \ingroup _trinary_function 00119 * This eval is for the a?b:c syntax, since it's not allowed to overload 00120 * these operators. 00121 */ 00122 template<class E1, class T2, class E3, std::size_t Sz> 00123 inline 00124 XprVector< 00125 XprEval< 00126 XprVector<E1, Sz>, 00127 VectorConstReference<T2, Sz>, 00128 XprVector<E3, Sz> 00129 >, 00130 Sz 00131 > 00132 eval(const XprVector<E1, Sz>& e1, const Vector<T2, Sz>& v2, const XprVector<E3, Sz>& e3) { 00133 typedef XprEval< 00134 XprVector<E1, Sz>, 00135 VectorConstReference<T2, Sz>, 00136 XprVector<E3, Sz> 00137 > expr_type; 00138 return XprVector<expr_type, Sz>( 00139 expr_type(e1, v2.const_ref(), e3)); 00140 } 00141 00142 00143 /** 00144 * eval(const XprVector<E1, Sz>& e1, const XprVector<E2, Sz>& e2, const Vector<T3, Sz>& v3) 00145 * \brief Evals the vector expressions. 00146 * \ingroup _trinary_function 00147 * This eval is for the a?b:c syntax, since it's not allowed to overload 00148 * these operators. 00149 */ 00150 template<class E1, class E2, class T3, std::size_t Sz> 00151 inline 00152 XprVector< 00153 XprEval< 00154 XprVector<E1, Sz>, 00155 XprVector<E2, Sz>, 00156 VectorConstReference<T3, Sz> 00157 >, 00158 Sz 00159 > 00160 eval(const XprVector<E1, Sz>& e1, const XprVector<E2, Sz>& e2, const Vector<T3, Sz>& v3) { 00161 typedef XprEval< 00162 XprVector<E1, Sz>, 00163 XprVector<E2, Sz>, 00164 VectorConstReference<T3, Sz> 00165 > expr_type; 00166 return XprVector<expr_type, Sz>( 00167 expr_type(e1, e2, v3.const_ref())); 00168 } 00169 00170 00171 /** 00172 * eval(const XprVector<E1, Sz>& e1, const XprVector<E2, Sz>& e2, const XprVector<E3, Sz>& e3) 00173 * \brief Evals the vector expressions. 00174 * \ingroup _trinary_function 00175 * This eval is for the a?b:c syntax, since it's not allowed to overload 00176 * these operators. 00177 */ 00178 template<class E1, class E2, class E3, std::size_t Sz> 00179 inline 00180 XprVector< 00181 XprEval< 00182 XprVector<E1, Sz>, 00183 XprVector<E2, Sz>, 00184 XprVector<E3, Sz> 00185 >, 00186 Sz 00187 > 00188 eval(const XprVector<E1, Sz>& e1, const XprVector<E2, Sz>& e2, const XprVector<E3, Sz>& e3) { 00189 typedef XprEval< 00190 XprVector<E1, Sz>, 00191 XprVector<E2, Sz>, 00192 XprVector<E3, Sz> 00193 > expr_type; 00194 return XprVector<expr_type, Sz>(expr_type(e1, e2, e3)); 00195 } 00196 00197 00198 /* 00199 * trinary evaluation functions with vectors, xpr of and POD 00200 * 00201 * XprVector<E, Sz> ? POD1 : POD2 00202 * XprVector<E1, Sz> ? POD : XprVector<E3, Sz> 00203 * XprVector<E1, Sz> ? XprVector<E2, Sz> : POD 00204 */ 00205 #define TVMET_IMPLEMENT_MACRO(POD) \ 00206 template<class E, std::size_t Sz> \ 00207 inline \ 00208 XprVector< \ 00209 XprEval< \ 00210 XprVector<E, Sz>, \ 00211 XprLiteral< POD >, \ 00212 XprLiteral< POD > \ 00213 >, \ 00214 Sz \ 00215 > \ 00216 eval(const XprVector<E, Sz>& e, POD x2, POD x3) { \ 00217 typedef XprEval< \ 00218 XprVector<E, Sz>, \ 00219 XprLiteral< POD >, \ 00220 XprLiteral< POD > \ 00221 > expr_type; \ 00222 return XprVector<expr_type, Sz>( \ 00223 expr_type(e, XprLiteral< POD >(x2), XprLiteral< POD >(x3))); \ 00224 } \ 00225 \ 00226 template<class E1, class E3, std::size_t Sz> \ 00227 inline \ 00228 XprVector< \ 00229 XprEval< \ 00230 XprVector<E1, Sz>, \ 00231 XprLiteral< POD >, \ 00232 XprVector<E3, Sz> \ 00233 >, \ 00234 Sz \ 00235 > \ 00236 eval(const XprVector<E1, Sz>& e1, POD x2, const XprVector<E3, Sz>& e3) { \ 00237 typedef XprEval< \ 00238 XprVector<E1, Sz>, \ 00239 XprLiteral< POD >, \ 00240 XprVector<E3, Sz> \ 00241 > expr_type; \ 00242 return XprVector<expr_type, Sz>( \ 00243 expr_type(e1, XprLiteral< POD >(x2), e3)); \ 00244 } \ 00245 \ 00246 template<class E1, class E2, std::size_t Sz> \ 00247 inline \ 00248 XprVector< \ 00249 XprEval< \ 00250 XprVector<E1, Sz>, \ 00251 XprVector<E2, Sz>, \ 00252 XprLiteral< POD > \ 00253 >, \ 00254 Sz \ 00255 > \ 00256 eval(const XprVector<E1, Sz>& e1, const XprVector<E2, Sz>& e2, POD x3) { \ 00257 typedef XprEval< \ 00258 XprVector<E1, Sz>, \ 00259 XprVector<E2, Sz>, \ 00260 XprLiteral< POD > \ 00261 > expr_type; \ 00262 return XprVector<expr_type, Sz>( \ 00263 expr_type(e1, e2, XprLiteral< POD >(x3))); \ 00264 } 00265 00266 TVMET_IMPLEMENT_MACRO(int) 00267 00268 #if defined(TVMET_HAVE_LONG_LONG) 00269 TVMET_IMPLEMENT_MACRO(long long int) 00270 #endif // defined(TVMET_HAVE_LONG_LONG) 00271 00272 TVMET_IMPLEMENT_MACRO(float) 00273 TVMET_IMPLEMENT_MACRO(double) 00274 00275 #if defined(TVMET_HAVE_LONG_DOUBLE) 00276 TVMET_IMPLEMENT_MACRO(long double) 00277 #endif // defined(TVMET_HAVE_LONG_DOUBLE) 00278 00279 #undef TVMET_IMPLEMENT_MACRO 00280 00281 00282 /* 00283 * trinary evaluation functions with vectors, xpr of and complex<> types 00284 * 00285 * XprVector<E, Sz> e, std::complex<T> z2, std::complex<T> z3 00286 * XprVector<E1, Sz> e1, std::complex<T> z2, XprVector<E3, Sz> e3 00287 * XprVector<E1, Sz> e1, XprVector<E2, Sz> e2, std::complex<T> z3 00288 */ 00289 #if defined(TVMET_HAVE_COMPLEX) 00290 00291 00292 /** 00293 * eval(const XprVector<E, Sz>& e, std::complex<T> z2, std::complex<T> z3) 00294 * \brief Evals the vector expressions. 00295 * \ingroup _trinary_function 00296 * This eval is for the a?b:c syntax, since it's not allowed to overload 00297 * these operators. 00298 */ 00299 template<class E, std::size_t Sz, class T> 00300 inline 00301 XprVector< 00302 XprEval< 00303 XprVector<E, Sz>, 00304 XprLiteral< std::complex<T> >, 00305 XprLiteral< std::complex<T> > 00306 >, 00307 Sz 00308 > 00309 eval(const XprVector<E, Sz>& e, std::complex<T> z2, std::complex<T> z3) { 00310 typedef XprEval< 00311 XprVector<E, Sz>, 00312 XprLiteral< std::complex<T> >, 00313 XprLiteral< std::complex<T> > 00314 > expr_type; 00315 return XprVector<expr_type, Sz>( 00316 expr_type(e, XprLiteral< std::complex<T> >(z2), XprLiteral< std::complex<T> >(z3))); 00317 } 00318 00319 /** 00320 * eval(const XprVector<E1, Sz>& e1, std::complex<T> z2, const XprVector<E3, Sz>& e3) 00321 * \brief Evals the vector expressions. 00322 * \ingroup _trinary_function 00323 * This eval is for the a?b:c syntax, since it's not allowed to overload 00324 * these operators. 00325 */ 00326 template<class E1, class E3, std::size_t Sz, class T> 00327 inline 00328 XprVector< 00329 XprEval< 00330 XprVector<E1, Sz>, 00331 XprLiteral< std::complex<T> >, 00332 XprVector<E3, Sz> 00333 >, 00334 Sz 00335 > 00336 eval(const XprVector<E1, Sz>& e1, std::complex<T> z2, const XprVector<E3, Sz>& e3) { 00337 typedef XprEval< 00338 XprVector<E1, Sz>, 00339 XprLiteral< std::complex<T> >, 00340 XprVector<E3, Sz> 00341 > expr_type; 00342 return XprVector<expr_type, Sz>( 00343 expr_type(e1, XprLiteral< std::complex<T> >(z2), e3)); 00344 } 00345 00346 /** 00347 * eval(const XprVector<E1, Sz>& e1, const XprVector<E2, Sz>& e2, std::complex<T> z3) 00348 * \brief Evals the vector expressions. 00349 * \ingroup _trinary_function 00350 * This eval is for the a?b:c syntax, since it's not allowed to overload 00351 * these operators. 00352 */ 00353 template<class E1, class E2, std::size_t Sz, class T> 00354 inline 00355 XprVector< 00356 XprEval< 00357 XprVector<E1, Sz>, 00358 XprVector<E2, Sz>, 00359 XprLiteral< std::complex<T> > 00360 >, 00361 Sz 00362 > 00363 eval(const XprVector<E1, Sz>& e1, const XprVector<E2, Sz>& e2, std::complex<T> z3) { 00364 typedef XprEval< 00365 XprVector<E1, Sz>, 00366 XprVector<E2, Sz>, 00367 XprLiteral< std::complex<T> > 00368 > expr_type; 00369 return XprVector<expr_type, Sz>( 00370 expr_type(e1, e2, XprLiteral< std::complex<T> >(z3))); 00371 } 00372 #endif // defined(TVMET_HAVE_COMPLEX) 00373 00374 00375 } // namespace tvmet 00376 00377 #endif // TVMET_VECTOR_EVAL_H 00378 00379 // Local Variables: 00380 // mode:C++ 00381 // tab-width:8 00382 // End:
Generated on Tue Jul 12 2022 21:02:14 by
1.7.2