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 
43 #include <stdexcept>
73 #include <blaze/util/Assert.h>
74 #include <blaze/util/DisableIf.h>
75 #include <blaze/util/EnableIf.h>
77 #include <blaze/util/mpl/And.h>
78 #include <blaze/util/mpl/Max.h>
79 #include <blaze/util/mpl/Or.h>
80 #include <blaze/util/SelectType.h>
81 #include <blaze/util/Types.h>
84 
85 
86 namespace blaze {
87 
88 //=================================================================================================
89 //
90 // CLASS SMATSMATADDEXPR
91 //
92 //=================================================================================================
93 
94 //*************************************************************************************************
101 template< typename MT1 // Type of the left-hand side sparse matrix
102  , typename MT2 > // Type of the right-hand side sparse matrix
103 class SMatSMatAddExpr : public SparseMatrix< SMatSMatAddExpr<MT1,MT2>, false >
104  , private MatMatAddExpr
105  , private Computation
106 {
107  private:
108  //**Type definitions****************************************************************************
109  typedef typename MT1::ResultType RT1;
110  typedef typename MT2::ResultType RT2;
111  typedef typename MT1::CompositeType CT1;
112  typedef typename MT2::CompositeType CT2;
113  typedef typename MT1::ReturnType RN1;
114  typedef typename MT2::ReturnType RN2;
115  //**********************************************************************************************
116 
117  //**Return type evaluation**********************************************************************
119 
124  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
125 
128  //**********************************************************************************************
129 
130  //**Serial evaluation strategy******************************************************************
132 
137  template< typename T1, typename T2, typename T3 >
138  struct UseSymmetricKernel {
141  };
143  //**********************************************************************************************
144 
145  //**Parallel evaluation strategy****************************************************************
147 
152  template< typename MT >
153  struct UseSMPAssign {
154  enum { value = MT::smpAssignable };
155  };
157  //**********************************************************************************************
158 
159  public:
160  //**Type definitions****************************************************************************
166 
169 
171  typedef const ResultType CompositeType;
172 
174  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
175 
177  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
178  //**********************************************************************************************
179 
180  //**Compilation flags***************************************************************************
182  enum { smpAssignable = 0 };
183  //**********************************************************************************************
184 
185  //**Constructor*********************************************************************************
191  explicit inline SMatSMatAddExpr( const MT1& lhs, const MT2& rhs )
192  : lhs_( lhs ) // Left-hand side sparse matrix of the addition expression
193  , rhs_( rhs ) // Right-hand side sparse matrix of the addition expression
194  {
195  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
196  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
197  }
198  //**********************************************************************************************
199 
200  //**Access operator*****************************************************************************
207  inline ReturnType operator()( size_t i, size_t j ) const {
208  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
209  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
210  return lhs_(i,j) + rhs_(i,j);
211  }
212  //**********************************************************************************************
213 
214  //**Rows function*******************************************************************************
219  inline size_t rows() const {
220  return lhs_.rows();
221  }
222  //**********************************************************************************************
223 
224  //**Columns function****************************************************************************
229  inline size_t columns() const {
230  return lhs_.columns();
231  }
232  //**********************************************************************************************
233 
234  //**NonZeros function***************************************************************************
239  inline size_t nonZeros() const {
240  return lhs_.nonZeros() + rhs_.nonZeros();
241  }
242  //**********************************************************************************************
243 
244  //**NonZeros function***************************************************************************
250  inline size_t nonZeros( size_t i ) const {
251  return lhs_.nonZeros(i) + rhs_.nonZeros(i);
252  }
253  //**********************************************************************************************
254 
255  //**Left operand access*************************************************************************
260  inline LeftOperand leftOperand() const {
261  return lhs_;
262  }
263  //**********************************************************************************************
264 
265  //**Right operand access************************************************************************
270  inline RightOperand rightOperand() const {
271  return rhs_;
272  }
273  //**********************************************************************************************
274 
275  //**********************************************************************************************
281  template< typename T >
282  inline bool canAlias( const T* alias ) const {
283  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
284  }
285  //**********************************************************************************************
286 
287  //**********************************************************************************************
293  template< typename T >
294  inline bool isAliased( const T* alias ) const {
295  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
296  }
297  //**********************************************************************************************
298 
299  private:
300  //**Member variables****************************************************************************
301  LeftOperand lhs_;
302  RightOperand rhs_;
303  //**********************************************************************************************
304 
305  //**Assignment to dense matrices****************************************************************
317  template< typename MT // Type of the target dense matrix
318  , bool SO > // Storage order of the target dense matrix
319  friend inline void assign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
320  {
322 
323  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
324  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
325 
326  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
327 
328  assign( ~lhs, rhs.lhs_ );
329 
331  addAssign( ~lhs, rhs.rhs_ );
332  }
333  else
334  {
335  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
336 
337  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
338  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
339  BLAZE_INTERNAL_ASSERT( B.rows() == (~lhs).rows() , "Invalid number of rows" );
340  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
341 
342  for( size_t i=0UL; i<(~lhs).rows(); ++i ) {
343  const RightIterator end( B.end(i) );
344  for( RightIterator element=B.begin(i); element!=end; ++element ) {
345  if( isDefault( (~lhs)(i,element->index()) ) )
346  (~lhs)(i,element->index()) = element->value();
347  else
348  (~lhs)(i,element->index()) += element->value();
349  }
350  }
351  }
352  }
354  //**********************************************************************************************
355 
356  //**Assignment to row-major sparse matrices*****************************************************
368  template< typename MT > // Type of the target sparse matrix
369  friend inline void assign( SparseMatrix<MT,false>& lhs, const SMatSMatAddExpr& rhs )
370  {
372 
373  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
374  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
375 
376  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
377  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
378 
379  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
380  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
381 
382  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
383  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
384  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
385  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
386  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
387  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
388 
389  // Final memory allocation (based on the evaluated operands)
390  (~lhs).reserve( A.nonZeros() + B.nonZeros() );
391 
392  // Performing the matrix addition
393  for( size_t i=0UL; i<(~lhs).rows(); ++i )
394  {
395  const LeftIterator lend( A.end(i) );
396  const RightIterator rend( B.end(i) );
397 
398  LeftIterator l( A.begin(i) );
399  RightIterator r( B.begin(i) );
400 
401  while( l != lend && r != rend )
402  {
403  if( l->index() < r->index() ) {
404  (~lhs).append( i, l->index(), l->value() );
405  ++l;
406  }
407  else if( l->index() > r->index() ) {
408  (~lhs).append( i, r->index(), r->value() );
409  ++r;
410  }
411  else {
412  (~lhs).append( i, l->index(), l->value()+r->value() );
413  ++l;
414  ++r;
415  }
416  }
417 
418  while( l != lend ) {
419  (~lhs).append( i, l->index(), l->value() );
420  ++l;
421  }
422 
423  while( r != rend ) {
424  (~lhs).append( i, r->index(), r->value() );
425  ++r;
426  }
427 
428  (~lhs).finalize( i );
429  }
430  }
432  //**********************************************************************************************
433 
434  //**Assignment to column-major sparse matrices**************************************************
446  template< typename MT > // Type of the target sparse matrix
447  friend inline typename DisableIf< UseSymmetricKernel<MT,MT1,MT2> >::Type
448  assign( SparseMatrix<MT,true>& lhs, const SMatSMatAddExpr& rhs )
449  {
451 
453 
454  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
455  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
456 
457  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
458  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
459 
460  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
461  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
462 
463  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
464  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
465  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
466  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
467  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
468  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
469 
470  const size_t m( A.rows() );
471  const size_t n( A.columns() );
472 
473  // Counting the number of elements per column
474  std::vector<size_t> nonzeros( n, 0UL );
475  for( size_t i=0UL; i<m; ++i )
476  {
477  const LeftIterator lend( A.end(i) );
478  const RightIterator rend( B.end(i) );
479 
480  LeftIterator l( A.begin(i) );
481  RightIterator r( B.begin(i) );
482 
483  while( l != lend && r != rend )
484  {
485  if( l->index() < r->index() ) {
486  ++nonzeros[l->index()];
487  ++l;
488  }
489  else if( l->index() > r->index() ) {
490  ++nonzeros[r->index()];
491  ++r;
492  }
493  else {
494  ++nonzeros[l->index()];
495  ++l;
496  ++r;
497  }
498  }
499 
500  while( l != lend ) {
501  ++nonzeros[l->index()];
502  ++l;
503  }
504 
505  while( r != rend ) {
506  ++nonzeros[r->index()];
507  ++r;
508  }
509  }
510 
511  // Resizing the left-hand side sparse matrix
512  for( size_t j=0UL; j<n; ++j ) {
513  (~lhs).reserve( j, nonzeros[j] );
514  }
515 
516  // Performing the matrix addition
517  for( size_t i=0UL; i<m; ++i )
518  {
519  const LeftIterator lend( A.end(i) );
520  const RightIterator rend( B.end(i) );
521 
522  LeftIterator l( A.begin(i) );
523  RightIterator r( B.begin(i) );
524 
525  while( l != lend && r != rend )
526  {
527  if( l->index() < r->index() ) {
528  (~lhs).append( i, l->index(), l->value() );
529  ++l;
530  }
531  else if( l->index() > r->index() ) {
532  (~lhs).append( i, r->index(), r->value() );
533  ++r;
534  }
535  else {
536  (~lhs).append( i, l->index(), l->value()+r->value() );
537  ++l;
538  ++r;
539  }
540  }
541 
542  while( l != lend ) {
543  (~lhs).append( i, l->index(), l->value() );
544  ++l;
545  }
546 
547  while( r != rend ) {
548  (~lhs).append( i, r->index(), r->value() );
549  ++r;
550  }
551  }
552  }
554  //**********************************************************************************************
555 
556  //**Assignment to column-major sparse matrices**************************************************
568  template< typename MT > // Type of the target sparse matrix
569  friend inline typename EnableIf< UseSymmetricKernel<MT,MT1,MT2> >::Type
570  assign( SparseMatrix<MT,true>& lhs, const SMatSMatAddExpr& rhs )
571  {
573 
575 
576  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
577  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
578 
579  assign( ~lhs, trans( rhs.lhs_ ) + trans( rhs.rhs_ ) );
580  }
582  //**********************************************************************************************
583 
584  //**Addition assignment to dense matrices*******************************************************
596  template< typename MT // Type of the target dense matrix
597  , bool SO > // Storage order of the target dense matrix
598  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
599  {
601 
602  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
603  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
604 
605  addAssign( ~lhs, rhs.lhs_ );
606  addAssign( ~lhs, rhs.rhs_ );
607  }
609  //**********************************************************************************************
610 
611  //**Addition assignment to sparse matrices******************************************************
612  // No special implementation for the addition assignment to sparse matrices.
613  //**********************************************************************************************
614 
615  //**Subtraction assignment to dense matrices****************************************************
627  template< typename MT // Type of the target dense matrix
628  , bool SO > // Storage order of the target dense matrix
629  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
630  {
632 
633  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
634  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
635 
636  subAssign( ~lhs, rhs.lhs_ );
637  subAssign( ~lhs, rhs.rhs_ );
638  }
640  //**********************************************************************************************
641 
642  //**Subtraction assignment to sparse matrices***************************************************
643  // No special implementation for the subtraction assignment to sparse matrices.
644  //**********************************************************************************************
645 
646  //**Multiplication assignment to dense matrices*************************************************
647  // No special implementation for the multiplication assignment to dense matrices.
648  //**********************************************************************************************
649 
650  //**Multiplication assignment to sparse matrices************************************************
651  // No special implementation for the multiplication assignment to sparse matrices.
652  //**********************************************************************************************
653 
654  //**SMP assignment to dense matrices************************************************************
655  // No special implementation for the SMP assignment to dense matrices.
656  //**********************************************************************************************
657 
658  //**SMP assignment to sparse matrices***********************************************************
659  // No special implementation for the SMP assignment to sparse matrices.
660  //**********************************************************************************************
661 
662  //**SMP addition assignment to dense matrices***************************************************
676  template< typename MT // Type of the target dense matrix
677  , bool SO > // Storage order of the target dense matrix
678  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
679  smpAddAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
680  {
682 
683  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
684  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
685 
686  smpAddAssign( ~lhs, rhs.lhs_ );
687  smpAddAssign( ~lhs, rhs.rhs_ );
688  }
690  //**********************************************************************************************
691 
692  //**SMP addition assignment to sparse matrices**************************************************
693  // No special implementation for the SMP addition assignment to sparse matrices.
694  //**********************************************************************************************
695 
696  //**SMP subtraction assignment to dense matrices************************************************
710  template< typename MT // Type of the target dense matrix
711  , bool SO > // Storage order of the target dense matrix
712  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
713  smpSubAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
714  {
716 
717  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
718  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
719 
720  smpSubAssign( ~lhs, rhs.lhs_ );
721  smpSubAssign( ~lhs, rhs.rhs_ );
722  }
724  //**********************************************************************************************
725 
726  //**SMP subtraction assignment to sparse matrices***********************************************
727  // No special implementation for the SMP subtraction assignment to sparse matrices.
728  //**********************************************************************************************
729 
730  //**SMP multiplication assignment to dense matrices*********************************************
731  // No special implementation for the SMP multiplication assignment to dense matrices.
732  //**********************************************************************************************
733 
734  //**SMP multiplication assignment to sparse matrices********************************************
735  // No special implementation for the SMP multiplication assignment to sparse matrices.
736  //**********************************************************************************************
737 
738  //**Compile time checks*************************************************************************
746  //**********************************************************************************************
747 };
748 //*************************************************************************************************
749 
750 
751 
752 
753 //=================================================================================================
754 //
755 // GLOBAL BINARY ARITHMETIC OPERATORS
756 //
757 //=================================================================================================
758 
759 //*************************************************************************************************
785 template< typename T1 // Type of the left-hand side sparse matrix
786  , typename T2 > // Type of the right-hand side sparse matrix
787 inline const SMatSMatAddExpr<T1,T2>
789 {
791 
792  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
793  throw std::invalid_argument( "Matrix sizes do not match" );
794 
795  return SMatSMatAddExpr<T1,T2>( ~lhs, ~rhs );
796 }
797 //*************************************************************************************************
798 
799 
800 
801 
802 //=================================================================================================
803 //
804 // ROWS SPECIALIZATIONS
805 //
806 //=================================================================================================
807 
808 //*************************************************************************************************
810 template< typename MT1, typename MT2 >
811 struct Rows< SMatSMatAddExpr<MT1,MT2> >
812  : public Max< Rows<MT1>, Rows<MT2> >::Type
813 {};
815 //*************************************************************************************************
816 
817 
818 
819 
820 //=================================================================================================
821 //
822 // COLUMNS SPECIALIZATIONS
823 //
824 //=================================================================================================
825 
826 //*************************************************************************************************
828 template< typename MT1, typename MT2 >
829 struct Columns< SMatSMatAddExpr<MT1,MT2> >
830  : public Max< Columns<MT1>, Columns<MT2> >::Type
831 {};
833 //*************************************************************************************************
834 
835 
836 
837 
838 //=================================================================================================
839 //
840 // ISSYMMETRIC SPECIALIZATIONS
841 //
842 //=================================================================================================
843 
844 //*************************************************************************************************
846 template< typename MT1, typename MT2 >
847 struct IsSymmetric< SMatSMatAddExpr<MT1,MT2> >
848  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
849 {};
851 //*************************************************************************************************
852 
853 
854 
855 
856 //=================================================================================================
857 //
858 // ISLOWER SPECIALIZATIONS
859 //
860 //=================================================================================================
861 
862 //*************************************************************************************************
864 template< typename MT1, typename MT2 >
865 struct IsLower< SMatSMatAddExpr<MT1,MT2> >
866  : public IsTrue< And< IsLower<MT1>, IsLower<MT2> >::value >
867 {};
869 //*************************************************************************************************
870 
871 
872 
873 
874 //=================================================================================================
875 //
876 // ISUNILOWER SPECIALIZATIONS
877 //
878 //=================================================================================================
879 
880 //*************************************************************************************************
882 template< typename MT1, typename MT2 >
883 struct IsUniLower< SMatSMatAddExpr<MT1,MT2> >
884  : public IsTrue< Or< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >
885  , And< IsUniLower<MT2>, IsStrictlyLower<MT1> > >::value >
886 {};
888 //*************************************************************************************************
889 
890 
891 
892 
893 //=================================================================================================
894 //
895 // ISSTRICTLYLOWER SPECIALIZATIONS
896 //
897 //=================================================================================================
898 
899 //*************************************************************************************************
901 template< typename MT1, typename MT2 >
902 struct IsStrictlyLower< SMatSMatAddExpr<MT1,MT2> >
903  : public IsTrue< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
904 {};
906 //*************************************************************************************************
907 
908 
909 
910 
911 //=================================================================================================
912 //
913 // ISUPPER SPECIALIZATIONS
914 //
915 //=================================================================================================
916 
917 //*************************************************************************************************
919 template< typename MT1, typename MT2 >
920 struct IsUpper< SMatSMatAddExpr<MT1,MT2> >
921  : public IsTrue< And< IsUpper<MT1>, IsUpper<MT2> >::value >
922 {};
924 //*************************************************************************************************
925 
926 
927 
928 
929 //=================================================================================================
930 //
931 // ISUNIUPPER SPECIALIZATIONS
932 //
933 //=================================================================================================
934 
935 //*************************************************************************************************
937 template< typename MT1, typename MT2 >
938 struct IsUniUpper< SMatSMatAddExpr<MT1,MT2> >
939  : public IsTrue< Or< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >
940  , And< IsUniUpper<MT2>, IsStrictlyUpper<MT1> > >::value >
941 {};
943 //*************************************************************************************************
944 
945 
946 
947 
948 //=================================================================================================
949 //
950 // ISSTRICTLYUPPER SPECIALIZATIONS
951 //
952 //=================================================================================================
953 
954 //*************************************************************************************************
956 template< typename MT1, typename MT2 >
957 struct IsStrictlyUpper< SMatSMatAddExpr<MT1,MT2> >
958  : public IsTrue< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
959 {};
961 //*************************************************************************************************
962 
963 
964 
965 
966 //=================================================================================================
967 //
968 // EXPRESSION TRAIT SPECIALIZATIONS
969 //
970 //=================================================================================================
971 
972 //*************************************************************************************************
974 template< typename MT1, typename MT2, bool AF >
975 struct SubmatrixExprTrait< SMatSMatAddExpr<MT1,MT2>, AF >
976 {
977  public:
978  //**********************************************************************************************
979  typedef typename AddExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
980  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
981  //**********************************************************************************************
982 };
984 //*************************************************************************************************
985 
986 
987 //*************************************************************************************************
989 template< typename MT1, typename MT2 >
990 struct RowExprTrait< SMatSMatAddExpr<MT1,MT2> >
991 {
992  public:
993  //**********************************************************************************************
994  typedef typename AddExprTrait< typename RowExprTrait<const MT1>::Type
995  , typename RowExprTrait<const MT2>::Type >::Type Type;
996  //**********************************************************************************************
997 };
999 //*************************************************************************************************
1000 
1001 
1002 //*************************************************************************************************
1004 template< typename MT1, typename MT2 >
1005 struct ColumnExprTrait< SMatSMatAddExpr<MT1,MT2> >
1006 {
1007  public:
1008  //**********************************************************************************************
1009  typedef typename AddExprTrait< typename ColumnExprTrait<const MT1>::Type
1010  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
1011  //**********************************************************************************************
1012 };
1014 //*************************************************************************************************
1015 
1016 } // namespace blaze
1017 
1018 #endif
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatSMatAddExpr.h:239
SMatSMatAddExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the SMatSMatAddExpr class.
Definition: SMatSMatAddExpr.h:191
Header file for the Max class template.
AddExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: SMatSMatAddExpr.h:127
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:258
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:174
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:209
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatSMatAddExpr.h:294
Header file for the ColumnExprTrait class template.
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2507
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:261
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:316
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:161
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:699
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatSMatAddExpr.h:207
Header file for the Computation base class.
AddTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SMatSMatAddExpr.h:162
Header file for the RequiresEvaluation type trait.
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:107
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:861
Header file for the SparseMatrix base class.
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:109
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatSMatAddExpr.h:250
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:114
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:111
#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: StorageOrder.h:161
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2511
Header file for the Or class template.
BLAZE_ALWAYS_INLINE void assign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the assignment of a matrix to a matrix.
Definition: Matrix.h:635
Header file for the Columns type trait.
const DenseIterator< Type > operator+(const DenseIterator< Type > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:556
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:282
RightOperand rhs_
Right-hand side sparse matrix of the addition expression.
Definition: SMatSMatAddExpr.h:302
Constraints on the storage order of matrix types.
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:112
RightOperand rightOperand() const
Returns the right-hand side sparse matrix operand.
Definition: SMatSMatAddExpr.h:270
MT1::ReturnType RN1
Return type of the left-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:113
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: StorageOrder.h:81
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2506
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:150
Header file for the addition trait.
BLAZE_ALWAYS_INLINE void addAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the addition assignment of a matrix to a matrix.
Definition: Matrix.h:742
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: SMatSMatAddExpr.h:168
LeftOperand lhs_
Left-hand side sparse matrix of the addition expression.
Definition: SMatSMatAddExpr.h:301
LeftOperand leftOperand() const
Returns the left-hand side sparse matrix operand.
Definition: SMatSMatAddExpr.h:260
Constraint on the data type.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatSMatAddExpr.h:219
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatSMatAddExpr.h:229
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:110
ResultType::ElementType ElementType
Resulting element type.
Definition: SMatSMatAddExpr.h:165
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:171
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:177
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:937
Header file for the IsComputation type trait class.
Expression object for sparse matrix-sparse matrix additions.The SMatSMatAddExpr class represents the ...
Definition: Forward.h:96
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:2502
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:332
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatSMatAddExpr.h:164
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatSMatAddExpr.h:163
Header file for the IsUpper 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.
BLAZE_ALWAYS_INLINE void subAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the subtraction assignment of a matrix to matrix.
Definition: Matrix.h:849