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