TSMatTSMatAddExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATTSMATADDEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATTSMATADDEXPR_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 TSMATTSMATADDEXPR
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 TSMatTSMatAddExpr : public SparseMatrix< TSMatTSMatAddExpr<MT1,MT2>, true >
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::ReturnType RN1;
112  typedef typename MT2::ReturnType RN2;
113  typedef typename MT1::CompositeType CT1;
114  typedef typename MT2::CompositeType CT2;
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 TSMatTSMatAddExpr( 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****************************************************************
318  template< typename MT // Type of the target dense matrix
319  , bool SO > // Storage order of the target dense matrix
320  friend inline void assign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatAddExpr& rhs )
321  {
323 
324  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
325  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
326 
327  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
328 
329  assign( ~lhs, rhs.lhs_ );
330 
332  addAssign( ~lhs, rhs.rhs_ );
333  }
334  else
335  {
336  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
337 
338  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
339  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
340  BLAZE_INTERNAL_ASSERT( B.rows() == (~lhs).rows() , "Invalid number of rows" );
341  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
342 
343  for( size_t j=0UL; j<(~lhs).columns(); ++j ) {
344  const RightIterator end( B.end(j) );
345  for( RightIterator element=B.begin(j); element!=end; ++element ) {
346  if( isDefault( (~lhs)(element->index(),j) ) )
347  (~lhs)(element->index(),j) = element->value();
348  else
349  (~lhs)(element->index(),j) += element->value();
350  }
351  }
352  }
353  }
355  //**********************************************************************************************
356 
357  //**Assignment to row-major sparse matrices*****************************************************
370  template< typename MT > // Type of the target sparse matrix
371  friend inline typename DisableIf< UseSymmetricKernel<MT,MT1,MT2> >::Type
373  {
375 
377 
378  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
379  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
380 
381  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
382  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
383 
384  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
385  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
386 
387  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
388  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
389  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
390  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
391  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
392  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
393 
394  const size_t m( rhs.rows() );
395  const size_t n( rhs.columns() );
396 
397  // Counting the number of elements per column
398  std::vector<size_t> nonzeros( m, 0UL );
399  for( size_t j=0UL; j<n; ++j )
400  {
401  const LeftIterator lend( A.end(j) );
402  const RightIterator rend( B.end(j) );
403 
404  LeftIterator l( A.begin(j) );
405  RightIterator r( B.begin(j) );
406 
407  while( l != lend && r != rend )
408  {
409  if( l->index() < r->index() ) {
410  ++nonzeros[l->index()];
411  ++l;
412  }
413  else if( l->index() > r->index() ) {
414  ++nonzeros[r->index()];
415  ++r;
416  }
417  else {
418  ++nonzeros[l->index()];
419  ++l;
420  ++r;
421  }
422  }
423 
424  while( l != lend ) {
425  ++nonzeros[l->index()];
426  ++l;
427  }
428 
429  while( r != rend ) {
430  ++nonzeros[r->index()];
431  ++r;
432  }
433  }
434 
435  // Resizing the left-hand side sparse matrix
436  for( size_t i=0UL; i<m; ++i ) {
437  (~lhs).reserve( i, nonzeros[i] );
438  }
439 
440  // Performing the matrix addition
441  for( size_t j=0UL; j<n; ++j )
442  {
443  const LeftIterator lend( A.end(j) );
444  const RightIterator rend( B.end(j) );
445 
446  LeftIterator l( A.begin(j) );
447  RightIterator r( B.begin(j) );
448 
449  while( l != lend && r != rend )
450  {
451  if( l->index() < r->index() ) {
452  (~lhs).append( l->index(), j, l->value() );
453  ++l;
454  }
455  else if( l->index() > r->index() ) {
456  (~lhs).append( r->index(), j, r->value() );
457  ++r;
458  }
459  else {
460  (~lhs).append( l->index(), j, l->value()+r->value() );
461  ++l;
462  ++r;
463  }
464  }
465 
466  while( l != lend ) {
467  (~lhs).append( l->index(), j, l->value() );
468  ++l;
469  }
470 
471  while( r != rend ) {
472  (~lhs).append( r->index(), j, r->value() );
473  ++r;
474  }
475  }
476  }
478  //**********************************************************************************************
479 
480  //**Assignment to row-major sparse matrices*****************************************************
493  template< typename MT > // Type of the target sparse matrix
494  friend inline typename EnableIf< UseSymmetricKernel<MT,MT1,MT2> >::Type
495  assign( SparseMatrix<MT,false>& lhs, const TSMatTSMatAddExpr& rhs )
496  {
498 
500 
501  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
502  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
503 
504  assign( ~lhs, trans( rhs.lhs_ ) + trans( rhs.rhs_ ) );
505  }
507  //**********************************************************************************************
508 
509  //**Assignment to column-major sparse matrices**************************************************
522  template< typename MT > // Type of the target sparse matrix
523  friend inline void assign( SparseMatrix<MT,true>& lhs, const TSMatTSMatAddExpr& rhs )
524  {
526 
527  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
528  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
529 
530  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
531  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
532 
533  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
534  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
535 
536  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
537  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
538  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
539  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
540  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
541  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
542 
543  // Final memory allocation (based on the evaluated operands)
544  (~lhs).reserve( A.nonZeros() + B.nonZeros() );
545 
546  // Performing the matrix addition
547  for( size_t j=0UL; j<(~lhs).columns(); ++j )
548  {
549  const LeftIterator lend( A.end(j) );
550  const RightIterator rend( B.end(j) );
551 
552  LeftIterator l( A.begin(j) );
553  RightIterator r( B.begin(j) );
554 
555  while( l != lend && r != rend )
556  {
557  if( l->index() < r->index() ) {
558  (~lhs).append( l->index(), j, l->value() );
559  ++l;
560  }
561  else if( l->index() > r->index() ) {
562  (~lhs).append( r->index(), j, r->value() );
563  ++r;
564  }
565  else {
566  (~lhs).append( l->index(), j, l->value()+r->value() );
567  ++l;
568  ++r;
569  }
570  }
571 
572  while( l != lend ) {
573  (~lhs).append( l->index(), j, l->value() );
574  ++l;
575  }
576 
577  while( r != rend ) {
578  (~lhs).append( r->index(), j, r->value() );
579  ++r;
580  }
581 
582  (~lhs).finalize( j );
583  }
584  }
586  //**********************************************************************************************
587 
588  //**Addition assignment to dense matrices*******************************************************
601  template< typename MT // Type of the target dense matrix
602  , bool SO > // Storage order of the target dense matrix
603  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatAddExpr& rhs )
604  {
606 
607  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
608  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
609 
610  addAssign( ~lhs, rhs.lhs_ );
611  addAssign( ~lhs, rhs.rhs_ );
612  }
614  //**********************************************************************************************
615 
616  //**Addition assignment to sparse matrices******************************************************
617  // No special implementation for the addition assignment to sparse matrices.
618  //**********************************************************************************************
619 
620  //**Subtraction assignment to dense matrices****************************************************
633  template< typename MT // Type of the target dense matrix
634  , bool SO > // Storage order of the target dense matrix
635  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatAddExpr& rhs )
636  {
638 
639  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
640  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
641 
642  subAssign( ~lhs, rhs.lhs_ );
643  subAssign( ~lhs, rhs.rhs_ );
644  }
646  //**********************************************************************************************
647 
648  //**Subtraction assignment to sparse matrices***************************************************
649  // No special implementation for the subtraction assignment to sparse matrices.
650  //**********************************************************************************************
651 
652  //**Multiplication assignment to dense matrices*************************************************
653  // No special implementation for the multiplication assignment to dense matrices.
654  //**********************************************************************************************
655 
656  //**Multiplication assignment to sparse matrices************************************************
657  // No special implementation for the multiplication assignment to sparse matrices.
658  //**********************************************************************************************
659 
660  //**SMP assignment to dense matrices************************************************************
661  // No special implementation for the SMP assignment to dense matrices.
662  //**********************************************************************************************
663 
664  //**SMP assignment to sparse matrices***********************************************************
665  // No special implementation for the SMP assignment to sparse matrices.
666  //**********************************************************************************************
667 
668  //**SMP addition assignment to dense matrices***************************************************
683  template< typename MT // Type of the target dense matrix
684  , bool SO > // Storage order of the target dense matrix
685  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
686  smpAddAssign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatAddExpr& rhs )
687  {
689 
690  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
691  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
692 
693  smpAddAssign( ~lhs, rhs.lhs_ );
694  smpAddAssign( ~lhs, rhs.rhs_ );
695  }
697  //**********************************************************************************************
698 
699  //**SMP addition assignment to sparse matrices**************************************************
700  // No special implementation for the SMP addition assignment to sparse matrices.
701  //**********************************************************************************************
702 
703  //**SMP subtraction assignment to dense matrices************************************************
718  template< typename MT // Type of the target dense matrix
719  , bool SO > // Storage order of the target dense matrix
720  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
721  smpSubAssign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatAddExpr& rhs )
722  {
724 
725  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
726  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
727 
728  smpSubAssign( ~lhs, rhs.lhs_ );
729  smpSubAssign( ~lhs, rhs.rhs_ );
730  }
732  //**********************************************************************************************
733 
734  //**SMP subtraction assignment to sparse matrices***********************************************
735  // No special implementation for the SMP subtraction assignment to sparse matrices.
736  //**********************************************************************************************
737 
738  //**SMP multiplication assignment to dense matrices*********************************************
739  // No special implementation for the SMP multiplication assignment to dense matrices.
740  //**********************************************************************************************
741 
742  //**SMP multiplication assignment to sparse matrices********************************************
743  // No special implementation for the SMP multiplication assignment to sparse matrices.
744  //**********************************************************************************************
745 
746  //**Compile time checks*************************************************************************
754  //**********************************************************************************************
755 };
756 //*************************************************************************************************
757 
758 
759 
760 
761 //=================================================================================================
762 //
763 // GLOBAL BINARY ARITHMETIC OPERATORS
764 //
765 //=================================================================================================
766 
767 //*************************************************************************************************
793 template< typename T1 // Type of the left-hand side sparse matrix
794  , typename T2 > // Type of the right-hand side sparse matrix
795 inline const TSMatTSMatAddExpr<T1,T2>
797 {
799 
800  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
801  throw std::invalid_argument( "Matrix sizes do not match" );
802 
803  return TSMatTSMatAddExpr<T1,T2>( ~lhs, ~rhs );
804 }
805 //*************************************************************************************************
806 
807 
808 
809 
810 //=================================================================================================
811 //
812 // ROWS SPECIALIZATIONS
813 //
814 //=================================================================================================
815 
816 //*************************************************************************************************
818 template< typename MT1, typename MT2 >
819 struct Rows< TSMatTSMatAddExpr<MT1,MT2> >
820  : public Max< Rows<MT1>, Rows<MT2> >::Type
821 {};
823 //*************************************************************************************************
824 
825 
826 
827 
828 //=================================================================================================
829 //
830 // COLUMNS SPECIALIZATIONS
831 //
832 //=================================================================================================
833 
834 //*************************************************************************************************
836 template< typename MT1, typename MT2 >
837 struct Columns< TSMatTSMatAddExpr<MT1,MT2> >
838  : public Max< Columns<MT1>, Columns<MT2> >::Type
839 {};
841 //*************************************************************************************************
842 
843 
844 
845 
846 //=================================================================================================
847 //
848 // ISSYMMETRIC SPECIALIZATIONS
849 //
850 //=================================================================================================
851 
852 //*************************************************************************************************
854 template< typename MT1, typename MT2 >
855 struct IsSymmetric< TSMatTSMatAddExpr<MT1,MT2> >
856  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
857 {};
859 //*************************************************************************************************
860 
861 
862 
863 
864 //=================================================================================================
865 //
866 // ISLOWER SPECIALIZATIONS
867 //
868 //=================================================================================================
869 
870 //*************************************************************************************************
872 template< typename MT1, typename MT2 >
873 struct IsLower< TSMatTSMatAddExpr<MT1,MT2> >
874  : public IsTrue< And< IsLower<MT1>, IsLower<MT2> >::value >
875 {};
877 //*************************************************************************************************
878 
879 
880 
881 
882 //=================================================================================================
883 //
884 // ISUNILOWER SPECIALIZATIONS
885 //
886 //=================================================================================================
887 
888 //*************************************************************************************************
890 template< typename MT1, typename MT2 >
891 struct IsUniLower< TSMatTSMatAddExpr<MT1,MT2> >
892  : public IsTrue< Or< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >
893  , And< IsUniLower<MT2>, IsStrictlyLower<MT1> > >::value >
894 {};
896 //*************************************************************************************************
897 
898 
899 
900 
901 //=================================================================================================
902 //
903 // ISSTRICTLYLOWER SPECIALIZATIONS
904 //
905 //=================================================================================================
906 
907 //*************************************************************************************************
909 template< typename MT1, typename MT2 >
910 struct IsStrictlyLower< TSMatTSMatAddExpr<MT1,MT2> >
911  : public IsTrue< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
912 {};
914 //*************************************************************************************************
915 
916 
917 
918 
919 //=================================================================================================
920 //
921 // ISUPPER SPECIALIZATIONS
922 //
923 //=================================================================================================
924 
925 //*************************************************************************************************
927 template< typename MT1, typename MT2 >
928 struct IsUpper< TSMatTSMatAddExpr<MT1,MT2> >
929  : public IsTrue< And< IsUpper<MT1>, IsUpper<MT2> >::value >
930 {};
932 //*************************************************************************************************
933 
934 
935 
936 
937 //=================================================================================================
938 //
939 // ISUNIUPPER SPECIALIZATIONS
940 //
941 //=================================================================================================
942 
943 //*************************************************************************************************
945 template< typename MT1, typename MT2 >
946 struct IsUniUpper< TSMatTSMatAddExpr<MT1,MT2> >
947  : public IsTrue< Or< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >
948  , And< IsUniUpper<MT2>, IsStrictlyUpper<MT1> > >::value >
949 {};
951 //*************************************************************************************************
952 
953 
954 
955 
956 //=================================================================================================
957 //
958 // ISSTRICTLYUPPER SPECIALIZATIONS
959 //
960 //=================================================================================================
961 
962 //*************************************************************************************************
964 template< typename MT1, typename MT2 >
965 struct IsStrictlyUpper< TSMatTSMatAddExpr<MT1,MT2> >
966  : public IsTrue< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
967 {};
969 //*************************************************************************************************
970 
971 
972 
973 
974 //=================================================================================================
975 //
976 // EXPRESSION TRAIT SPECIALIZATIONS
977 //
978 //=================================================================================================
979 
980 //*************************************************************************************************
982 template< typename MT1, typename MT2, bool AF >
983 struct SubmatrixExprTrait< TSMatTSMatAddExpr<MT1,MT2>, AF >
984 {
985  public:
986  //**********************************************************************************************
987  typedef typename AddExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
988  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
989  //**********************************************************************************************
990 };
992 //*************************************************************************************************
993 
994 
995 //*************************************************************************************************
997 template< typename MT1, typename MT2 >
998 struct RowExprTrait< TSMatTSMatAddExpr<MT1,MT2> >
999 {
1000  public:
1001  //**********************************************************************************************
1002  typedef typename AddExprTrait< typename RowExprTrait<const MT1>::Type
1003  , typename RowExprTrait<const MT2>::Type >::Type Type;
1004  //**********************************************************************************************
1005 };
1007 //*************************************************************************************************
1008 
1009 
1010 //*************************************************************************************************
1012 template< typename MT1, typename MT2 >
1013 struct ColumnExprTrait< TSMatTSMatAddExpr<MT1,MT2> >
1014 {
1015  public:
1016  //**********************************************************************************************
1017  typedef typename AddExprTrait< typename ColumnExprTrait<const MT1>::Type
1018  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
1019  //**********************************************************************************************
1020 };
1022 //*************************************************************************************************
1023 
1024 } // namespace blaze
1025 
1026 #endif
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:109
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TSMatTSMatAddExpr.h:294
Header file for the Max class template.
Evaluation of the return type of an addition expression.Via this type trait it is possible to evaluat...
Definition: AddExprTrait.h:104
TSMatTSMatAddExpr< MT1, MT2 > This
Type of this TSMatTSMatAddExpr instance.
Definition: TSMatTSMatAddExpr.h:161
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.
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: TSMatTSMatAddExpr.h:250
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
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:209
LeftOperand lhs_
Left-hand side sparse matrix of the addition expression.
Definition: TSMatTSMatAddExpr.h:301
Header file for the ColumnExprTrait class template.
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: TSMatTSMatAddExpr.h:168
MT2::CompositeType CT2
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:114
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.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatTSMatAddExpr.h:207
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
Header file for the Computation base class.
Header file for the RequiresEvaluation type trait.
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:113
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.
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.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
RightOperand rightOperand() const
Returns the right-hand side transpose sparse matrix operand.
Definition: TSMatTSMatAddExpr.h:270
#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
Expression object for transpose sparse matrix-transpose sparse matrix additions.The TSMatTSMatAddExpr...
Definition: Forward.h:144
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2511
RightOperand rhs_
Right-hand side sparse matrix of the addition expression.
Definition: TSMatTSMatAddExpr.h:302
Header file for the Or class template.
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:110
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.
AddTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: TSMatTSMatAddExpr.h:162
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.
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:174
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.
MT2::ReturnType RN2
Return type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:112
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Header file for the serial shim.
AddExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: TSMatTSMatAddExpr.h:127
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TSMatTSMatAddExpr.h:164
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatTSMatAddExpr.h:163
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
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: TSMatTSMatAddExpr.h:239
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
Constraint on the data type.
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatTSMatAddExpr.h:171
Header file for the isDefault shim.
MT1::ReturnType RN1
Return type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:111
TSMatTSMatAddExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the TSMatTSMatAddExpr class.
Definition: TSMatTSMatAddExpr.h:191
Constraint on the data type.
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:177
Header file for the MatMatAddExpr base class.
Header file for the RemoveReference type trait.
Substitution Failure Is Not An Error (SFINAE) class.The DisableIf class template is an auxiliary tool...
Definition: DisableIf.h:184
size_t rows() const
Returns the current number of rows of the matrix.
Definition: TSMatTSMatAddExpr.h:219
ResultType::ElementType ElementType
Resulting element type.
Definition: TSMatTSMatAddExpr.h:165
LeftOperand leftOperand() const
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatTSMatAddExpr.h:260
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.
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
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TSMatTSMatAddExpr.h:282
#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
size_t columns() const
Returns the current number of columns of the matrix.
Definition: TSMatTSMatAddExpr.h:229
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