All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SMatTSMatAddExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATTSMATADDEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATTSMATADDEXPR_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 SMATTSMATADDEXPR
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 SMatTSMatAddExpr : public SparseMatrix< SMatTSMatAddExpr<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::ReturnType RN1;
106  typedef typename MT2::ReturnType RN2;
107  typedef typename MT1::CompositeType CT1;
108  typedef typename MT2::CompositeType CT2;
109  //**********************************************************************************************
110 
111  //**Return type evaluation**********************************************************************
113 
118  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
119 
122  //**********************************************************************************************
123 
124  //**Serial evaluation strategy******************************************************************
126 
132  template< typename T1, typename T2 >
133  struct UseSymmetricKernel {
135  enum { value = IsSymmetric<T2>::value };
136  };
138  //**********************************************************************************************
139 
140  //**Parallel evaluation strategy****************************************************************
142 
147  template< typename MT >
148  struct UseSMPAssign {
149  enum { value = MT::smpAssignable };
150  };
152  //**********************************************************************************************
153 
154  public:
155  //**Type definitions****************************************************************************
161 
164 
166  typedef const ResultType CompositeType;
167 
169  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
170 
172  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
173  //**********************************************************************************************
174 
175  //**Compilation flags***************************************************************************
177  enum { smpAssignable = 0 };
178  //**********************************************************************************************
179 
180  //**Constructor*********************************************************************************
186  explicit inline SMatTSMatAddExpr( const MT1& lhs, const MT2& rhs )
187  : lhs_( lhs ) // Left-hand side sparse matrix of the addition expression
188  , rhs_( rhs ) // Right-hand side sparse matrix of the addition expression
189  {
190  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
191  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
192  }
193  //**********************************************************************************************
194 
195  //**Access operator*****************************************************************************
202  inline ReturnType operator()( size_t i, size_t j ) const {
203  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
204  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
205  return lhs_(i,j) + rhs_(i,j);
206  }
207  //**********************************************************************************************
208 
209  //**Rows function*******************************************************************************
214  inline size_t rows() const {
215  return lhs_.rows();
216  }
217  //**********************************************************************************************
218 
219  //**Columns function****************************************************************************
224  inline size_t columns() const {
225  return lhs_.columns();
226  }
227  //**********************************************************************************************
228 
229  //**NonZeros function***************************************************************************
234  inline size_t nonZeros() const {
235  return lhs_.nonZeros() + rhs_.nonZeros();
236  }
237  //**********************************************************************************************
238 
239  //**NonZeros function***************************************************************************
245  inline size_t nonZeros( size_t i ) const {
246  return lhs_.nonZeros(i) + rhs_.nonZeros(i);
247  }
248  //**********************************************************************************************
249 
250  //**Left operand access*************************************************************************
255  inline LeftOperand leftOperand() const {
256  return lhs_;
257  }
258  //**********************************************************************************************
259 
260  //**Right operand access************************************************************************
265  inline RightOperand rightOperand() const {
266  return rhs_;
267  }
268  //**********************************************************************************************
269 
270  //**********************************************************************************************
276  template< typename T >
277  inline bool canAlias( const T* alias ) const {
278  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
279  }
280  //**********************************************************************************************
281 
282  //**********************************************************************************************
288  template< typename T >
289  inline bool isAliased( const T* alias ) const {
290  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
291  }
292  //**********************************************************************************************
293 
294  private:
295  //**Member variables****************************************************************************
298  //**********************************************************************************************
299 
300  //**Assignment to dense matrices****************************************************************
312  template< typename MT // Type of the target dense matrix
313  , bool SO > // Storage order of the target dense matrix
314  friend inline void assign( DenseMatrix<MT,SO>& lhs, const SMatTSMatAddExpr& rhs )
315  {
317 
318  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
319  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
320 
321  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
322 
323  assign( ~lhs, rhs.lhs_ );
324 
326  addAssign( ~lhs, rhs.rhs_ );
327  }
328  else
329  {
330  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
331 
332  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
333  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
334  BLAZE_INTERNAL_ASSERT( B.rows() == (~lhs).rows() , "Invalid number of rows" );
335  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
336 
337  for( size_t j=0UL; j<(~lhs).columns(); ++j ) {
338  const RightIterator end( B.end(j) );
339  for( RightIterator element=B.begin(j); element!=end; ++element ) {
340  if( isDefault( (~lhs)(element->index(),j) ) )
341  (~lhs)(element->index(),j) = element->value();
342  else
343  (~lhs)(element->index(),j) += element->value();
344  }
345  }
346  }
347  }
349  //**********************************************************************************************
350 
351  //**Assignment to row-major sparse matrices*****************************************************
364  template< typename MT > // Type of the target sparse matrix
365  friend inline typename DisableIf< UseSymmetricKernel<MT,MT2> >::Type
367  {
369 
370  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
371  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
372 
373  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
374  typedef typename RT2::OppositeType::ConstIterator RightIterator;
375 
376  // Evaluation of the left-hand side sparse matrix operand
377  CT1 A( serial( rhs.lhs_ ) );
378 
379  // Evaluation of the right-hand side sparse matrix operand
380  const typename RT2::OppositeType B( serial( rhs.rhs_ ) );
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 row-major sparse matrices*****************************************************
447  template< typename MT > // Type of the target sparse matrix
448  friend inline typename EnableIf< UseSymmetricKernel<MT,MT2> >::Type
449  assign( SparseMatrix<MT,false>& lhs, const SMatTSMatAddExpr& rhs )
450  {
452 
453  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
454  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
455 
456  assign( ~lhs, rhs.lhs_ + trans( rhs.rhs_ ) );
457  }
459  //**********************************************************************************************
460 
461  //**Assignment to column-major sparse matrices**************************************************
474  template< typename MT > // Type of the target sparse matrix
475  friend inline typename DisableIf< UseSymmetricKernel<MT,MT1> >::Type
476  assign( SparseMatrix<MT,true>& lhs, const SMatTSMatAddExpr& rhs )
477  {
479 
481 
482  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
483  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
484 
485  typedef typename RT1::OppositeType::ConstIterator LeftIterator;
486  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
487 
488  // Evaluation of the left-hand side sparse matrix operand
489  const typename RT1::OppositeType A( serial( rhs.lhs_ ) );
490 
491  // Evaluation of the right-hand side sparse matrix operand
492  CT2 B( serial( rhs.rhs_ ) );
493 
494  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
495  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
496  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
497  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
498  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
499  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
500 
501  // Final memory allocation (based on the evaluated operands)
502  (~lhs).reserve( A.nonZeros() + B.nonZeros() );
503 
504  // Performing the matrix addition
505  for( size_t j=0UL; j<(~lhs).columns(); ++j )
506  {
507  const LeftIterator lend( A.end(j) );
508  const RightIterator rend( B.end(j) );
509 
510  LeftIterator l( A.begin(j) );
511  RightIterator r( B.begin(j) );
512 
513  while( l != lend && r != rend )
514  {
515  if( l->index() < r->index() ) {
516  (~lhs).append( l->index(), j, l->value() );
517  ++l;
518  }
519  else if( l->index() > r->index() ) {
520  (~lhs).append( r->index(), j, r->value() );
521  ++r;
522  }
523  else {
524  (~lhs).append( l->index(), j, l->value()+r->value() );
525  ++l;
526  ++r;
527  }
528  }
529 
530  while( l != lend ) {
531  (~lhs).append( l->index(), j, l->value() );
532  ++l;
533  }
534 
535  while( r != rend ) {
536  (~lhs).append( r->index(), j, r->value() );
537  ++r;
538  }
539 
540  (~lhs).finalize( j );
541  }
542  }
544  //**********************************************************************************************
545 
546  //**Assignment to column-major sparse matrices**************************************************
559  template< typename MT > // Type of the target sparse matrix
560  friend inline typename EnableIf< UseSymmetricKernel<MT,MT1> >::Type
561  assign( SparseMatrix<MT,true>& lhs, const SMatTSMatAddExpr& rhs )
562  {
564 
566 
567  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
568  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
569 
570  assign( ~lhs, trans( rhs.lhs_ ) + rhs.rhs_ );
571  }
573  //**********************************************************************************************
574 
575  //**Addition assignment to dense matrices*******************************************************
588  template< typename MT // Type of the target dense matrix
589  , bool SO > // Storage order of the target dense matrix
590  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const SMatTSMatAddExpr& rhs )
591  {
593 
594  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
595  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
596 
597  addAssign( ~lhs, rhs.lhs_ );
598  addAssign( ~lhs, rhs.rhs_ );
599  }
601  //**********************************************************************************************
602 
603  //**Addition assignment to sparse matrices******************************************************
604  // No special implementation for the addition assignment to sparse matrices.
605  //**********************************************************************************************
606 
607  //**Subtraction assignment to dense matrices****************************************************
620  template< typename MT // Type of the target dense matrix
621  , bool SO > // Storage order of the target dense matrix
622  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const SMatTSMatAddExpr& rhs )
623  {
625 
626  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
627  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
628 
629  subAssign( ~lhs, rhs.lhs_ );
630  subAssign( ~lhs, rhs.rhs_ );
631  }
633  //**********************************************************************************************
634 
635  //**Subtraction assignment to sparse matrices***************************************************
636  // No special implementation for the subtraction assignment to sparse matrices.
637  //**********************************************************************************************
638 
639  //**Multiplication assignment to dense matrices*************************************************
640  // No special implementation for the multiplication assignment to dense matrices.
641  //**********************************************************************************************
642 
643  //**Multiplication assignment to sparse matrices************************************************
644  // No special implementation for the multiplication assignment to sparse matrices.
645  //**********************************************************************************************
646 
647  //**SMP assignment to dense matrices************************************************************
648  // No special implementation for the SMP assignment to dense matrices.
649  //**********************************************************************************************
650 
651  //**SMP assignment to sparse matrices***********************************************************
652  // No special implementation for the SMP assignment to sparse matrices.
653  //**********************************************************************************************
654 
655  //**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 SMatTSMatAddExpr& 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************************************************
705  template< typename MT // Type of the target dense matrix
706  , bool SO > // Storage order of the target dense matrix
707  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
708  smpSubAssign( DenseMatrix<MT,SO>& lhs, const SMatTSMatAddExpr& rhs )
709  {
711 
712  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
713  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
714 
715  smpSubAssign( ~lhs, rhs.lhs_ );
716  smpSubAssign( ~lhs, rhs.rhs_ );
717  }
719  //**********************************************************************************************
720 
721  //**SMP subtraction assignment to sparse matrices***********************************************
722  // No special implementation for the SMP subtraction assignment to sparse matrices.
723  //**********************************************************************************************
724 
725  //**SMP multiplication assignment to dense matrices*********************************************
726  // No special implementation for the SMP multiplication assignment to dense matrices.
727  //**********************************************************************************************
728 
729  //**SMP multiplication assignment to sparse matrices********************************************
730  // No special implementation for the SMP multiplication assignment to sparse matrices.
731  //**********************************************************************************************
732 
733  //**Compile time checks*************************************************************************
741  //**********************************************************************************************
742 };
743 //*************************************************************************************************
744 
745 
746 
747 
748 //=================================================================================================
749 //
750 // GLOBAL BINARY ARITHMETIC OPERATORS
751 //
752 //=================================================================================================
753 
754 //*************************************************************************************************
783 template< typename T1 // Type of the left-hand side sparse matrix
784  , typename T2 > // Type of the right-hand side sparse matrix
785 inline const SMatTSMatAddExpr<T1,T2>
787 {
789 
790  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
791  throw std::invalid_argument( "Matrix sizes do not match" );
792 
793  return SMatTSMatAddExpr<T1,T2>( ~lhs, ~rhs );
794 }
795 //*************************************************************************************************
796 
797 
798 //*************************************************************************************************
827 template< typename T1 // Type of the left-hand side sparse matrix
828  , typename T2 > // Type of the right-hand side sparse matrix
829 inline const SMatTSMatAddExpr<T2,T1>
831 {
833 
834  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
835  throw std::invalid_argument( "Matrix sizes do not match" );
836 
837  return SMatTSMatAddExpr<T2,T1>( ~rhs, ~lhs );
838 }
839 //*************************************************************************************************
840 
841 
842 
843 
844 //=================================================================================================
845 //
846 // ROWS SPECIALIZATIONS
847 //
848 //=================================================================================================
849 
850 //*************************************************************************************************
852 template< typename MT1, typename MT2 >
853 struct Rows< SMatTSMatAddExpr<MT1,MT2> >
854  : public Max< Rows<MT1>, Rows<MT2> >::Type
855 {};
857 //*************************************************************************************************
858 
859 
860 
861 
862 //=================================================================================================
863 //
864 // COLUMNS SPECIALIZATIONS
865 //
866 //=================================================================================================
867 
868 //*************************************************************************************************
870 template< typename MT1, typename MT2 >
871 struct Columns< SMatTSMatAddExpr<MT1,MT2> >
872  : public Max< Columns<MT1>, Columns<MT2> >::Type
873 {};
875 //*************************************************************************************************
876 
877 
878 
879 
880 //=================================================================================================
881 //
882 // ISSYMMETRIC SPECIALIZATIONS
883 //
884 //=================================================================================================
885 
886 //*************************************************************************************************
888 template< typename MT1, typename MT2 >
889 struct IsSymmetric< SMatTSMatAddExpr<MT1,MT2> >
890  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
891 {};
893 //*************************************************************************************************
894 
895 
896 
897 
898 //=================================================================================================
899 //
900 // ISLOWER SPECIALIZATIONS
901 //
902 //=================================================================================================
903 
904 //*************************************************************************************************
906 template< typename MT1, typename MT2 >
907 struct IsLower< SMatTSMatAddExpr<MT1,MT2> >
908  : public IsTrue< IsLower<MT1>::value && IsLower<MT2>::value >
909 {};
911 //*************************************************************************************************
912 
913 
914 
915 
916 //=================================================================================================
917 //
918 // ISUPPER SPECIALIZATIONS
919 //
920 //=================================================================================================
921 
922 //*************************************************************************************************
924 template< typename MT1, typename MT2 >
925 struct IsUpper< SMatTSMatAddExpr<MT1,MT2> >
926  : public IsTrue< IsUpper<MT1>::value && IsUpper<MT2>::value >
927 {};
929 //*************************************************************************************************
930 
931 
932 
933 
934 //=================================================================================================
935 //
936 // EXPRESSION TRAIT SPECIALIZATIONS
937 //
938 //=================================================================================================
939 
940 //*************************************************************************************************
942 template< typename MT1, typename MT2, bool AF >
943 struct SubmatrixExprTrait< SMatTSMatAddExpr<MT1,MT2>, AF >
944 {
945  public:
946  //**********************************************************************************************
947  typedef typename AddExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
948  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
949  //**********************************************************************************************
950 };
952 //*************************************************************************************************
953 
954 
955 //*************************************************************************************************
957 template< typename MT1, typename MT2 >
958 struct RowExprTrait< SMatTSMatAddExpr<MT1,MT2> >
959 {
960  public:
961  //**********************************************************************************************
962  typedef typename AddExprTrait< typename RowExprTrait<const MT1>::Type
963  , typename RowExprTrait<const MT2>::Type >::Type Type;
964  //**********************************************************************************************
965 };
967 //*************************************************************************************************
968 
969 
970 //*************************************************************************************************
972 template< typename MT1, typename MT2 >
973 struct ColumnExprTrait< SMatTSMatAddExpr<MT1,MT2> >
974 {
975  public:
976  //**********************************************************************************************
977  typedef typename AddExprTrait< typename ColumnExprTrait<const MT1>::Type
978  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
979  //**********************************************************************************************
980 };
982 //*************************************************************************************************
983 
984 } // namespace blaze
985 
986 #endif
AddExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: SMatTSMatAddExpr.h:121
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.
LeftOperand lhs_
Left-hand side sparse matrix of the addition expression.
Definition: SMatTSMatAddExpr.h:296
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:205
Header file for the ColumnExprTrait class template.
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
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: SMatTSMatAddExpr.h:107
Header file for the AddExprTrait class template.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatTSMatAddExpr.h:224
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.
MT2::ReturnType RN2
Evaluation type of the right-hand side sparse matrix expression.
Definition: SMatTSMatAddExpr.h:106
Header file for the RequiresEvaluation type trait.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2474
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
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatTSMatAddExpr.h:245
Header file for the SparseMatrix base class.
Constraint on the data type.
ResultType::ElementType ElementType
Resulting element type.
Definition: SMatTSMatAddExpr.h:160
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 IsSymmetric type trait.
#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: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.
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: SMatTSMatAddExpr.h:163
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatTSMatAddExpr.h:159
Constraints on the storage order of matrix types.
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatTSMatAddExpr.h:234
LeftOperand leftOperand() const
Returns the left-hand side sparse matrix operand.
Definition: SMatTSMatAddExpr.h:255
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.
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: SMatTSMatAddExpr.h:169
Header file for the EnableIf class template.
Header file for the serial shim.
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_DIFFERENT_STORAGE_ORDER(T1, T2)
Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type ...
Definition: StorageOrder.h:325
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatTSMatAddExpr.h:202
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
RightOperand rhs_
Right-hand side sparse matrix of the addition expression.
Definition: SMatTSMatAddExpr.h:297
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
Constraint on the data type.
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.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatTSMatAddExpr.h:214
RightOperand rightOperand() const
Returns the right-hand side transpose sparse matrix operand.
Definition: SMatTSMatAddExpr.h:265
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatTSMatAddExpr.h:277
Header file for the MatMatAddExpr base class.
Header file for the RemoveReference type trait.
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatTSMatAddExpr.h:166
Substitution Failure Is Not An Error (SFINAE) class.The DisableIf class template is an auxiliary tool...
Definition: DisableIf.h:184
Expression object for sparse matrix-transpose sparse matrix additions.The SMatTSMatAddExpr class repr...
Definition: Forward.h:104
MT1::ReturnType RN1
Evaluation type of the left-hand side sparse matrix expression.
Definition: SMatTSMatAddExpr.h:105
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.
AddTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SMatTSMatAddExpr.h:157
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.
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:332
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatTSMatAddExpr.h:289
Header file for basic type definitions.
SMatTSMatAddExpr< MT1, MT2 > This
Type of this SMatTSMatAddExpr instance.
Definition: SMatTSMatAddExpr.h:156
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: SMatTSMatAddExpr.h:103
Header file for the IsUpper type trait.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatTSMatAddExpr.h:158
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: SMatTSMatAddExpr.h:104
MT2::CompositeType CT2
Composite type of the right-hand side sparse matrix expression.
Definition: SMatTSMatAddExpr.h:108
Header file for the IsResizable type trait.
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: SMatTSMatAddExpr.h:172
SMatTSMatAddExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the SMatTSMatAddExpr class.
Definition: SMatTSMatAddExpr.h:186
#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