OPAL (Object Oriented Parallel Accelerator Library) 2022.1
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
20template<class T1, class T2, class OP> struct TSV_MetaBinary {};
21template<class T1, class T2, class OP> struct TSV_MetaBinaryScalar {};
22
24//
25// Specializations for Vektors of arbitrary size.
26//
28
29template<class T1, class T2, class OP, unsigned D>
30struct 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
42template<class T1, class T2, class OP, unsigned D>
43struct 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
55template<class T1, class T2, class OP, unsigned D>
56struct 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
74template<class T1, class T2, class OP>
75struct 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
84template<class T1, class T2, class OP>
85struct 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
94template<class T1, class T2, class OP>
95struct 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
110template<class T1, class T2, class OP>
111struct 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
121template<class T1, class T2, class OP>
122struct 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
132template<class T1, class T2, class OP>
133struct 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
149template<class T1, class T2, class OP>
150struct 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
161template<class T1, class T2, class OP>
162struct 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
173template<class T1, class T2, class OP>
174struct 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
191template<class T1, class T2, class OP, unsigned D>
192struct 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
204template<class T1, class T2, class OP, unsigned D>
205struct 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
217template<class T1, class T2, class OP, unsigned D>
218struct 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
236template<class T1, class T2, class OP>
237struct 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
246template<class T1, class T2, class OP>
247struct 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
256template<class T1, class T2, class OP>
257struct 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
272template<class T1, class T2, class OP>
273struct 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
285template<class T1, class T2, class OP>
286struct 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
298template<class T1, class T2, class OP>
299struct 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
317template<class T1, class T2, class OP>
318struct 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
335template<class T1, class T2, class OP>
336struct 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
353template<class T1, class T2, class OP>
354struct 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
377template<class T1, class T2, class OP, unsigned D>
378struct 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
390template<class T1, class T2, class OP, unsigned D>
391struct 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
403template<class T1, class T2, class OP, unsigned D>
404struct 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
422template<class T1, class T2, class OP>
423struct 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
432template<class T1, class T2, class OP>
433struct 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
442template<class T1, class T2, class OP>
443struct 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
458template<class T1, class T2, class OP>
459struct 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
470template<class T1, class T2, class OP>
471struct 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
482template<class T1, class T2, class OP>
483struct 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
500template<class T1, class T2, class OP>
501struct 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
515template<class T1, class T2, class OP>
516struct 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
530template<class T1, class T2, class OP>
531struct 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
551template<class T1, class T2, class OP, unsigned D>
552struct 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
571template<class T1, class T2, class OP, unsigned D>
572struct 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
591template<class T1, class T2, class OP, unsigned D>
592struct 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
604template<class T1, class T2, class OP, unsigned D>
605struct 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
617template<class T1, class T2, class OP, unsigned D>
618struct 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
636template<class T1, class T2, class OP>
637struct 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
647template<class T1, class T2, class OP>
648struct 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
658template<class T1, class T2, class OP>
659struct 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
675template<class T1, class T2, class OP>
676struct 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
685template<class T1, class T2, class OP>
686struct 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
695template<class T1, class T2, class OP>
696struct 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
711template<class T1, class T2, class OP>
712struct 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
723template<class T1, class T2, class OP>
724struct 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
735template<class T1, class T2, class OP>
736struct 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 ***************************************************************************/
PETE_apply
void PETE_apply(const OpPeriodic< T > &, T &a, const T &b)
Definition: BCond.hpp:353
Tenzor
Definition: Tenzor.h:35
Vektor
Definition: Vektor.h:32
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_MetaBinary< Vektor< T1, D >, Vektor< T2, D >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:32
TSV_MetaBinaryScalar< Vektor< T1, D >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:45
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< T1, Vektor< T2, D >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:58
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_MetaBinary< Vektor< T1, 1 >, Vektor< T2, 1 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:77
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< Vektor< T1, 1 >, T2, OP >::apply
static Vektor< T0, 1 > apply(const Vektor< T1, 1 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:89
TSV_MetaBinaryScalar< Vektor< T1, 1 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:87
TSV_MetaBinaryScalar< T1, Vektor< T2, 1 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:97
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_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< Vektor< T1, 2 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:124
TSV_MetaBinaryScalar< Vektor< T1, 2 >, T2, OP >::apply
static Vektor< T0, 2 > apply(const Vektor< T1, 2 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:126
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, Vektor< T2, 2 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:135
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< Vektor< T1, 3 >, T2, OP >::apply
static Vektor< T0, 3 > apply(const Vektor< T1, 3 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:166
TSV_MetaBinaryScalar< Vektor< T1, 3 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:164
TSV_MetaBinaryScalar< T1, Vektor< T2, 3 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:176
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< 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< Tenzor< T1, D >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:207
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_MetaBinaryScalar< T1, Tenzor< T2, D >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:220
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_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< 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, 1 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:249
TSV_MetaBinaryScalar< T1, Tenzor< T2, 1 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:259
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< 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< Tenzor< T1, 2 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:288
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< T1, Tenzor< T2, 2 >, OP >::apply
static Tenzor< T0, 2 > apply(T1 lhs, const Tenzor< T2, 2 > &rhs)
Definition: TSVMetaBinary.h:303
TSV_MetaBinaryScalar< T1, Tenzor< T2, 2 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:301
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< Tenzor< T1, 3 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:338
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, Tenzor< T2, 3 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:356
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< 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
TSV_MetaBinaryScalar< SymTenzor< T1, D >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:393
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, SymTenzor< T2, D >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:406
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_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< SymTenzor< T1, 1 >, T2, OP >::apply
static SymTenzor< T0, 1 > apply(const SymTenzor< T1, 1 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:437
TSV_MetaBinaryScalar< SymTenzor< T1, 1 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:435
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_MetaBinaryScalar< T1, SymTenzor< T2, 1 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:445
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< SymTenzor< T1, 2 >, T2, OP >::apply
static SymTenzor< T0, 2 > apply(const SymTenzor< T1, 2 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:475
TSV_MetaBinaryScalar< SymTenzor< T1, 2 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:473
TSV_MetaBinaryScalar< T1, SymTenzor< T2, 2 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:485
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< 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< 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, 3 >, T2, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:518
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< T1, SymTenzor< T2, 3 >, OP >::T0
PETEBinaryReturn< T1, T2, OP >::type T0
Definition: TSVMetaBinary.h:533
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_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< AntiSymTenzor< T1, D >, T2, OP >::apply
static AntiSymTenzor< T0, D > apply(const AntiSymTenzor< T1, D > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:609
TSV_MetaBinaryScalar< T1, AntiSymTenzor< T2, D >, OP >::apply
static AntiSymTenzor< T0, D > apply(T1 lhs, const AntiSymTenzor< T2, D > &rhs)
Definition: TSVMetaBinary.h:622
TSV_MetaBinary< AntiSymTenzor< T1, 1 >, AntiSymTenzor< T2, 1 >, OP >::apply
static AntiSymTenzor< T0, 1 > apply(const AntiSymTenzor< T1, 1 > &, const AntiSymTenzor< T2, 1 > &)
Definition: TSVMetaBinary.h:641
TSV_MetaBinaryScalar< AntiSymTenzor< T1, 1 >, T2, OP >::apply
static AntiSymTenzor< T0, 1 > apply(const AntiSymTenzor< T1, 1 > &, T2)
Definition: TSVMetaBinary.h:652
TSV_MetaBinaryScalar< T1, AntiSymTenzor< T2, 1 >, OP >::apply
static AntiSymTenzor< T0, 1 > apply(T1, const AntiSymTenzor< T2, 1 > &)
Definition: TSVMetaBinary.h:663
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< 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, 2 >, OP >::apply
static AntiSymTenzor< T0, 2 > apply(T1 lhs, const AntiSymTenzor< T2, 2 > &rhs)
Definition: TSVMetaBinary.h:700
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< AntiSymTenzor< T1, 3 >, T2, OP >::apply
static AntiSymTenzor< T0, 3 > apply(const AntiSymTenzor< T1, 3 > &lhs, T2 rhs)
Definition: TSVMetaBinary.h:728
TSV_MetaBinaryScalar< T1, AntiSymTenzor< T2, 3 >, OP >::apply
static AntiSymTenzor< T0, 3 > apply(T1 lhs, const AntiSymTenzor< T2, 3 > &rhs)
Definition: TSVMetaBinary.h:740
PETEBinaryReturn::type
PETE_ComputeBinaryType< T1, T2, Op, Op::tag >::type type
Definition: TypeComputations.h:248
Generated on Thu Oct 20 2022 17:40:07 for OPAL (Object Oriented Parallel Accelerator Library) by doxygen 1.9.3