IPPL: src/AppTypes/TSVMetaAssign.h Source File

00001 // -*- C++ -*-
00002 /***************************************************************************
00003  *
00004  * The IPPL Framework
00005  * 
00006  *
00007  * Visit http://people.web.psi.ch/adelmann/ for more details
00008  *
00009  ***************************************************************************/
00010 
00011 #ifndef TSV_META_ASSIGN_H
00012 #define TSV_META_ASSIGN_H
00013 
00015 //
00016 // Definition of structs TSV_MetaAssign and TSV_MetaAssignScalar
00017 //
00019 
00020 template<class T1, class T2, class OP> struct TSV_MetaAssign {};
00021 template<class T1, class T2, class OP> struct TSV_MetaAssignScalar {};
00022 
00024 //
00025 // Specializations for Vektors of arbitrary size.
00026 //
00028 
00029 template<class T1, class T2, class OP, unsigned D>
00030 struct TSV_MetaAssign< Vektor<T1,D> , Vektor<T2,D> , OP >
00031 {
00032   inline static void
00033   apply( Vektor<T1,D>& lhs, const Vektor<T2,D>& rhs) {
00034     for (unsigned d=0; d<D; ++d)
00035       PETE_apply( OP(), lhs[d] , rhs[d]);
00036   }
00037 };
00038 
00039 template<class T1, class T2, class OP, unsigned D>
00040 struct TSV_MetaAssignScalar< Vektor<T1,D> , T2 , OP >
00041 {
00042   inline static void
00043   apply( Vektor<T1,D>& lhs, T2 rhs ) {
00044     for (unsigned d=0; d<D; ++d)
00045       PETE_apply( OP(), lhs[d] , rhs);
00046   }
00047 };
00048 
00050 //
00051 // Specializations for Vektors with D=1.
00052 //
00054 
00055 template<class T1, class T2, class OP>
00056 struct TSV_MetaAssign< Vektor<T1,1> , Vektor<T2,1> , OP >
00057 {
00058   inline static void
00059   apply( Vektor<T1,1>& lhs, const Vektor<T2,1>& rhs) {
00060     PETE_apply( OP(), lhs[0] , rhs[0] );
00061   }
00062 };
00063 
00064 template<class T1, class T2, class OP>
00065 struct TSV_MetaAssignScalar< Vektor<T1,1> , T2 , OP >
00066 {
00067   inline static void
00068   apply( Vektor<T1,1>& lhs, T2 rhs ) {
00069     PETE_apply( OP(), lhs[0] , rhs );
00070   }
00071 };
00072 
00074 //
00075 // Specializations for Vektors with D=2.
00076 //
00078 
00079 template<class T1, class T2, class OP>
00080 struct TSV_MetaAssign< Vektor<T1,2> , Vektor<T2,2> , OP >
00081 {
00082   inline static void
00083   apply( Vektor<T1,2>& lhs, const Vektor<T2,2>& rhs) {
00084     PETE_apply( OP(), lhs[0] , rhs[0] );
00085     PETE_apply( OP(), lhs[1] , rhs[1] );
00086   }
00087 };
00088 
00089 template<class T1, class T2, class OP>
00090 struct TSV_MetaAssignScalar< Vektor<T1,2> , T2 , OP >
00091 {
00092   inline static void
00093   apply( Vektor<T1,2>& lhs, T2 rhs ) {
00094     PETE_apply( OP(), lhs[0] , rhs );
00095     PETE_apply( OP(), lhs[1] , rhs );
00096   }
00097 };
00098 
00100 //
00101 // Specializations for Vektors with D=3.
00102 //
00104 
00105 template<class T1, class T2, class OP>
00106 struct TSV_MetaAssign< Vektor<T1,3> , Vektor<T2,3> , OP >
00107 {
00108   inline static void
00109   apply( Vektor<T1,3>& lhs, const Vektor<T2,3>& rhs) {
00110     PETE_apply( OP(), lhs[0] , rhs[0] );
00111     PETE_apply( OP(), lhs[1] , rhs[1] );
00112     PETE_apply( OP(), lhs[2] , rhs[2] );
00113   }
00114 };
00115 
00116 template<class T1, class T2, class OP>
00117 struct TSV_MetaAssignScalar< Vektor<T1,3> , T2 , OP >
00118 {
00119   inline static void
00120   apply( Vektor<T1,3>& lhs, T2 rhs ) {
00121     PETE_apply( OP(), lhs[0] , rhs );
00122     PETE_apply( OP(), lhs[1] , rhs );
00123     PETE_apply( OP(), lhs[2] , rhs );
00124   }
00125 };
00126 
00128 //
00129 // The default definitions for Tenzors of arbitrary size.
00130 //
00132 
00133 template<class T1, class T2, class OP, unsigned D>
00134 struct TSV_MetaAssign< Tenzor<T1,D> , Tenzor<T2,D> , OP >
00135 {
00136   inline static void
00137   apply( Tenzor<T1,D>& lhs, const Tenzor<T2,D>& rhs) {
00138     for (unsigned d=0; d<D*D; ++d)
00139       PETE_apply( OP(), lhs[d] , rhs[d]);
00140   }
00141 };
00142 
00143 template<class T1, class T2, class OP, unsigned D>
00144 struct TSV_MetaAssignScalar< Tenzor<T1,D> , T2 , OP >
00145 {
00146   inline static void
00147   apply( Tenzor<T1,D>& lhs, T2 rhs ) {
00148     for (unsigned d=0; d<D*D; ++d)
00149       PETE_apply( OP(), lhs[d] , rhs);
00150   }
00151 };
00152 
00154 //
00155 // Specializations for Tenzors with D=1.
00156 //
00158 
00159 template<class T1, class T2, class OP>
00160 struct TSV_MetaAssign< Tenzor<T1,1> , Tenzor<T2,1> , OP >
00161 {
00162   inline static void
00163   apply( Tenzor<T1,1>& lhs, const Tenzor<T2,1>& rhs) {
00164     PETE_apply( OP(), lhs[0] , rhs[0] );
00165   }
00166 };
00167 
00168 template<class T1, class T2, class OP>
00169 struct TSV_MetaAssignScalar< Tenzor<T1,1> , T2 , OP >
00170 {
00171   inline static void
00172   apply( Tenzor<T1,1>& lhs, T2 rhs ) {
00173     PETE_apply( OP(), lhs[0] , rhs );
00174   }
00175 };
00176 
00178 //
00179 // Specializations for Tenzors with D=2.
00180 //
00182 
00183 template<class T1, class T2, class OP>
00184 struct TSV_MetaAssign< Tenzor<T1,2> , Tenzor<T2,2> , OP >
00185 {
00186   inline static void
00187   apply( Tenzor<T1,2>& lhs, const Tenzor<T2,2>& rhs) {
00188     PETE_apply( OP(), lhs[0] , rhs[0] );
00189     PETE_apply( OP(), lhs[1] , rhs[1] );
00190     PETE_apply( OP(), lhs[2] , rhs[2] );
00191     PETE_apply( OP(), lhs[3] , rhs[3] );
00192   }
00193 };
00194 
00195 template<class T1, class T2, class OP>
00196 struct TSV_MetaAssignScalar< Tenzor<T1,2> , T2 , OP >
00197 {
00198   inline static void
00199   apply( Tenzor<T1,2>& lhs, T2 rhs ) {
00200     PETE_apply( OP(), lhs[0] , rhs );
00201     PETE_apply( OP(), lhs[1] , rhs );
00202     PETE_apply( OP(), lhs[2] , rhs );
00203     PETE_apply( OP(), lhs[3] , rhs );
00204   }
00205 };
00206 
00208 //
00209 // Specializations for Tenzors with D=3.
00210 //
00212 
00213 template<class T1, class T2, class OP>
00214 struct TSV_MetaAssign< Tenzor<T1,3> , Tenzor<T2,3> , OP >
00215 {
00216   inline static void
00217   apply( Tenzor<T1,3>& lhs, const Tenzor<T2,3>& rhs) {
00218     PETE_apply( OP(), lhs[0] , rhs[0] );
00219     PETE_apply( OP(), lhs[1] , rhs[1] );
00220     PETE_apply( OP(), lhs[2] , rhs[2] );
00221     PETE_apply( OP(), lhs[3] , rhs[3] );
00222     PETE_apply( OP(), lhs[4] , rhs[4] );
00223     PETE_apply( OP(), lhs[5] , rhs[5] );
00224     PETE_apply( OP(), lhs[6] , rhs[6] );
00225     PETE_apply( OP(), lhs[7] , rhs[7] );
00226     PETE_apply( OP(), lhs[8] , rhs[8] );
00227   }
00228 };
00229 
00230 template<class T1, class T2, class OP>
00231 struct TSV_MetaAssignScalar< Tenzor<T1,3> , T2 , OP >
00232 {
00233   inline static void
00234   apply( Tenzor<T1,3>& lhs, T2 rhs ) {
00235     PETE_apply( OP(), lhs[0] , rhs );
00236     PETE_apply( OP(), lhs[1] , rhs );
00237     PETE_apply( OP(), lhs[2] , rhs );
00238     PETE_apply( OP(), lhs[3] , rhs );
00239     PETE_apply( OP(), lhs[4] , rhs );
00240     PETE_apply( OP(), lhs[5] , rhs );
00241     PETE_apply( OP(), lhs[6] , rhs );
00242     PETE_apply( OP(), lhs[7] , rhs );
00243     PETE_apply( OP(), lhs[8] , rhs );
00244   }
00245 };
00246 
00248 //
00249 // The default definitions for SymTenzors of arbitrary size.
00250 //
00252 
00253 template<class T1, class T2, class OP, unsigned D>
00254 struct TSV_MetaAssign< SymTenzor<T1,D> , SymTenzor<T2,D> , OP >
00255 {
00256   inline static void
00257   apply( SymTenzor<T1,D>& lhs, const SymTenzor<T2,D>& rhs) {
00258     for (unsigned d=0; d<D*(D+1)/2; ++d)
00259       PETE_apply( OP(), lhs[d] , rhs[d]);
00260   }
00261 };
00262 
00263 template<class T1, class T2, class OP, unsigned D>
00264 struct TSV_MetaAssignScalar< SymTenzor<T1,D> , T2 , OP >
00265 {
00266   inline static void
00267   apply( SymTenzor<T1,D>& lhs, T2 rhs ) {
00268     for (unsigned d=0; d<D*(D+1)/2; ++d)
00269       PETE_apply( OP(), lhs[d] , rhs);
00270   }
00271 };
00272 
00274 //
00275 // Specializations for SymTenzors with D=1.
00276 //
00278 
00279 template<class T1, class T2, class OP>
00280 struct TSV_MetaAssign< SymTenzor<T1,1> , SymTenzor<T2,1> , OP >
00281 {
00282   inline static void
00283   apply( SymTenzor<T1,1>& lhs, const SymTenzor<T2,1>& rhs) {
00284     PETE_apply( OP(), lhs[0] , rhs[0] );
00285   }
00286 };
00287 
00288 template<class T1, class T2, class OP>
00289 struct TSV_MetaAssignScalar< SymTenzor<T1,1> , T2 , OP >
00290 {
00291   inline static void
00292   apply( SymTenzor<T1,1>& lhs, T2 rhs ) {
00293     PETE_apply( OP(), lhs[0] , rhs );
00294   }
00295 };
00296 
00298 //
00299 // Specializations for SymTenzors with D=2.
00300 //
00302 
00303 template<class T1, class T2, class OP>
00304 struct TSV_MetaAssign< SymTenzor<T1,2> , SymTenzor<T2,2> , OP >
00305 {
00306   inline static void
00307   apply( SymTenzor<T1,2>& lhs, const SymTenzor<T2,2>& rhs) {
00308     PETE_apply( OP(), lhs[0] , rhs[0] );
00309     PETE_apply( OP(), lhs[1] , rhs[1] );
00310     PETE_apply( OP(), lhs[2] , rhs[2] );
00311   }
00312 };
00313 
00314 template<class T1, class T2, class OP>
00315 struct TSV_MetaAssignScalar< SymTenzor<T1,2> , T2 , OP >
00316 {
00317   inline static void
00318   apply( SymTenzor<T1,2>& lhs, T2 rhs ) {
00319     PETE_apply( OP(), lhs[0] , rhs );
00320     PETE_apply( OP(), lhs[1] , rhs );
00321     PETE_apply( OP(), lhs[2] , rhs );
00322   }
00323 };
00324 
00326 //
00327 // Specializations for SymTenzors with D=3.
00328 //
00330 
00331 template<class T1, class T2, class OP>
00332 struct TSV_MetaAssign< SymTenzor<T1,3> , SymTenzor<T2,3> , OP >
00333 {
00334   inline static void
00335   apply( SymTenzor<T1,3>& lhs, const SymTenzor<T2,3>& rhs) {
00336     PETE_apply( OP(), lhs[0] , rhs[0] );
00337     PETE_apply( OP(), lhs[1] , rhs[1] );
00338     PETE_apply( OP(), lhs[2] , rhs[2] );
00339     PETE_apply( OP(), lhs[3] , rhs[3] );
00340     PETE_apply( OP(), lhs[4] , rhs[4] );
00341     PETE_apply( OP(), lhs[5] , rhs[5] );
00342   }
00343 };
00344 
00345 template<class T1, class T2, class OP>
00346 struct TSV_MetaAssignScalar< SymTenzor<T1,3> , T2 , OP >
00347 {
00348   inline static void
00349   apply( SymTenzor<T1,3>& lhs, T2 rhs ) {
00350     PETE_apply( OP(), lhs[0] , rhs );
00351     PETE_apply( OP(), lhs[1] , rhs );
00352     PETE_apply( OP(), lhs[2] , rhs );
00353     PETE_apply( OP(), lhs[3] , rhs );
00354     PETE_apply( OP(), lhs[4] , rhs );
00355     PETE_apply( OP(), lhs[5] , rhs );
00356   }
00357 };
00358 
00360 //
00361 // The default definitions for AntiSymTenzors of arbitrary size.
00362 //
00364 
00365 template<class T1, class T2, class OP, unsigned D>
00366 struct TSV_MetaAssign< AntiSymTenzor<T1,D> , AntiSymTenzor<T2,D> , OP >
00367 {
00368   inline static void
00369   apply( AntiSymTenzor<T1,D>& lhs, const AntiSymTenzor<T2,D>& rhs) {
00370     for (unsigned d=0; d<D*(D-1)/2; ++d)
00371       PETE_apply( OP(), lhs[d] , rhs[d]);
00372   }
00373 };
00374 
00375 template<class T1, class T2, class OP, unsigned D>
00376 struct TSV_MetaAssignScalar< AntiSymTenzor<T1,D> , T2 , OP >
00377 {
00378   inline static void
00379   apply( AntiSymTenzor<T1,D>& lhs, T2 rhs ) {
00380     for (unsigned d=0; d<D*(D-1)/2; ++d)
00381       PETE_apply( OP(), lhs[d] , rhs);
00382   }
00383 };
00384 
00386 //
00387 // Specializations for AntiSymTenzors with D=1.
00388 //
00390 
00391 template<class T1, class T2, class OP>
00392 struct TSV_MetaAssign< AntiSymTenzor<T1,1> , AntiSymTenzor<T2,1> , OP >
00393 {
00394   inline static void
00395   apply( AntiSymTenzor<T1,1>& lhs, const AntiSymTenzor<T2,1>& rhs) {
00396   }
00397 };
00398 
00399 template<class T1, class T2, class OP>
00400 struct TSV_MetaAssignScalar< AntiSymTenzor<T1,1> , T2 , OP >
00401 {
00402   inline static void
00403   apply( AntiSymTenzor<T1,1>& lhs, T2 rhs ) {
00404   }
00405 };
00406 
00408 //
00409 // Specializations for AntiSymTenzors with D=2.
00410 //
00412 
00413 template<class T1, class T2, class OP>
00414 struct TSV_MetaAssign< AntiSymTenzor<T1,2> , AntiSymTenzor<T2,2> , OP >
00415 {
00416   inline static void
00417   apply( AntiSymTenzor<T1,2>& lhs, const AntiSymTenzor<T2,2>& rhs) {
00418     PETE_apply( OP(), lhs[0] , rhs[0] );
00419   }
00420 };
00421 
00422 template<class T1, class T2, class OP>
00423 struct TSV_MetaAssignScalar< AntiSymTenzor<T1,2> , T2 , OP >
00424 {
00425   inline static void
00426   apply( AntiSymTenzor<T1,2>& lhs, T2 rhs ) {
00427     PETE_apply( OP(), lhs[0] , rhs );
00428   }
00429 };
00430 
00432 //
00433 // Specializations for AntiSymTenzors with D=3.
00434 //
00436 
00437 template<class T1, class T2, class OP>
00438 struct TSV_MetaAssign< AntiSymTenzor<T1,3> , AntiSymTenzor<T2,3> , OP >
00439 {
00440   inline static void
00441   apply( AntiSymTenzor<T1,3>& lhs, const AntiSymTenzor<T2,3>& rhs) {
00442     PETE_apply( OP(), lhs[0] , rhs[0] );
00443     PETE_apply( OP(), lhs[1] , rhs[1] );
00444     PETE_apply( OP(), lhs[2] , rhs[2] );
00445   }
00446 };
00447 
00448 template<class T1, class T2, class OP>
00449 struct TSV_MetaAssignScalar< AntiSymTenzor<T1,3> , T2 , OP >
00450 {
00451   inline static void
00452   apply( AntiSymTenzor<T1,3>& lhs, T2 rhs ) {
00453     PETE_apply( OP(), lhs[0] , rhs );
00454     PETE_apply( OP(), lhs[1] , rhs );
00455     PETE_apply( OP(), lhs[2] , rhs );
00456   }
00457 };
00458 
00460 
00461 #endif // TSV_META_ASSIGN_H
00462 
00463 /***************************************************************************
00464  * $RCSfile: TSVMetaAssign.h,v $   $Author: adelmann $
00465  * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:24 $
00466  * IPPL_VERSION_ID: $Id: TSVMetaAssign.h,v 1.1.1.1 2003/01/23 07:40:24 adelmann Exp $ 
00467  ***************************************************************************/
00468