SMatSMatAddExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATSMATADDEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATSMATADDEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
73 #include <blaze/util/Assert.h>
74 #include <blaze/util/DisableIf.h>
75 #include <blaze/util/EnableIf.h>
76 #include <blaze/util/Exception.h>
78 #include <blaze/util/mpl/And.h>
79 #include <blaze/util/mpl/Max.h>
80 #include <blaze/util/mpl/Or.h>
81 #include <blaze/util/SelectType.h>
82 #include <blaze/util/Types.h>
85 
86 
87 namespace blaze {
88 
89 //=================================================================================================
90 //
91 // CLASS SMATSMATADDEXPR
92 //
93 //=================================================================================================
94 
95 //*************************************************************************************************
102 template< typename MT1 // Type of the left-hand side sparse matrix
103  , typename MT2 > // Type of the right-hand side sparse matrix
104 class SMatSMatAddExpr : public SparseMatrix< SMatSMatAddExpr<MT1,MT2>, false >
105  , private MatMatAddExpr
106  , private Computation
107 {
108  private:
109  //**Type definitions****************************************************************************
110  typedef typename MT1::ResultType RT1;
111  typedef typename MT2::ResultType RT2;
112  typedef typename MT1::CompositeType CT1;
113  typedef typename MT2::CompositeType CT2;
114  typedef typename MT1::ReturnType RN1;
115  typedef typename MT2::ReturnType RN2;
116  //**********************************************************************************************
117 
118  //**Return type evaluation**********************************************************************
120 
125  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
126 
129  //**********************************************************************************************
130 
131  //**Serial evaluation strategy******************************************************************
133 
138  template< typename T1, typename T2, typename T3 >
139  struct UseSymmetricKernel {
142  };
144  //**********************************************************************************************
145 
146  //**Parallel evaluation strategy****************************************************************
148 
153  template< typename MT >
154  struct UseSMPAssign {
155  enum { value = MT::smpAssignable };
156  };
158  //**********************************************************************************************
159 
160  public:
161  //**Type definitions****************************************************************************
167 
170 
172  typedef const ResultType CompositeType;
173 
175  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
176 
178  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
179  //**********************************************************************************************
180 
181  //**Compilation flags***************************************************************************
183  enum { smpAssignable = 0 };
184  //**********************************************************************************************
185 
186  //**Constructor*********************************************************************************
192  explicit inline SMatSMatAddExpr( const MT1& lhs, const MT2& rhs )
193  : lhs_( lhs ) // Left-hand side sparse matrix of the addition expression
194  , rhs_( rhs ) // Right-hand side sparse matrix of the addition expression
195  {
196  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
197  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
198  }
199  //**********************************************************************************************
200 
201  //**Access operator*****************************************************************************
208  inline ReturnType operator()( size_t i, size_t j ) const {
209  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
210  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
211  return lhs_(i,j) + rhs_(i,j);
212  }
213  //**********************************************************************************************
214 
215  //**At function*********************************************************************************
223  inline ReturnType at( size_t i, size_t j ) const {
224  if( i >= lhs_.rows() ) {
225  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
226  }
227  if( j >= lhs_.columns() ) {
228  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
229  }
230  return (*this)(i,j);
231  }
232  //**********************************************************************************************
233 
234  //**Rows function*******************************************************************************
239  inline size_t rows() const {
240  return lhs_.rows();
241  }
242  //**********************************************************************************************
243 
244  //**Columns function****************************************************************************
249  inline size_t columns() const {
250  return lhs_.columns();
251  }
252  //**********************************************************************************************
253 
254  //**NonZeros function***************************************************************************
259  inline size_t nonZeros() const {
260  return lhs_.nonZeros() + rhs_.nonZeros();
261  }
262  //**********************************************************************************************
263 
264  //**NonZeros function***************************************************************************
270  inline size_t nonZeros( size_t i ) const {
271  return lhs_.nonZeros(i) + rhs_.nonZeros(i);
272  }
273  //**********************************************************************************************
274 
275  //**Left operand access*************************************************************************
280  inline LeftOperand leftOperand() const {
281  return lhs_;
282  }
283  //**********************************************************************************************
284 
285  //**Right operand access************************************************************************
290  inline RightOperand rightOperand() const {
291  return rhs_;
292  }
293  //**********************************************************************************************
294 
295  //**********************************************************************************************
301  template< typename T >
302  inline bool canAlias( const T* alias ) const {
303  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
304  }
305  //**********************************************************************************************
306 
307  //**********************************************************************************************
313  template< typename T >
314  inline bool isAliased( const T* alias ) const {
315  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
316  }
317  //**********************************************************************************************
318 
319  private:
320  //**Member variables****************************************************************************
321  LeftOperand lhs_;
322  RightOperand rhs_;
323  //**********************************************************************************************
324 
325  //**Assignment to dense matrices****************************************************************
337  template< typename MT // Type of the target dense matrix
338  , bool SO > // Storage order of the target dense matrix
339  friend inline void assign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
340  {
342 
343  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
344  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
345 
346  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
347 
348  assign( ~lhs, rhs.lhs_ );
349 
351  addAssign( ~lhs, rhs.rhs_ );
352  }
353  else
354  {
355  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
356 
357  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
358  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
359  BLAZE_INTERNAL_ASSERT( B.rows() == (~lhs).rows() , "Invalid number of rows" );
360  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
361 
362  for( size_t i=0UL; i<(~lhs).rows(); ++i ) {
363  const RightIterator end( B.end(i) );
364  for( RightIterator element=B.begin(i); element!=end; ++element ) {
365  if( isDefault( (~lhs)(i,element->index()) ) )
366  (~lhs)(i,element->index()) = element->value();
367  else
368  (~lhs)(i,element->index()) += element->value();
369  }
370  }
371  }
372  }
374  //**********************************************************************************************
375 
376  //**Assignment to row-major sparse matrices*****************************************************
388  template< typename MT > // Type of the target sparse matrix
389  friend inline void assign( SparseMatrix<MT,false>& lhs, const SMatSMatAddExpr& rhs )
390  {
392 
393  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
394  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
395 
396  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
397  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
398 
399  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
400  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
401 
402  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
403  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
404  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
405  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
406  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
407  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
408 
409  // Final memory allocation (based on the evaluated operands)
410  (~lhs).reserve( A.nonZeros() + B.nonZeros() );
411 
412  // Performing the matrix addition
413  for( size_t i=0UL; i<(~lhs).rows(); ++i )
414  {
415  const LeftIterator lend( A.end(i) );
416  const RightIterator rend( B.end(i) );
417 
418  LeftIterator l( A.begin(i) );
419  RightIterator r( B.begin(i) );
420 
421  while( l != lend && r != rend )
422  {
423  if( l->index() < r->index() ) {
424  (~lhs).append( i, l->index(), l->value() );
425  ++l;
426  }
427  else if( l->index() > r->index() ) {
428  (~lhs).append( i, r->index(), r->value() );
429  ++r;
430  }
431  else {
432  (~lhs).append( i, l->index(), l->value()+r->value() );
433  ++l;
434  ++r;
435  }
436  }
437 
438  while( l != lend ) {
439  (~lhs).append( i, l->index(), l->value() );
440  ++l;
441  }
442 
443  while( r != rend ) {
444  (~lhs).append( i, r->index(), r->value() );
445  ++r;
446  }
447 
448  (~lhs).finalize( i );
449  }
450  }
452  //**********************************************************************************************
453 
454  //**Assignment to column-major sparse matrices**************************************************
466  template< typename MT > // Type of the target sparse matrix
467  friend inline typename DisableIf< UseSymmetricKernel<MT,MT1,MT2> >::Type
468  assign( SparseMatrix<MT,true>& lhs, const SMatSMatAddExpr& rhs )
469  {
471 
473 
474  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
475  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
476 
477  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
478  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
479 
480  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
481  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
482 
483  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
484  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
485  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
486  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
487  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
488  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
489 
490  const size_t m( A.rows() );
491  const size_t n( A.columns() );
492 
493  // Counting the number of elements per column
494  std::vector<size_t> nonzeros( n, 0UL );
495  for( size_t i=0UL; i<m; ++i )
496  {
497  const LeftIterator lend( A.end(i) );
498  const RightIterator rend( B.end(i) );
499 
500  LeftIterator l( A.begin(i) );
501  RightIterator r( B.begin(i) );
502 
503  while( l != lend && r != rend )
504  {
505  if( l->index() < r->index() ) {
506  ++nonzeros[l->index()];
507  ++l;
508  }
509  else if( l->index() > r->index() ) {
510  ++nonzeros[r->index()];
511  ++r;
512  }
513  else {
514  ++nonzeros[l->index()];
515  ++l;
516  ++r;
517  }
518  }
519 
520  while( l != lend ) {
521  ++nonzeros[l->index()];
522  ++l;
523  }
524 
525  while( r != rend ) {
526  ++nonzeros[r->index()];
527  ++r;
528  }
529  }
530 
531  // Resizing the left-hand side sparse matrix
532  for( size_t j=0UL; j<n; ++j ) {
533  (~lhs).reserve( j, nonzeros[j] );
534  }
535 
536  // Performing the matrix addition
537  for( size_t i=0UL; i<m; ++i )
538  {
539  const LeftIterator lend( A.end(i) );
540  const RightIterator rend( B.end(i) );
541 
542  LeftIterator l( A.begin(i) );
543  RightIterator r( B.begin(i) );
544 
545  while( l != lend && r != rend )
546  {
547  if( l->index() < r->index() ) {
548  (~lhs).append( i, l->index(), l->value() );
549  ++l;
550  }
551  else if( l->index() > r->index() ) {
552  (~lhs).append( i, r->index(), r->value() );
553  ++r;
554  }
555  else {
556  (~lhs).append( i, l->index(), l->value()+r->value() );
557  ++l;
558  ++r;
559  }
560  }
561 
562  while( l != lend ) {
563  (~lhs).append( i, l->index(), l->value() );
564  ++l;
565  }
566 
567  while( r != rend ) {
568  (~lhs).append( i, r->index(), r->value() );
569  ++r;
570  }
571  }
572  }
574  //**********************************************************************************************
575 
576  //**Assignment to column-major sparse matrices**************************************************
588  template< typename MT > // Type of the target sparse matrix
589  friend inline typename EnableIf< UseSymmetricKernel<MT,MT1,MT2> >::Type
590  assign( SparseMatrix<MT,true>& lhs, const SMatSMatAddExpr& rhs )
591  {
593 
595 
596  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
597  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
598 
599  assign( ~lhs, trans( rhs.lhs_ ) + trans( rhs.rhs_ ) );
600  }
602  //**********************************************************************************************
603 
604  //**Addition assignment to dense matrices*******************************************************
616  template< typename MT // Type of the target dense matrix
617  , bool SO > // Storage order of the target dense matrix
618  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
619  {
621 
622  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
623  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
624 
625  addAssign( ~lhs, rhs.lhs_ );
626  addAssign( ~lhs, rhs.rhs_ );
627  }
629  //**********************************************************************************************
630 
631  //**Addition assignment to sparse matrices******************************************************
632  // No special implementation for the addition assignment to sparse matrices.
633  //**********************************************************************************************
634 
635  //**Subtraction assignment to dense matrices****************************************************
647  template< typename MT // Type of the target dense matrix
648  , bool SO > // Storage order of the target dense matrix
649  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
650  {
652 
653  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
654  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
655 
656  subAssign( ~lhs, rhs.lhs_ );
657  subAssign( ~lhs, rhs.rhs_ );
658  }
660  //**********************************************************************************************
661 
662  //**Subtraction assignment to sparse matrices***************************************************
663  // No special implementation for the subtraction assignment to sparse matrices.
664  //**********************************************************************************************
665 
666  //**Multiplication assignment to dense matrices*************************************************
667  // No special implementation for the multiplication assignment to dense matrices.
668  //**********************************************************************************************
669 
670  //**Multiplication assignment to sparse matrices************************************************
671  // No special implementation for the multiplication assignment to sparse matrices.
672  //**********************************************************************************************
673 
674  //**SMP assignment to dense matrices************************************************************
675  // No special implementation for the SMP assignment to dense matrices.
676  //**********************************************************************************************
677 
678  //**SMP assignment to sparse matrices***********************************************************
679  // No special implementation for the SMP assignment to sparse matrices.
680  //**********************************************************************************************
681 
682  //**SMP addition assignment to dense matrices***************************************************
696  template< typename MT // Type of the target dense matrix
697  , bool SO > // Storage order of the target dense matrix
698  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
699  smpAddAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
700  {
702 
703  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
704  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
705 
706  smpAddAssign( ~lhs, rhs.lhs_ );
707  smpAddAssign( ~lhs, rhs.rhs_ );
708  }
710  //**********************************************************************************************
711 
712  //**SMP addition assignment to sparse matrices**************************************************
713  // No special implementation for the SMP addition assignment to sparse matrices.
714  //**********************************************************************************************
715 
716  //**SMP subtraction assignment to dense matrices************************************************
730  template< typename MT // Type of the target dense matrix
731  , bool SO > // Storage order of the target dense matrix
732  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
733  smpSubAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
734  {
736 
737  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
738  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
739 
740  smpSubAssign( ~lhs, rhs.lhs_ );
741  smpSubAssign( ~lhs, rhs.rhs_ );
742  }
744  //**********************************************************************************************
745 
746  //**SMP subtraction assignment to sparse matrices***********************************************
747  // No special implementation for the SMP subtraction assignment to sparse matrices.
748  //**********************************************************************************************
749 
750  //**SMP multiplication assignment to dense matrices*********************************************
751  // No special implementation for the SMP multiplication assignment to dense matrices.
752  //**********************************************************************************************
753 
754  //**SMP multiplication assignment to sparse matrices********************************************
755  // No special implementation for the SMP multiplication assignment to sparse matrices.
756  //**********************************************************************************************
757 
758  //**Compile time checks*************************************************************************
766  //**********************************************************************************************
767 };
768 //*************************************************************************************************
769 
770 
771 
772 
773 //=================================================================================================
774 //
775 // GLOBAL BINARY ARITHMETIC OPERATORS
776 //
777 //=================================================================================================
778 
779 //*************************************************************************************************
805 template< typename T1 // Type of the left-hand side sparse matrix
806  , typename T2 > // Type of the right-hand side sparse matrix
807 inline const SMatSMatAddExpr<T1,T2>
809 {
811 
812  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
813  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
814  }
815 
816  return SMatSMatAddExpr<T1,T2>( ~lhs, ~rhs );
817 }
818 //*************************************************************************************************
819 
820 
821 
822 
823 //=================================================================================================
824 //
825 // ROWS SPECIALIZATIONS
826 //
827 //=================================================================================================
828 
829 //*************************************************************************************************
831 template< typename MT1, typename MT2 >
832 struct Rows< SMatSMatAddExpr<MT1,MT2> >
833  : public Max< Rows<MT1>, Rows<MT2> >
834 {};
836 //*************************************************************************************************
837 
838 
839 
840 
841 //=================================================================================================
842 //
843 // COLUMNS SPECIALIZATIONS
844 //
845 //=================================================================================================
846 
847 //*************************************************************************************************
849 template< typename MT1, typename MT2 >
850 struct Columns< SMatSMatAddExpr<MT1,MT2> >
851  : public Max< Columns<MT1>, Columns<MT2> >
852 {};
854 //*************************************************************************************************
855 
856 
857 
858 
859 //=================================================================================================
860 //
861 // ISSYMMETRIC SPECIALIZATIONS
862 //
863 //=================================================================================================
864 
865 //*************************************************************************************************
867 template< typename MT1, typename MT2 >
868 struct IsSymmetric< SMatSMatAddExpr<MT1,MT2> >
869  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
870 {};
872 //*************************************************************************************************
873 
874 
875 
876 
877 //=================================================================================================
878 //
879 // ISHERMITIAN SPECIALIZATIONS
880 //
881 //=================================================================================================
882 
883 //*************************************************************************************************
885 template< typename MT1, typename MT2 >
886 struct IsHermitian< SMatSMatAddExpr<MT1,MT2> >
887  : public IsTrue< IsHermitian<MT1>::value && IsHermitian<MT2>::value >
888 {};
890 //*************************************************************************************************
891 
892 
893 
894 
895 //=================================================================================================
896 //
897 // ISLOWER SPECIALIZATIONS
898 //
899 //=================================================================================================
900 
901 //*************************************************************************************************
903 template< typename MT1, typename MT2 >
904 struct IsLower< SMatSMatAddExpr<MT1,MT2> >
905  : public IsTrue< And< IsLower<MT1>, IsLower<MT2> >::value >
906 {};
908 //*************************************************************************************************
909 
910 
911 
912 
913 //=================================================================================================
914 //
915 // ISUNILOWER SPECIALIZATIONS
916 //
917 //=================================================================================================
918 
919 //*************************************************************************************************
921 template< typename MT1, typename MT2 >
922 struct IsUniLower< SMatSMatAddExpr<MT1,MT2> >
923  : public IsTrue< Or< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >
924  , And< IsUniLower<MT2>, IsStrictlyLower<MT1> > >::value >
925 {};
927 //*************************************************************************************************
928 
929 
930 
931 
932 //=================================================================================================
933 //
934 // ISSTRICTLYLOWER SPECIALIZATIONS
935 //
936 //=================================================================================================
937 
938 //*************************************************************************************************
940 template< typename MT1, typename MT2 >
941 struct IsStrictlyLower< SMatSMatAddExpr<MT1,MT2> >
942  : public IsTrue< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
943 {};
945 //*************************************************************************************************
946 
947 
948 
949 
950 //=================================================================================================
951 //
952 // ISUPPER SPECIALIZATIONS
953 //
954 //=================================================================================================
955 
956 //*************************************************************************************************
958 template< typename MT1, typename MT2 >
959 struct IsUpper< SMatSMatAddExpr<MT1,MT2> >
960  : public IsTrue< And< IsUpper<MT1>, IsUpper<MT2> >::value >
961 {};
963 //*************************************************************************************************
964 
965 
966 
967 
968 //=================================================================================================
969 //
970 // ISUNIUPPER SPECIALIZATIONS
971 //
972 //=================================================================================================
973 
974 //*************************************************************************************************
976 template< typename MT1, typename MT2 >
977 struct IsUniUpper< SMatSMatAddExpr<MT1,MT2> >
978  : public IsTrue< Or< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >
979  , And< IsUniUpper<MT2>, IsStrictlyUpper<MT1> > >::value >
980 {};
982 //*************************************************************************************************
983 
984 
985 
986 
987 //=================================================================================================
988 //
989 // ISSTRICTLYUPPER SPECIALIZATIONS
990 //
991 //=================================================================================================
992 
993 //*************************************************************************************************
995 template< typename MT1, typename MT2 >
996 struct IsStrictlyUpper< SMatSMatAddExpr<MT1,MT2> >
997  : public IsTrue< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
998 {};
1000 //*************************************************************************************************
1001 
1002 
1003 
1004 
1005 //=================================================================================================
1006 //
1007 // EXPRESSION TRAIT SPECIALIZATIONS
1008 //
1009 //=================================================================================================
1010 
1011 //*************************************************************************************************
1013 template< typename MT1, typename MT2, bool AF >
1014 struct SubmatrixExprTrait< SMatSMatAddExpr<MT1,MT2>, AF >
1015 {
1016  public:
1017  //**********************************************************************************************
1018  typedef typename AddExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
1019  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
1020  //**********************************************************************************************
1021 };
1023 //*************************************************************************************************
1024 
1025 
1026 //*************************************************************************************************
1028 template< typename MT1, typename MT2 >
1029 struct RowExprTrait< SMatSMatAddExpr<MT1,MT2> >
1030 {
1031  public:
1032  //**********************************************************************************************
1033  typedef typename AddExprTrait< typename RowExprTrait<const MT1>::Type
1034  , typename RowExprTrait<const MT2>::Type >::Type Type;
1035  //**********************************************************************************************
1036 };
1038 //*************************************************************************************************
1039 
1040 
1041 //*************************************************************************************************
1043 template< typename MT1, typename MT2 >
1044 struct ColumnExprTrait< SMatSMatAddExpr<MT1,MT2> >
1045 {
1046  public:
1047  //**********************************************************************************************
1048  typedef typename AddExprTrait< typename ColumnExprTrait<const MT1>::Type
1049  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
1050  //**********************************************************************************************
1051 };
1053 //*************************************************************************************************
1054 
1055 } // namespace blaze
1056 
1057 #endif
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exceptionThis macro encapsulates the default way of...
Definition: Exception.h:187
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatSMatAddExpr.h:259
SMatSMatAddExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the SMatSMatAddExpr class.
Definition: SMatSMatAddExpr.h:192
Header file for the Max class template.
AddExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: SMatSMatAddExpr.h:128
Evaluation of the return type of an addition expression.Via this type trait it is possible to evaluat...
Definition: AddExprTrait.h:104
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
Header file for basic type definitions.
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:250
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:175
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:207
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatSMatAddExpr.h:314
Header file for the ColumnExprTrait class template.
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2588
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:259
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:308
Header file for the And class template.
Header file for the AddExprTrait class template.
SMatSMatAddExpr< MT1, MT2 > This
Type of this SMatSMatAddExpr instance.
Definition: SMatSMatAddExpr.h:162
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatSMatAddExpr.h:208
Header file for the Computation base class.
Constraints on the storage order of matrix types.
AddTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SMatSMatAddExpr.h:163
Header file for the IsUniLower type trait.
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:117
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:547
Header file for the SparseMatrix base class.
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:110
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatSMatAddExpr.h:270
Constraint on the data type.
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
Header file for the DisableIf class template.
Header file for the IsTemporary type trait class.
Header file for the IsStrictlyUpper type trait.
MT2::ReturnType RN2
Return type of the right-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:115
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:112
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a column-major dense or sparse matri...
Definition: ColumnMajorMatrix.h:79
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: SMatSMatAddExpr.h:223
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2592
Header file for the Or class template.
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exceptionThis macro encapsulates the default way of Bla...
Definition: Exception.h:331
const DenseIterator< Type, AF > operator+(const DenseIterator< Type, AF > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:610
Header file for the Columns type trait.
Header file for the IsLower type trait.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatSMatAddExpr.h:302
RightOperand rhs_
Right-hand side sparse matrix of the addition expression.
Definition: SMatSMatAddExpr.h:322
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATADDEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix ...
Definition: MatMatAddExpr.h:165
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Header file for the serial shim.
MT2::CompositeType CT2
Composite type of the right-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:113
RightOperand rightOperand() const
Returns the right-hand side sparse matrix operand.
Definition: SMatSMatAddExpr.h:290
MT1::ReturnType RN1
Return type of the left-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:114
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
EnableIf< IsDenseMatrix< MT1 > >::Type smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:116
Header file for the SubmatrixExprTrait class template.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: RowMajorMatrix.h:79
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2587
Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given...
Definition: RemoveReference.h:69
Header file for run time assertion macros.
Base template for the AddTrait class.
Definition: AddTrait.h:138
Header file for the addition trait.
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: SMatSMatAddExpr.h:169
LeftOperand lhs_
Left-hand side sparse matrix of the addition expression.
Definition: SMatSMatAddExpr.h:321
LeftOperand leftOperand() const
Returns the left-hand side sparse matrix operand.
Definition: SMatSMatAddExpr.h:280
Constraint on the data type.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatSMatAddExpr.h:239
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatSMatAddExpr.h:249
Header file for the isDefault shim.
Constraint on the data type.
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:111
Constraints on the storage order of matrix types.
ResultType::ElementType ElementType
Resulting element type.
Definition: SMatSMatAddExpr.h:166
Header file for the MatMatAddExpr base class.
Header file for the RemoveReference type trait.
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatSMatAddExpr.h:172
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:178
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:944
Header file for the IsComputation type trait class.
Expression object for sparse matrix-sparse matrix additions.The SMatSMatAddExpr class represents the ...
Definition: Forward.h:106
EnableIf< IsDenseMatrix< MT1 > >::Type smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2583
Header file for the IsTrue value trait.
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:324
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatSMatAddExpr.h:165
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatSMatAddExpr.h:164
Header file for the IsUpper type trait.
Header file for exception macros.
Header file for the IsHermitian type trait.
Header file for the IsResizable type trait.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type...
Definition: SparseMatrix.h:79
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.