QDP++
qdp_qdpsubtype.h
Go to the documentation of this file.
1// -*- C++ -*-
7
8#ifndef QDP_QDPSUBTYPE_H
9#define QDP_QDPSUBTYPE_H
10
11namespace QDP {
12
13
15
20template<class T, class C>
21class QDPSubType
22{
24 typedef typename QDPSubTypeTrait<C>::Type_t CC;
25
26public:
28 QDPSubType() {}
29
31 QDPSubType(const QDPSubType&) {}
32
34 ~QDPSubType() {}
35
36
37 //---------------------------------------------------------
38 // Operators
39
40 inline
41 void assign(const typename WordType<C>::Type_t& rhs)
42 {
43 typedef typename SimpleScalar<typename WordType<C>::Type_t>::Type_t Scalar_t;
44 if (getOwnsMemory()) {
45 evaluate_F(getF(),OpAssign(),PETE_identity(Scalar_t(rhs)),subset());
46 } else {
47 C tmp(getF(),1.0);
48 evaluate(tmp,OpAssign(),PETE_identity(Scalar_t(rhs)),subset());
49 }
50 }
51
52 inline
53 void assign(const Zero&)
54 {
55 if (getOwnsMemory()) {
56 zero_rep_F(getF(),subset());
57 } else {
58 C tmp(getF(),1.0);
59 zero_rep(tmp,subset());
60 }
61 }
62
63 template<class T1,class C1>
64 inline
65 void assign(const QDPType<T1,C1>& rhs)
66 {
67 if (getOwnsMemory()) {
68 evaluate_F(getF(),OpAssign(),PETE_identity(rhs),subset());
69 } else {
70 C tmp(getF(),1.0);
71 evaluate(tmp,OpAssign(),PETE_identity(rhs),subset());
72 }
73 }
74
75
76 template<class T1,class C1>
77 inline
78 void assign(const QDPSubType<T1,C1>& rhs)
79 {
80 if (getOwnsMemory() && rhs.getOwnsMemory()) {
81 //std::cout << "own = own\n";
82 if (subset().numSiteTable() != rhs.subset().numSiteTable())
83 QDP_error_exit("assignment with incompatible subset sizes");
84 for(int j=0; j < subset().numSiteTable(); ++j)
85 getF()[j] = rhs.getF()[j];
86 } else
87
88#if 0
89 if (!getOwnsMemory() && rhs.getOwnsMemory()) {
90 //std::cout << "view = own\n";
91 if (subset().numSiteTable() != rhs.subset().numSiteTable())
92 QDP_error_exit("assignment with incompatible subset sizes");
93 const int *tab = subset().siteTable().slice();
94 for(int j=0; j < subset().numSiteTable(); ++j) {
95 int i = tab[j];
96 getF()[i] = rhs.getF()[j];
97 }
98 }
99 if (getOwnsMemory() && !rhs.getOwnsMemory()) {
100 //std::cout << "own = view\n";
101 if (subset().numSiteTable() != rhs.subset().numSiteTable())
102 QDP_error_exit("assignment with incompatible subset sizes");
103 const int *tab = rhs.subset().siteTable().slice();
104 for(int j=0; j < rhs.subset().numSiteTable(); ++j) {
105 int i = tab[j];
106 getF()[j] = rhs.getF()[i];
107 }
108 }
109 if (!getOwnsMemory() && !rhs.getOwnsMemory())
110#endif
111 QDP_error_exit("assignment of two view subtypes is not supported");
112 }
113
114
115 template<class T1,class C1>
116 inline
117 void assign(const QDPExpr<T1,C1>& rhs)
118 {
119 if (getOwnsMemory()) {
120 evaluate_F(getF(),OpAssign(),rhs,subset());
121 } else {
122 C tmp(getF(),1.0);
123 evaluate(tmp,OpAssign(),rhs,subset());
124 }
125 }
126
127 inline
128 void operator+=(const typename WordType<C>::Type_t& rhs)
129 {
130 typedef typename SimpleScalar<typename WordType<C>::Type_t>::Type_t Scalar_t;
131 if (getOwnsMemory()) {
132 evaluate_F(getF(),OpAddAssign(),PETE_identity(Scalar_t(rhs)),subset());
133 } else {
134 C tmp(getF(),1.0);
135 evaluate(tmp,OpAddAssign(),PETE_identity(Scalar_t(rhs)),subset());
136 }
137 }
138
139 template<class T1,class C1>
140 inline
141 void operator+=(const QDPType<T1,C1>& rhs)
142 {
143 if (getOwnsMemory()) {
144 evaluate_F(getF(),OpAddAssign(),PETE_identity(rhs),subset());
145 } else {
146 C tmp(getF(),1.0);
147 evaluate(tmp,OpAddAssign(),PETE_identity(rhs),subset());
148 }
149 }
150
151 template<class T1,class C1>
152 inline
153 void operator+=(const QDPExpr<T1,C1>& rhs)
154 {
155 if (getOwnsMemory()) {
156 evaluate_F(getF(),OpAddAssign(),rhs,subset());
157 } else {
158 C tmp(getF(),1.0);
159 evaluate(tmp,OpAddAssign(),rhs,subset());
160 }
161 }
162
163 inline
164 void operator-=(const typename WordType<C>::Type_t& rhs)
165 {
166 typedef typename SimpleScalar<typename WordType<C>::Type_t>::Type_t Scalar_t;
167 if (getOwnsMemory()) {
168 evaluate_F(getF(),OpSubtractAssign(),PETE_identity(Scalar_t(rhs)),subset());
169 } else {
170 C tmp(getF(),1.0);
171 evaluate(tmp,OpSubtractAssign(),PETE_identity(Scalar_t(rhs)),subset());
172 }
173 }
174
175 template<class T1,class C1>
176 inline
177 void operator-=(const QDPType<T1,C1>& rhs)
178 {
179 if (getOwnsMemory()) {
180 evaluate_F(getF(),OpSubtractAssign(),PETE_identity(rhs),subset());
181 } else {
182 C tmp(getF(),1.0);
183 evaluate(tmp,OpSubtractAssign(),PETE_identity(rhs),subset());
184 }
185 }
186
187 template<class T1,class C1>
188 inline
189 void operator-=(const QDPExpr<T1,C1>& rhs)
190 {
191 if (getOwnsMemory()) {
192 evaluate_F(getF(),OpSubtractAssign(),rhs,subset());
193 } else {
194 C tmp(getF(),1.0);
195 evaluate(tmp,OpSubtractAssign(),rhs,subset());
196 }
197 }
198
199 inline
200 void operator*=(const typename WordType<C>::Type_t& rhs)
201 {
202 typedef typename SimpleScalar<typename WordType<C>::Type_t>::Type_t Scalar_t;
203 if (getOwnsMemory()) {
204 evaluate_F(getF(),OpMultiplyAssign(),PETE_identity(Scalar_t(rhs)),subset());
205 } else {
206 C tmp(getF(),1.0);
207 evaluate(tmp,OpMultiplyAssign(),PETE_identity(Scalar_t(rhs)),subset());
208 }
209 }
210
211 template<class T1,class C1>
212 inline
213 void operator*=(const QDPType<T1,C1>& rhs)
214 {
215 if (getOwnsMemory()) {
216 evaluate_F(getF(),OpMultiplyAssign(),PETE_identity(rhs),subset());
217 } else {
218 C tmp(getF(),1.0);
219 evaluate(tmp,OpMultiplyAssign(),PETE_identity(rhs),subset());
220 }
221 }
222
223 template<class T1,class C1>
224 inline
225 void operator*=(const QDPExpr<T1,C1>& rhs)
226 {
227 if (getOwnsMemory()) {
228 evaluate_F(getF(),OpMultiplyAssign(),rhs,subset());
229 } else {
230 C tmp(getF(),1.0);
231 evaluate(tmp,OpMultiplyAssign(),rhs,subset());
232 }
233 }
234
235 inline
236 void operator/=(const typename WordType<C>::Type_t& rhs)
237 {
238 typedef typename SimpleScalar<typename WordType<C>::Type_t>::Type_t Scalar_t;
239 if (getOwnsMemory()) {
240 evaluate_F(getF(),OpDivideAssign(),PETE_identity(Scalar_t(rhs)),subset());
241 } else {
242 C tmp(getF(),1.0);
243 evaluate(tmp,OpDivideAssign(),PETE_identity(Scalar_t(rhs)),subset());
244 }
245 }
246
247 template<class T1,class C1>
248 inline
249 void operator/=(const QDPType<T1,C1>& rhs)
250 {
251 if (getOwnsMemory()) {
252 evaluate_F(getF(),OpDivideAssign(),PETE_identity(rhs),subset());
253 } else {
254 C tmp(getF(),1.0);
255 evaluate(tmp,OpDivideAssign(),PETE_identity(rhs),subset());
256 }
257 }
258
259 template<class T1,class C1>
260 inline
261 void operator/=(const QDPExpr<T1,C1>& rhs)
262 {
263 if (getOwnsMemory()) {
264 evaluate_F(getF(),OpDivideAssign(),rhs,subset());
265 } else {
266 C tmp(getF(),1.0);
267 evaluate(tmp,OpDivideAssign(),rhs,subset());
268 }
269 }
270
271 inline
272 void operator%=(const typename WordType<C>::Type_t& rhs)
273 {
274 typedef typename SimpleScalar<typename WordType<C>::Type_t>::Type_t Scalar_t;
275 if (getOwnsMemory()) {
276 evaluate_F(getF(),OpModAssign(),PETE_identity(Scalar_t(rhs)),subset());
277 } else {
278 C tmp(getF(),1.0);
279 evaluate(tmp,OpModAssign(),PETE_identity(Scalar_t(rhs)),subset());
280 }
281 }
282
283 template<class T1,class C1>
284 inline
285 void operator%=(const QDPType<T1,C1>& rhs)
286 {
287 if (getOwnsMemory()) {
288 evaluate_F(getF(),OpModAssign(),PETE_identity(rhs),subset());
289 } else {
290 C tmp(getF(),1.0);
291 evaluate(tmp,OpModAssign(),PETE_identity(rhs),subset());
292 }
293 }
294
295 template<class T1,class C1>
296 inline
297 void operator%=(const QDPExpr<T1,C1>& rhs)
298 {
299 if (getOwnsMemory()) {
300 evaluate_F(getF(),OpModAssign(),rhs,subset());
301 } else {
302 C tmp(getF(),1.0);
303 evaluate(tmp,OpModAssign(),rhs,subset());
304 }
305 }
306
307 inline
308 void operator|=(const typename WordType<C>::Type_t& rhs)
309 {
310 typedef typename SimpleScalar<typename WordType<C>::Type_t>::Type_t Scalar_t;
311 if (getOwnsMemory()) {
312 evaluate_F(getF(),OpBitwiseOrAssign(),PETE_identity(Scalar_t(rhs)),subset());
313 } else {
314 C tmp(getF(),1.0);
315 evaluate(tmp,OpBitwiseOrAssign(),PETE_identity(Scalar_t(rhs)),subset());
316 }
317 }
318
319 template<class T1,class C1>
320 inline
321 void operator|=(const QDPType<T1,C1>& rhs)
322 {
323 if (getOwnsMemory()) {
324 evaluate_F(getF(),OpBitwiseOrAssign(),PETE_identity(rhs),subset());
325 } else {
326 C tmp(getF(),1.0);
327 evaluate(tmp,OpBitwiseOrAssign(),PETE_identity(rhs),subset());
328 }
329 }
330
331 template<class T1,class C1>
332 inline
333 void operator|=(const QDPExpr<T1,C1>& rhs)
334 {
335 if (getOwnsMemory()) {
336 evaluate_F(getF(),OpBitwiseOrAssign(),PETE_identity(rhs),subset());
337 } else {
338 C tmp(getF(),1.0);
339 evaluate(tmp,OpBitwiseOrAssign(),PETE_identity(rhs),subset());
340 }
341 }
342
343 inline
344 void operator&=(const typename WordType<C>::Type_t& rhs)
345 {
346 typedef typename SimpleScalar<typename WordType<C>::Type_t>::Type_t Scalar_t;
347 if (getOwnsMemory()) {
348 evaluate_F(getF(),OpBitwiseAndAssign(),PETE_identity(Scalar_t(rhs)),subset());
349 } else {
350 C tmp(getF(),1.0);
351 evaluate(tmp,OpBitwiseAndAssign(),PETE_identity(Scalar_t(rhs)),subset());
352 }
353 }
354
355 template<class T1,class C1>
356 inline
357 void operator&=(const QDPType<T1,C1>& rhs)
358 {
359 if (getOwnsMemory()) {
360 evaluate_F(getF(),OpBitwiseAndAssign(),PETE_identity(rhs),subset());
361 } else {
362 C tmp(getF(),1.0);
363 evaluate(tmp,OpBitwiseAndAssign(),PETE_identity(rhs),subset());
364 }
365 }
366
367 template<class T1,class C1>
368 inline
369 void operator&=(const QDPExpr<T1,C1>& rhs)
370 {
371 if (getOwnsMemory()) {
372 evaluate_F(getF(),OpBitwiseAndAssign(),rhs,subset());
373 } else {
374 C tmp(getF(),1.0);
375 evaluate(tmp,OpBitwiseAndAssign(),rhs,subset());
376 }
377 }
378
379 inline
380 void operator^=(const typename WordType<C>::Type_t& rhs)
381 {
382 typedef typename SimpleScalar<typename WordType<C>::Type_t>::Type_t Scalar_t;
383 if (getOwnsMemory()) {
384 evaluate_F(getF(),OpBitwiseXorAssign(),PETE_identity(Scalar_t(rhs)),subset());
385 } else {
386 C tmp(getF(),1.0);
387 evaluate(tmp,OpBitwiseXorAssign(),PETE_identity(Scalar_t(rhs)),subset());
388 }
389 }
390
391 template<class T1,class C1>
392 inline
393 void operator^=(const QDPType<T1,C1>& rhs)
394 {
395 if (getOwnsMemory()) {
396 evaluate_F(getF(),OpBitwiseXorAssign(),PETE_identity(rhs),subset());
397 } else {
398 C tmp(getF(),1.0);
399 evaluate(tmp,OpBitwiseXorAssign(),PETE_identity(rhs),subset());
400 }
401 }
402
403 template<class T1,class C1>
404 inline
405 void operator^=(const QDPExpr<T1,C1>& rhs)
406 {
407 if (getOwnsMemory()) {
408 evaluate_F(getF(),OpBitwiseXorAssign(),rhs,subset());
409 } else {
410 C tmp(getF(),1.0);
411 evaluate(tmp,OpBitwiseXorAssign(),rhs,subset());
412 }
413 }
414
415 inline
416 void operator<<=(const typename WordType<C>::Type_t& rhs)
417 {
418 typedef typename SimpleScalar<typename WordType<C>::Type_t>::Type_t Scalar_t;
419 if (getOwnsMemory()) {
420 evaluate_F(getF(),OpLeftShiftAssign(),PETE_identity(Scalar_t(rhs)),subset());
421 } else {
422 C tmp(getF(),1.0);
423 evaluate(tmp,OpLeftShiftAssign(),PETE_identity(Scalar_t(rhs)),subset());
424 }
425 }
426
427 template<class T1,class C1>
428 inline
429 void operator<<=(const QDPType<T1,C1>& rhs)
430 {
431 if (getOwnsMemory()) {
432 evaluate_F(getF(),OpLeftShiftAssign(),PETE_identity(rhs),subset());
433 } else {
434 C tmp(getF(),1.0);
435 evaluate(tmp,OpLeftShiftAssign(),PETE_identity(rhs),subset());
436 }
437 }
438
439 template<class T1,class C1>
440 inline
441 void operator<<=(const QDPExpr<T1,C1>& rhs)
442 {
443 if (getOwnsMemory()) {
444 evaluate_F(getF(),OpLeftShiftAssign(),rhs,subset());
445 } else {
446 C tmp(getF(),1.0);
447 evaluate(tmp,OpLeftShiftAssign(),rhs,subset());
448 }
449 }
450
451
452 inline
453 void operator>>=(const typename WordType<C>::Type_t& rhs)
454 {
455 typedef typename SimpleScalar<typename WordType<C>::Type_t>::Type_t Scalar_t;
456 if (getOwnsMemory()) {
457 evaluate_F(getF(),OpRightShiftAssign(),PETE_identity(Scalar_t(rhs)),subset());
458 } else {
459 C tmp(getF(),1.0);
460 evaluate(tmp,OpRightShiftAssign(),PETE_identity(Scalar_t(rhs)),subset());
461 }
462 }
463
464 template<class T1,class C1>
465 inline
466 void operator>>=(const QDPType<T1,C1>& rhs)
467 {
468 if (getOwnsMemory()) {
469 evaluate_F(getF(),OpRightShiftAssign(),PETE_identity(rhs),subset());
470 } else {
471 C tmp(getF(),1.0);
472 evaluate(tmp,OpRightShiftAssign(),PETE_identity(rhs),subset());
473 }
474 }
475
476 template<class T1,class C1>
477 inline
478 void operator>>=(const QDPExpr<T1,C1>& rhs)
479 {
480 if (getOwnsMemory()) {
481 evaluate_F(getF(),OpRightShiftAssign(),rhs,subset());
482 } else {
483 C tmp(getF(),1.0);
484 evaluate(tmp,OpRightShiftAssign(),rhs,subset());
485 }
486 }
487
488private:
490 inline
491 C& operator=(const QDPSubType& rhs) {}
492
493public:
494 //C& field() {return static_cast<CC*>(this)->field();}
495 bool getOwnsMemory() { return static_cast<CC*>(this)->getOwnsMemory(); }
496 bool getOwnsMemory() const { return static_cast<const CC*>(this)->getOwnsMemory(); }
497 T* getF() {return static_cast<CC*>(this)->getF();}
498 T* getF() const {return static_cast<CC const *>(this)->getF();}
499 const Subset& subset() const {return static_cast<const CC*>(this)->subset();}
500
501};
502
503
504} // namespace QDP
505
506#endif
507
508
509
QDP::QDPExpr
Expression class for QDP.
Definition qdp_qdpexpr.h:16
QDP::QDPSubType
QDPSubType - type representing a field living on a subset.
Definition qdp_qdpsubtype.h:22
QDP::QDPSubType::subset
const Subset & subset() const
Definition qdp_qdpsubtype.h:499
QDP::QDPSubType::QDPSubType
QDPSubType(const QDPSubType &)
Copy constructor.
Definition qdp_qdpsubtype.h:31
QDP::QDPSubType::operator-=
void operator-=(const typename WordType< C >::Type_t &rhs)
Definition qdp_qdpsubtype.h:164
QDP::QDPSubType::operator/=
void operator/=(const QDPExpr< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:261
QDP::QDPSubType::operator+=
void operator+=(const typename WordType< C >::Type_t &rhs)
Definition qdp_qdpsubtype.h:128
QDP::QDPSubType::assign
void assign(const QDPType< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:65
QDP::QDPSubType::assign
void assign(const Zero &)
Definition qdp_qdpsubtype.h:53
QDP::QDPSubType::~QDPSubType
~QDPSubType()
Destructor.
Definition qdp_qdpsubtype.h:34
QDP::QDPSubType::operator^=
void operator^=(const QDPType< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:393
QDP::QDPSubType::operator&=
void operator&=(const QDPExpr< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:369
QDP::QDPSubType::operator<<=
void operator<<=(const QDPExpr< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:441
QDP::QDPSubType::assign
void assign(const typename WordType< C >::Type_t &rhs)
Definition qdp_qdpsubtype.h:41
QDP::QDPSubType::operator%=
void operator%=(const QDPExpr< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:297
QDP::QDPSubType::operator%=
void operator%=(const QDPType< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:285
QDP::QDPSubType::QDPSubType
QDPSubType()
Default constructor.
Definition qdp_qdpsubtype.h:28
QDP::QDPSubType::operator>>=
void operator>>=(const QDPType< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:466
QDP::QDPSubType::operator^=
void operator^=(const typename WordType< C >::Type_t &rhs)
Definition qdp_qdpsubtype.h:380
QDP::QDPSubType::operator%=
void operator%=(const typename WordType< C >::Type_t &rhs)
Definition qdp_qdpsubtype.h:272
QDP::QDPSubType::operator<<=
void operator<<=(const QDPType< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:429
QDP::QDPSubType::assign
void assign(const QDPExpr< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:117
QDP::QDPSubType::operator>>=
void operator>>=(const QDPExpr< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:478
QDP::QDPSubType::operator-=
void operator-=(const QDPType< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:177
QDP::QDPSubType::getOwnsMemory
bool getOwnsMemory() const
Definition qdp_qdpsubtype.h:496
QDP::QDPSubType::operator>>=
void operator>>=(const typename WordType< C >::Type_t &rhs)
Definition qdp_qdpsubtype.h:453
QDP::QDPSubType::operator*=
void operator*=(const typename WordType< C >::Type_t &rhs)
Definition qdp_qdpsubtype.h:200
QDP::QDPSubType::operator&=
void operator&=(const QDPType< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:357
QDP::QDPSubType::operator<<=
void operator<<=(const typename WordType< C >::Type_t &rhs)
Definition qdp_qdpsubtype.h:416
QDP::QDPSubType::assign
void assign(const QDPSubType< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:78
QDP::QDPSubType::operator|=
void operator|=(const typename WordType< C >::Type_t &rhs)
Definition qdp_qdpsubtype.h:308
QDP::QDPSubType::operator|=
void operator|=(const QDPExpr< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:333
QDP::QDPSubType::operator+=
void operator+=(const QDPType< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:141
QDP::QDPSubType::operator|=
void operator|=(const QDPType< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:321
QDP::QDPSubType::operator&=
void operator&=(const typename WordType< C >::Type_t &rhs)
Definition qdp_qdpsubtype.h:344
QDP::QDPSubType::operator/=
void operator/=(const typename WordType< C >::Type_t &rhs)
Definition qdp_qdpsubtype.h:236
QDP::QDPSubType::operator^=
void operator^=(const QDPExpr< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:405
QDP::QDPSubType::operator+=
void operator+=(const QDPExpr< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:153
QDP::QDPSubType::operator*=
void operator*=(const QDPType< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:213
QDP::QDPSubType::operator*=
void operator*=(const QDPExpr< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:225
QDP::QDPSubType::operator-=
void operator-=(const QDPExpr< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:189
QDP::QDPSubType::operator/=
void operator/=(const QDPType< T1, C1 > &rhs)
Definition qdp_qdpsubtype.h:249
QDP::QDPType
QDPType - major type class/container for all QDP objects.
Definition qdp_qdptype.h:29
QDP::Subset
Subsets - controls how lattices are looped.
Definition qdp_subset.h:39
QDP::Subset::siteTable
const multi1d< int > & siteTable() const
Definition qdp_subset.h:83
QDP::Subset::numSiteTable
int numSiteTable() const
Definition qdp_subset.h:84
QDP::multi1d::slice
const T * slice() const
Return ref to a column slice.
Definition qdp_multi.h:225
QDP::zero_rep
void zero_rep(IScalar< T > &dest)
dest = 0
Definition qdp_inner.h:1841
QDP::evaluate
void evaluate(OLattice< DCol > &d, const OpAssign &op, const QDPExpr< BinaryNode< OpMultiply, Reference< QDPType< DCol, OLattice< DCol > > >, Reference< QDPType< DCol, OLattice< DCol > > > >, OLattice< DCol > > &rhs, const Subset &s)
Definition qdp_scalarsite_linalg_double.cc:78
QDP::C
OLattice< PScalar< PColorMatrix< RComplexFloat, 3 > > > C
Definition qdp_scalarsite_generic_linalg.h:12
QDP
Yet another random number generator.
Definition qdp_bgq_threadbind.cc:16
QDP::QDP_error_exit
void QDP_error_exit(const char *format,...)
Simple error display and abort routine.
Definition qdp_util.cc:93
QDP::PETE_identity
MakeReturn< UnaryNode< OpIdentity, typenameCreateLeaf< QDPExpr< T1, C1 > >::Leaf_t >, typenameUnaryReturn< C1, OpIdentity >::Type_t >::Expression_t PETE_identity(const QDPExpr< T1, C1 > &l)
Definition qdp.h:5531
QDP::evaluate_F
void evaluate_F(T *dest, const Op &op, const QDPExpr< RHS, OScalar< T1 > > &rhs, const Subset &s)
Definition qdp_outer.h:242
QDP::zero_rep_F
void zero_rep_F(T *dest, const Subset &s)
Definition qdp_globalfuncs_subtype.h:171
QDP::SimpleScalar
Construct simple word type. Default behavior is empty.
Definition qdp_traits.h:93
QDP::Zero
Simple zero tag.
Definition qdp_traits.h:122
Generated by doxygen 1.16.1