QDP++
qdp_optops.h
Go to the documentation of this file.
1// -*- C++ -*-
2
9
10#ifndef QDP_OPTOPS_H
11#define QDP_OPTOPS_H
12
13namespace QDP {
14
15//-----------------------------------------------------------------------------
16// Optimization hooks
17//-----------------------------------------------------------------------------
18
19struct OpAdjMultiply
20{
21 PETE_EMPTY_CONSTRUCTORS(OpAdjMultiply)
22 template<class T1, class T2>
23 inline typename BinaryReturn<T1, T2, OpAdjMultiply >::Type_t
24 operator()(const T1 &a, const T2 &b) const
25 {
26// cerr << "adjMultiply" << endl;
27// return (adj(a)*b);
28 return adjMultiply(a,b);
29 }
30};
31
32struct OpMultiplyAdj
33{
34 PETE_EMPTY_CONSTRUCTORS(OpMultiplyAdj)
35 template<class T1, class T2>
36 inline typename BinaryReturn<T1, T2, OpMultiplyAdj >::Type_t
37 operator()(const T1 &a, const T2 &b) const
38 {
39// cerr << "multiplyAdj" << endl;
40// return (a*adj(b));
41 return multiplyAdj(a,b);
42 }
43};
44
45struct OpAdjMultiplyAdj
46{
47 PETE_EMPTY_CONSTRUCTORS(OpAdjMultiplyAdj)
48 template<class T1, class T2>
49 inline typename BinaryReturn<T1, T2, OpAdjMultiplyAdj >::Type_t
50 operator()(const T1 &a, const T2 &b) const
51 {
52// cerr << "adjMultiplyAdj" << endl;
53// return (adj(a)*adj(b));
54 return adjMultiplyAdj(a,b);
55 }
56};
57
58// adjMultiply(l,r) <- adj(l)*r
59template<class T1,class C1,class T2,class C2>
60inline typename MakeReturn<BinaryNode<OpAdjMultiply,
61 typename CreateLeaf<QDPExpr<UnaryNode<OpIdentity,T1>,C1> >::Leaf_t,
62 typename CreateLeaf<QDPType<T2,C2> >::Leaf_t>,
63 typename BinaryReturn<C1,C2,OpAdjMultiply>::Type_t >::Expression_t
64operator*(const QDPExpr<UnaryNode<FnAdjoint,T1>,C1> & l,
65 const QDPType<T2,C2> & r)
66{
67 // cerr << "adjMultiply(l,r) <- adj(l)*r" << endl;
68
69 typedef UnaryNode<OpIdentity,T1> NewExpr1_t; // The adj does not change container type
70
71 typedef BinaryNode<OpAdjMultiply,
72 typename CreateLeaf<QDPExpr<UnaryNode<OpIdentity,T1>,C1> >::Leaf_t,
73 typename CreateLeaf<QDPType<T2,C2> >::Leaf_t> Tree_t;
74 typedef typename BinaryReturn<C1,C2,OpAdjMultiply>::Type_t Container_t;
75 return MakeReturn<Tree_t,Container_t>::make(Tree_t(
76 CreateLeaf<QDPExpr<NewExpr1_t,C1> >::make(NewExpr1_t(l.expression().child())),
77 CreateLeaf<QDPType<T2,C2> >::make(r)));
78}
79
80// adjMultiply<l,Expr> <- adj(l)*Expr
81template<class T1,class C1,class T2,class C2>
82inline typename MakeReturn<BinaryNode<OpAdjMultiply,
83 typename CreateLeaf<QDPExpr<UnaryNode<OpIdentity,T1>,C1> >::Leaf_t,
84 typename CreateLeaf<QDPExpr<T2,C2> >::Leaf_t>,
85 typename BinaryReturn<C1,C2,OpAdjMultiply>::Type_t >::Expression_t
86operator*(const QDPExpr<UnaryNode<FnAdjoint,T1>,C1> & l,
87 const QDPExpr<T2,C2> & r)
88{
89 //cerr << "adjMultiply(l,Expr) <- adj(l)*Expr" << endl;
90
91 typedef UnaryNode<OpIdentity,T1> NewExpr1_t; // The adj does not change container type
92
93 typedef BinaryNode<OpAdjMultiply,
94 typename CreateLeaf<QDPExpr<UnaryNode<OpIdentity,T1>,C1> >::Leaf_t,
95 typename CreateLeaf<QDPExpr<T2,C2> >::Leaf_t> Tree_t;
96 typedef typename BinaryReturn<C1,C2,OpAdjMultiply>::Type_t Container_t;
97 return MakeReturn<Tree_t,Container_t>::make(Tree_t(
98 CreateLeaf<QDPExpr<NewExpr1_t,C1> >::make(NewExpr1_t(l.expression().child())),
99 CreateLeaf<QDPExpr<T2,C2> >::make(r)));
100}
101
102// multplyAdj(l,r) <- l*adj(r)
103template<class T1,class C1,class T2,class C2>
104inline typename MakeReturn<BinaryNode<OpMultiplyAdj,
105 typename CreateLeaf<QDPType<T1,C1> >::Leaf_t,
106 typename CreateLeaf<QDPExpr<UnaryNode<OpIdentity,T2>,C2> >::Leaf_t>,
107 typename BinaryReturn<C1,C2,OpMultiplyAdj>::Type_t >::Expression_t
108operator*(const QDPType<T1,C1> & l,
109 const QDPExpr<UnaryNode<FnAdjoint,T2>,C2> & r)
110{
111// cerr << "multiplyAdj(l,r) <- l*adj(r)" << endl;
112
113 typedef UnaryNode<OpIdentity,T2> NewExpr2_t; // The adj does not change container type
114
115 typedef BinaryNode<OpMultiplyAdj,
116 typename CreateLeaf<QDPType<T1,C1> >::Leaf_t,
117 typename CreateLeaf<QDPExpr<UnaryNode<OpIdentity,T2>,C2> >::Leaf_t> Tree_t;
118 typedef typename BinaryReturn<C1,C2,OpMultiplyAdj>::Type_t Container_t;
119 return MakeReturn<Tree_t,Container_t>::make(Tree_t(
120 CreateLeaf<QDPType<T1,C1> >::make(l),
121 CreateLeaf<QDPExpr<NewExpr2_t,C2> >::make(NewExpr2_t(r.expression().child()))));
122}
123
124// multiplyAdj(Expr,r) <- Expr*adj(r)
125template<class T1,class C1,class T2,class C2>
126inline typename MakeReturn<BinaryNode<OpMultiplyAdj,
127 typename CreateLeaf<QDPExpr<T1,C1> >::Leaf_t,
128 typename CreateLeaf<QDPExpr<UnaryNode<OpIdentity,T2>,C2> >::Leaf_t>,
129 typename BinaryReturn<C1,C2,OpMultiplyAdj>::Type_t >::Expression_t
130operator*(const QDPExpr<T1,C1> & l,
131 const QDPExpr<UnaryNode<FnAdjoint,T2>,C2> & r)
132{
133// cerr << "multiplyAdj(Expr,r) <- Expr*adj(r)" << endl;
134
135 typedef UnaryNode<OpIdentity,T2> NewExpr2_t; // The adj does not change container type
136
137 typedef BinaryNode<OpMultiplyAdj,
138 typename CreateLeaf<QDPExpr<T1,C1> >::Leaf_t,
139 typename CreateLeaf<QDPExpr<UnaryNode<OpIdentity,T2>,C2> >::Leaf_t> Tree_t;
140 typedef typename BinaryReturn<C1,C2,OpMultiplyAdj>::Type_t Container_t;
141 return MakeReturn<Tree_t,Container_t>::make(Tree_t(
142 CreateLeaf<QDPExpr<T1,C1> >::make(l),
143 CreateLeaf<QDPExpr<NewExpr2_t,C2> >::make(NewExpr2_t(r.expression().child()))));
144}
145
146// adjMultiplyAdj(l,r) <- adj(l)*adj(r)
147template<class T1,class C1,class T2,class C2>
148inline typename MakeReturn<BinaryNode<OpAdjMultiplyAdj,
149 typename CreateLeaf<QDPExpr<UnaryNode<OpIdentity,T1>,C1> >::Leaf_t,
150 typename CreateLeaf<QDPExpr<UnaryNode<OpIdentity,T2>,C2> >::Leaf_t>,
151 typename BinaryReturn<C1,C2,OpAdjMultiplyAdj>::Type_t >::Expression_t
152operator*(const QDPExpr<UnaryNode<FnAdjoint,T1>,C1> & l,
153 const QDPExpr<UnaryNode<FnAdjoint,T2>,C2> & r)
154{
155// cerr << "adjMultiplyAdj(l,r) <- adj(l)*adj(r)" << endl;
156
157 typedef UnaryNode<OpIdentity,T1> NewExpr1_t; // The adj does not change container type
158 typedef UnaryNode<OpIdentity,T2> NewExpr2_t; // The adj does not change container type
159
160 typedef BinaryNode<OpAdjMultiplyAdj,
161 typename CreateLeaf<QDPExpr<UnaryNode<OpIdentity,T1>,C1> >::Leaf_t,
162 typename CreateLeaf<QDPExpr<UnaryNode<OpIdentity,T2>,C2> >::Leaf_t> Tree_t;
163 typedef typename BinaryReturn<C1,C2,OpAdjMultiplyAdj>::Type_t Container_t;
164 return MakeReturn<Tree_t,Container_t>::make(Tree_t(
165 CreateLeaf<QDPExpr<NewExpr1_t,C1> >::make(NewExpr1_t(l.expression().child())),
166 CreateLeaf<QDPExpr<NewExpr2_t,C2> >::make(NewExpr2_t(r.expression().child()))));
167}
168
169
170struct FnTraceMultiply
171{
172 PETE_EMPTY_CONSTRUCTORS(FnTraceMultiply)
173 template<class T1, class T2>
174 inline typename BinaryReturn<T1, T2, FnTraceMultiply >::Type_t
175 operator()(const T1 &a, const T2 &b) const
176 {
177// cerr << "FnTraceMultiply()" << endl;
178// return trace(a*b);
179 return traceMultiply(a,b);
180 }
181};
182
183struct FnTraceColorMultiply
184{
185 PETE_EMPTY_CONSTRUCTORS(FnTraceColorMultiply)
186 template<class T1, class T2>
187 inline typename BinaryReturn<T1, T2, FnTraceColorMultiply >::Type_t
188 operator()(const T1 &a, const T2 &b) const
189 {
190// cerr << "FnTraceColorMultiply()" << endl;
191// return traceColor(a*b);
192 return traceColorMultiply(a,b);
193 }
194};
195
196struct FnTraceSpinMultiply
197{
198 PETE_EMPTY_CONSTRUCTORS(FnTraceSpinMultiply)
199 template<class T1, class T2>
200 inline typename BinaryReturn<T1, T2, FnTraceSpinMultiply >::Type_t
201 operator()(const T1 &a, const T2 &b) const
202 {
203// cerr << "FnTraceSpinMultiply()" << endl;
204// return traceSpin(a*b);
205 return traceSpinMultiply(a,b);
206 }
207};
208
209struct FnTraceSpinOuterProduct
210{
211 PETE_EMPTY_CONSTRUCTORS(FnTraceSpinOuterProduct)
212 template<class T1, class T2>
213 inline typename BinaryReturn<T1, T2, FnTraceSpinOuterProduct >::Type_t
214 operator()(const T1 &a, const T2 &b) const
215 {
216// cerr << "FnTraceSpinOuterProduct()" << endl;
217// return traceSpin(outerProduct(a,b));
218 return traceSpinOuterProduct(a,b);
219 }
220};
221
222struct FnTraceSpinQuarkContract13
223{
224 PETE_EMPTY_CONSTRUCTORS(FnTraceSpinQuarkContract13)
225 template<class T1, class T2>
226 inline typename BinaryReturn<T1, T2, FnTraceSpinQuarkContract13 >::Type_t
227 operator()(const T1 &a, const T2 &b) const
228 {
229// cerr << "FnTraceSpinQuarkContract13()" << endl;
230// return (traceSpin(quarkContract13(a,b)));
231 return (traceSpinQuarkContract13(a,b));
232 }
233};
234
235
236#if 1
237
239template<class T1,class T2,class CC>
240inline typename MakeReturn<BinaryNode<FnTraceMultiply,T1,T2>,
241 typename UnaryReturn<CC,FnTrace>::Type_t>::Expression_t
242trace(const QDPExpr<BinaryNode<OpMultiply,T1,T2>,CC> & ll)
243{
244// cerr << "traceMultiply(l,r) <- trace(l*r)" << endl;
245
246 typedef BinaryNode<FnTraceMultiply,T1,T2> Tree_t;
247 typedef typename UnaryReturn<CC,FnTrace>::Type_t Container_t;
248 return MakeReturn<Tree_t,Container_t>::make(Tree_t(
249 ll.expression().left(),
250 ll.expression().right()));
251}
252
254template<class T1,class T2,class CC>
255inline typename MakeReturn<BinaryNode<FnTraceColorMultiply,T1,T2>,
256 typename UnaryReturn<CC,FnTrace>::Type_t>::Expression_t
257traceColor(const QDPExpr<BinaryNode<OpMultiply,T1,T2>,CC> & ll)
258{
259// cerr << "traceColorMultiply(l,r) <- traceColor(l*r)" << endl;
260
261 typedef BinaryNode<FnTraceColorMultiply,T1,T2> Tree_t;
262 typedef typename UnaryReturn<CC,FnTrace>::Type_t Container_t;
263 return MakeReturn<Tree_t,Container_t>::make(Tree_t(
264 ll.expression().left(),
265 ll.expression().right()));
266}
267
269template<class T1,class T2,class CC>
270inline typename MakeReturn<BinaryNode<FnTraceSpinMultiply,T1,T2>,
271 typename UnaryReturn<CC,FnTrace>::Type_t>::Expression_t
272traceSpin(const QDPExpr<BinaryNode<OpMultiply,T1,T2>,CC> & ll)
273{
274// cerr << "traceSpinMultiply(l,r) <- traceSpin(l*r)" << endl;
275
276 typedef BinaryNode<FnTraceSpinMultiply,T1,T2> Tree_t;
277 typedef typename UnaryReturn<CC,FnTrace>::Type_t Container_t;
278 return MakeReturn<Tree_t,Container_t>::make(Tree_t(
279 ll.expression().left(),
280 ll.expression().right()));
281}
282
284template<class T1,class T2,class CC>
285inline typename MakeReturn<BinaryNode<FnTraceSpinOuterProduct,T1,T2>,
286 typename UnaryReturn<CC,FnTrace>::Type_t>::Expression_t
287traceSpin(const QDPExpr<BinaryNode<FnOuterProduct,T1,T2>,CC> & ll)
288{
289// cerr << "traceSpinOuterProduct(l,r) <- traceSpin(outerProduct(l,r))" << endl;
290
291 typedef BinaryNode<FnTraceSpinOuterProduct,T1,T2> Tree_t;
292 typedef typename UnaryReturn<CC,FnTrace>::Type_t Container_t;
293 return MakeReturn<Tree_t,Container_t>::make(Tree_t(
294 ll.expression().left(),
295 ll.expression().right()));
296}
297
299template<class T1,class T2,class CC>
300inline typename MakeReturn<BinaryNode<FnLocalInnerProduct,T1,T2>,
301 typename UnaryReturn<CC,FnTrace>::Type_t>::Expression_t
302trace(const QDPExpr<BinaryNode<OpAdjMultiply,T1,T2>,CC> & ll)
303{
304// cerr << "localInnerProduct(l,r) <- trace(adj(l)*r)" << endl;
305
306 typedef BinaryNode<FnLocalInnerProduct,T1,T2> Tree_t;
307 typedef typename UnaryReturn<CC,FnTrace>::Type_t Container_t;
308 return MakeReturn<Tree_t,Container_t>::make(Tree_t(
309 ll.expression().left(),
310 ll.expression().right()));
311}
312
313
315template<class T1,class T2,class CC>
316inline typename MakeReturn<BinaryNode<FnTraceSpinQuarkContract13,T1,T2>,
317 typename UnaryReturn<CC,FnTrace>::Type_t>::Expression_t
318traceSpin(const QDPExpr<BinaryNode<FnQuarkContract13,T1,T2>,CC> & ll)
319{
320// cerr << "traceSpinQuarkContract13(l,r) <- traceSpin(quarkContract13(l,r))" << endl;
321
322 typedef BinaryNode<FnTraceSpinQuarkContract13,T1,T2> Tree_t;
323 typedef typename UnaryReturn<CC,FnTrace>::Type_t Container_t;
324 return MakeReturn<Tree_t,Container_t>::make(Tree_t(
325 ll.expression().left(),
326 ll.expression().right()));
327}
328
329
331template<class T1,class CC>
332inline typename MakeReturn<UnaryNode<FnRealTrace,T1>,
333 typename UnaryReturn<CC,FnReal>::Type_t>::Expression_t
334real(const QDPExpr<UnaryNode<FnTrace,T1>,CC> & ll)
335{
336// cerr << "realTrace(ll) <- real(trace(ll))" << endl;
337
338 typedef UnaryNode<FnRealTrace,T1> Tree_t;
339 typedef typename UnaryReturn<CC,FnReal>::Type_t Container_t;
340 return MakeReturn<Tree_t,Container_t>::make(Tree_t(
341 ll.expression().child()));
342}
343
345template<class T1,class T2,class CC>
346inline typename MakeReturn<BinaryNode<FnLocalInnerProductReal,T1,T2>,
347 typename UnaryReturn<CC,FnReal>::Type_t>::Expression_t
348real(const QDPExpr<BinaryNode<FnLocalInnerProduct,T1,T2>,CC> & ll)
349{
350// cerr << "localInnerProductReal(l,r) <- real(localInnerProduct(l,r))" << endl;
351
352 typedef BinaryNode<FnLocalInnerProductReal,T1,T2> Tree_t;
353 typedef typename UnaryReturn<CC,FnReal>::Type_t Container_t;
354 return MakeReturn<Tree_t,Container_t>::make(Tree_t(
355 ll.expression().left(),
356 ll.expression().right()));
357}
358
359#endif
360
361
362} // namespace QDP
363
364#endif
PETE_EMPTY_CONSTRUCTORS
#define PETE_EMPTY_CONSTRUCTORS(CLASS)
Definition PETE.h:58
QDP::QDPExpr
Expression class for QDP.
Definition qdp_qdpexpr.h:16
QDP::QDPType
QDPType - major type class/container for all QDP objects.
Definition qdp_qdptype.h:29
QDP::adjMultiplyAdj
BinaryReturn< IScalar< T1 >, IScalar< T2 >, OpAdjMultiplyAdj >::Type_t adjMultiplyAdj(const IScalar< T1 > &l, const IScalar< T2 > &r)
Definition qdp_inner.h:1198
QDP::multiplyAdj
BinaryReturn< IScalar< T1 >, IScalar< T2 >, OpMultiplyAdj >::Type_t multiplyAdj(const IScalar< T1 > &l, const IScalar< T2 > &r)
Definition qdp_inner.h:1189
QDP::adjMultiply
BinaryReturn< IScalar< T1 >, IScalar< T2 >, OpAdjMultiply >::Type_t adjMultiply(const IScalar< T1 > &l, const IScalar< T2 > &r)
Definition qdp_inner.h:1180
QDP::traceColorMultiply
BinaryReturn< PColorMatrix< T1, N >, PColorMatrix< T2, N >, FnTraceColorMultiply >::Type_t traceColorMultiply(const PColorMatrix< T1, N > &l, const PColorMatrix< T2, N > &r)
Definition qdp_primcolormat.h:322
QDP::traceMultiply
BinaryReturn< PMatrix< T1, N, C >, PMatrix< T2, N, C >, FnTraceMultiply >::Type_t traceMultiply(const PMatrix< T1, N, C > &l, const PMatrix< T2, N, C > &r)
Definition qdp_primmatrix.h:1055
QDP::traceSpinMultiply
BinaryReturn< PMatrix< T1, N, C >, PMatrix< T2, N, C >, FnTraceSpinMultiply >::Type_t traceSpinMultiply(const PMatrix< T1, N, C > &l, const PMatrix< T2, N, C > &r)
Definition qdp_primmatrix.h:1180
QDP::traceSpinOuterProduct
BinaryReturn< PScalar< T1 >, PScalar< T2 >, FnTraceSpinOuterProduct >::Type_t traceSpinOuterProduct(const PScalar< T1 > &l, const PScalar< T2 > &r)
PScalar = traceSpin(outerProduct(PScalar, PScalar)).
Definition qdp_primscalar.h:747
QDP::traceSpinQuarkContract13
BinaryReturn< PSpinMatrix< T1, 4 >, PSpinMatrix< T2, 4 >, FnTraceSpinQuarkContract13 >::Type_t traceSpinQuarkContract13(const PSpinMatrix< T1, 4 > &l, const PSpinMatrix< T2, 4 > &r)
PScalar = traceSpinQuarkContract13(PSpinMatrix,PSpinMatrix).
Definition qdp_primspinmat.h:1730
QDP
Yet another random number generator.
Definition qdp_bgq_threadbind.cc:16
QDP::traceSpin
MakeReturn< UnaryNode< FnTraceSpin, typenameCreateLeaf< QDPExpr< T1, C1 > >::Leaf_t >, typenameUnaryReturn< C1, FnTraceSpin >::Type_t >::Expression_t traceSpin(const QDPExpr< T1, C1 > &l)
Definition qdp.h:4959
QDP::real
MakeReturn< UnaryNode< FnReal, typenameCreateLeaf< QDPExpr< T1, C1 > >::Leaf_t >, typenameUnaryReturn< C1, FnReal >::Type_t >::Expression_t real(const QDPExpr< T1, C1 > &l)
Definition qdp.h:4972
QDP::trace
MakeReturn< UnaryNode< FnTrace, typenameCreateLeaf< QDPExpr< T1, C1 > >::Leaf_t >, typenameUnaryReturn< C1, FnTrace >::Type_t >::Expression_t trace(const QDPExpr< T1, C1 > &l)
Definition qdp.h:4907
QDP::operator*
MakeReturn< BinaryNode< OpMultiply, typenameCreateLeaf< QDPType< T1, C1 > >::Leaf_t, typenameCreateLeaf< QDPExpr< T2, C2 > >::Leaf_t >, typenameBinaryReturn< C1, C2, OpMultiply >::Type_t >::Expression_t operator*(const QDPType< T1, C1 > &l, const QDPExpr< T2, C2 > &r)
Definition qdp.h:2588
QDP::traceColor
MakeReturn< UnaryNode< FnTraceColor, typenameCreateLeaf< QDPExpr< T1, C1 > >::Leaf_t >, typenameUnaryReturn< C1, FnTraceColor >::Type_t >::Expression_t traceColor(const QDPExpr< T1, C1 > &l)
Definition qdp.h:4946
BinaryReturn::Type_t
Promote< T1, T2 >::Type_t Type_t
Definition TypeComputations.h:376
QDP::BinaryReturn::Type_t
Promote< T1, T2 >::Type_t Type_t
Definition qdp.h:377
QDP::FnTraceColorMultiply::operator()
BinaryReturn< T1, T2, FnTraceColorMultiply >::Type_t operator()(const T1 &a, const T2 &b) const
Definition qdp_optops.h:188
QDP::FnTraceMultiply::operator()
BinaryReturn< T1, T2, FnTraceMultiply >::Type_t operator()(const T1 &a, const T2 &b) const
Definition qdp_optops.h:175
QDP::FnTraceSpinMultiply::operator()
BinaryReturn< T1, T2, FnTraceSpinMultiply >::Type_t operator()(const T1 &a, const T2 &b) const
Definition qdp_optops.h:201
QDP::FnTraceSpinOuterProduct::operator()
BinaryReturn< T1, T2, FnTraceSpinOuterProduct >::Type_t operator()(const T1 &a, const T2 &b) const
Definition qdp_optops.h:214
QDP::FnTraceSpinQuarkContract13::operator()
BinaryReturn< T1, T2, FnTraceSpinQuarkContract13 >::Type_t operator()(const T1 &a, const T2 &b) const
Definition qdp_optops.h:227
QDP::MakeReturn::make
static Expression_t make(const T &a)
Definition qdp_qdpexpr.h:66
QDP::OpAdjMultiplyAdj::operator()
BinaryReturn< T1, T2, OpAdjMultiplyAdj >::Type_t operator()(const T1 &a, const T2 &b) const
Definition qdp_optops.h:50
QDP::OpAdjMultiply::operator()
BinaryReturn< T1, T2, OpAdjMultiply >::Type_t operator()(const T1 &a, const T2 &b) const
Definition qdp_optops.h:24
QDP::OpMultiplyAdj::operator()
BinaryReturn< T1, T2, OpMultiplyAdj >::Type_t operator()(const T1 &a, const T2 &b) const
Definition qdp_optops.h:37
Generated by doxygen 1.16.1