All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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>
69 #include <blaze/util/Assert.h>
70 #include <blaze/util/DisableIf.h>
71 #include <blaze/util/EnableIf.h>
73 #include <blaze/util/mpl/Max.h>
74 #include <blaze/util/SelectType.h>
75 #include <blaze/util/Types.h>
78 
79 
80 namespace blaze {
81 
82 //=================================================================================================
83 //
84 // CLASS SMATSMATADDEXPR
85 //
86 //=================================================================================================
87 
88 //*************************************************************************************************
95 template< typename MT1 // Type of the left-hand side sparse matrix
96  , typename MT2 > // Type of the right-hand side sparse matrix
97 class SMatSMatAddExpr : public SparseMatrix< SMatSMatAddExpr<MT1,MT2>, false >
98  , private MatMatAddExpr
99  , private Computation
100 {
101  private:
102  //**Type definitions****************************************************************************
103  typedef typename MT1::ResultType RT1;
104  typedef typename MT2::ResultType RT2;
105  typedef typename MT1::CompositeType CT1;
106  typedef typename MT2::CompositeType CT2;
107  typedef typename MT1::ReturnType RN1;
108  typedef typename MT2::ReturnType RN2;
109  //**********************************************************************************************
110 
111  //**Return type evaluation**********************************************************************
113 
118  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
119 
122  //**********************************************************************************************
123 
124  //**Serial evaluation strategy******************************************************************
126 
131  template< typename T1, typename T2, typename T3 >
132  struct UseSymmetricKernel {
135  };
137  //**********************************************************************************************
138 
139  //**Parallel evaluation strategy****************************************************************
141 
146  template< typename MT >
147  struct UseSMPAssign {
148  enum { value = MT::smpAssignable };
149  };
151  //**********************************************************************************************
152 
153  public:
154  //**Type definitions****************************************************************************
160 
163 
165  typedef const ResultType CompositeType;
166 
168  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
169 
171  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
172  //**********************************************************************************************
173 
174  //**Compilation flags***************************************************************************
176  enum { smpAssignable = 0 };
177  //**********************************************************************************************
178 
179  //**Constructor*********************************************************************************
185  explicit inline SMatSMatAddExpr( const MT1& lhs, const MT2& rhs )
186  : lhs_( lhs ) // Left-hand side sparse matrix of the addition expression
187  , rhs_( rhs ) // Right-hand side sparse matrix of the addition expression
188  {
189  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
190  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
191  }
192  //**********************************************************************************************
193 
194  //**Access operator*****************************************************************************
201  inline ReturnType operator()( size_t i, size_t j ) const {
202  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
203  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
204  return lhs_(i,j) + rhs_(i,j);
205  }
206  //**********************************************************************************************
207 
208  //**Rows function*******************************************************************************
213  inline size_t rows() const {
214  return lhs_.rows();
215  }
216  //**********************************************************************************************
217 
218  //**Columns function****************************************************************************
223  inline size_t columns() const {
224  return lhs_.columns();
225  }
226  //**********************************************************************************************
227 
228  //**NonZeros function***************************************************************************
233  inline size_t nonZeros() const {
234  return lhs_.nonZeros() + rhs_.nonZeros();
235  }
236  //**********************************************************************************************
237 
238  //**NonZeros function***************************************************************************
244  inline size_t nonZeros( size_t i ) const {
245  return lhs_.nonZeros(i) + rhs_.nonZeros(i);
246  }
247  //**********************************************************************************************
248 
249  //**Left operand access*************************************************************************
254  inline LeftOperand leftOperand() const {
255  return lhs_;
256  }
257  //**********************************************************************************************
258 
259  //**Right operand access************************************************************************
264  inline RightOperand rightOperand() const {
265  return rhs_;
266  }
267  //**********************************************************************************************
268 
269  //**********************************************************************************************
275  template< typename T >
276  inline bool canAlias( const T* alias ) const {
277  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
278  }
279  //**********************************************************************************************
280 
281  //**********************************************************************************************
287  template< typename T >
288  inline bool isAliased( const T* alias ) const {
289  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
290  }
291  //**********************************************************************************************
292 
293  private:
294  //**Member variables****************************************************************************
297  //**********************************************************************************************
298 
299  //**Assignment to dense matrices****************************************************************
311  template< typename MT // Type of the target dense matrix
312  , bool SO > // Storage order of the target dense matrix
313  friend inline void assign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
314  {
316 
317  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
318  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
319 
320  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
321 
322  assign( ~lhs, rhs.lhs_ );
323 
325  addAssign( ~lhs, rhs.rhs_ );
326  }
327  else
328  {
329  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
330 
331  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
332  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
333  BLAZE_INTERNAL_ASSERT( B.rows() == (~lhs).rows() , "Invalid number of rows" );
334  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
335 
336  for( size_t i=0UL; i<(~lhs).rows(); ++i ) {
337  const RightIterator end( B.end(i) );
338  for( RightIterator element=B.begin(i); element!=end; ++element ) {
339  if( isDefault( (~lhs)(i,element->index()) ) )
340  (~lhs)(i,element->index()) = element->value();
341  else
342  (~lhs)(i,element->index()) += element->value();
343  }
344  }
345  }
346  }
348  //**********************************************************************************************
349 
350  //**Assignment to row-major sparse matrices*****************************************************
362  template< typename MT > // Type of the target sparse matrix
363  friend inline void assign( SparseMatrix<MT,false>& lhs, const SMatSMatAddExpr& rhs )
364  {
366 
367  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
368  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
369 
370  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
371  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
372 
373  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
374  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
375 
376  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
377  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
378  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
379  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
380  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
381  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
382 
383  // Final memory allocation (based on the evaluated operands)
384  (~lhs).reserve( A.nonZeros() + B.nonZeros() );
385 
386  // Performing the matrix addition
387  for( size_t i=0UL; i<(~lhs).rows(); ++i )
388  {
389  const LeftIterator lend( A.end(i) );
390  const RightIterator rend( B.end(i) );
391 
392  LeftIterator l( A.begin(i) );
393  RightIterator r( B.begin(i) );
394 
395  while( l != lend && r != rend )
396  {
397  if( l->index() < r->index() ) {
398  (~lhs).append( i, l->index(), l->value() );
399  ++l;
400  }
401  else if( l->index() > r->index() ) {
402  (~lhs).append( i, r->index(), r->value() );
403  ++r;
404  }
405  else {
406  (~lhs).append( i, l->index(), l->value()+r->value() );
407  ++l;
408  ++r;
409  }
410  }
411 
412  while( l != lend ) {
413  (~lhs).append( i, l->index(), l->value() );
414  ++l;
415  }
416 
417  while( r != rend ) {
418  (~lhs).append( i, r->index(), r->value() );
419  ++r;
420  }
421 
422  (~lhs).finalize( i );
423  }
424  }
426  //**********************************************************************************************
427 
428  //**Assignment to column-major sparse matrices**************************************************
440  template< typename MT > // Type of the target sparse matrix
441  friend inline typename DisableIf< UseSymmetricKernel<MT,MT1,MT2> >::Type
442  assign( SparseMatrix<MT,true>& lhs, const SMatSMatAddExpr& rhs )
443  {
445 
447 
448  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
449  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
450 
451  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
452  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
453 
454  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
455  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
456 
457  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
458  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
459  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
460  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
461  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
462  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
463 
464  const size_t m( A.rows() );
465  const size_t n( A.columns() );
466 
467  // Counting the number of elements per column
468  std::vector<size_t> nonzeros( n, 0UL );
469  for( size_t i=0UL; i<m; ++i )
470  {
471  const LeftIterator lend( A.end(i) );
472  const RightIterator rend( B.end(i) );
473 
474  LeftIterator l( A.begin(i) );
475  RightIterator r( B.begin(i) );
476 
477  while( l != lend && r != rend )
478  {
479  if( l->index() < r->index() ) {
480  ++nonzeros[l->index()];
481  ++l;
482  }
483  else if( l->index() > r->index() ) {
484  ++nonzeros[r->index()];
485  ++r;
486  }
487  else {
488  ++nonzeros[l->index()];
489  ++l;
490  ++r;
491  }
492  }
493 
494  while( l != lend ) {
495  ++nonzeros[l->index()];
496  ++l;
497  }
498 
499  while( r != rend ) {
500  ++nonzeros[r->index()];
501  ++r;
502  }
503  }
504 
505  // Resizing the left-hand side sparse matrix
506  for( size_t j=0UL; j<n; ++j ) {
507  (~lhs).reserve( j, nonzeros[j] );
508  }
509 
510  // Performing the matrix addition
511  for( size_t i=0UL; i<m; ++i )
512  {
513  const LeftIterator lend( A.end(i) );
514  const RightIterator rend( B.end(i) );
515 
516  LeftIterator l( A.begin(i) );
517  RightIterator r( B.begin(i) );
518 
519  while( l != lend && r != rend )
520  {
521  if( l->index() < r->index() ) {
522  (~lhs).append( i, l->index(), l->value() );
523  ++l;
524  }
525  else if( l->index() > r->index() ) {
526  (~lhs).append( i, r->index(), r->value() );
527  ++r;
528  }
529  else {
530  (~lhs).append( i, l->index(), l->value()+r->value() );
531  ++l;
532  ++r;
533  }
534  }
535 
536  while( l != lend ) {
537  (~lhs).append( i, l->index(), l->value() );
538  ++l;
539  }
540 
541  while( r != rend ) {
542  (~lhs).append( i, r->index(), r->value() );
543  ++r;
544  }
545  }
546  }
548  //**********************************************************************************************
549 
550  //**Assignment to column-major sparse matrices**************************************************
562  template< typename MT > // Type of the target sparse matrix
563  friend inline typename EnableIf< UseSymmetricKernel<MT,MT1,MT2> >::Type
564  assign( SparseMatrix<MT,true>& lhs, const SMatSMatAddExpr& rhs )
565  {
567 
569 
570  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
571  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
572 
573  assign( ~lhs, trans( rhs.lhs_ ) + trans( rhs.rhs_ ) );
574  }
576  //**********************************************************************************************
577 
578  //**Addition assignment to dense matrices*******************************************************
590  template< typename MT // Type of the target dense matrix
591  , bool SO > // Storage order of the target dense matrix
592  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
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  addAssign( ~lhs, rhs.lhs_ );
600  addAssign( ~lhs, rhs.rhs_ );
601  }
603  //**********************************************************************************************
604 
605  //**Addition assignment to sparse matrices******************************************************
606  // No special implementation for the addition assignment to sparse matrices.
607  //**********************************************************************************************
608 
609  //**Subtraction assignment to dense matrices****************************************************
621  template< typename MT // Type of the target dense matrix
622  , bool SO > // Storage order of the target dense matrix
623  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
624  {
626 
627  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
628  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
629 
630  subAssign( ~lhs, rhs.lhs_ );
631  subAssign( ~lhs, rhs.rhs_ );
632  }
634  //**********************************************************************************************
635 
636  //**Subtraction assignment to sparse matrices***************************************************
637  // No special implementation for the subtraction assignment to sparse matrices.
638  //**********************************************************************************************
639 
640  //**Multiplication assignment to dense matrices*************************************************
641  // No special implementation for the multiplication assignment to dense matrices.
642  //**********************************************************************************************
643 
644  //**Multiplication assignment to sparse matrices************************************************
645  // No special implementation for the multiplication assignment to sparse matrices.
646  //**********************************************************************************************
647 
648  //**SMP assignment to dense matrices************************************************************
649  // No special implementation for the SMP assignment to dense matrices.
650  //**********************************************************************************************
651 
652  //**SMP assignment to sparse matrices***********************************************************
653  // No special implementation for the SMP assignment to sparse matrices.
654  //**********************************************************************************************
655 
656  //**SMP addition assignment to dense matrices***************************************************
670  template< typename MT // Type of the target dense matrix
671  , bool SO > // Storage order of the target dense matrix
672  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
673  smpAddAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
674  {
676 
677  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
678  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
679 
680  smpAddAssign( ~lhs, rhs.lhs_ );
681  smpAddAssign( ~lhs, rhs.rhs_ );
682  }
684  //**********************************************************************************************
685 
686  //**SMP addition assignment to sparse matrices**************************************************
687  // No special implementation for the SMP addition assignment to sparse matrices.
688  //**********************************************************************************************
689 
690  //**SMP subtraction assignment to dense matrices************************************************
704  template< typename MT // Type of the target dense matrix
705  , bool SO > // Storage order of the target dense matrix
706  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
707  smpSubAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatAddExpr& rhs )
708  {
710 
711  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
712  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
713 
714  smpSubAssign( ~lhs, rhs.lhs_ );
715  smpSubAssign( ~lhs, rhs.rhs_ );
716  }
718  //**********************************************************************************************
719 
720  //**SMP subtraction assignment to sparse matrices***********************************************
721  // No special implementation for the SMP subtraction assignment to sparse matrices.
722  //**********************************************************************************************
723 
724  //**SMP multiplication assignment to dense matrices*********************************************
725  // No special implementation for the SMP multiplication assignment to dense matrices.
726  //**********************************************************************************************
727 
728  //**SMP multiplication assignment to sparse matrices********************************************
729  // No special implementation for the SMP multiplication assignment to sparse matrices.
730  //**********************************************************************************************
731 
732  //**Compile time checks*************************************************************************
740  //**********************************************************************************************
741 };
742 //*************************************************************************************************
743 
744 
745 
746 
747 //=================================================================================================
748 //
749 // GLOBAL BINARY ARITHMETIC OPERATORS
750 //
751 //=================================================================================================
752 
753 //*************************************************************************************************
779 template< typename T1 // Type of the left-hand side sparse matrix
780  , typename T2 > // Type of the right-hand side sparse matrix
781 inline const SMatSMatAddExpr<T1,T2>
783 {
785 
786  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
787  throw std::invalid_argument( "Matrix sizes do not match" );
788 
789  return SMatSMatAddExpr<T1,T2>( ~lhs, ~rhs );
790 }
791 //*************************************************************************************************
792 
793 
794 
795 
796 //=================================================================================================
797 //
798 // ROWS SPECIALIZATIONS
799 //
800 //=================================================================================================
801 
802 //*************************************************************************************************
804 template< typename MT1, typename MT2 >
805 struct Rows< SMatSMatAddExpr<MT1,MT2> >
806  : public Max< Rows<MT1>, Rows<MT2> >::Type
807 {};
809 //*************************************************************************************************
810 
811 
812 
813 
814 //=================================================================================================
815 //
816 // COLUMNS SPECIALIZATIONS
817 //
818 //=================================================================================================
819 
820 //*************************************************************************************************
822 template< typename MT1, typename MT2 >
823 struct Columns< SMatSMatAddExpr<MT1,MT2> >
824  : public Max< Columns<MT1>, Columns<MT2> >::Type
825 {};
827 //*************************************************************************************************
828 
829 
830 
831 
832 //=================================================================================================
833 //
834 // ISSYMMETRIC SPECIALIZATIONS
835 //
836 //=================================================================================================
837 
838 //*************************************************************************************************
840 template< typename MT1, typename MT2 >
841 struct IsSymmetric< SMatSMatAddExpr<MT1,MT2> >
842  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
843 {};
845 //*************************************************************************************************
846 
847 
848 
849 
850 //=================================================================================================
851 //
852 // ISLOWER SPECIALIZATIONS
853 //
854 //=================================================================================================
855 
856 //*************************************************************************************************
858 template< typename MT1, typename MT2 >
859 struct IsLower< SMatSMatAddExpr<MT1,MT2> >
860  : public IsTrue< IsLower<MT1>::value && IsLower<MT2>::value >
861 {};
863 //*************************************************************************************************
864 
865 
866 
867 
868 //=================================================================================================
869 //
870 // ISUPPER SPECIALIZATIONS
871 //
872 //=================================================================================================
873 
874 //*************************************************************************************************
876 template< typename MT1, typename MT2 >
877 struct IsUpper< SMatSMatAddExpr<MT1,MT2> >
878  : public IsTrue< IsUpper<MT1>::value && IsUpper<MT2>::value >
879 {};
881 //*************************************************************************************************
882 
883 
884 
885 
886 //=================================================================================================
887 //
888 // EXPRESSION TRAIT SPECIALIZATIONS
889 //
890 //=================================================================================================
891 
892 //*************************************************************************************************
894 template< typename MT1, typename MT2, bool AF >
895 struct SubmatrixExprTrait< SMatSMatAddExpr<MT1,MT2>, AF >
896 {
897  public:
898  //**********************************************************************************************
899  typedef typename AddExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
900  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
901  //**********************************************************************************************
902 };
904 //*************************************************************************************************
905 
906 
907 //*************************************************************************************************
909 template< typename MT1, typename MT2 >
910 struct RowExprTrait< SMatSMatAddExpr<MT1,MT2> >
911 {
912  public:
913  //**********************************************************************************************
914  typedef typename AddExprTrait< typename RowExprTrait<const MT1>::Type
915  , typename RowExprTrait<const MT2>::Type >::Type Type;
916  //**********************************************************************************************
917 };
919 //*************************************************************************************************
920 
921 
922 //*************************************************************************************************
924 template< typename MT1, typename MT2 >
925 struct ColumnExprTrait< SMatSMatAddExpr<MT1,MT2> >
926 {
927  public:
928  //**********************************************************************************************
929  typedef typename AddExprTrait< typename ColumnExprTrait<const MT1>::Type
930  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
931  //**********************************************************************************************
932 };
934 //*************************************************************************************************
935 
936 } // namespace blaze
937 
938 #endif
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
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.
RightOperand rhs_
Right-hand side sparse matrix of the addition expression.
Definition: SMatSMatAddExpr.h:296
LeftOperand leftOperand() const
Returns the left-hand side sparse matrix operand.
Definition: SMatSMatAddExpr.h:254
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
RightOperand rightOperand() const
Returns the right-hand side sparse matrix operand.
Definition: SMatSMatAddExpr.h:264
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:205
Header file for the ColumnExprTrait class template.
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatSMatAddExpr.h:233
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2478
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:257
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 AddExprTrait class template.
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:695
Header file for the Computation base class.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatSMatAddExpr.h:223
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:168
Header file for the RequiresEvaluation type trait.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatSMatAddExpr.h:213
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatSMatAddExpr.h:165
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
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.
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatSMatAddExpr.h:244
Header file for the IsTemporary type trait class.
Header file for the IsSymmetric type trait.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatSMatAddExpr.h:288
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatSMatAddExpr.h:201
#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 SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: SMatSMatAddExpr.h:162
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:103
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatSMatAddExpr.h:158
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2482
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.
Constraints on the storage order of matrix types.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatSMatAddExpr.h:157
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
MT2::CompositeType CT2
Composite type of the right-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:106
#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 serial shim.
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:104
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:105
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:2477
Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given...
Definition: RemoveReference.h:69
MT2::ReturnType RN2
Return type of the right-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:108
Header file for run time assertion macros.
Base template for the AddTrait class.
Definition: AddTrait.h:142
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
MT1::ReturnType RN1
Return type of the left-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:107
Constraint on the data type.
AddExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: SMatSMatAddExpr.h:121
AddTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SMatSMatAddExpr.h:156
Header file for the isDefault shim.
BLAZE_ALWAYS_INLINE bool isDefault(const NonNumericProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: NonNumericProxy.h:874
Constraint on the data type.
Header file for the MatMatAddExpr base class.
Header file for the RemoveReference type trait.
ResultType::ElementType ElementType
Resulting element type.
Definition: SMatSMatAddExpr.h:159
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatSMatAddExpr.h:276
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: SMatSMatAddExpr.h:171
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:932
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:2473
Header file for the IsTrue value trait.
SMatSMatAddExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the SMatSMatAddExpr class.
Definition: SMatSMatAddExpr.h:185
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:332
Header file for basic type definitions.
SMatSMatAddExpr< MT1, MT2 > This
Type of this SMatSMatAddExpr instance.
Definition: SMatSMatAddExpr.h:155
Header file for the IsUpper type trait.
LeftOperand lhs_
Left-hand side sparse matrix of the addition expression.
Definition: SMatSMatAddExpr.h:295
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