QDP++
qdp_primspinmat.h
Go to the documentation of this file.
1// -*- C++ -*-
2
6
7#ifndef QDP_PRIMSPINMAT_H
8#define QDP_PRIMSPINMAT_H
9
10namespace QDP {
11
12
13//-------------------------------------------------------------------------------------
21
22
24
31template <class T, int N> class PSpinMatrix : public PMatrix<T, N, PSpinMatrix>
32{
33public:
35
36 template<class T1>
37 inline
38 PSpinMatrix& operator=(const PScalar<T1>& rhs)
39 {
40 this->assign(rhs);
41 return *this;
42 }
43
45
46 template<class T1>
47 inline
48 PSpinMatrix& operator=(const PSpinMatrix<T1,N>& rhs)
49 {
50 this->assign(rhs);
51 return *this;
52 }
53
54};
55 // end of group primspinmatrix
57
58#if 0
60
63template <class T> class PSpinMatrix<T,4> : public PMatrix<T,4, PSpinMatrix>
64{
65public:
66};
67#endif
68
69
70//-----------------------------------------------------------------------------
71// Traits classes
72//-----------------------------------------------------------------------------
73
74// Underlying word type
75template<class T1, int N>
76struct WordType<PSpinMatrix<T1,N> >
77{
78 typedef typename WordType<T1>::Type_t Type_t;
79};
80
81template<class T1, int N>
86
87template<class T1, int N>
92
93// Internally used scalars
94template<class T, int N>
98
99// Makes a primitive into a scalar leaving grid alone
100template<class T, int N>
104
105// Makes a lattice scalar leaving primitive indices alone
106template<class T, int N>
110
111
112//-----------------------------------------------------------------------------
113// Traits classes to support return types
114//-----------------------------------------------------------------------------
115
116// Default unary(PSpinMatrix) -> PSpinMatrix
117template<class T1, int N, class Op>
121
122// Default binary(PScalar,PSpinMatrix) -> PSpinMatrix
123template<class T1, class T2, int N, class Op>
127
128// Default binary(PSpinMatrix,PSpinMatrix) -> PSpinMatrix
129template<class T1, class T2, int N, class Op>
133
134// Default binary(PSpinMatrix,PScalar) -> PSpinMatrix
135template<class T1, int N, class T2, class Op>
139
140
141#if 0
142template<class T1, class T2>
143struct UnaryReturn<PSpinMatrix<T2,N>, OpCast<T1> > {
144 typedef PScalar<typename UnaryReturn<T, OpCast>::Type_t, N> Type_t;
145// typedef T1 Type_t;
146};
147#endif
148
149
150// Assignment is different
151template<class T1, class T2, int N>
155
156template<class T1, class T2, int N>
160
161template<class T1, class T2, int N>
165
166template<class T1, class T2, int N>
170
171
172template<class T1, class T2, int N>
176
177template<class T1, class T2, int N>
181
182template<class T1, class T2, int N>
186
187template<class T1, class T2, int N>
191
192template<class T1, class T2, int N>
196
197
198
199// SpinMatrix
200template<class T, int N>
204
205template<class T, int N>
209
210template<class T, int N>
214
215template<class T, int N>
219
220template<class T, int N>
224
225template<class T, int N>
229
230template<class T1, class T2, int N>
234
235template<class T1, class T2, int N>
239
240template<class T1, class T2, int N>
244
245template<class T1, class T2, int N>
249
250template<class T1, class T2, int N>
254
255template<class T1, class T2, int N>
259
260template<class T1, class T2, int N>
264
265template<class T1, class T2, int N>
269
270template<class T1, class T2, int N>
274
275template<class T1, class T2, int N>
279
280template<class T1, class T2, int N>
284
285template<class T1, class T2, int N>
289
290template<class T1, class T2, int N>
294
295template<class T1, class T2, int N>
299
300template<class T1, class T2, int N>
304
305
306
307// Gamma algebra
308template<int m, class T2, int N, class OpGammaConstMultiply>
312
313template<class T2, int N, int m, class OpMultiplyGammaConst>
317
318template<class T2, int N, class OpGammaTypeMultiply>
322
323template<class T2, int N, class OpMultiplyGammaType>
327
328
329// Gamma algebra
330template<int m, class T2, int N, class OpGammaConstDPMultiply>
334
335template<class T2, int N, int m, class OpMultiplyGammaConstDP>
339
340template<class T2, int N, class OpGammaTypeDPMultiply>
344
345template<class T2, int N, class OpMultiplyGammaTypeDP>
349
350
351
352
353//-----------------------------------------------------------------------------
354// Operators
355//-----------------------------------------------------------------------------
358
359// SpinMatrix class primitive operations
360
361// trace = traceSpin(source1)
363template<class T, int N>
367
368template<class T, int N>
369inline typename UnaryReturn<PSpinMatrix<T,N>, FnTraceSpin>::Type_t
370traceSpin(const PSpinMatrix<T,N>& s1)
371{
372 typename UnaryReturn<PSpinMatrix<T,N>, FnTraceSpin>::Type_t d;
373
374 // Since the spin index is eaten, do not need to pass on function by
375 // calling trace(...) again
376 d.elem() = s1.elem(0,0);
377 for(int i=1; i < N; ++i)
378 d.elem() += s1.elem(i,i);
379
380 return d;
381}
382
384template<class T1, class T2, int N>
388
389template<class T1, class T2, int N>
390inline typename BinaryReturn<PSpinMatrix<T1,N>, PSpinMatrix<T2,N>, FnTraceSpinMultiply>::Type_t
391traceSpinMultiply(const PSpinMatrix<T1,N>& l, const PSpinMatrix<T2,N>& r)
392{
393 typename BinaryReturn<PSpinMatrix<T1,N>, PSpinMatrix<T2,N>, FnTraceSpinMultiply>::Type_t d;
394
395 // The traceSpin is eaten here
396 d.elem() = l.elem(0,0) * r.elem(0,0);
397 for(int k=1; k < N; ++k)
398 d.elem() += l.elem(0,k) * r.elem(k,0);
399
400 for(int j=1; j < N; ++j)
401 for(int k=0; k < N; ++k)
402 d.elem() += l.elem(j,k) * r.elem(k,j);
403
404 return d;
405}
406
408template<class T1, class T2, int N>
412
413template<class T1, class T2, int N, template<class,int> class C>
414inline typename BinaryReturn<PSpinMatrix<T1,N>, PScalar<T2>, FnTraceSpinMultiply>::Type_t
415traceSpinMultiply(const PSpinMatrix<T1,N>& l, const PScalar<T2>& r)
416{
417 typename BinaryReturn<PSpinMatrix<T1,N>, PScalar<T2>, FnTraceSpinMultiply>::Type_t d;
418
419 // The traceSpin is eaten here
420 d.elem() = l.elem(0,0) * r.elem();
421 for(int k=1; k < N; ++k)
422 d.elem() += l.elem(k,k) * r.elem();
423
424 return d;
425}
426
427// PScalar = traceSpinMultiply(PScalar,PSpinMatrix)
428template<class T1, class T2, int N>
432
433template<class T1, class T2, int N>
434inline typename BinaryReturn<PScalar<T1>, PSpinMatrix<T2,N>, FnTraceSpinMultiply>::Type_t
435traceSpinMultiply(const PScalar<T1>& l, const PSpinMatrix<T2,N>& r)
436{
437 typename BinaryReturn<PScalar<T1>, PSpinMatrix<T2,N>, FnTraceSpinMultiply>::Type_t d;
438
439 // The traceSpin is eaten here
440 d.elem() = l.elem() * r.elem(0,0);
441 for(int k=1; k < N; ++k)
442 d.elem() += l.elem() * r.elem(k,k);
443
444 return d;
445}
446
447
448
450template <class T, int N>
454
456
457template<class T, int N>
458inline typename UnaryReturn<PSpinMatrix<T,N>, FnTransposeSpin >::Type_t
459transposeSpin(const PSpinMatrix<T,N>& s1)
460{
461 typename UnaryReturn<PSpinMatrix<T,N>, FnTransposeSpin>::Type_t d;
462
463 for(int i=0; i < N; i++) {
464 for(int j=0; j < N; j++) {
465 // Transpose, so flip indices
466 d.elem(i,j) = s1.elem(j,i);
467 }
468 }
469 return d;
470}
471
472
473//-----------------------------------------------
475template<class T1, class T2, int N>
479
480template<class T1, class T2, int N>
481inline typename BinaryReturn<PSpinMatrix<T1,N>, PSpinMatrix<T2,N>, FnLocalColorInnerProduct>::Type_t
482localColorInnerProduct(const PSpinMatrix<T1,N>& l, const PSpinMatrix<T2,N>& r)
483{
484 typename BinaryReturn<PSpinMatrix<T1,N>, PSpinMatrix<T2,N>, FnLocalColorInnerProduct>::Type_t d;
485
486 for(int i=0; i < N; ++i)
487 for(int j=0; j < N; ++j)
488 {
489 d.elem(i,j) = localColorInnerProduct(l.elem(0,i), r.elem(0,j));
490 for(int k=1; k < N; ++k)
491 d.elem(i,j) += localColorInnerProduct(l.elem(k,i), r.elem(k,j));
492 }
493
494 return d;
495}
496
497
498//-----------------------------------------------
499// OuterProduct must be handled specially for each color and spin
500// The problem is the traits class - I have no way to say to PVector's
501// transform into a PMatrix but downcast the trait to a PColorMatrix or
502// PSpinMatrix
503
505template<class T1, class T2, int N>
509
510template<class T1, class T2, int N>
511inline typename BinaryReturn<PSpinVector<T1,N>, PSpinVector<T2,N>, FnOuterProduct>::Type_t
512outerProduct(const PSpinVector<T1,N>& l, const PSpinVector<T2,N>& r)
513{
514 typename BinaryReturn<PSpinVector<T1,N>, PSpinVector<T2,N>, FnOuterProduct>::Type_t d;
515
516 for(int i=0; i < N; ++i)
517 for(int j=0; j < N; ++j)
518 d.elem(i,j) = outerProduct(l.elem(i),r.elem(j));
519
520 return d;
521}
522
523
524//-----------------------------------------------
525// Optimization of traceSpin(outerProduct(PSpinVector, PSpinVector))
526
528template<class T1, class T2, int N>
532
533template<class T1, class T2, int N>
534inline typename BinaryReturn<PSpinVector<T1,N>, PSpinVector<T2,N>, FnTraceSpinOuterProduct>::Type_t
535traceSpinOuterProduct(const PSpinVector<T1,N>& l, const PSpinVector<T2,N>& r)
536{
537 typename BinaryReturn<PSpinVector<T1,N>, PSpinVector<T2,N>, FnTraceSpinOuterProduct>::Type_t d;
538
539 d.elem() = outerProduct(l.elem(0),r.elem(0));
540 for(int i=1; i < N; ++i)
541 d.elem() += outerProduct(l.elem(i),r.elem(i));
542
543 return d;
544}
545
546
547//-----------------------------------------------
548// Peeking and poking
550
551template<class T, int N>
555
556template<class T, int N>
557inline typename UnaryReturn<PSpinMatrix<T,N>, FnPeekSpinMatrix>::Type_t
558peekSpin(const PSpinMatrix<T,N>& l, int row, int col)
559{
560 typename UnaryReturn<PSpinMatrix<T,N>, FnPeekSpinMatrix>::Type_t d;
561
562 // Note, do not need to propagate down since the function is eaten at this level
563 d.elem() = l.elem(row,col);
564 return d;
565}
566
568template<class T1, class T2, int N>
569inline PSpinMatrix<T1,N>&
570pokeSpin(PSpinMatrix<T1,N>& l, const PScalar<T2>& r, int row, int col)
571{
572 // Note, do not need to propagate down since the function is eaten at this level
573 l.elem(row,col) = r.elem();
574 return l;
575}
576
577
578
579//-----------------------------------------------
580
581// SpinMatrix<4> = Gamma<4,m> * SpinMatrix<4>
582// There are 16 cases here for Nd=4
583template<class T2>
584inline typename BinaryReturn<GammaConst<4,0>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
585operator*(const GammaConst<4,0>&, const PSpinMatrix<T2,4>& r)
586{
587 typename BinaryReturn<GammaConst<4,0>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
588
589 for(int i=0; i < 4; ++i)
590 {
591 d.elem(0,i) = r.elem(0,i);
592 d.elem(1,i) = r.elem(1,i);
593 d.elem(2,i) = r.elem(2,i);
594 d.elem(3,i) = r.elem(3,i);
595 }
596
597 return d;
598}
599
600template<class T2>
601inline typename BinaryReturn<GammaConst<4,1>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
602operator*(const GammaConst<4,1>&, const PSpinMatrix<T2,4>& r)
603{
604 typename BinaryReturn<GammaConst<4,1>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
605
606 for(int i=0; i < 4; ++i)
607 {
608 d.elem(0,i) = timesI(r.elem(3,i));
609 d.elem(1,i) = timesI(r.elem(2,i));
610 d.elem(2,i) = timesMinusI(r.elem(1,i));
611 d.elem(3,i) = timesMinusI(r.elem(0,i));
612 }
613
614 return d;
615}
616
617template<class T2>
618inline typename BinaryReturn<GammaConst<4,2>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
619operator*(const GammaConst<4,2>&, const PSpinMatrix<T2,4>& r)
620{
621 typename BinaryReturn<GammaConst<4,2>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
622
623 for(int i=0; i < 4; ++i)
624 {
625 d.elem(0,i) = -r.elem(3,i);
626 d.elem(1,i) = r.elem(2,i);
627 d.elem(2,i) = r.elem(1,i);
628 d.elem(3,i) = -r.elem(0,i);
629 }
630
631 return d;
632}
633
634template<class T2>
635inline typename BinaryReturn<GammaConst<4,3>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
636operator*(const GammaConst<4,3>&, const PSpinMatrix<T2,4>& r)
637{
638 typename BinaryReturn<GammaConst<4,3>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
639
640 for(int i=0; i < 4; ++i)
641 {
642 d.elem(0,i) = timesMinusI(r.elem(0,i));
643 d.elem(1,i) = timesI(r.elem(1,i));
644 d.elem(2,i) = timesMinusI(r.elem(2,i));
645 d.elem(3,i) = timesI(r.elem(3,i));
646 }
647
648 return d;
649}
650
651template<class T2>
652inline typename BinaryReturn<GammaConst<4,4>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
653operator*(const GammaConst<4,4>&, const PSpinMatrix<T2,4>& r)
654{
655 typename BinaryReturn<GammaConst<4,4>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
656
657 for(int i=0; i < 4; ++i)
658 {
659 d.elem(0,i) = timesI(r.elem(2,i));
660 d.elem(1,i) = timesMinusI(r.elem(3,i));
661 d.elem(2,i) = timesMinusI(r.elem(0,i));
662 d.elem(3,i) = timesI(r.elem(1,i));
663 }
664
665 return d;
666}
667
668template<class T2>
669inline typename BinaryReturn<GammaConst<4,5>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
670operator*(const GammaConst<4,5>&, const PSpinMatrix<T2,4>& r)
671{
672 typename BinaryReturn<GammaConst<4,5>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
673
674 for(int i=0; i < 4; ++i)
675 {
676 d.elem(0,i) = -r.elem(1,i);
677 d.elem(1,i) = r.elem(0,i);
678 d.elem(2,i) = -r.elem(3,i);
679 d.elem(3,i) = r.elem(2,i);
680 }
681
682 return d;
683}
684
685template<class T2>
686inline typename BinaryReturn<GammaConst<4,6>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
687operator*(const GammaConst<4,6>&, const PSpinMatrix<T2,4>& r)
688{
689 typename BinaryReturn<GammaConst<4,6>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
690
691 for(int i=0; i < 4; ++i)
692 {
693 d.elem(0,i) = timesMinusI(r.elem(1,i));
694 d.elem(1,i) = timesMinusI(r.elem(0,i));
695 d.elem(2,i) = timesMinusI(r.elem(3,i));
696 d.elem(3,i) = timesMinusI(r.elem(2,i));
697 }
698
699 return d;
700}
701
702template<class T2>
703inline typename BinaryReturn<GammaConst<4,7>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
704operator*(const GammaConst<4,7>&, const PSpinMatrix<T2,4>& r)
705{
706 typename BinaryReturn<GammaConst<4,7>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
707
708 for(int i=0; i < 4; ++i)
709 {
710 d.elem(0,i) = r.elem(2,i);
711 d.elem(1,i) = r.elem(3,i);
712 d.elem(2,i) = -r.elem(0,i);
713 d.elem(3,i) = -r.elem(1,i);
714 }
715
716 return d;
717}
718
719template<class T2>
720inline typename BinaryReturn<GammaConst<4,8>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
721operator*(const GammaConst<4,8>&, const PSpinMatrix<T2,4>& r)
722{
723 typename BinaryReturn<GammaConst<4,8>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
724
725 for(int i=0; i < 4; ++i)
726 {
727 d.elem(0,i) = r.elem(2,i);
728 d.elem(1,i) = r.elem(3,i);
729 d.elem(2,i) = r.elem(0,i);
730 d.elem(3,i) = r.elem(1,i);
731 }
732
733 return d;
734}
735
736template<class T2>
737inline typename BinaryReturn<GammaConst<4,9>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
738operator*(const GammaConst<4,9>&, const PSpinMatrix<T2,4>& r)
739{
740 typename BinaryReturn<GammaConst<4,9>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
741
742 for(int i=0; i < 4; ++i)
743 {
744 d.elem(0,i) = timesI(r.elem(1,i));
745 d.elem(1,i) = timesI(r.elem(0,i));
746 d.elem(2,i) = timesMinusI(r.elem(3,i));
747 d.elem(3,i) = timesMinusI(r.elem(2,i));
748 }
749
750 return d;
751}
752
753template<class T2>
754inline typename BinaryReturn<GammaConst<4,10>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
755operator*(const GammaConst<4,10>&, const PSpinMatrix<T2,4>& r)
756{
757 typename BinaryReturn<GammaConst<4,10>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
758
759 for(int i=0; i < 4; ++i)
760 {
761 d.elem(0,i) = -r.elem(1,i);
762 d.elem(1,i) = r.elem(0,i);
763 d.elem(2,i) = r.elem(3,i);
764 d.elem(3,i) = -r.elem(2,i);
765 }
766
767 return d;
768}
769
770template<class T2>
771inline typename BinaryReturn<GammaConst<4,11>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
772operator*(const GammaConst<4,11>&, const PSpinMatrix<T2,4>& r)
773{
774 typename BinaryReturn<GammaConst<4,11>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
775
776 for(int i=0; i < 4; ++i)
777 {
778 d.elem(0,i) = timesMinusI(r.elem(2,i));
779 d.elem(1,i) = timesI(r.elem(3,i));
780 d.elem(2,i) = timesMinusI(r.elem(0,i));
781 d.elem(3,i) = timesI(r.elem(1,i));
782 }
783
784 return d;
785}
786
787template<class T2>
788inline typename BinaryReturn<GammaConst<4,12>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
789operator*(const GammaConst<4,12>&, const PSpinMatrix<T2,4>& r)
790{
791 typename BinaryReturn<GammaConst<4,12>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
792
793 for(int i=0; i < 4; ++i)
794 {
795 d.elem(0,i) = timesI(r.elem(0,i));
796 d.elem(1,i) = timesMinusI(r.elem(1,i));
797 d.elem(2,i) = timesMinusI(r.elem(2,i));
798 d.elem(3,i) = timesI(r.elem(3,i));
799 }
800
801 return d;
802}
803
804template<class T2>
805inline typename BinaryReturn<GammaConst<4,13>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
806operator*(const GammaConst<4,13>&, const PSpinMatrix<T2,4>& r)
807{
808 typename BinaryReturn<GammaConst<4,13>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
809
810 for(int i=0; i < 4; ++i)
811 {
812 d.elem(0,i) = -r.elem(3,i);
813 d.elem(1,i) = r.elem(2,i);
814 d.elem(2,i) = -r.elem(1,i);
815 d.elem(3,i) = r.elem(0,i);
816 }
817
818 return d;
819}
820
821template<class T2>
822inline typename BinaryReturn<GammaConst<4,14>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
823operator*(const GammaConst<4,14>&, const PSpinMatrix<T2,4>& r)
824{
825 typename BinaryReturn<GammaConst<4,14>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
826
827 for(int i=0; i < 4; ++i)
828 {
829 d.elem(0,i) = timesMinusI(r.elem(3,i));
830 d.elem(1,i) = timesMinusI(r.elem(2,i));
831 d.elem(2,i) = timesMinusI(r.elem(1,i));
832 d.elem(3,i) = timesMinusI(r.elem(0,i));
833 }
834
835 return d;
836}
837
838template<class T2>
839inline typename BinaryReturn<GammaConst<4,15>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t
840operator*(const GammaConst<4,15>&, const PSpinMatrix<T2,4>& r)
841{
842 typename BinaryReturn<GammaConst<4,15>, PSpinMatrix<T2,4>, OpGammaConstMultiply>::Type_t d;
843
844 for(int i=0; i < 4; ++i)
845 {
846 d.elem(0,i) = r.elem(0,i);
847 d.elem(1,i) = r.elem(1,i);
848 d.elem(2,i) = -r.elem(2,i);
849 d.elem(3,i) = -r.elem(3,i);
850 }
851
852 return d;
853}
854
855
856// SpinMatrix<4> = SpinMatrix<4> * Gamma<4,m>
857// There are 16 cases here for Nd=4
858template<class T2>
859inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,0>, OpGammaConstMultiply>::Type_t
860operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,0>&)
861{
862 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,0>, OpGammaConstMultiply>::Type_t d;
863
864 for(int i=0; i < 4; ++i)
865 {
866 d.elem(i,0) = l.elem(i,0);
867 d.elem(i,1) = l.elem(i,1);
868 d.elem(i,2) = l.elem(i,2);
869 d.elem(i,3) = l.elem(i,3);
870 }
871
872 return d;
873}
874
875template<class T2>
876inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,1>, OpGammaConstMultiply>::Type_t
877operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,1>&)
878{
879 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,1>, OpGammaConstMultiply>::Type_t d;
880
881 for(int i=0; i < 4; ++i)
882 {
883 d.elem(i,0) = timesMinusI(l.elem(i,3));
884 d.elem(i,1) = timesMinusI(l.elem(i,2));
885 d.elem(i,2) = timesI(l.elem(i,1));
886 d.elem(i,3) = timesI(l.elem(i,0));
887 }
888
889 return d;
890}
891
892template<class T2>
893inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,2>, OpGammaConstMultiply>::Type_t
894operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,2>&)
895{
896 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,2>, OpGammaConstMultiply>::Type_t d;
897
898 for(int i=0; i < 4; ++i)
899 {
900 d.elem(i,0) = -l.elem(i,3);
901 d.elem(i,1) = l.elem(i,2);
902 d.elem(i,2) = l.elem(i,1);
903 d.elem(i,3) = -l.elem(i,0);
904 }
905
906 return d;
907}
908
909template<class T2>
910inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,3>, OpGammaConstMultiply>::Type_t
911operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,3>&)
912{
913 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,3>, OpGammaConstMultiply>::Type_t d;
914
915 for(int i=0; i < 4; ++i)
916 {
917 d.elem(i,0) = timesMinusI(l.elem(i,0));
918 d.elem(i,1) = timesI(l.elem(i,1));
919 d.elem(i,2) = timesMinusI(l.elem(i,2));
920 d.elem(i,3) = timesI(l.elem(i,3));
921 }
922
923 return d;
924}
925
926template<class T2>
927inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,4>, OpGammaConstMultiply>::Type_t
928operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,4>&)
929{
930 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,4>, OpGammaConstMultiply>::Type_t d;
931
932 for(int i=0; i < 4; ++i)
933 {
934 d.elem(i,0) = timesMinusI(l.elem(i,2));
935 d.elem(i,1) = timesI(l.elem(i,3));
936 d.elem(i,2) = timesI(l.elem(i,0));
937 d.elem(i,3) = timesMinusI(l.elem(i,1));
938 }
939
940 return d;
941}
942
943template<class T2>
944inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,5>, OpGammaConstMultiply>::Type_t
945operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,5>&)
946{
947 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,5>, OpGammaConstMultiply>::Type_t d;
948
949 for(int i=0; i < 4; ++i)
950 {
951 d.elem(i,0) = l.elem(i,1);
952 d.elem(i,1) = -l.elem(i,0);
953 d.elem(i,2) = l.elem(i,3);
954 d.elem(i,3) = -l.elem(i,2);
955 }
956
957 return d;
958}
959
960template<class T2>
961inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,6>, OpGammaConstMultiply>::Type_t
962operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,6>&)
963{
964 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,6>, OpGammaConstMultiply>::Type_t d;
965
966 for(int i=0; i < 4; ++i)
967 {
968 d.elem(i,0) = timesMinusI(l.elem(i,1));
969 d.elem(i,1) = timesMinusI(l.elem(i,0));
970 d.elem(i,2) = timesMinusI(l.elem(i,3));
971 d.elem(i,3) = timesMinusI(l.elem(i,2));
972 }
973
974 return d;
975}
976
977template<class T2>
978inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,7>, OpGammaConstMultiply>::Type_t
979operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,7>&)
980{
981 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,7>, OpGammaConstMultiply>::Type_t d;
982
983 for(int i=0; i < 4; ++i)
984 {
985 d.elem(i,0) = -l.elem(i,2);
986 d.elem(i,1) = -l.elem(i,3);
987 d.elem(i,2) = l.elem(i,0);
988 d.elem(i,3) = l.elem(i,1);
989 }
990
991 return d;
992}
993
994template<class T2>
995inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,8>, OpGammaConstMultiply>::Type_t
996operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,8>&)
997{
998 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,8>, OpGammaConstMultiply>::Type_t d;
999
1000 for(int i=0; i < 4; ++i)
1001 {
1002 d.elem(i,0) = l.elem(i,2);
1003 d.elem(i,1) = l.elem(i,3);
1004 d.elem(i,2) = l.elem(i,0);
1005 d.elem(i,3) = l.elem(i,1);
1006 }
1007
1008 return d;
1009}
1010
1011template<class T2>
1012inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,9>, OpGammaConstMultiply>::Type_t
1013operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,9>&)
1014{
1015 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,9>, OpGammaConstMultiply>::Type_t d;
1016
1017 for(int i=0; i < 4; ++i)
1018 {
1019 d.elem(i,0) = timesI(l.elem(i,1));
1020 d.elem(i,1) = timesI(l.elem(i,0));
1021 d.elem(i,2) = timesMinusI(l.elem(i,3));
1022 d.elem(i,3) = timesMinusI(l.elem(i,2));
1023 }
1024
1025 return d;
1026}
1027
1028template<class T2>
1029inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,10>, OpGammaConstMultiply>::Type_t
1030operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,10>&)
1031{
1032 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,10>, OpGammaConstMultiply>::Type_t d;
1033
1034 for(int i=0; i < 4; ++i)
1035 {
1036 d.elem(i,0) = l.elem(i,1);
1037 d.elem(i,1) = -l.elem(i,0);
1038 d.elem(i,2) = -l.elem(i,3);
1039 d.elem(i,3) = l.elem(i,2);
1040 }
1041
1042 return d;
1043}
1044
1045template<class T2>
1046inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,11>, OpGammaConstMultiply>::Type_t
1047operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,11>&)
1048{
1049 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,11>, OpGammaConstMultiply>::Type_t d;
1050
1051 for(int i=0; i < 4; ++i)
1052 {
1053 d.elem(i,0) = timesMinusI(l.elem(i,2));
1054 d.elem(i,1) = timesI(l.elem(i,3));
1055 d.elem(i,2) = timesMinusI(l.elem(i,0));
1056 d.elem(i,3) = timesI(l.elem(i,1));
1057 }
1058
1059 return d;
1060}
1061
1062template<class T2>
1063inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,12>, OpGammaConstMultiply>::Type_t
1064operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,12>&)
1065{
1066 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,12>, OpGammaConstMultiply>::Type_t d;
1067
1068 for(int i=0; i < 4; ++i)
1069 {
1070 d.elem(i,0) = timesI(l.elem(i,0));
1071 d.elem(i,1) = timesMinusI(l.elem(i,1));
1072 d.elem(i,2) = timesMinusI(l.elem(i,2));
1073 d.elem(i,3) = timesI(l.elem(i,3));
1074 }
1075
1076 return d;
1077}
1078
1079template<class T2>
1080inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,13>, OpGammaConstMultiply>::Type_t
1081operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,13>&)
1082{
1083 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,13>, OpGammaConstMultiply>::Type_t d;
1084
1085 for(int i=0; i < 4; ++i)
1086 {
1087 d.elem(i,0) = l.elem(i,3);
1088 d.elem(i,1) = -l.elem(i,2);
1089 d.elem(i,2) = l.elem(i,1);
1090 d.elem(i,3) = -l.elem(i,0);
1091 }
1092
1093 return d;
1094}
1095
1096template<class T2>
1097inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,14>, OpGammaConstMultiply>::Type_t
1098operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,14>&)
1099{
1100 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,14>, OpGammaConstMultiply>::Type_t d;
1101
1102 for(int i=0; i < 4; ++i)
1103 {
1104 d.elem(i,0) = timesMinusI(l.elem(i,3));
1105 d.elem(i,1) = timesMinusI(l.elem(i,2));
1106 d.elem(i,2) = timesMinusI(l.elem(i,1));
1107 d.elem(i,3) = timesMinusI(l.elem(i,0));
1108 }
1109
1110 return d;
1111}
1112
1113template<class T2>
1114inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,15>, OpGammaConstMultiply>::Type_t
1115operator*(const PSpinMatrix<T2,4>& l, const GammaConst<4,15>&)
1116{
1117 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConst<4,15>, OpGammaConstMultiply>::Type_t d;
1118
1119 for(int i=0; i < 4; ++i)
1120 {
1121 d.elem(i,0) = l.elem(i,0);
1122 d.elem(i,1) = l.elem(i,1);
1123 d.elem(i,2) = -l.elem(i,2);
1124 d.elem(i,3) = -l.elem(i,3);
1125 }
1126
1127 return d;
1128}
1129
1130
1131//-----------------------------------------------
1132
1133// SpinMatrix<4> = GammaDP<4,m> * SpinMatrix<4>
1134// There are 16 cases here for Nd=4
1135template<class T2>
1136inline typename BinaryReturn<GammaConstDP<4,0>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1137operator*(const GammaConstDP<4,0>&, const PSpinMatrix<T2,4>& r)
1138{
1139 typename BinaryReturn<GammaConstDP<4,0>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1140
1141 for(int i=0; i < 4; ++i)
1142 {
1143 d.elem(0,i) = r.elem(0,i);
1144 d.elem(1,i) = r.elem(1,i);
1145 d.elem(2,i) = r.elem(2,i);
1146 d.elem(3,i) = r.elem(3,i);
1147 }
1148
1149 return d;
1150}
1151
1152template<class T2>
1153inline typename BinaryReturn<GammaConstDP<4,1>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1154operator*(const GammaConstDP<4,1>&, const PSpinMatrix<T2,4>& r)
1155{
1156 typename BinaryReturn<GammaConstDP<4,1>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1157
1158 for(int i=0; i < 4; ++i)
1159 {
1160 d.elem(0,i) = timesMinusI(r.elem(3,i));
1161 d.elem(1,i) = timesMinusI(r.elem(2,i));
1162 d.elem(2,i) = timesI(r.elem(1,i));
1163 d.elem(3,i) = timesI(r.elem(0,i));
1164 }
1165
1166 return d;
1167}
1168
1169template<class T2>
1170inline typename BinaryReturn<GammaConstDP<4,2>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1171operator*(const GammaConstDP<4,2>&, const PSpinMatrix<T2,4>& r)
1172{
1173 typename BinaryReturn<GammaConstDP<4,2>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1174
1175 for(int i=0; i < 4; ++i)
1176 {
1177 d.elem(0,i) = -r.elem(3,i);
1178 d.elem(1,i) = r.elem(2,i);
1179 d.elem(2,i) = r.elem(1,i);
1180 d.elem(3,i) = -r.elem(0,i);
1181 }
1182
1183 return d;
1184}
1185
1186template<class T2>
1187inline typename BinaryReturn<GammaConstDP<4,3>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1188operator*(const GammaConstDP<4,3>&, const PSpinMatrix<T2,4>& r)
1189{
1190 typename BinaryReturn<GammaConstDP<4,3>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1191
1192 for(int i=0; i < 4; ++i)
1193 {
1194 d.elem(0,i) = timesI(r.elem(0,i));
1195 d.elem(1,i) = timesMinusI(r.elem(1,i));
1196 d.elem(2,i) = timesI(r.elem(2,i));
1197 d.elem(3,i) = timesMinusI(r.elem(3,i));
1198 }
1199
1200 return d;
1201}
1202
1203template<class T2>
1204inline typename BinaryReturn<GammaConstDP<4,4>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1205operator*(const GammaConstDP<4,4>&, const PSpinMatrix<T2,4>& r)
1206{
1207 typename BinaryReturn<GammaConstDP<4,4>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1208
1209 for(int i=0; i < 4; ++i)
1210 {
1211 d.elem(0,i) = timesMinusI(r.elem(2,i));
1212 d.elem(1,i) = timesI(r.elem(3,i));
1213 d.elem(2,i) = timesI(r.elem(0,i));
1214 d.elem(3,i) = timesMinusI(r.elem(1,i));
1215 }
1216
1217 return d;
1218}
1219
1220template<class T2>
1221inline typename BinaryReturn<GammaConstDP<4,5>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1222operator*(const GammaConstDP<4,5>&, const PSpinMatrix<T2,4>& r)
1223{
1224 typename BinaryReturn<GammaConstDP<4,5>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1225
1226 for(int i=0; i < 4; ++i)
1227 {
1228 d.elem(0,i) = -r.elem(1,i);
1229 d.elem(1,i) = r.elem(0,i);
1230 d.elem(2,i) = -r.elem(3,i);
1231 d.elem(3,i) = r.elem(2,i);
1232 }
1233
1234 return d;
1235}
1236
1237template<class T2>
1238inline typename BinaryReturn<GammaConstDP<4,6>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1239operator*(const GammaConstDP<4,6>&, const PSpinMatrix<T2,4>& r)
1240{
1241 typename BinaryReturn<GammaConstDP<4,6>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1242
1243 for(int i=0; i < 4; ++i)
1244 {
1245 d.elem(0,i) = timesI(r.elem(1,i));
1246 d.elem(1,i) = timesI(r.elem(0,i));
1247 d.elem(2,i) = timesI(r.elem(3,i));
1248 d.elem(3,i) = timesI(r.elem(2,i));
1249 }
1250
1251 return d;
1252}
1253
1254template<class T2>
1255inline typename BinaryReturn<GammaConstDP<4,7>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1256operator*(const GammaConstDP<4,7>&, const PSpinMatrix<T2,4>& r)
1257{
1258 typename BinaryReturn<GammaConstDP<4,7>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1259
1260 for(int i=0; i < 4; ++i)
1261 {
1262 d.elem(0,i) = r.elem(2,i);
1263 d.elem(1,i) = r.elem(3,i);
1264 d.elem(2,i) = -r.elem(0,i);
1265 d.elem(3,i) = -r.elem(1,i);
1266 }
1267
1268 return d;
1269}
1270
1271template<class T2>
1272inline typename BinaryReturn<GammaConstDP<4,8>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1273operator*(const GammaConstDP<4,8>&, const PSpinMatrix<T2,4>& r)
1274{
1275 typename BinaryReturn<GammaConstDP<4,8>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1276
1277 for(int i=0; i < 4; ++i)
1278 {
1279 d.elem(0,i) = r.elem(0,i);
1280 d.elem(1,i) = r.elem(1,i);
1281 d.elem(2,i) = -r.elem(2,i);
1282 d.elem(3,i) = -r.elem(3,i);
1283 }
1284
1285 return d;
1286}
1287
1288template<class T2>
1289inline typename BinaryReturn<GammaConstDP<4,9>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1290operator*(const GammaConstDP<4,9>&, const PSpinMatrix<T2,4>& r)
1291{
1292 typename BinaryReturn<GammaConstDP<4,9>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1293
1294 for(int i=0; i < 4; ++i)
1295 {
1296 d.elem(0,i) = timesI(r.elem(3,i));
1297 d.elem(1,i) = timesI(r.elem(2,i));
1298 d.elem(2,i) = timesI(r.elem(1,i));
1299 d.elem(3,i) = timesI(r.elem(0,i));
1300 }
1301
1302 return d;
1303}
1304
1305template<class T2>
1306inline typename BinaryReturn<GammaConstDP<4,10>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1307operator*(const GammaConstDP<4,10>&, const PSpinMatrix<T2,4>& r)
1308{
1309 typename BinaryReturn<GammaConstDP<4,10>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1310
1311 for(int i=0; i < 4; ++i)
1312 {
1313 d.elem(0,i) = r.elem(3,i);
1314 d.elem(1,i) = -r.elem(2,i);
1315 d.elem(2,i) = r.elem(1,i);
1316 d.elem(3,i) = -r.elem(0,i);
1317 }
1318
1319 return d;
1320}
1321
1322template<class T2>
1323inline typename BinaryReturn<GammaConstDP<4,11>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1324operator*(const GammaConstDP<4,11>&, const PSpinMatrix<T2,4>& r)
1325{
1326 typename BinaryReturn<GammaConstDP<4,11>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1327
1328 for(int i=0; i < 4; ++i)
1329 {
1330 d.elem(0,i) = timesI(r.elem(0,i));
1331 d.elem(1,i) = timesMinusI(r.elem(1,i));
1332 d.elem(2,i) = timesMinusI(r.elem(2,i));
1333 d.elem(3,i) = timesI(r.elem(3,i));
1334 }
1335
1336 return d;
1337}
1338
1339template<class T2>
1340inline typename BinaryReturn<GammaConstDP<4,12>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1341operator*(const GammaConstDP<4,12>&, const PSpinMatrix<T2,4>& r)
1342{
1343 typename BinaryReturn<GammaConstDP<4,12>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1344
1345 for(int i=0; i < 4; ++i)
1346 {
1347 d.elem(0,i) = timesI(r.elem(2,i));
1348 d.elem(1,i) = timesMinusI(r.elem(3,i));
1349 d.elem(2,i) = timesI(r.elem(0,i));
1350 d.elem(3,i) = timesMinusI(r.elem(1,i));
1351 }
1352
1353 return d;
1354}
1355
1356template<class T2>
1357inline typename BinaryReturn<GammaConstDP<4,13>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1358operator*(const GammaConstDP<4,13>&, const PSpinMatrix<T2,4>& r)
1359{
1360 typename BinaryReturn<GammaConstDP<4,13>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1361
1362 for(int i=0; i < 4; ++i)
1363 {
1364 d.elem(0,i) = -r.elem(1,i);
1365 d.elem(1,i) = r.elem(0,i);
1366 d.elem(2,i) = r.elem(3,i);
1367 d.elem(3,i) = -r.elem(2,i);
1368 }
1369
1370 return d;
1371}
1372
1373template<class T2>
1374inline typename BinaryReturn<GammaConstDP<4,14>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1375operator*(const GammaConstDP<4,14>&, const PSpinMatrix<T2,4>& r)
1376{
1377 typename BinaryReturn<GammaConstDP<4,14>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1378
1379 for(int i=0; i < 4; ++i)
1380 {
1381 d.elem(0,i) = timesI(r.elem(1,i));
1382 d.elem(1,i) = timesI(r.elem(0,i));
1383 d.elem(2,i) = timesMinusI(r.elem(3,i));
1384 d.elem(3,i) = timesMinusI(r.elem(2,i));
1385 }
1386
1387 return d;
1388}
1389
1390template<class T2>
1391inline typename BinaryReturn<GammaConstDP<4,15>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t
1392operator*(const GammaConstDP<4,15>&, const PSpinMatrix<T2,4>& r)
1393{
1394 typename BinaryReturn<GammaConstDP<4,15>, PSpinMatrix<T2,4>, OpGammaConstDPMultiply>::Type_t d;
1395
1396 for(int i=0; i < 4; ++i)
1397 {
1398 d.elem(0,i) = -r.elem(2,i);
1399 d.elem(1,i) = -r.elem(3,i);
1400 d.elem(2,i) = -r.elem(0,i);
1401 d.elem(3,i) = -r.elem(1,i);
1402 }
1403
1404 return d;
1405}
1406
1407
1408// SpinMatrix<4> = SpinMatrix<4> * GammaDP<4,m>
1409// There are 16 cases here for Nd=4
1410template<class T2>
1411inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,0>, OpGammaConstDPMultiply>::Type_t
1412operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,0>&)
1413{
1414 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,0>, OpGammaConstDPMultiply>::Type_t d;
1415
1416 for(int i=0; i < 4; ++i)
1417 {
1418 d.elem(i,0) = l.elem(i,0);
1419 d.elem(i,1) = l.elem(i,1);
1420 d.elem(i,2) = l.elem(i,2);
1421 d.elem(i,3) = l.elem(i,3);
1422 }
1423
1424 return d;
1425}
1426
1427template<class T2>
1428inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,1>, OpGammaConstDPMultiply>::Type_t
1429operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,1>&)
1430{
1431 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,1>, OpGammaConstDPMultiply>::Type_t d;
1432
1433 for(int i=0; i < 4; ++i)
1434 {
1435 d.elem(i,0) = timesI(l.elem(i,3));
1436 d.elem(i,1) = timesI(l.elem(i,2));
1437 d.elem(i,2) = timesMinusI(l.elem(i,1));
1438 d.elem(i,3) = timesMinusI(l.elem(i,0));
1439 }
1440
1441 return d;
1442}
1443
1444template<class T2>
1445inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,2>, OpGammaConstDPMultiply>::Type_t
1446operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,2>&)
1447{
1448 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,2>, OpGammaConstDPMultiply>::Type_t d;
1449
1450 for(int i=0; i < 4; ++i)
1451 {
1452 d.elem(i,0) = -l.elem(i,3);
1453 d.elem(i,1) = l.elem(i,2);
1454 d.elem(i,2) = l.elem(i,1);
1455 d.elem(i,3) = -l.elem(i,0);
1456 }
1457
1458 return d;
1459}
1460
1461template<class T2>
1462inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,3>, OpGammaConstDPMultiply>::Type_t
1463operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,3>&)
1464{
1465 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,3>, OpGammaConstDPMultiply>::Type_t d;
1466
1467 for(int i=0; i < 4; ++i)
1468 {
1469 d.elem(i,0) = timesI(l.elem(i,0));
1470 d.elem(i,1) = timesMinusI(l.elem(i,1));
1471 d.elem(i,2) = timesI(l.elem(i,2));
1472 d.elem(i,3) = timesMinusI(l.elem(i,3));
1473 }
1474
1475 return d;
1476}
1477
1478template<class T2>
1479inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,4>, OpGammaConstDPMultiply>::Type_t
1480operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,4>&)
1481{
1482 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,4>, OpGammaConstDPMultiply>::Type_t d;
1483
1484 for(int i=0; i < 4; ++i)
1485 {
1486 d.elem(i,0) = timesI(l.elem(i,2));
1487 d.elem(i,1) = timesMinusI(l.elem(i,3));
1488 d.elem(i,2) = timesMinusI(l.elem(i,0));
1489 d.elem(i,3) = timesI(l.elem(i,1));
1490 }
1491
1492 return d;
1493}
1494
1495template<class T2>
1496inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,5>, OpGammaConstDPMultiply>::Type_t
1497operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,5>&)
1498{
1499 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,5>, OpGammaConstDPMultiply>::Type_t d;
1500
1501 for(int i=0; i < 4; ++i)
1502 {
1503 d.elem(i,0) = l.elem(i,1);
1504 d.elem(i,1) = -l.elem(i,0);
1505 d.elem(i,2) = l.elem(i,3);
1506 d.elem(i,3) = -l.elem(i,2);
1507 }
1508
1509 return d;
1510}
1511
1512template<class T2>
1513inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,6>, OpGammaConstDPMultiply>::Type_t
1514operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,6>&)
1515{
1516 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,6>, OpGammaConstDPMultiply>::Type_t d;
1517
1518 for(int i=0; i < 4; ++i)
1519 {
1520 d.elem(i,0) = timesI(l.elem(i,1));
1521 d.elem(i,1) = timesI(l.elem(i,0));
1522 d.elem(i,2) = timesI(l.elem(i,3));
1523 d.elem(i,3) = timesI(l.elem(i,2));
1524 }
1525
1526 return d;
1527}
1528
1529template<class T2>
1530inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,7>, OpGammaConstDPMultiply>::Type_t
1531operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,7>&)
1532{
1533 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,7>, OpGammaConstDPMultiply>::Type_t d;
1534
1535 for(int i=0; i < 4; ++i)
1536 {
1537 d.elem(i,0) = -l.elem(i,2);
1538 d.elem(i,1) = -l.elem(i,3);
1539 d.elem(i,2) = l.elem(i,0);
1540 d.elem(i,3) = l.elem(i,1);
1541 }
1542
1543 return d;
1544}
1545
1546template<class T2>
1547inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,8>, OpGammaConstDPMultiply>::Type_t
1548operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,8>&)
1549{
1550 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,8>, OpGammaConstDPMultiply>::Type_t d;
1551
1552 for(int i=0; i < 4; ++i)
1553 {
1554 d.elem(i,0) = l.elem(i,0);
1555 d.elem(i,1) = l.elem(i,1);
1556 d.elem(i,2) = -l.elem(i,2);
1557 d.elem(i,3) = -l.elem(i,3);
1558 }
1559
1560 return d;
1561}
1562
1563template<class T2>
1564inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,9>, OpGammaConstDPMultiply>::Type_t
1565operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,9>&)
1566{
1567 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,9>, OpGammaConstDPMultiply>::Type_t d;
1568
1569 for(int i=0; i < 4; ++i)
1570 {
1571 d.elem(i,0) = timesI(l.elem(i,3));
1572 d.elem(i,1) = timesI(l.elem(i,2));
1573 d.elem(i,2) = timesI(l.elem(i,1));
1574 d.elem(i,3) = timesI(l.elem(i,0));
1575 }
1576
1577 return d;
1578}
1579
1580template<class T2>
1581inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,10>, OpGammaConstDPMultiply>::Type_t
1582operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,10>&)
1583{
1584 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,10>, OpGammaConstDPMultiply>::Type_t d;
1585
1586 for(int i=0; i < 4; ++i)
1587 {
1588 d.elem(i,0) = -l.elem(i,3);
1589 d.elem(i,1) = l.elem(i,2);
1590 d.elem(i,2) = -l.elem(i,1);
1591 d.elem(i,3) = l.elem(i,0);
1592 }
1593
1594 return d;
1595}
1596
1597template<class T2>
1598inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,11>, OpGammaConstDPMultiply>::Type_t
1599operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,11>&)
1600{
1601 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,11>, OpGammaConstDPMultiply>::Type_t d;
1602
1603 for(int i=0; i < 4; ++i)
1604 {
1605 d.elem(i,0) = timesI(l.elem(i,0));
1606 d.elem(i,1) = timesMinusI(l.elem(i,1));
1607 d.elem(i,2) = timesMinusI(l.elem(i,2));
1608 d.elem(i,3) = timesI(l.elem(i,3));
1609 }
1610
1611 return d;
1612}
1613
1614template<class T2>
1615inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,12>, OpGammaConstDPMultiply>::Type_t
1616operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,12>&)
1617{
1618 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,12>, OpGammaConstDPMultiply>::Type_t d;
1619
1620 for(int i=0; i < 4; ++i)
1621 {
1622 d.elem(i,0) = timesI(l.elem(i,2));
1623 d.elem(i,1) = timesMinusI(l.elem(i,3));
1624 d.elem(i,2) = timesI(l.elem(i,0));
1625 d.elem(i,3) = timesMinusI(l.elem(i,1));
1626 }
1627
1628 return d;
1629}
1630
1631template<class T2>
1632inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,13>, OpGammaConstDPMultiply>::Type_t
1633operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,13>&)
1634{
1635 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,13>, OpGammaConstDPMultiply>::Type_t d;
1636
1637 for(int i=0; i < 4; ++i)
1638 {
1639 d.elem(i,0) = l.elem(i,1);
1640 d.elem(i,1) = -l.elem(i,0);
1641 d.elem(i,2) = -l.elem(i,3);
1642 d.elem(i,3) = l.elem(i,2);
1643 }
1644
1645 return d;
1646}
1647
1648template<class T2>
1649inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,14>, OpGammaConstDPMultiply>::Type_t
1650operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,14>&)
1651{
1652 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,14>, OpGammaConstDPMultiply>::Type_t d;
1653
1654 for(int i=0; i < 4; ++i)
1655 {
1656 d.elem(i,0) = timesI(l.elem(i,1));
1657 d.elem(i,1) = timesI(l.elem(i,0));
1658 d.elem(i,2) = timesMinusI(l.elem(i,3));
1659 d.elem(i,3) = timesMinusI(l.elem(i,2));
1660 }
1661
1662 return d;
1663}
1664
1665template<class T2>
1666inline typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,15>, OpGammaConstDPMultiply>::Type_t
1667operator*(const PSpinMatrix<T2,4>& l, const GammaConstDP<4,15>&)
1668{
1669 typename BinaryReturn<PSpinMatrix<T2,4>, GammaConstDP<4,15>, OpGammaConstDPMultiply>::Type_t d;
1670
1671 for(int i=0; i < 4; ++i)
1672 {
1673 d.elem(i,0) = -l.elem(i,2);
1674 d.elem(i,1) = -l.elem(i,3);
1675 d.elem(i,2) = -l.elem(i,0);
1676 d.elem(i,3) = -l.elem(i,1);
1677 }
1678
1679 return d;
1680}
1681
1682
1683//-----------------------------------------------------------------------------
1685template<class T>
1686inline typename UnaryReturn<PSpinMatrix<T,4>, FnChiralProjectPlus>::Type_t
1687chiralProjectPlus(const PSpinMatrix<T,4>& s1)
1688{
1689 typename UnaryReturn<PSpinMatrix<T,4>, FnChiralProjectPlus>::Type_t d;
1690
1691 for(int i=0; i < 4; ++i)
1692 {
1693 d.elem(0,i) = s1.elem(0,i);
1694 d.elem(1,i) = s1.elem(1,i);
1695 zero_rep(d.elem(2,i));
1696 zero_rep(d.elem(3,i));
1697 }
1698
1699 return d;
1700}
1701
1703template<class T>
1704inline typename UnaryReturn<PSpinMatrix<T,4>, FnChiralProjectMinus>::Type_t
1705chiralProjectMinus(const PSpinMatrix<T,4>& s1)
1706{
1707 typename UnaryReturn<PSpinMatrix<T,4>, FnChiralProjectMinus>::Type_t d;
1708
1709 for(int i=0; i < 4; ++i)
1710 {
1711 zero_rep(d.elem(0,i));
1712 zero_rep(d.elem(1,i));
1713 d.elem(2,i) = s1.elem(2,i);
1714 d.elem(3,i) = s1.elem(3,i);
1715 }
1716
1717 return d;
1718}
1719
1720//------------------------------------------
1721// PScalar = traceSpinQuarkContract13(PSpinMatrix,PSpinMatrix)
1722template<class T1, class T2>
1726
1728template<class T1, class T2>
1729inline typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnTraceSpinQuarkContract13>::Type_t
1730traceSpinQuarkContract13(const PSpinMatrix<T1,4>& l, const PSpinMatrix<T2,4>& r)
1731{
1732 typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnTraceSpinQuarkContract13>::Type_t d;
1733
1734 d.elem() = quarkContractXX(l.elem(0,0), r.elem(0,0));
1735 for(int k=1; k < 4; ++k)
1736 d.elem() += quarkContractXX(l.elem(k,0), r.elem(k,0));
1737
1738 for(int j=1; j < 4; ++j)
1739 for(int k=0; k < 4; ++k)
1740 d.elem() += quarkContractXX(l.elem(k,j), r.elem(k,j));
1741
1742 return d;
1743}
1744
1745
1746// quark propagator contraction
1747template<class T1, class T2>
1748inline typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnQuarkContract13>::Type_t
1749quarkContract13(const PSpinMatrix<T1,4>& s1, const PSpinMatrix<T2,4>& s2)
1750{
1751 typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnQuarkContract13>::Type_t d;
1752
1753 for(int j=0; j < 4; ++j)
1754 for(int i=0; i < 4; ++i)
1755 {
1756 d.elem(i,j) = quarkContractXX(s1.elem(0,i), s2.elem(0,j));
1757 for(int k=1; k < 4; ++k)
1758 d.elem(i,j) += quarkContractXX(s1.elem(k,i), s2.elem(k,j));
1759 }
1760
1761 return d;
1762}
1763
1764template<class T1, class T2>
1765inline typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnQuarkContract14>::Type_t
1766quarkContract14(const PSpinMatrix<T1,4>& s1, const PSpinMatrix<T2,4>& s2)
1767{
1768 typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnQuarkContract14>::Type_t d;
1769
1770 for(int j=0; j < 4; ++j)
1771 for(int i=0; i < 4; ++i)
1772 {
1773 d.elem(i,j) = quarkContractXX(s1.elem(0,i), s2.elem(j,0));
1774 for(int k=1; k < 4; ++k)
1775 d.elem(i,j) += quarkContractXX(s1.elem(k,i), s2.elem(j,k));
1776 }
1777
1778 return d;
1779}
1780
1781template<class T1, class T2>
1782inline typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnQuarkContract23>::Type_t
1783quarkContract23(const PSpinMatrix<T1,4>& s1, const PSpinMatrix<T2,4>& s2)
1784{
1785 typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnQuarkContract23>::Type_t d;
1786
1787 for(int j=0; j < 4; ++j)
1788 for(int i=0; i < 4; ++i)
1789 {
1790 d.elem(i,j) = quarkContractXX(s1.elem(i,0), s2.elem(0,j));
1791 for(int k=1; k < 4; ++k)
1792 d.elem(i,j) += quarkContractXX(s1.elem(i,k), s2.elem(k,j));
1793 }
1794
1795 return d;
1796}
1797
1798template<class T1, class T2>
1799inline typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnQuarkContract24>::Type_t
1800quarkContract24(const PSpinMatrix<T1,4>& s1, const PSpinMatrix<T2,4>& s2)
1801{
1802 typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnQuarkContract24>::Type_t d;
1803
1804 for(int j=0; j < 4; ++j)
1805 for(int i=0; i < 4; ++i)
1806 {
1807 d.elem(i,j) = quarkContractXX(s1.elem(i,0), s2.elem(j,0));
1808 for(int k=1; k < 4; ++k)
1809 d.elem(i,j) += quarkContractXX(s1.elem(i,k), s2.elem(j,k));
1810 }
1811
1812 return d;
1813}
1814
1815template<class T1, class T2>
1816inline typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnQuarkContract12>::Type_t
1817quarkContract12(const PSpinMatrix<T1,4>& s1, const PSpinMatrix<T2,4>& s2)
1818{
1819 typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnQuarkContract12>::Type_t d;
1820
1821 for(int j=0; j < 4; ++j)
1822 for(int i=0; i < 4; ++i)
1823 {
1824 d.elem(i,j) = quarkContractXX(s1.elem(0,0), s2.elem(i,j));
1825 for(int k=1; k < 4; ++k)
1826 d.elem(i,j) += quarkContractXX(s1.elem(k,k), s2.elem(i,j));
1827 }
1828
1829 return d;
1830}
1831
1832template<class T1, class T2>
1833inline typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnQuarkContract34>::Type_t
1834quarkContract34(const PSpinMatrix<T1,4>& s1, const PSpinMatrix<T2,4>& s2)
1835{
1836 typename BinaryReturn<PSpinMatrix<T1,4>, PSpinMatrix<T2,4>, FnQuarkContract34>::Type_t d;
1837
1838 for(int j=0; j < 4; ++j)
1839 for(int i=0; i < 4; ++i)
1840 {
1841 d.elem(i,j) = quarkContractXX(s1.elem(i,j), s2.elem(0,0));
1842 for(int k=1; k < 4; ++k)
1843 d.elem(i,j) += quarkContractXX(s1.elem(i,j), s2.elem(k,k));
1844 }
1845
1846 return d;
1847}
1848 // end of group primspinmatrix
1850
1851} // namespace QDP
1852
1853#endif
QDP::PMatrix< T, N, PSpinMatrix >::assign
CC & assign(const PScalar< T1 > &rhs)
Definition qdp_primmatrix.h:42
QDP::PScalar
Primitive Scalar.
Definition qdp_primscalar.h:25
QDP::PSpinMatrix
Primitive Spin Matrix class.
Definition qdp_primspinmat.h:32
QDP::PSpinMatrix::operator=
PSpinMatrix & operator=(const PScalar< T1 > &rhs)
PSpinMatrix = PScalar.
Definition qdp_primspinmat.h:38
QDP::PSpinMatrix::operator=
PSpinMatrix & operator=(const PSpinMatrix< T1, N > &rhs)
PSpinMatrix = PSpinMatrix.
Definition qdp_primspinmat.h:48
QDP::PSpinVector
Primitive spin Vector class.
Definition qdp_primspinvec.h:33
QDP::zero_rep
void zero_rep(IScalar< T > &dest)
dest = 0
Definition qdp_inner.h:1841
QDP::C
OLattice< PScalar< PColorMatrix< RComplexFloat, 3 > > > C
Definition qdp_scalarsite_generic_linalg.h:12
QDP::quarkContractXX
BinaryReturn< PColorMatrix< T1, 3 >, PColorMatrix< T2, 3 >, FnQuarkContractXX >::Type_t quarkContractXX(const PColorMatrix< T1, 3 > &s1, const PColorMatrix< T2, 3 > &s2)
dest = QuarkContractXX(Qprop1,Qprop2)
Definition qdp_primcolormat.h:611
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::timesMinusI
MakeReturn< UnaryNode< FnTimesMinusI, typenameCreateLeaf< QDPExpr< T1, C1 > >::Leaf_t >, typenameUnaryReturn< C1, FnTimesMinusI >::Type_t >::Expression_t timesMinusI(const QDPExpr< T1, C1 > &l)
Definition qdp.h:5024
QDP::timesI
MakeReturn< UnaryNode< FnTimesI, typenameCreateLeaf< QDPExpr< T1, C1 > >::Leaf_t >, typenameUnaryReturn< C1, FnTimesI >::Type_t >::Expression_t timesI(const QDPExpr< T1, C1 > &l)
Definition qdp.h:5011
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::quarkContract14
MakeReturn< BinaryNode< FnQuarkContract14, typenameCreateLeaf< QDPType< T1, C1 > >::Leaf_t, typenameCreateLeaf< QDPExpr< T2, C2 > >::Leaf_t >, typenameBinaryReturn< C1, C2, FnQuarkContract14 >::Type_t >::Expression_t quarkContract14(const QDPType< T1, C1 > &l, const QDPExpr< T2, C2 > &r)
Definition qdp.h:2476
QDP::quarkContract12
MakeReturn< BinaryNode< FnQuarkContract12, typenameCreateLeaf< QDPType< T1, C1 > >::Leaf_t, typenameCreateLeaf< QDPExpr< T2, C2 > >::Leaf_t >, typenameBinaryReturn< C1, C2, FnQuarkContract12 >::Type_t >::Expression_t quarkContract12(const QDPType< T1, C1 > &l, const QDPExpr< T2, C2 > &r)
Definition qdp.h:2524
QDP::quarkContract34
MakeReturn< BinaryNode< FnQuarkContract34, typenameCreateLeaf< QDPType< T1, C1 > >::Leaf_t, typenameCreateLeaf< QDPExpr< T2, C2 > >::Leaf_t >, typenameBinaryReturn< C1, C2, FnQuarkContract34 >::Type_t >::Expression_t quarkContract34(const QDPType< T1, C1 > &l, const QDPExpr< T2, C2 > &r)
Definition qdp.h:2540
QDP::outerProduct
MakeReturn< BinaryNode< FnOuterProduct, typenameCreateLeaf< QDPType< T1, C1 > >::Leaf_t, typenameCreateLeaf< QDPExpr< T2, C2 > >::Leaf_t >, typenameBinaryReturn< C1, C2, FnOuterProduct >::Type_t >::Expression_t outerProduct(const QDPType< T1, C1 > &l, const QDPExpr< T2, C2 > &r)
Definition qdp.h:2364
QDP::localColorInnerProduct
MakeReturn< BinaryNode< FnLocalColorInnerProduct, typenameCreateLeaf< QDPType< T1, C1 > >::Leaf_t, typenameCreateLeaf< QDPExpr< T2, C2 > >::Leaf_t >, typenameBinaryReturn< C1, C2, FnLocalColorInnerProduct >::Type_t >::Expression_t localColorInnerProduct(const QDPType< T1, C1 > &l, const QDPExpr< T2, C2 > &r)
Definition qdp.h:2444
QDP::peekSpin
MakeReturn< UnaryNode< FnPeekSpinMatrix, typenameCreateLeaf< QDPExpr< T1, C1 > >::Leaf_t >, C1 >::Expression_t peekSpin(const QDPExpr< T1, C1 > &l, int row, int col)
Definition qdp_newops.h:258
QDP::transposeSpin
MakeReturn< UnaryNode< FnTransposeSpin, typenameCreateLeaf< QDPExpr< T1, C1 > >::Leaf_t >, typenameUnaryReturn< C1, FnTransposeSpin >::Type_t >::Expression_t transposeSpin(const QDPExpr< T1, C1 > &l)
Definition qdp.h:4894
QDP::chiralProjectMinus
MakeReturn< UnaryNode< FnChiralProjectMinus, typenameCreateLeaf< QDPExpr< T1, C1 > >::Leaf_t >, typenameUnaryReturn< C1, FnChiralProjectMinus >::Type_t >::Expression_t chiralProjectMinus(const QDPExpr< T1, C1 > &l)
Definition qdp.h:5271
QDP::quarkContract23
MakeReturn< BinaryNode< FnQuarkContract23, typenameCreateLeaf< QDPType< T1, C1 > >::Leaf_t, typenameCreateLeaf< QDPExpr< T2, C2 > >::Leaf_t >, typenameBinaryReturn< C1, C2, FnQuarkContract23 >::Type_t >::Expression_t quarkContract23(const QDPType< T1, C1 > &l, const QDPExpr< T2, C2 > &r)
Definition qdp.h:2492
QDP::chiralProjectPlus
MakeReturn< UnaryNode< FnChiralProjectPlus, typenameCreateLeaf< QDPExpr< T1, C1 > >::Leaf_t >, typenameUnaryReturn< C1, FnChiralProjectPlus >::Type_t >::Expression_t chiralProjectPlus(const QDPExpr< T1, C1 > &l)
Definition qdp.h:5258
QDP::quarkContract13
MakeReturn< BinaryNode< FnQuarkContract13, typenameCreateLeaf< QDPType< T1, C1 > >::Leaf_t, typenameCreateLeaf< QDPExpr< T2, C2 > >::Leaf_t >, typenameBinaryReturn< C1, C2, FnQuarkContract13 >::Type_t >::Expression_t quarkContract13(const QDPType< T1, C1 > &l, const QDPExpr< T2, C2 > &r)
Definition qdp.h:2460
QDP::quarkContract24
MakeReturn< BinaryNode< FnQuarkContract24, typenameCreateLeaf< QDPType< T1, C1 > >::Leaf_t, typenameCreateLeaf< QDPExpr< T2, C2 > >::Leaf_t >, typenameBinaryReturn< C1, C2, FnQuarkContract24 >::Type_t >::Expression_t quarkContract24(const QDPType< T1, C1 > &l, const QDPExpr< T2, C2 > &r)
Definition qdp.h:2508
QDP::pokeSpin
C1 & pokeSpin(QDPType< T1, C1 > &l, const QDPExpr< T2, C2 > &r, int row, int col)
Definition qdp_newops.h:509
QDP::BinaryReturn< GammaConstDP< N, m >, PSpinMatrix< T2, N >, OpGammaConstDPMultiply >::Type_t
PSpinMatrix< typename UnaryReturn< T2, OpUnaryPlus >::Type_t, N > Type_t
Definition qdp_primspinmat.h:332
QDP::BinaryReturn< GammaConst< N, m >, PSpinMatrix< T2, N >, OpGammaConstMultiply >::Type_t
PSpinMatrix< typename UnaryReturn< T2, OpUnaryPlus >::Type_t, N > Type_t
Definition qdp_primspinmat.h:310
QDP::BinaryReturn< GammaTypeDP< N >, PSpinMatrix< T2, N >, OpGammaTypeDPMultiply >::Type_t
PSpinMatrix< typename UnaryReturn< T2, OpUnaryPlus >::Type_t, N > Type_t
Definition qdp_primspinmat.h:342
QDP::BinaryReturn< GammaType< N >, PSpinMatrix< T2, N >, OpGammaTypeMultiply >::Type_t
PSpinMatrix< typename UnaryReturn< T2, OpUnaryPlus >::Type_t, N > Type_t
Definition qdp_primspinmat.h:320
QDP::BinaryReturn< PScalar< T1 >, PSpinMatrix< T2, N >, FnInnerProductReal >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnInnerProductReal >::Type_t > Type_t
Definition qdp_primspinmat.h:287
QDP::BinaryReturn< PScalar< T1 >, PSpinMatrix< T2, N >, FnInnerProduct >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnInnerProduct >::Type_t > Type_t
Definition qdp_primspinmat.h:257
QDP::BinaryReturn< PScalar< T1 >, PSpinMatrix< T2, N >, FnLocalInnerProductReal >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnLocalInnerProductReal >::Type_t > Type_t
Definition qdp_primspinmat.h:302
QDP::BinaryReturn< PScalar< T1 >, PSpinMatrix< T2, N >, FnLocalInnerProduct >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnLocalInnerProduct >::Type_t > Type_t
Definition qdp_primspinmat.h:272
QDP::BinaryReturn< PScalar< T1 >, PSpinMatrix< T2, N >, FnTraceMultiply >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnTraceMultiply >::Type_t > Type_t
Definition qdp_primspinmat.h:242
QDP::BinaryReturn< PScalar< T1 >, PSpinMatrix< T2, N >, FnTraceSpinMultiply >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnTraceSpinMultiply >::Type_t > Type_t
Definition qdp_primspinmat.h:430
QDP::BinaryReturn< PScalar< T1 >, PSpinMatrix< T2, N >, Op >::Type_t
PSpinMatrix< typename BinaryReturn< T1, T2, Op >::Type_t, N > Type_t
Definition qdp_primspinmat.h:125
QDP::BinaryReturn< PSpinMatrix< T1, 4 >, PSpinMatrix< T2, 4 >, FnTraceSpinQuarkContract13 >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnTraceSpinQuarkContract13 >::Type_t > Type_t
Definition qdp_primspinmat.h:1724
QDP::BinaryReturn< PSpinMatrix< T1, N >, PScalar< T2 >, FnInnerProductReal >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnInnerProductReal >::Type_t > Type_t
Definition qdp_primspinmat.h:282
QDP::BinaryReturn< PSpinMatrix< T1, N >, PScalar< T2 >, FnInnerProduct >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnInnerProduct >::Type_t > Type_t
Definition qdp_primspinmat.h:252
QDP::BinaryReturn< PSpinMatrix< T1, N >, PScalar< T2 >, FnLocalInnerProductReal >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnLocalInnerProductReal >::Type_t > Type_t
Definition qdp_primspinmat.h:297
QDP::BinaryReturn< PSpinMatrix< T1, N >, PScalar< T2 >, FnLocalInnerProduct >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnLocalInnerProduct >::Type_t > Type_t
Definition qdp_primspinmat.h:267
QDP::BinaryReturn< PSpinMatrix< T1, N >, PScalar< T2 >, FnTraceMultiply >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnTraceMultiply >::Type_t > Type_t
Definition qdp_primspinmat.h:237
QDP::BinaryReturn< PSpinMatrix< T1, N >, PScalar< T2 >, FnTraceSpinMultiply >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnTraceSpinMultiply >::Type_t > Type_t
Definition qdp_primspinmat.h:410
QDP::BinaryReturn< PSpinMatrix< T1, N >, PScalar< T2 >, Op >::Type_t
PSpinMatrix< typename BinaryReturn< T1, T2, Op >::Type_t, N > Type_t
Definition qdp_primspinmat.h:137
QDP::BinaryReturn< PSpinMatrix< T1, N >, PSpinMatrix< T2, N >, FnLocalColorInnerProduct >::Type_t
PSpinMatrix< typename BinaryReturn< T1, T2, FnLocalColorInnerProduct >::Type_t, N > Type_t
Definition qdp_primspinmat.h:477
QDP::BinaryReturn< PSpinMatrix< T1, N >, PSpinMatrix< T2, N >, FnInnerProductReal >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnInnerProductReal >::Type_t > Type_t
Definition qdp_primspinmat.h:277
QDP::BinaryReturn< PSpinMatrix< T1, N >, PSpinMatrix< T2, N >, FnInnerProduct >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnInnerProduct >::Type_t > Type_t
Definition qdp_primspinmat.h:247
QDP::BinaryReturn< PSpinMatrix< T1, N >, PSpinMatrix< T2, N >, FnLocalInnerProduct >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnLocalInnerProduct >::Type_t > Type_t
Definition qdp_primspinmat.h:262
QDP::BinaryReturn< PSpinMatrix< T1, N >, PSpinMatrix< T2, N >, FnTraceMultiply >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnTraceMultiply >::Type_t > Type_t
Definition qdp_primspinmat.h:232
QDP::BinaryReturn< PSpinMatrix< T1, N >, PSpinMatrix< T2, N >, FnTraceSpinMultiply >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnTraceSpinMultiply >::Type_t > Type_t
Definition qdp_primspinmat.h:386
QDP::BinaryReturn< PSpinMatrix< T1, N >, PSpinMatrix< T2, N >, Op >::Type_t
PSpinMatrix< typename BinaryReturn< T1, T2, Op >::Type_t, N > Type_t
Definition qdp_primspinmat.h:131
QDP::BinaryReturn< PSpinMatrix< T1, N >, PSpinMatrix< T2, N >, FnLocalInnerProductReal >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnLocalInnerProductReal >::Type_t > Type_t
Definition qdp_primspinmat.h:292
QDP::BinaryReturn< PSpinMatrix< T2, N >, GammaConstDP< N, m >, OpMultiplyGammaConstDP >::Type_t
PSpinMatrix< typename UnaryReturn< T2, OpUnaryPlus >::Type_t, N > Type_t
Definition qdp_primspinmat.h:337
QDP::BinaryReturn< PSpinMatrix< T2, N >, GammaConst< N, m >, OpMultiplyGammaConst >::Type_t
PSpinMatrix< typename UnaryReturn< T2, OpUnaryPlus >::Type_t, N > Type_t
Definition qdp_primspinmat.h:315
QDP::BinaryReturn< PSpinMatrix< T2, N >, GammaTypeDP< N >, OpMultiplyGammaTypeDP >::Type_t
PSpinMatrix< typename UnaryReturn< T2, OpUnaryPlus >::Type_t, N > Type_t
Definition qdp_primspinmat.h:347
QDP::BinaryReturn< PSpinMatrix< T2, N >, GammaType< N >, OpMultiplyGammaType >::Type_t
PSpinMatrix< typename UnaryReturn< T2, OpUnaryPlus >::Type_t, N > Type_t
Definition qdp_primspinmat.h:325
QDP::BinaryReturn< PSpinVector< T1, N >, PSpinVector< T2, N >, FnOuterProduct >::Type_t
PSpinMatrix< typename BinaryReturn< T1, T2, FnOuterProduct >::Type_t, N > Type_t
Definition qdp_primspinmat.h:507
QDP::BinaryReturn< PSpinVector< T1, N >, PSpinVector< T2, N >, FnTraceSpinOuterProduct >::Type_t
PScalar< typename BinaryReturn< T1, T2, FnOuterProduct >::Type_t > Type_t
Definition qdp_primspinmat.h:530
QDP::DoublePrecType< PSpinMatrix< T1, N > >::Type_t
PSpinMatrix< typename DoublePrecType< T1 >::Type_t, N > Type_t
Definition qdp_primspinmat.h:90
QDP::FnPeekSpinMatrix
Structure for extracting spin matrix components.
Definition qdp_newops.h:222
QDP::InternalScalar< PSpinMatrix< T, N > >::Type_t
PScalar< typename InternalScalar< T >::Type_t > Type_t
Definition qdp_primspinmat.h:96
QDP::InternalScalar
Construct simple word type used at some level within primitives.
Definition qdp_traits.h:98
QDP::LatticeScalar< PSpinMatrix< T, N > >::Type_t
PSpinMatrix< typename LatticeScalar< T >::Type_t, N > Type_t
Definition qdp_primspinmat.h:108
QDP::LatticeScalar
Makes a lattice scalar leaving primitive indices alone.
Definition qdp_traits.h:108
QDP::PrimitiveScalar< PSpinMatrix< T, N > >::Type_t
PScalar< typename PrimitiveScalar< T >::Type_t > Type_t
Definition qdp_primspinmat.h:102
QDP::PrimitiveScalar
Makes a primitive scalar leaving grid alone.
Definition qdp_traits.h:103
QDP::SinglePrecType< PSpinMatrix< T1, N > >::Type_t
PSpinMatrix< typename SinglePrecType< T1 >::Type_t, N > Type_t
Definition qdp_primspinmat.h:84
QDP::UnaryReturn< PSpinMatrix< T1, N >, Op >::Type_t
PSpinMatrix< typename UnaryReturn< T1, Op >::Type_t, N > Type_t
Definition qdp_primspinmat.h:119
QDP::UnaryReturn< PSpinMatrix< T, N >, FnImagTrace >::Type_t
PScalar< typename UnaryReturn< T, FnImagTrace >::Type_t > Type_t
Definition qdp_primspinmat.h:212
QDP::UnaryReturn< PSpinMatrix< T, N >, FnLocalNorm2 >::Type_t
PScalar< typename UnaryReturn< T, FnLocalNorm2 >::Type_t > Type_t
Definition qdp_primspinmat.h:227
QDP::UnaryReturn< PSpinMatrix< T, N >, FnNorm2 >::Type_t
PScalar< typename UnaryReturn< T, FnNorm2 >::Type_t > Type_t
Definition qdp_primspinmat.h:222
QDP::UnaryReturn< PSpinMatrix< T, N >, FnPeekSpinMatrix >::Type_t
PScalar< typename UnaryReturn< T, FnPeekSpinMatrix >::Type_t > Type_t
Definition qdp_primspinmat.h:553
QDP::UnaryReturn< PSpinMatrix< T, N >, FnRealTrace >::Type_t
PScalar< typename UnaryReturn< T, FnRealTrace >::Type_t > Type_t
Definition qdp_primspinmat.h:207
QDP::UnaryReturn< PSpinMatrix< T, N >, FnSumMulti >::Type_t
PSpinMatrix< typename UnaryReturn< T, FnSumMulti >::Type_t, N > Type_t
Definition qdp_primspinmat.h:217
QDP::UnaryReturn< PSpinMatrix< T, N >, FnTraceSpin >::Type_t
PScalar< typename UnaryReturn< T, FnTraceSpin >::Type_t > Type_t
Definition qdp_primspinmat.h:365
QDP::UnaryReturn< PSpinMatrix< T, N >, FnTrace >::Type_t
PScalar< typename UnaryReturn< T, FnTrace >::Type_t > Type_t
Definition qdp_primspinmat.h:202
QDP::UnaryReturn< PSpinMatrix< T, N >, FnTransposeSpin >::Type_t
PSpinMatrix< typename UnaryReturn< T, FnTransposeSpin >::Type_t, N > Type_t
Definition qdp_primspinmat.h:452
QDP::WordType
Find the underlying word type of a field.
Definition qdp_traits.h:29
Generated by doxygen 1.16.1