Tiny Vector Matrix library using Expression Templates

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 
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 
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 
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 
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 
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 
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 
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 
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 
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:
include/tvmet/VectorEval.h
