softsusy is hosted by Hepforge, IPPP Durham
SOFTSUSY  4.1
xpr-matrix.h
Go to the documentation of this file.
1 
10 #ifndef XPR_MATRIX_H
11 #define XPR_MATRIX_H
12 
13 #include "xpr-base.h"
14 #include "mycomplex.h"
15 
16 
17 /******************* ADDITION ******************************/
19 template<typename T, typename A, typename B>
20 MatXpr< T,
21  MatXprBinOp<T,
24  OpAdd<T> > >
26 {
29  OpAdd<T> > ExprT;
30 
31  return MatXpr< T, ExprT >(
32  ExprT( MatConstRef<T,MatIndexable<T,A> >(a),
34 }
35 
37 template<typename T, typename A, typename B>
38 MatXpr< T,
39  MatXprBinOp<T,
42  OpAdd<T> > >
44 {
47  OpAdd<T> > ExprT;
48 
49  return MatXpr< T, ExprT >(
50  ExprT( MatConstRef<T,MatXpr<T,A> >(a),
52 }
53 
55 template<typename T, typename A, typename B>
56 MatXpr< T,
57  MatXprBinOp<T,
60  OpAdd<T> > >
62 {
65  OpAdd<T> > ExprT;
66 
67  return MatXpr< T, ExprT >(
68  ExprT( MatConstRef<T,MatIndexable<T,A> >(a),
69  MatConstRef<T,MatXpr<T,B> >(b) ));
70 }
71 
73 template<typename T, typename A, typename B>
74 MatXpr< T,
75  MatXprBinOp<T,
78  OpAdd<T> > >
79 operator+( const MatXpr<T,A>& a, const MatXpr<T,B>& b )
80 {
83  OpAdd<T> > ExprT;
84 
85  return MatXpr< T, ExprT >(
86  ExprT( MatConstRef<T,MatXpr<T,A> >(a),
87  MatConstRef<T,MatXpr<T,B> >(b) ));
88 }
89 
90 /****** ADDITION TO TRACE *******************/
92 template<typename T, typename B>
93 MatXpr< T,
96  OpAdd<T> > >
97 operator+( T a, const MatIndexable<T,B>& b )
98 {
99  typedef MatXprScalDiagOp1< T,
101  OpAdd<T> > ExprT;
102 
103  return MatXpr< T, ExprT >(
104  ExprT( a,
105  MatConstRef<T,MatIndexable<T,B> >(b) ));
106 }
107 
109 template<typename T, typename B>
110 MatXpr< T,
113  OpAdd<T> > >
114 operator+( const MatIndexable<T,B>& b, T a )
115 {
116  typedef MatXprScalDiagOp2< T,
118  OpAdd<T> > ExprT;
119 
120  return MatXpr< T, ExprT >(
121  ExprT(
122  MatConstRef<T,MatIndexable<T,B> >(b) , a));
123 }
124 
126 template<typename T, typename B>
127 MatXpr< T,
130  OpAdd<T> > >
131 operator+( T a, const MatXpr<T,B>& b )
132 {
133  typedef MatXprScalDiagOp1< T,
135  OpAdd<T> > ExprT;
136 
137  return MatXpr< T, ExprT >(
138  ExprT( a,
139  MatConstRef<T,MatXpr<T,B> >(b) ));
140 }
141 
143 template<typename T, typename B>
144 MatXpr< T,
147  OpAdd<T> > >
148 operator+( const MatXpr<T,B>& b, T a )
149 {
150  typedef MatXprScalDiagOp2< T,
152  OpAdd<T> > ExprT;
153 
154  return MatXpr< T, ExprT >(
155  ExprT(
156  MatConstRef<T,MatXpr<T,B> >(b) , a));
157 }
158 
159 
160 
161 /******************* SUBTRACTION ******************************/
163 template<typename T, typename A, typename B>
164 MatXpr< T,
165  MatXprBinOp<T,
168  OpSubtract<T> > >
170 {
173  OpSubtract<T> > ExprT;
174 
175  return MatXpr< T, ExprT >(
176  ExprT( MatConstRef<T,MatIndexable<T,A> >(a),
177  MatConstRef<T,MatIndexable<T,B> >(b) ));
178 }
179 
181 template<typename T, typename A, typename B>
182 MatXpr< T,
183  MatXprBinOp<T,
186  OpSubtract<T> > >
188 {
191  OpSubtract<T> > ExprT;
192 
193  return MatXpr< T, ExprT >(
194  ExprT( MatConstRef<T,MatXpr<T,A> >(a),
195  MatConstRef<T,MatIndexable<T,B> >(b) ));
196 }
197 
199 template<typename T, typename A, typename B>
200 MatXpr< T,
201  MatXprBinOp<T,
204  OpSubtract<T> > >
206 {
209  OpSubtract<T> > ExprT;
210 
211  return MatXpr< T, ExprT >(
212  ExprT( MatConstRef<T,MatIndexable<T,A> >(a),
213  MatConstRef<T,MatXpr<T,B> >(b) ));
214 }
215 
217 template<typename T, typename A, typename B>
218 MatXpr< T,
219  MatXprBinOp<T,
222  OpSubtract<T> > >
223 operator-( const MatXpr<T,A>& a, const MatXpr<T,B>& b )
224 {
227  OpSubtract<T> > ExprT;
228 
229  return MatXpr< T, ExprT >(
230  ExprT( MatConstRef<T,MatXpr<T,A> >(a),
231  MatConstRef<T,MatXpr<T,B> >(b) ));
232 }
233 
234 /************* OUTER PRODUCT ************/
236 template<typename T, typename A, typename B>
237 MatXpr< T,
238  MatXprOuterOp<T,
241  OpMultiply<T> > >
242 outerProduct( const Xpr<T,A>& a, const Xpr<T,B>& b )
243 {
246  OpMultiply<T> > ExprT;
247 
248  return MatXpr< T, ExprT >(
249  ExprT( ConstRef<T,Xpr<T,A> >(a),
250  ConstRef<T,Xpr<T,B> >(b) ));
251 }
252 
254 template<typename T, typename A, typename B>
255 MatXpr< T,
256  MatXprOuterOp<T,
259  OpMultiply<T> > >
260 outerProduct( const Indexable<T,A>& a, const Xpr<T,B>& b )
261 {
264  OpMultiply<T> > ExprT;
265 
266  return MatXpr< T, ExprT >(
267  ExprT( ConstRef<T,Indexable<T,A> >(a),
268  ConstRef<T,Xpr<T,B> >(b) ));
269 }
270 
272 template<typename T, typename A, typename B>
273 MatXpr< T,
274  MatXprOuterOp<T,
277  OpMultiply<T> > >
278 outerProduct( const Xpr<T,A>& a, const Indexable<T,B>& b )
279 {
282  OpMultiply<T> > ExprT;
283 
284  return MatXpr< T, ExprT >(
285  ExprT( ConstRef<T,Xpr<T,A> >(a),
286  ConstRef<T,Indexable<T,B> >(b) ));
287 }
288 
290 template<typename T, typename A, typename B>
291 MatXpr< T,
292  MatXprOuterOp<T,
295  OpMultiply<T> > >
297 {
300  OpMultiply<T> > ExprT;
301 
302  return MatXpr< T, ExprT >(
303  ExprT( ConstRef<T,Indexable<T,A> >(a),
304  ConstRef<T,Indexable<T,B> >(b) ));
305 }
306 
307 /************* UNARY NEGATIVE **************/
309 template<typename T, typename A>
310 MatXpr< T,
311  MatXprUnaryOp<T,
313  OpNegate<T> > >
315 {
317  OpNegate<T> > ExprT;
318 
319  return MatXpr< T, ExprT >(
320  ExprT( MatConstRef<T,MatXpr<T,A> >(a) ));
321 }
322 
324 template<typename T, typename A>
325 MatXpr< T,
326  MatXprUnaryOp<T,
328  OpNegate<T> > >
330 {
332  OpNegate<T> > ExprT;
333 
334  return MatXpr< T, ExprT >(
335  ExprT( MatConstRef<T,MatIndexable<T,A> >(a) ));
336 }
337 
338 /****** SUBTRACTION FROM TRACE *******************/
340 template<typename T, typename B>
341 MatXpr< T,
344  OpSubtract<T> > >
345 operator-( T a, const MatIndexable<T,B>& b )
346 {
347  typedef MatXprScalDiagOp1< T,
349  OpSubtract<T> > ExprT;
350 
351  return MatXpr< T, ExprT >(
352  ExprT( a,
353  MatConstRef<T,MatIndexable<T,B> >(b) ));
354 }
355 
357 template<typename T, typename B>
358 MatXpr< T,
361  OpSubtract<T> > >
362 operator-( const MatIndexable<T,B>& b, T a )
363 {
364  typedef MatXprScalDiagOp2< T,
366  OpSubtract<T> > ExprT;
367 
368  return MatXpr< T, ExprT >(
369  ExprT( MatConstRef<T,MatIndexable<T,B> >(b) , a));
370 }
371 
373 template<typename T, typename B>
374 MatXpr< T,
377  OpSubtract<T> > >
378 operator-( T a, const MatXpr<T,B>& b )
379 {
380  typedef MatXprScalDiagOp1< T,
382  OpSubtract<T> > ExprT;
383 
384  return MatXpr< T, ExprT >(
385  ExprT( a,
386  MatConstRef<T,MatXpr<T,B> >(b) ));
387 }
388 
390 template<typename T, typename B>
391 MatXpr< T,
394  OpSubtract<T> > >
395 operator-( const MatXpr<T,B>& b, T a )
396 {
397  typedef MatXprScalDiagOp2< T,
399  OpSubtract<T> > ExprT;
400 
401  return MatXpr< T, ExprT >(
402  ExprT( MatConstRef<T,MatXpr<T,B> >(b) , a ));
403 }
404 
406 template<typename T, typename B>
407 MatXpr< T,
408  MatXprScalOp<T,
410  OpMultiply<T> > >
411 operator*( T a, const MatIndexable<T,B>& b )
412 {
413  typedef MatXprScalOp< T,
415  OpMultiply<T> > ExprT;
416 
417  return MatXpr< T, ExprT >( ExprT( a, MatConstRef<T,MatIndexable<T,B> >(b) ));
418 }
419 
421 template<typename T, typename B>
422 MatXpr< T,
423  MatXprScalOp<T,
425  OpMultiply<T> > >
426 operator*( int a, const MatIndexable<T,B>& b )
427 {
428  typedef MatXprScalOp< T,
430  OpMultiply<T> > ExprT;
431 
432  return MatXpr< T, ExprT >( ExprT( static_cast<T>(a), MatConstRef<T,MatIndexable<T,B> >(b) ));
433 }
434 
436 template<typename B>
437 MatXpr< Complex,
441 operator*( double a, const MatIndexable<Complex,B>& b )
442 {
443  typedef MatXprScalOp< Complex,
445  OpMultiply<Complex> > ExprT;
446 
448 }
449 
451 template<typename B>
452 MatXpr< Complex,
456 operator*( double a, const MatXpr<Complex,B>& b )
457 {
458  typedef MatXprScalOp< Complex,
460  OpMultiply<Complex> > ExprT;
461 
463 }
464 
466 template<typename B>
467 MatXpr< Complex,
471 operator*( const MatIndexable<Complex,B>& b , double a)
472 {
473  typedef MatXprScalOp< Complex,
475  OpMultiply<Complex> > ExprT;
476 
478 }
479 
481 template<typename B>
482 MatXpr< Complex,
486 operator*( const MatXpr<Complex,B>& b , double a)
487 {
488  typedef MatXprScalOp< Complex,
490  OpMultiply<Complex> > ExprT;
491 
493 }
494 
495 
497 template<typename T, typename B>
498 MatXpr< T,
499  MatXprScalOp<T,
501  OpMultiply<T> > >
502 operator*( const MatIndexable<T,B>& b, T a )
503 {
504  typedef MatXprScalOp< T,
506  OpMultiply<T> > ExprT;
507 
508  return MatXpr< T, ExprT >(
509  ExprT( a,
510  MatConstRef<T,MatIndexable<T,B> >(b) ));
511 }
512 
514 template<typename T, typename B>
515 MatXpr< T,
516  MatXprScalOp<T,
518  OpMultiply<T> > >
519 operator*( const MatIndexable<T,B>& b, int a )
520 {
521  typedef MatXprScalOp< T,
523  OpMultiply<T> > ExprT;
524 
525  return MatXpr< T, ExprT >(
526  ExprT( static_cast<T>(a),
527  MatConstRef<T,MatIndexable<T,B> >(b) ));
528 }
529 
531 template<typename T, typename B>
532 MatXpr< T,
533  MatXprScalOp<T,
535  OpMultiply<T> > >
536 operator*( T a, const MatXpr<T,B>& b )
537 {
538  typedef MatXprScalOp< T,
540  OpMultiply<T> > ExprT;
541 
542  return MatXpr< T, ExprT >(
543  ExprT( a,
544  MatConstRef<T,MatXpr<T,B> >(b) ));
545 }
546 
548 template<typename T, typename B>
549 MatXpr< T,
550  MatXprScalOp<T,
552  OpMultiply<T> > >
553 operator*( int a, const MatXpr<T,B>& b )
554 {
555  typedef MatXprScalOp< T,
557  OpMultiply<T> > ExprT;
558 
559  return MatXpr< T, ExprT >(
560  ExprT( static_cast<T>(a),
561  MatConstRef<T,MatXpr<T,B> >(b) ));
562 }
563 
565 template<typename T, typename B>
566 MatXpr< T,
567  MatXprScalOp<T,
569  OpMultiply<T> > >
570 operator*( const MatXpr<T,B>& b, T a )
571 {
572  typedef MatXprScalOp< T,
574  OpMultiply<T> > ExprT;
575 
576  return MatXpr< T, ExprT >(
577  ExprT( a,
578  MatConstRef<T,MatXpr<T,B> >(b) ));
579 }
580 
582 template<typename T, typename B>
583 MatXpr< T,
584  MatXprScalOp<T,
586  OpMultiply<T> > >
587 operator*( const MatXpr<T,B>& b, int a )
588 {
589  typedef MatXprScalOp< T,
591  OpMultiply<T> > ExprT;
592 
593  return MatXpr< T, ExprT >(
594  ExprT( static_cast<T>(a),
595  MatConstRef<T,MatXpr<T,B> >(b) ));
596 }
597 
598 /****** DIVIDE BY SCALAR ***************/
600 template<typename T, typename B >
602 operator/( const MatIndexable<T,B>& b, T a )
603 {
605 
606  return MatXpr< T, ExprT >(ExprT (1.0/a, MatConstRef<T,MatIndexable<T,B> >(b)) );
607 }
608 
609 
611 template<typename T, typename B >
613 operator/( const MatXpr<T,B>& b, T a )
614 {
616 
617  return MatXpr< T, ExprT >(ExprT (1.0/a, MatConstRef<T,MatXpr<T,B> >(b)) );
618 }
619 
620 
621 
622 
623 /************ MATRIX MULTIPLY ***************/
625 template<typename T, typename A, typename B>
626 MatXpr< T,
627  MatXprMatMultOp<T,
631 {
634 
635  return MatXpr< T, ExprT >(
636  ExprT( MatConstRef<T,MatIndexable<T,A> >(a),
637  MatConstRef<T,MatIndexable<T,B> >(b) ));
638 }
639 
641 template<typename T, typename A, typename B>
642 MatXpr< T,
643  MatXprMatMultOp<T,
647 {
650 
651  return MatXpr< T, ExprT >(
652  ExprT( MatConstRef<T,MatXpr<T,A> >(a),
653  MatConstRef<T,MatIndexable<T,B> >(b) ));
654 }
655 
657 template<typename T, typename A, typename B>
658 MatXpr< T,
659  MatXprMatMultOp<T,
663 {
665  MatConstRef<T,MatXpr<T,B> > > ExprT;
666 
667  return MatXpr< T, ExprT >(
668  ExprT( MatConstRef<T,MatIndexable<T,A> >(a),
669  MatConstRef<T,MatXpr<T,B> >(b) ));
670 }
671 
673 template<typename T, typename A, typename B>
674 MatXpr< T,
675  MatXprMatMultOp<T,
678 operator*( const MatXpr<T,A>& a, const MatXpr<T,B>& b )
679 {
681  MatConstRef<T,MatXpr<T,B> > > ExprT;
682 
683  return MatXpr< T, ExprT >(
684  ExprT( MatConstRef<T,MatXpr<T,A> >(a),
685  MatConstRef<T,MatXpr<T,B> >(b) ));
686 }
687 
689 template<typename A, typename B>
690 MatXpr< Complex,
695 {
698 
701  MatConstRef<double,MatIndexable<double,B> >(b) ));
702 }
703 
705 template<typename A, typename B>
706 MatXpr< Complex,
711 {
714 
717  MatConstRef<double,MatIndexable<double,B> >(b) ));
718 }
719 
721 template<typename A, typename B>
722 MatXpr< Complex,
727 {
730 
733  MatConstRef<double,MatXpr<double,B> >(b) ));
734 }
735 
737 template<typename A, typename B>
738 MatXpr< Complex,
743 {
746 
749  MatConstRef<double,MatXpr<double,B> >(b) ));
750 }
751 
752 // special 2
754 template<typename A, typename B>
755 MatXpr< Complex,
760 {
763 
765  ExprT( MatConstRef<double,MatIndexable<double,A> >(a),
767 }
768 
770 template<typename A, typename B>
771 MatXpr< Complex,
776 {
779 
781  ExprT( MatConstRef<double,MatXpr<double,A> >(a),
783 }
784 
786 template<typename A, typename B>
787 MatXpr< Complex,
792 {
795 
797  ExprT( MatConstRef<double,MatIndexable<double,A> >(a),
799 }
800 
802 template<typename A, typename B>
803 MatXpr< Complex,
808 {
811 
813  ExprT( MatConstRef<double,MatXpr<double,A> >(a),
815 }
816 
817 /************ MATRIX * VECTOR MULTIPLY ***************/
819 template<typename T, typename A, typename B>
820 Xpr< T,
821  XprMatMultOp<T,
825 {
827  ConstRef<T,Indexable<T,B> > > ExprT;
828 
829  return Xpr< T, ExprT >(
830  ExprT( MatConstRef<T,MatIndexable<T,A> >(a),
831  ConstRef<T,Indexable<T,B> >(b) ));
832 }
833 
835 template<typename A, typename B>
836 Xpr< Complex,
841 {
844 
845  return Xpr< Complex, ExprT >(
847  ConstRef<double,Indexable<double,B> >(b) ));
848 }
849 
851 template<typename A, typename B>
852 Xpr< Complex,
857 {
860 
861  return Xpr< Complex, ExprT >(
862  ExprT( MatConstRef<double,MatIndexable<double,A> >(a),
864 }
865 
866 
867 #endif
drop-in replacement for the original home-grown Complex class
Definition: mycomplex.h:17
const version of under-object for speed upgrade of linear algebra
Definition: xpr-base.h:36
provides indexing of xpr type objects
Definition: xpr-base.h:79
const version of xpr matrix
Definition: xpr-base.h:209
Indexable form of xpr matrix.
Definition: xpr-base.h:373
binary operator between two matrices
Definition: xpr-base.h:220
xpr Matrix multiplication
Definition: xpr-base.h:252
outer form of xpr matrix operator
Definition: xpr-base.h:236
scalar operator on diagonal parts of xpr matrix
Definition: xpr-base.h:341
scalar operator on diagonal parts of xpr matrix - different place for const
Definition: xpr-base.h:357
scalar operator on xpr matrix
Definition: xpr-base.h:325
unary operator on an xpr matrix
Definition: xpr-base.h:310
matrix form of xpr object
Definition: xpr-base.h:191
Add two xpr objects.
Definition: xpr-base.h:149
multiply two xpr objects
Definition: xpr-base.h:169
take the negative of an xpr object
Definition: xpr-base.h:178
subtract two xpr objects
Definition: xpr-base.h:159
another xpr matrix multiplication
Definition: xpr-base.h:281
Under-object for speed upgrade of linear algebra.
Definition: xpr-base.h:25
complex numbers and operators between them
Symbolic under-object for vectors/matrices for speed upgrade. The linear algebra operations are often...
MatXpr< T, MatXprScalOp< T, MatConstRef< T, MatIndexable< T, B > >, OpMultiply< T > > > operator*(T a, const MatIndexable< T, B > &b)
multiply xpr matrix by a scalar
Definition: xpr-matrix.h:411
MatXpr< T, MatXprOuterOp< T, ConstRef< T, Xpr< T, A > >, ConstRef< T, Xpr< T, B > >, OpMultiply< T > > > outerProduct(const Xpr< T, A > &a, const Xpr< T, B > &b)
outer product of xpr matrices
Definition: xpr-matrix.h:242
MatXpr< T, MatXprBinOp< T, MatConstRef< T, MatIndexable< T, A > >, MatConstRef< T, MatIndexable< T, B > >, OpSubtract< T > > > operator-(const MatIndexable< T, A > &a, const MatIndexable< T, B > &b)
xpr matrix subtraction
Definition: xpr-matrix.h:169
MatXpr< T, MatXprBinOp< T, MatConstRef< T, MatIndexable< T, A > >, MatConstRef< T, MatIndexable< T, B > >, OpAdd< T > > > operator+(const MatIndexable< T, A > &a, const MatIndexable< T, B > &b)
add two xpr matrices
Definition: xpr-matrix.h:25
MatXpr< T, MatXprScalOp< T, MatConstRef< T, MatIndexable< T, B > >, OpMultiply< T > > > operator/(const MatIndexable< T, B > &b, T a)
divide xpr matrix by scalar
Definition: xpr-matrix.h:602