OPAL (Object Oriented Parallel Accelerator Library)  2.2.0
OPAL
TSVMetaBinary.h
Go to the documentation of this file.
1 // -*- C++ -*-
2 /***************************************************************************
3  *
4  * The IPPL Framework
5  *
6  *
7  * Visit http://people.web.psi.ch/adelmann/ for more details
8  *
9  ***************************************************************************/
10 
11 #ifndef TSV_META_BINARY_H
12 #define TSV_META_BINARY_H
13 
15 //
16 // Definition of structs TSV_MetaBinary and TSV_MetaBinaryScalar
17 //
19 
20 template<class T1, class T2, class OP> struct TSV_MetaBinary {};
21 template<class T1, class T2, class OP> struct TSV_MetaBinaryScalar {};
22 
24 //
25 // Specializations for Vektors of arbitrary size.
26 //
28 
29 template<class T1, class T2, class OP, unsigned D>
30 struct TSV_MetaBinary< Vektor<T1,D> , Vektor<T2,D> , OP >
31 {
32  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
33  inline static Vektor<T0,D>
34  apply(const Vektor<T1,D>& lhs, const Vektor<T2,D>& rhs) {
35  Vektor<T0,D> ret;
36  for (unsigned d=0; d<D; ++d)
37  ret[d] = PETE_apply(OP(),lhs[d] , rhs[d]);
38  return ret;
39  }
40 };
41 
42 template<class T1, class T2, class OP, unsigned D>
43 struct TSV_MetaBinaryScalar< Vektor<T1,D> , T2 , OP >
44 {
45  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
46  inline static Vektor<T0,D>
47  apply(const Vektor<T1,D>& lhs, T2 rhs) {
48  Vektor<T0,D> ret;
49  for (unsigned d=0; d<D; ++d)
50  ret[d] = PETE_apply( OP(), lhs[d] , rhs );
51  return ret;
52  }
53 };
54 
55 template<class T1, class T2, class OP, unsigned D>
56 struct TSV_MetaBinaryScalar< T1, Vektor<T2,D> , OP >
57 {
58  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
59  inline static Vektor<T0,D>
60  apply(T1 lhs, const Vektor<T2,D>& rhs) {
61  Vektor<T0,D> ret;
62  for (unsigned d=0; d<D; ++d)
63  ret[d] = PETE_apply( OP(), lhs , rhs[d]);
64  return ret;
65  }
66 };
67 
69 //
70 // Specializations of TSV_MetaBinary for Vektors with D=1.
71 //
73 
74 template<class T1, class T2, class OP>
75 struct TSV_MetaBinary< Vektor<T1,1> , Vektor<T2,1> , OP >
76 {
77  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
78  inline static Vektor<T0,1>
79  apply(const Vektor<T1,1>& lhs, const Vektor<T2,1>& rhs) {
80  return Vektor<T0,1>( PETE_apply( OP(), lhs[0], rhs[0] ) );
81  }
82 };
83 
84 template<class T1, class T2, class OP>
85 struct TSV_MetaBinaryScalar< Vektor<T1,1> , T2 , OP >
86 {
87  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
88  inline static Vektor<T0,1>
89  apply(const Vektor<T1,1>& lhs, T2 rhs) {
90  return Vektor<T0,1>( PETE_apply( OP(), lhs[0], rhs ) );
91  }
92 };
93 
94 template<class T1, class T2, class OP>
95 struct TSV_MetaBinaryScalar< T1, Vektor<T2,1> , OP >
96 {
97  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
98  inline static Vektor<T0,1>
99  apply(T1 lhs, const Vektor<T2,1>& rhs) {
100  return Vektor<T0,1>( PETE_apply( OP(), lhs, rhs[0] ) );
101  }
102 };
103 
105 //
106 // Specializations of TSV_MetaBinary for Vektors with D=2.
107 //
109 
110 template<class T1, class T2, class OP>
111 struct TSV_MetaBinary< Vektor<T1,2> , Vektor<T2,2> , OP >
112 {
113  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
114  inline static Vektor<T0,2>
115  apply(const Vektor<T1,2>& lhs, const Vektor<T2,2>& rhs) {
116  return Vektor<T0,2>( PETE_apply( OP(), lhs[0], rhs[0] ) ,
117  PETE_apply( OP(), lhs[1], rhs[1] ) );
118  }
119 };
120 
121 template<class T1, class T2, class OP>
122 struct TSV_MetaBinaryScalar< Vektor<T1,2> , T2 , OP >
123 {
124  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
125  inline static Vektor<T0,2>
126  apply(const Vektor<T1,2>& lhs, T2 rhs) {
127  return Vektor<T0,2>( PETE_apply( OP(), lhs[0], rhs ) ,
128  PETE_apply( OP(), lhs[1], rhs ) );
129  }
130 };
131 
132 template<class T1, class T2, class OP>
133 struct TSV_MetaBinaryScalar< T1, Vektor<T2,2> , OP >
134 {
135  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
136  inline static Vektor<T0,2>
137  apply(T1 lhs, const Vektor<T2,2>& rhs) {
138  return Vektor<T0,2>( PETE_apply( OP(), lhs, rhs[0] ) ,
139  PETE_apply( OP(), lhs, rhs[1] ) );
140  }
141 };
142 
144 //
145 // Specializations of TSV_MetaBinary for Vektors with D=3.
146 //
148 
149 template<class T1, class T2, class OP>
150 struct TSV_MetaBinary< Vektor<T1,3> , Vektor<T2,3> , OP >
151 {
152  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
153  inline static Vektor<T0,3>
154  apply(const Vektor<T1,3>& lhs, const Vektor<T2,3>& rhs) {
155  return Vektor<T0,3>( PETE_apply( OP(), lhs[0], rhs[0] ) ,
156  PETE_apply( OP(), lhs[1], rhs[1] ) ,
157  PETE_apply( OP(), lhs[2], rhs[2] ) );
158  }
159 };
160 
161 template<class T1, class T2, class OP>
162 struct TSV_MetaBinaryScalar< Vektor<T1,3> , T2 , OP >
163 {
164  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
165  inline static Vektor<T0,3>
166  apply(const Vektor<T1,3>& lhs, T2 rhs) {
167  return Vektor<T0,3>( PETE_apply( OP(), lhs[0], rhs ) ,
168  PETE_apply( OP(), lhs[1], rhs ) ,
169  PETE_apply( OP(), lhs[2], rhs ) );
170  }
171 };
172 
173 template<class T1, class T2, class OP>
174 struct TSV_MetaBinaryScalar< T1, Vektor<T2,3> , OP >
175 {
176  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
177  inline static Vektor<T0,3>
178  apply(T1 lhs, const Vektor<T2,3>& rhs) {
179  return Vektor<T0,3>( PETE_apply( OP(), lhs, rhs[0] ) ,
180  PETE_apply( OP(), lhs, rhs[1] ) ,
181  PETE_apply( OP(), lhs, rhs[2] ) );
182  }
183 };
184 
186 //
187 // Specializations for Tenzors of arbitrary size.
188 //
190 
191 template<class T1, class T2, class OP, unsigned D>
192 struct TSV_MetaBinary< Tenzor<T1,D> , Tenzor<T2,D> , OP >
193 {
194  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
195  inline static Tenzor<T0,D>
196  apply(const Tenzor<T1,D>& lhs, const Tenzor<T2,D>& rhs) {
197  Tenzor<T0,D> ret;
198  for (unsigned d=0; d<D*D; ++d)
199  ret[d] = PETE_apply(OP(),lhs[d] , rhs[d]);
200  return ret;
201  }
202 };
203 
204 template<class T1, class T2, class OP, unsigned D>
205 struct TSV_MetaBinaryScalar< Tenzor<T1,D> , T2 , OP >
206 {
207  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
208  inline static Tenzor<T0,D>
209  apply(const Tenzor<T1,D>& lhs, T2 rhs) {
210  Tenzor<T0,D> ret;
211  for (unsigned d=0; d<D*D; ++d)
212  ret[d] = PETE_apply( OP(), lhs[d] , rhs );
213  return ret;
214  }
215 };
216 
217 template<class T1, class T2, class OP, unsigned D>
218 struct TSV_MetaBinaryScalar< T1, Tenzor<T2,D> , OP >
219 {
220  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
221  inline static Tenzor<T0,D>
222  apply(T1 lhs, const Tenzor<T2,D>& rhs) {
223  Tenzor<T0,D> ret;
224  for (unsigned d=0; d<D*D; ++d)
225  ret[d] = PETE_apply( OP(), lhs , rhs[d]);
226  return ret;
227  }
228 };
229 
231 //
232 // Specializations of TSV_MetaBinary for Tenzors with D=1.
233 //
235 
236 template<class T1, class T2, class OP>
237 struct TSV_MetaBinary< Tenzor<T1,1> , Tenzor<T2,1> , OP >
238 {
239  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
240  inline static Tenzor<T0,1>
241  apply(const Tenzor<T1,1>& lhs, const Tenzor<T2,1>& rhs) {
242  return Tenzor<T0,1>( PETE_apply( OP(), lhs[0], rhs[0] ) );
243  }
244 };
245 
246 template<class T1, class T2, class OP>
247 struct TSV_MetaBinaryScalar< Tenzor<T1,1> , T2 , OP >
248 {
249  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
250  inline static Tenzor<T0,1>
251  apply(const Tenzor<T1,1>& lhs, T2 rhs) {
252  return Tenzor<T0,1>( PETE_apply( OP(), lhs[0], rhs ) );
253  }
254 };
255 
256 template<class T1, class T2, class OP>
257 struct TSV_MetaBinaryScalar< T1, Tenzor<T2,1> , OP >
258 {
259  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
260  inline static Tenzor<T0,1>
261  apply(T1 lhs, const Tenzor<T2,1>& rhs) {
262  return Tenzor<T0,1>( PETE_apply( OP(), lhs, rhs[0] ) );
263  }
264 };
265 
267 //
268 // Specializations of TSV_MetaBinary for Tenzors with D=2.
269 //
271 
272 template<class T1, class T2, class OP>
273 struct TSV_MetaBinary< Tenzor<T1,2> , Tenzor<T2,2> , OP >
274 {
275  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
276  inline static Tenzor<T0,2>
277  apply(const Tenzor<T1,2>& lhs, const Tenzor<T2,2>& rhs) {
278  return Tenzor<T0,2>( PETE_apply( OP(), lhs[0], rhs[0] ) ,
279  PETE_apply( OP(), lhs[1], rhs[1] ) ,
280  PETE_apply( OP(), lhs[2], rhs[2] ) ,
281  PETE_apply( OP(), lhs[3], rhs[3] ) );
282  }
283 };
284 
285 template<class T1, class T2, class OP>
286 struct TSV_MetaBinaryScalar< Tenzor<T1,2> , T2 , OP >
287 {
288  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
289  inline static Tenzor<T0,2>
290  apply(const Tenzor<T1,2>& lhs, T2 rhs) {
291  return Tenzor<T0,2>( PETE_apply( OP(), lhs[0], rhs ) ,
292  PETE_apply( OP(), lhs[1], rhs ) ,
293  PETE_apply( OP(), lhs[2], rhs ) ,
294  PETE_apply( OP(), lhs[3], rhs ) );
295  }
296 };
297 
298 template<class T1, class T2, class OP>
299 struct TSV_MetaBinaryScalar< T1, Tenzor<T2,2> , OP >
300 {
301  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
302  inline static Tenzor<T0,2>
303  apply(T1 lhs, const Tenzor<T2,2>& rhs) {
304  return Tenzor<T0,2>( PETE_apply( OP(), lhs, rhs[0] ) ,
305  PETE_apply( OP(), lhs, rhs[1] ) ,
306  PETE_apply( OP(), lhs, rhs[2] ) ,
307  PETE_apply( OP(), lhs, rhs[3] ) );
308  }
309 };
310 
312 //
313 // Specializations of TSV_MetaBinary for Tenzors with D=3.
314 //
316 
317 template<class T1, class T2, class OP>
318 struct TSV_MetaBinary< Tenzor<T1,3> , Tenzor<T2,3> , OP >
319 {
320  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
321  inline static Tenzor<T0,3>
322  apply(const Tenzor<T1,3>& lhs, const Tenzor<T2,3>& rhs) {
323  return Tenzor<T0,3>( PETE_apply( OP(), lhs[0], rhs[0] ) ,
324  PETE_apply( OP(), lhs[1], rhs[1] ) ,
325  PETE_apply( OP(), lhs[2], rhs[2] ) ,
326  PETE_apply( OP(), lhs[3], rhs[3] ) ,
327  PETE_apply( OP(), lhs[4], rhs[4] ) ,
328  PETE_apply( OP(), lhs[5], rhs[5] ) ,
329  PETE_apply( OP(), lhs[6], rhs[6] ) ,
330  PETE_apply( OP(), lhs[7], rhs[7] ) ,
331  PETE_apply( OP(), lhs[8], rhs[8] ) );
332  }
333 };
334 
335 template<class T1, class T2, class OP>
336 struct TSV_MetaBinaryScalar< Tenzor<T1,3> , T2 , OP >
337 {
338  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
339  inline static Tenzor<T0,3>
340  apply(const Tenzor<T1,3>& lhs, T2 rhs) {
341  return Tenzor<T0,3>( PETE_apply( OP(), lhs[0], rhs ) ,
342  PETE_apply( OP(), lhs[1], rhs ) ,
343  PETE_apply( OP(), lhs[2], rhs ) ,
344  PETE_apply( OP(), lhs[3], rhs ) ,
345  PETE_apply( OP(), lhs[4], rhs ) ,
346  PETE_apply( OP(), lhs[5], rhs ) ,
347  PETE_apply( OP(), lhs[6], rhs ) ,
348  PETE_apply( OP(), lhs[7], rhs ) ,
349  PETE_apply( OP(), lhs[8], rhs ) );
350  }
351 };
352 
353 template<class T1, class T2, class OP>
354 struct TSV_MetaBinaryScalar< T1, Tenzor<T2,3> , OP >
355 {
356  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
357  inline static Tenzor<T0,3>
358  apply(T1 lhs, const Tenzor<T2,3>& rhs) {
359  return Tenzor<T0,3>( PETE_apply( OP(), lhs, rhs[0] ) ,
360  PETE_apply( OP(), lhs, rhs[1] ) ,
361  PETE_apply( OP(), lhs, rhs[2] ) ,
362  PETE_apply( OP(), lhs, rhs[3] ) ,
363  PETE_apply( OP(), lhs, rhs[4] ) ,
364  PETE_apply( OP(), lhs, rhs[5] ) ,
365  PETE_apply( OP(), lhs, rhs[6] ) ,
366  PETE_apply( OP(), lhs, rhs[7] ) ,
367  PETE_apply( OP(), lhs, rhs[8] ) );
368  }
369 };
370 
372 //
373 // Specializations for SymTenzors of arbitrary size.
374 //
376 
377 template<class T1, class T2, class OP, unsigned D>
378 struct TSV_MetaBinary< SymTenzor<T1,D> , SymTenzor<T2,D> , OP >
379 {
380  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
381  inline static SymTenzor<T0,D>
382  apply(const SymTenzor<T1,D>& lhs, const SymTenzor<T2,D>& rhs) {
383  SymTenzor<T0,D> ret;
384  for (unsigned d=0; d<D*(D+1)/2; ++d)
385  ret[d] = PETE_apply(OP(),lhs[d] , rhs[d]);
386  return ret;
387  }
388 };
389 
390 template<class T1, class T2, class OP, unsigned D>
391 struct TSV_MetaBinaryScalar< SymTenzor<T1,D> , T2 , OP >
392 {
393  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
394  inline static SymTenzor<T0,D>
395  apply(const SymTenzor<T1,D>& lhs, T2 rhs) {
396  SymTenzor<T0,D> ret;
397  for (unsigned d=0; d<D*(D+1)/2; ++d)
398  ret[d] = PETE_apply( OP(), lhs[d] , rhs );
399  return ret;
400  }
401 };
402 
403 template<class T1, class T2, class OP, unsigned D>
404 struct TSV_MetaBinaryScalar< T1, SymTenzor<T2,D> , OP >
405 {
406  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
407  inline static SymTenzor<T0,D>
408  apply(T1 lhs, const SymTenzor<T2,D>& rhs) {
409  SymTenzor<T0,D> ret;
410  for (unsigned d=0; d<D*(D+1)/2; ++d)
411  ret[d] = PETE_apply( OP(), lhs , rhs[d]);
412  return ret;
413  }
414 };
415 
417 //
418 // Specializations of TSV_MetaBinary for SymTenzors with D=1.
419 //
421 
422 template<class T1, class T2, class OP>
423 struct TSV_MetaBinary< SymTenzor<T1,1> , SymTenzor<T2,1> , OP >
424 {
425  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
426  inline static SymTenzor<T0,1>
427  apply(const SymTenzor<T1,1>& lhs, const SymTenzor<T2,1>& rhs) {
428  return SymTenzor<T0,1>( PETE_apply( OP(), lhs[0], rhs[0] ) );
429  }
430 };
431 
432 template<class T1, class T2, class OP>
433 struct TSV_MetaBinaryScalar< SymTenzor<T1,1> , T2 , OP >
434 {
435  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
436  inline static SymTenzor<T0,1>
437  apply(const SymTenzor<T1,1>& lhs, T2 rhs) {
438  return SymTenzor<T0,1>( PETE_apply( OP(), lhs[0], rhs ) );
439  }
440 };
441 
442 template<class T1, class T2, class OP>
443 struct TSV_MetaBinaryScalar< T1, SymTenzor<T2,1> , OP >
444 {
445  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
446  inline static SymTenzor<T0,1>
447  apply(T1 lhs, const SymTenzor<T2,1>& rhs) {
448  return SymTenzor<T0,1>( PETE_apply( OP(), lhs, rhs[0] ) );
449  }
450 };
451 
453 //
454 // Specializations of TSV_MetaBinary for SymTenzors with D=2.
455 //
457 
458 template<class T1, class T2, class OP>
459 struct TSV_MetaBinary< SymTenzor<T1,2> , SymTenzor<T2,2> , OP >
460 {
461  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
462  inline static SymTenzor<T0,2>
463  apply(const SymTenzor<T1,2>& lhs, const SymTenzor<T2,2>& rhs) {
464  return SymTenzor<T0,2>( PETE_apply( OP(), lhs[0], rhs[0] ) ,
465  PETE_apply( OP(), lhs[1], rhs[1] ) ,
466  PETE_apply( OP(), lhs[2], rhs[2] ) );
467  }
468 };
469 
470 template<class T1, class T2, class OP>
471 struct TSV_MetaBinaryScalar< SymTenzor<T1,2> , T2 , OP >
472 {
473  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
474  inline static SymTenzor<T0,2>
475  apply(const SymTenzor<T1,2>& lhs, T2 rhs) {
476  return SymTenzor<T0,2>( PETE_apply( OP(), lhs[0], rhs ) ,
477  PETE_apply( OP(), lhs[1], rhs ) ,
478  PETE_apply( OP(), lhs[2], rhs ) );
479  }
480 };
481 
482 template<class T1, class T2, class OP>
483 struct TSV_MetaBinaryScalar< T1, SymTenzor<T2,2> , OP >
484 {
485  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
486  inline static SymTenzor<T0,2>
487  apply(T1 lhs, const SymTenzor<T2,2>& rhs) {
488  return SymTenzor<T0,2>( PETE_apply( OP(), lhs, rhs[0] ) ,
489  PETE_apply( OP(), lhs, rhs[1] ) ,
490  PETE_apply( OP(), lhs, rhs[2] ) );
491  }
492 };
493 
495 //
496 // Specializations of TSV_MetaBinary for SymTenzors with D=3.
497 //
499 
500 template<class T1, class T2, class OP>
501 struct TSV_MetaBinary< SymTenzor<T1,3> , SymTenzor<T2,3> , OP >
502 {
503  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
504  inline static SymTenzor<T0,3>
505  apply(const SymTenzor<T1,3>& lhs, const SymTenzor<T2,3>& rhs) {
506  return SymTenzor<T0,3>( PETE_apply( OP(), lhs[0], rhs[0] ) ,
507  PETE_apply( OP(), lhs[1], rhs[1] ) ,
508  PETE_apply( OP(), lhs[2], rhs[2] ) ,
509  PETE_apply( OP(), lhs[3], rhs[3] ) ,
510  PETE_apply( OP(), lhs[4], rhs[4] ) ,
511  PETE_apply( OP(), lhs[5], rhs[5] ) );
512  }
513 };
514 
515 template<class T1, class T2, class OP>
516 struct TSV_MetaBinaryScalar< SymTenzor<T1,3> , T2 , OP >
517 {
518  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
519  inline static SymTenzor<T0,3>
520  apply(const SymTenzor<T1,3>& lhs, T2 rhs) {
521  return SymTenzor<T0,3>( PETE_apply( OP(), lhs[0], rhs ) ,
522  PETE_apply( OP(), lhs[1], rhs ) ,
523  PETE_apply( OP(), lhs[2], rhs ) ,
524  PETE_apply( OP(), lhs[3], rhs ) ,
525  PETE_apply( OP(), lhs[4], rhs ) ,
526  PETE_apply( OP(), lhs[5], rhs ) );
527  }
528 };
529 
530 template<class T1, class T2, class OP>
531 struct TSV_MetaBinaryScalar< T1, SymTenzor<T2,3> , OP >
532 {
533  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
534  inline static SymTenzor<T0,3>
535  apply(T1 lhs, const SymTenzor<T2,3>& rhs) {
536  return SymTenzor<T0,3>( PETE_apply( OP(), lhs, rhs[0] ) ,
537  PETE_apply( OP(), lhs, rhs[1] ) ,
538  PETE_apply( OP(), lhs, rhs[2] ) ,
539  PETE_apply( OP(), lhs, rhs[3] ) ,
540  PETE_apply( OP(), lhs, rhs[4] ) ,
541  PETE_apply( OP(), lhs, rhs[5] ) );
542  }
543 };
544 
546 //
547 // Specialization for SymTenzor OP Tenzor of arbitrary size.
548 //
550 
551 template<class T1, class T2, class OP, unsigned D>
552 struct TSV_MetaBinary< SymTenzor<T1,D>, Tenzor<T2,D>, OP >
553 {
554  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
555  inline static Tenzor<T0,D>
556  apply(const SymTenzor<T1,D> &lhs, const Tenzor<T2,D> &rhs) {
557  Tenzor<T0,D> ret;
558  for (unsigned i = 0; i < D; i++)
559  for (unsigned j = 0; j < D; j++)
560  ret(i, j) = PETE_apply(OP(), lhs(i, j), rhs(i, j));
561  return ret;
562  }
563 };
564 
566 //
567 // Specialization for Tenzor OP SymTenzor of arbitrary size.
568 //
570 
571 template<class T1, class T2, class OP, unsigned D>
572 struct TSV_MetaBinary< Tenzor<T1,D>, SymTenzor<T2,D>, OP >
573 {
574  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
575  inline static Tenzor<T0,D>
576  apply(const Tenzor<T1,D> &lhs, const SymTenzor<T2,D> &rhs) {
577  Tenzor<T0,D> ret;
578  for (unsigned i = 0; i < D; i++)
579  for (unsigned j = 0; j < D; j++)
580  ret(i, j) = PETE_apply(OP(), lhs(i, j), rhs(i, j));
581  return ret;
582  }
583 };
584 
586 //
587 // Specializations for AntiSymTenzors of arbitrary size.
588 //
590 
591 template<class T1, class T2, class OP, unsigned D>
592 struct TSV_MetaBinary< AntiSymTenzor<T1,D> , AntiSymTenzor<T2,D> , OP >
593 {
594  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
595  inline static AntiSymTenzor<T0,D>
596  apply(const AntiSymTenzor<T1,D>& lhs, const AntiSymTenzor<T2,D>& rhs) {
597  AntiSymTenzor<T0,D> ret;
598  for (unsigned d=0; d<D*(D-1)/2; ++d)
599  ret[d] = PETE_apply(OP(),lhs[d] , rhs[d]);
600  return ret;
601  }
602 };
603 
604 template<class T1, class T2, class OP, unsigned D>
605 struct TSV_MetaBinaryScalar< AntiSymTenzor<T1,D> , T2 , OP >
606 {
607  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
608  inline static AntiSymTenzor<T0,D>
609  apply(const AntiSymTenzor<T1,D>& lhs, T2 rhs) {
610  AntiSymTenzor<T0,D> ret;
611  for (unsigned d=0; d<D*(D-1)/2; ++d)
612  ret[d] = PETE_apply( OP(), lhs[d] , rhs );
613  return ret;
614  }
615 };
616 
617 template<class T1, class T2, class OP, unsigned D>
618 struct TSV_MetaBinaryScalar< T1, AntiSymTenzor<T2,D> , OP >
619 {
620  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
621  inline static AntiSymTenzor<T0,D>
622  apply(T1 lhs, const AntiSymTenzor<T2,D>& rhs) {
623  AntiSymTenzor<T0,D> ret;
624  for (unsigned d=0; d<D*(D-1)/2; ++d)
625  ret[d] = PETE_apply( OP(), lhs , rhs[d]);
626  return ret;
627  }
628 };
629 
631 //
632 // Specializations of TSV_MetaBinary for AntiSymTenzors with D=1.
633 //
635 
636 template<class T1, class T2, class OP>
637 struct TSV_MetaBinary< AntiSymTenzor<T1,1> , AntiSymTenzor<T2,1> , OP >
638 {
639  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
640  inline static AntiSymTenzor<T0,1>
641  apply(const AntiSymTenzor<T1,1>& lhs, const AntiSymTenzor<T2,1>& rhs) {
642  typedef typename AntiSymTenzor<T0,1>::DontInitialize T;
643  return AntiSymTenzor<T0,1>( T() );
644  }
645 };
646 
647 template<class T1, class T2, class OP>
648 struct TSV_MetaBinaryScalar< AntiSymTenzor<T1,1> , T2 , OP >
649 {
650  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
651  inline static AntiSymTenzor<T0,1>
652  apply(const AntiSymTenzor<T1,1>& lhs, T2 rhs) {
653  typedef typename AntiSymTenzor<T0,1>::DontInitialize T;
654  return AntiSymTenzor<T0,1>( T() );
655  }
656 };
657 
658 template<class T1, class T2, class OP>
659 struct TSV_MetaBinaryScalar< T1, AntiSymTenzor<T2,1> , OP >
660 {
661  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
662  inline static AntiSymTenzor<T0,1>
663  apply(T1 lhs, const AntiSymTenzor<T2,1>& rhs) {
664  typedef typename AntiSymTenzor<T0,1>::DontInitialize T;
665  return AntiSymTenzor<T0,1>( T() );
666  }
667 };
668 
670 //
671 // Specializations of TSV_MetaBinary for AntiSymTenzors with D=2.
672 //
674 
675 template<class T1, class T2, class OP>
676 struct TSV_MetaBinary< AntiSymTenzor<T1,2> , AntiSymTenzor<T2,2> , OP >
677 {
678  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
679  inline static AntiSymTenzor<T0,2>
680  apply(const AntiSymTenzor<T1,2>& lhs, const AntiSymTenzor<T2,2>& rhs) {
681  return AntiSymTenzor<T0,2>( PETE_apply( OP(), lhs[0], rhs[0] ) );
682  }
683 };
684 
685 template<class T1, class T2, class OP>
686 struct TSV_MetaBinaryScalar< AntiSymTenzor<T1,2> , T2 , OP >
687 {
688  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
689  inline static AntiSymTenzor<T0,2>
690  apply(const AntiSymTenzor<T1,2>& lhs, T2 rhs) {
691  return AntiSymTenzor<T0,2>( PETE_apply( OP(), lhs[0], rhs ) );
692  }
693 };
694 
695 template<class T1, class T2, class OP>
696 struct TSV_MetaBinaryScalar< T1, AntiSymTenzor<T2,2> , OP >
697 {
698  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
699  inline static AntiSymTenzor<T0,2>
700  apply(T1 lhs, const AntiSymTenzor<T2,2>& rhs) {
701  return AntiSymTenzor<T0,2>( PETE_apply( OP(), lhs, rhs[0] ) );
702  }
703 };
704 
706 //
707 // Specializations of TSV_MetaBinary for AntiSymTenzors with D=3.
708 //
710 
711 template<class T1, class T2, class OP>
712 struct TSV_MetaBinary< AntiSymTenzor<T1,3> , AntiSymTenzor<T2,3> , OP >
713 {
714  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
715  inline static AntiSymTenzor<T0,3>
716  apply(const AntiSymTenzor<T1,3>& lhs, const AntiSymTenzor<T2,3>& rhs) {
717  return AntiSymTenzor<T0,3>( PETE_apply( OP(), lhs[0], rhs[0] ) ,
718  PETE_apply( OP(), lhs[1], rhs[1] ) ,
719  PETE_apply( OP(), lhs[2], rhs[2] ) );
720  }
721 };
722 
723 template<class T1, class T2, class OP>
724 struct TSV_MetaBinaryScalar< AntiSymTenzor<T1,3> , T2 , OP >
725 {
726  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
727  inline static AntiSymTenzor<T0,3>
728  apply(const AntiSymTenzor<T1,3>& lhs, T2 rhs) {
729  return AntiSymTenzor<T0,3>( PETE_apply( OP(), lhs[0], rhs ) ,
730  PETE_apply( OP(), lhs[1], rhs ) ,
731  PETE_apply( OP(), lhs[2], rhs ) );
732  }
733 };
734 
735 template<class T1, class T2, class OP>
736 struct TSV_MetaBinaryScalar< T1, AntiSymTenzor<T2,3> , OP >
737 {
738  typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
739  inline static AntiSymTenzor<T0,3>
740  apply(T1 lhs, const AntiSymTenzor<T2,3>& rhs) {
741  return AntiSymTenzor<T0,3>( PETE_apply( OP(), lhs, rhs[0] ) ,
742  PETE_apply( OP(), lhs, rhs[1] ) ,
743  PETE_apply( OP(), lhs, rhs[2] ) );
744  }
745 };
746 
748 
749 #endif // TSV_META_BINARY_H
750 
751 /***************************************************************************
752  * $RCSfile: TSVMetaBinary.h,v $ $Author: adelmann $
753  * $Revision: 1.1.1.1 $ $Date: 2003/01/23 07:40:24 $
754  * IPPL_VERSION_ID: $Id: TSVMetaBinary.h,v 1.1.1.1 2003/01/23 07:40:24 adelmann Exp $
755  ***************************************************************************/
TSV_MetaBinary< Vektor< T1, D >, Vektor< T2, D >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:32
PETE_apply
void PETE_apply(const OpPeriodic< T > &e, T &a, const T &b)
Definition: BCond.hpp:373
TSV_MetaBinary< Vektor< T1, 3 >, Vektor< T2, 3 >, OP >::apply
static Vektor< T0, 3 > apply(const Vektor< T1, 3 > &lhs, const Vektor< T2, 3 > &rhs)
Definition: TSVMetaBinary.h:154
TSV_MetaBinaryScalar< AntiSymTenzor< T1, D >, T2, OP >::apply
static AntiSymTenzor< T0, D > apply(const AntiSymTenzor< T1, D > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:609
TSV_MetaBinary< Vektor< T1, 1 >, Vektor< T2, 1 >, OP >::apply
static Vektor< T0, 1 > apply(const Vektor< T1, 1 > &lhs, const Vektor< T2, 1 > &rhs)
Definition: TSVMetaBinary.h:79
TSV_MetaBinaryScalar< T1, Vektor< T2, 3 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:176
TSV_MetaBinaryScalar< T1, SymTenzor< T2, 3 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:533
TSV_MetaBinaryScalar< SymTenzor< T1, 3 >, T2, OP >::apply
static SymTenzor< T0, 3 > apply(const SymTenzor< T1, 3 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:520
TSV_MetaBinaryScalar< SymTenzor< T1, 2 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:473
TSV_MetaBinary< SymTenzor< T1, D >, SymTenzor< T2, D >, OP >::apply
static SymTenzor< T0, D > apply(const SymTenzor< T1, D > &lhs, const SymTenzor< T2, D > &rhs)
Definition: TSVMetaBinary.h:382
Vektor
Definition: TSVMeta.h:24
T
Definition: rbendmap.h:8
TSV_MetaBinaryScalar< Tenzor< T1, 3 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:338
TSV_MetaBinaryScalar< SymTenzor< T1, 1 >, T2, OP >::apply
static SymTenzor< T0, 1 > apply(const SymTenzor< T1, 1 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:437
TSV_MetaBinary< SymTenzor< T1, D >, Tenzor< T2, D >, OP >::apply
static Tenzor< T0, D > apply(const SymTenzor< T1, D > &lhs, const Tenzor< T2, D > &rhs)
Definition: TSVMetaBinary.h:556
TSV_MetaBinaryScalar< T1, Tenzor< T2, D >, OP >::apply
static Tenzor< T0, D > apply(T1 lhs, const Tenzor< T2, D > &rhs)
Definition: TSVMetaBinary.h:222
TSV_MetaBinaryScalar< SymTenzor< T1, 1 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:435
TSV_MetaBinary< SymTenzor< T1, 3 >, SymTenzor< T2, 3 >, OP >::apply
static SymTenzor< T0, 3 > apply(const SymTenzor< T1, 3 > &lhs, const SymTenzor< T2, 3 > &rhs)
Definition: TSVMetaBinary.h:505
TSV_MetaBinaryScalar< T1, SymTenzor< T2, D >, OP >::apply
static SymTenzor< T0, D > apply(T1 lhs, const SymTenzor< T2, D > &rhs)
Definition: TSVMetaBinary.h:408
TSV_MetaBinaryScalar< T1, Vektor< T2, 1 >, OP >::apply
static Vektor< T0, 1 > apply(T1 lhs, const Vektor< T2, 1 > &rhs)
Definition: TSVMetaBinary.h:99
TSV_MetaBinaryScalar< SymTenzor< T1, D >, T2, OP >::apply
static SymTenzor< T0, D > apply(const SymTenzor< T1, D > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:395
TSV_MetaBinaryScalar< T1, AntiSymTenzor< T2, 2 >, OP >::apply
static AntiSymTenzor< T0, 2 > apply(T1 lhs, const AntiSymTenzor< T2, 2 > &rhs)
Definition: TSVMetaBinary.h:700
TSV_MetaBinaryScalar< Vektor< T1, 1 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:87
TSV_MetaBinary< Tenzor< T1, D >, Tenzor< T2, D >, OP >::apply
static Tenzor< T0, D > apply(const Tenzor< T1, D > &lhs, const Tenzor< T2, D > &rhs)
Definition: TSVMetaBinary.h:196
TSV_MetaBinaryScalar< T1, Vektor< T2, 1 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:97
TSV_MetaBinary< Vektor< T1, 2 >, Vektor< T2, 2 >, OP >::apply
static Vektor< T0, 2 > apply(const Vektor< T1, 2 > &lhs, const Vektor< T2, 2 > &rhs)
Definition: TSVMetaBinary.h:115
TSV_MetaBinaryScalar< T1, SymTenzor< T2, D >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:406
TSV_MetaBinaryScalar< Tenzor< T1, 3 >, T2, OP >::apply
static Tenzor< T0, 3 > apply(const Tenzor< T1, 3 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:340
TSV_MetaBinaryScalar< T1, SymTenzor< T2, 2 >, OP >::apply
static SymTenzor< T0, 2 > apply(T1 lhs, const SymTenzor< T2, 2 > &rhs)
Definition: TSVMetaBinary.h:487
TSV_MetaBinary< AntiSymTenzor< T1, 3 >, AntiSymTenzor< T2, 3 >, OP >::apply
static AntiSymTenzor< T0, 3 > apply(const AntiSymTenzor< T1, 3 > &lhs, const AntiSymTenzor< T2, 3 > &rhs)
Definition: TSVMetaBinary.h:716
TSV_MetaBinaryScalar< SymTenzor< T1, 2 >, T2, OP >::apply
static SymTenzor< T0, 2 > apply(const SymTenzor< T1, 2 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:475
TSV_MetaBinaryScalar< Tenzor< T1, 1 >, T2, OP >::apply
static Tenzor< T0, 1 > apply(const Tenzor< T1, 1 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:251
TSV_MetaBinaryScalar< Tenzor< T1, 2 >, T2, OP >::apply
static Tenzor< T0, 2 > apply(const Tenzor< T1, 2 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:290
TSV_MetaBinaryScalar< SymTenzor< T1, 3 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:518
TSV_MetaBinaryScalar< Vektor< T1, 1 >, T2, OP >::apply
static Vektor< T0, 1 > apply(const Vektor< T1, 1 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:89
TSV_MetaBinaryScalar< Tenzor< T1, 2 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:288
TSV_MetaBinaryScalar< T1, SymTenzor< T2, 1 >, OP >::apply
static SymTenzor< T0, 1 > apply(T1 lhs, const SymTenzor< T2, 1 > &rhs)
Definition: TSVMetaBinary.h:447
TSV_MetaBinary< Tenzor< T1, 3 >, Tenzor< T2, 3 >, OP >::apply
static Tenzor< T0, 3 > apply(const Tenzor< T1, 3 > &lhs, const Tenzor< T2, 3 > &rhs)
Definition: TSVMetaBinary.h:322
TSV_MetaBinaryScalar< T1, Tenzor< T2, 1 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:259
TSV_MetaBinaryScalar< Tenzor< T1, D >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:207
TSV_MetaBinaryScalar< T1, Vektor< T2, D >, OP >::apply
static Vektor< T0, D > apply(T1 lhs, const Vektor< T2, D > &rhs)
Definition: TSVMetaBinary.h:60
TSV_MetaBinaryScalar< Vektor< T1, 2 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:124
TSV_MetaBinary< Vektor< T1, 1 >, Vektor< T2, 1 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:77
TSV_MetaBinaryScalar< Tenzor< T1, 1 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:249
TSV_MetaBinaryScalar< T1, Vektor< T2, 2 >, OP >::apply
static Vektor< T0, 2 > apply(T1 lhs, const Vektor< T2, 2 > &rhs)
Definition: TSVMetaBinary.h:137
TSV_MetaBinaryScalar< T1, Tenzor< T2, D >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:220
TSV_MetaBinaryScalar< T1, Tenzor< T2, 3 >, OP >::apply
static Tenzor< T0, 3 > apply(T1 lhs, const Tenzor< T2, 3 > &rhs)
Definition: TSVMetaBinary.h:358
TSV_MetaBinary< Tenzor< T1, 2 >, Tenzor< T2, 2 >, OP >::apply
static Tenzor< T0, 2 > apply(const Tenzor< T1, 2 > &lhs, const Tenzor< T2, 2 > &rhs)
Definition: TSVMetaBinary.h:277
TSV_MetaBinaryScalar< T1, Vektor< T2, 2 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:135
TSV_MetaBinary< Tenzor< T1, 1 >, Tenzor< T2, 1 >, OP >::apply
static Tenzor< T0, 1 > apply(const Tenzor< T1, 1 > &lhs, const Tenzor< T2, 1 > &rhs)
Definition: TSVMetaBinary.h:241
TSV_MetaBinaryScalar< T1, AntiSymTenzor< T2, 3 >, OP >::apply
static AntiSymTenzor< T0, 3 > apply(T1 lhs, const AntiSymTenzor< T2, 3 > &rhs)
Definition: TSVMetaBinary.h:740
TSV_MetaBinaryScalar< Vektor< T1, D >, T2, OP >::apply
static Vektor< T0, D > apply(const Vektor< T1, D > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:47
TSV_MetaBinaryScalar< AntiSymTenzor< T1, 2 >, T2, OP >::apply
static AntiSymTenzor< T0, 2 > apply(const AntiSymTenzor< T1, 2 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:690
TSV_MetaBinaryScalar< T1, AntiSymTenzor< T2, D >, OP >::apply
static AntiSymTenzor< T0, D > apply(T1 lhs, const AntiSymTenzor< T2, D > &rhs)
Definition: TSVMetaBinary.h:622
PETEBinaryReturn::type
PETE_ComputeBinaryType< PETE_Type2Index< T1 >::val, PETE_Type2Index< T2 >::val, Op::tag >::type type
Definition: TypeComputations.h:352
TSV_MetaBinaryScalar< T1, SymTenzor< T2, 3 >, OP >::apply
static SymTenzor< T0, 3 > apply(T1 lhs, const SymTenzor< T2, 3 > &rhs)
Definition: TSVMetaBinary.h:535
TSV_MetaBinaryScalar< AntiSymTenzor< T1, 1 >, T2, OP >::apply
static AntiSymTenzor< T0, 1 > apply(const AntiSymTenzor< T1, 1 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:652
TSV_MetaBinaryScalar< T1, Tenzor< T2, 2 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:301
TSV_MetaBinaryScalar< Vektor< T1, 3 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:164
TSV_MetaBinary< SymTenzor< T1, 1 >, SymTenzor< T2, 1 >, OP >::apply
static SymTenzor< T0, 1 > apply(const SymTenzor< T1, 1 > &lhs, const SymTenzor< T2, 1 > &rhs)
Definition: TSVMetaBinary.h:427
TSV_MetaBinaryScalar< T1, Vektor< T2, D >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:58
TSV_MetaBinaryScalar< T1, Tenzor< T2, 3 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:356
TSV_MetaBinaryScalar< T1, Vektor< T2, 3 >, OP >::apply
static Vektor< T0, 3 > apply(T1 lhs, const Vektor< T2, 3 > &rhs)
Definition: TSVMetaBinary.h:178
TSV_MetaBinary< AntiSymTenzor< T1, 2 >, AntiSymTenzor< T2, 2 >, OP >::apply
static AntiSymTenzor< T0, 2 > apply(const AntiSymTenzor< T1, 2 > &lhs, const AntiSymTenzor< T2, 2 > &rhs)
Definition: TSVMetaBinary.h:680
TSV_MetaBinaryScalar< SymTenzor< T1, D >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:393
TSV_MetaBinaryScalar< T1, SymTenzor< T2, 1 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:445
TSV_MetaBinaryScalar< T1, Tenzor< T2, 2 >, OP >::apply
static Tenzor< T0, 2 > apply(T1 lhs, const Tenzor< T2, 2 > &rhs)
Definition: TSVMetaBinary.h:303
TSV_MetaBinary< Tenzor< T1, D >, SymTenzor< T2, D >, OP >::apply
static Tenzor< T0, D > apply(const Tenzor< T1, D > &lhs, const SymTenzor< T2, D > &rhs)
Definition: TSVMetaBinary.h:576
TSV_MetaBinary< AntiSymTenzor< T1, D >, AntiSymTenzor< T2, D >, OP >::apply
static AntiSymTenzor< T0, D > apply(const AntiSymTenzor< T1, D > &lhs, const AntiSymTenzor< T2, D > &rhs)
Definition: TSVMetaBinary.h:596
TSV_MetaBinaryScalar< T1, Tenzor< T2, 1 >, OP >::apply
static Tenzor< T0, 1 > apply(T1 lhs, const Tenzor< T2, 1 > &rhs)
Definition: TSVMetaBinary.h:261
TSV_MetaBinary< AntiSymTenzor< T1, 1 >, AntiSymTenzor< T2, 1 >, OP >::apply
static AntiSymTenzor< T0, 1 > apply(const AntiSymTenzor< T1, 1 > &lhs, const AntiSymTenzor< T2, 1 > &rhs)
Definition: TSVMetaBinary.h:641
TSV_MetaBinaryScalar< Vektor< T1, 3 >, T2, OP >::apply
static Vektor< T0, 3 > apply(const Vektor< T1, 3 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:166
TSV_MetaBinaryScalar< T1, SymTenzor< T2, 2 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:485
TSV_MetaBinary< SymTenzor< T1, 2 >, SymTenzor< T2, 2 >, OP >::apply
static SymTenzor< T0, 2 > apply(const SymTenzor< T1, 2 > &lhs, const SymTenzor< T2, 2 > &rhs)
Definition: TSVMetaBinary.h:463
TSV_MetaBinaryScalar< Tenzor< T1, D >, T2, OP >::apply
static Tenzor< T0, D > apply(const Tenzor< T1, D > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:209
TSV_MetaBinary< Vektor< T1, D >, Vektor< T2, D >, OP >::apply
static Vektor< T0, D > apply(const Vektor< T1, D > &lhs, const Vektor< T2, D > &rhs)
Definition: TSVMetaBinary.h:34
TSV_MetaBinaryScalar< Vektor< T1, D >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:45
TSV_MetaBinaryScalar< T1, AntiSymTenzor< T2, 1 >, OP >::apply
static AntiSymTenzor< T0, 1 > apply(T1 lhs, const AntiSymTenzor< T2, 1 > &rhs)
Definition: TSVMetaBinary.h:663
TSV_MetaBinaryScalar< AntiSymTenzor< T1, 3 >, T2, OP >::apply
static AntiSymTenzor< T0, 3 > apply(const AntiSymTenzor< T1, 3 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:728
TSV_MetaBinaryScalar< Vektor< T1, 2 >, T2, OP >::apply
static Vektor< T0, 2 > apply(const Vektor< T1, 2 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:126
Generated on Sat Jan 4 2020 14:47:32 for OPAL (Object Oriented Parallel Accelerator Library) by   doxygen 1.8.5