All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TSMatSMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATSMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATSMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
44 #include <vector>
56 #include <blaze/math/shims/Reset.h>
84 #include <blaze/util/Assert.h>
85 #include <blaze/util/DisableIf.h>
86 #include <blaze/util/EnableIf.h>
87 #include <blaze/util/InvalidType.h>
89 #include <blaze/util/SelectType.h>
90 #include <blaze/util/Types.h>
91 #include <blaze/util/Unused.h>
92 
93 
94 namespace blaze {
95 
96 //=================================================================================================
97 //
98 // CLASS TSMATSMATMULTEXPR
99 //
100 //=================================================================================================
101 
102 //*************************************************************************************************
109 template< typename MT1 // Type of the left-hand side sparse matrix
110  , typename MT2 > // Type of the right-hand side sparse matrix
111 class TSMatSMatMultExpr : public SparseMatrix< TSMatSMatMultExpr<MT1,MT2>, true >
112  , private MatMatMultExpr
113  , private Computation
114 {
115  private:
116  //**Type definitions****************************************************************************
117  typedef typename MT1::ResultType RT1;
118  typedef typename MT2::ResultType RT2;
119  typedef typename MT1::CompositeType CT1;
120  typedef typename MT2::CompositeType CT2;
121  //**********************************************************************************************
122 
123  //**********************************************************************************************
125  enum { evaluateLeft = RequiresEvaluation<MT1>::value };
126  //**********************************************************************************************
127 
128  //**********************************************************************************************
130  enum { evaluateRight = RequiresEvaluation<MT2>::value };
131  //**********************************************************************************************
132 
133  //**********************************************************************************************
135 
138  template< typename T1, typename T2, typename T3 >
139  struct UseSMPAssignKernel {
140  enum { value = evaluateLeft || evaluateRight };
141  };
143  //**********************************************************************************************
144 
145  public:
146  //**Type definitions****************************************************************************
152  typedef const ElementType ReturnType;
153  typedef const ResultType CompositeType;
154 
156  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
157 
159  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
160  //**********************************************************************************************
161 
162  //**Compilation flags***************************************************************************
164  enum { smpAssignable = !evaluateLeft && !evaluateRight };
165  //**********************************************************************************************
166 
167  //**Constructor*********************************************************************************
173  explicit inline TSMatSMatMultExpr( const MT1& lhs, const MT2& rhs )
174  : lhs_( lhs ) // Left-hand side sparse matrix of the multiplication expression
175  , rhs_( rhs ) // Right-hand side sparse matrix of the multiplication expression
176  {
177  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.rows(), "Invalid matrix sizes" );
178  }
179  //**********************************************************************************************
180 
181  //**Access operator*****************************************************************************
188  inline ReturnType operator()( size_t i, size_t j ) const {
189  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
190  BLAZE_INTERNAL_ASSERT( j < rhs_.columns(), "Invalid column access index" );
191 
192  ElementType tmp = ElementType();
193 
194  if( lhs_.columns() != 0UL ) {
195  tmp = lhs_(i,0UL) * rhs_(0UL,j);
196  for( size_t k=1UL; k<lhs_.columns(); ++k ) {
197  tmp += lhs_(i,k) * rhs_(k,j);
198  }
199  }
200 
201  return tmp;
202  }
203  //**********************************************************************************************
204 
205  //**Rows function*******************************************************************************
210  inline size_t rows() const {
211  return lhs_.rows();
212  }
213  //**********************************************************************************************
214 
215  //**Columns function****************************************************************************
220  inline size_t columns() const {
221  return rhs_.columns();
222  }
223  //**********************************************************************************************
224 
225  //**NonZeros function***************************************************************************
230  inline size_t nonZeros() const {
231  return 0UL;
232  }
233  //**********************************************************************************************
234 
235  //**NonZeros function***************************************************************************
241  inline size_t nonZeros( size_t i ) const {
242  UNUSED_PARAMETER( i );
243  return 0UL;
244  }
245  //**********************************************************************************************
246 
247  //**Left operand access*************************************************************************
252  inline LeftOperand leftOperand() const {
253  return lhs_;
254  }
255  //**********************************************************************************************
256 
257  //**Right operand access************************************************************************
262  inline RightOperand rightOperand() const {
263  return rhs_;
264  }
265  //**********************************************************************************************
266 
267  //**********************************************************************************************
273  template< typename T >
274  inline bool canAlias( const T* alias ) const {
275  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
276  }
277  //**********************************************************************************************
278 
279  //**********************************************************************************************
285  template< typename T >
286  inline bool isAliased( const T* alias ) const {
287  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
288  }
289  //**********************************************************************************************
290 
291  //**********************************************************************************************
296  inline bool canSMPAssign() const {
297  return ( rows() > SMP_TSMATSMATMULT_THRESHOLD );
298  }
299  //**********************************************************************************************
300 
301  private:
302  //**Member variables****************************************************************************
305  //**********************************************************************************************
306 
307  //**Assignment to dense matrices****************************************************************
320  template< typename MT // Type of the target dense matrix
321  , bool SO > // Storage order of the target dense matrix
322  friend void assign( DenseMatrix<MT,SO>& lhs, const TSMatSMatMultExpr& rhs )
323  {
325 
326  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
327  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
328 
329  CT1 A( rhs.lhs_ ); // Evaluation of the left-hand side sparse matrix operand
330  CT2 B( rhs.rhs_ ); // Evaluation of the right-hand side sparse matrix operand
331 
332  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
333  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
334  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
335  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
336  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
337  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
338 
339  TSMatSMatMultExpr::selectAssignKernel( ~lhs, A, B );
340  }
342  //**********************************************************************************************
343 
344  //**Serial assignment to dense matrices*********************************************************
358  template< typename MT3 // Type of the left-hand side target matrix
359  , typename MT4 // Type of the left-hand side matrix operand
360  , typename MT5 > // Type of the right-hand side matrix operand
361  static inline typename DisableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
362  selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
363  {
364  typedef typename MT4::ConstIterator LeftIterator;
365  typedef typename MT5::ConstIterator RightIterator;
366 
367  for( size_t j=0UL; j<A.columns(); ++j ) {
368  const LeftIterator lend( A.end(j) );
369  for( LeftIterator lelem=A.begin(j); lelem!=lend; ++lelem ) {
370  const RightIterator rend( B.end(j) );
371  for( RightIterator relem=B.begin(j); relem!=rend; ++relem )
372  {
374  isDefault( C(lelem->index(),relem->index()) ) ) {
375  C(lelem->index(),relem->index()) = lelem->value() * relem->value();
376  }
377  else {
378  C(lelem->index(),relem->index()) += lelem->value() * relem->value();
379  }
380  }
381  }
382  }
383  }
385  //**********************************************************************************************
386 
387  //**SMP assignment to dense matrices************************************************************
401  template< typename MT3 // Type of the left-hand side target matrix
402  , typename MT4 // Type of the left-hand side matrix operand
403  , typename MT5 > // Type of the right-hand side matrix operand
404  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
405  selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
406  {
407  smpAssign( C, A * B );
408  }
410  //**********************************************************************************************
411 
412  //**Assignment to row-major sparse matrices*****************************************************
425  template< typename MT > // Type of the target sparse matrix
426  friend inline void assign( SparseMatrix<MT,false>& lhs, const TSMatSMatMultExpr& rhs )
427  {
429 
430  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
431  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
432 
434 
435  const typename MT1::OppositeType tmp( rhs.lhs_ );
436  smpAssign( ~lhs, tmp * rhs.rhs_ );
437  }
439  //**********************************************************************************************
440 
441  //**Assignment to column-major sparse matrices**************************************************
454  template< typename MT > // Type of the target sparse matrix
455  friend inline void assign( SparseMatrix<MT,true>& lhs, const TSMatSMatMultExpr& rhs )
456  {
458 
459  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
460  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
461 
463 
464  const typename MT2::OppositeType tmp( rhs.rhs_ );
465  smpAssign( ~lhs, rhs.lhs_ * tmp );
466  }
468  //**********************************************************************************************
469 
470  //**Addition assignment to dense matrices*******************************************************
483  template< typename MT // Type of the target dense matrix
484  , bool SO > // Storage order of the target dense matarix
485  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const TSMatSMatMultExpr& rhs )
486  {
488 
489  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
490  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
491 
492  CT1 A( rhs.lhs_ ); // Evaluation of the left-hand side sparse matrix operand
493  CT2 B( rhs.rhs_ ); // Evaluation of the right-hand side sparse matrix operand
494 
495  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
496  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
497  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
498  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
499  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
500  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
501 
502  TSMatSMatMultExpr::selectAddAssignKernel( ~lhs, A, B );
503  }
505  //**********************************************************************************************
506 
507  //**Serial addition assignment to dense matrices************************************************
521  template< typename MT3 // Type of the left-hand side target matrix
522  , typename MT4 // Type of the left-hand side matrix operand
523  , typename MT5 > // Type of the right-hand side matrix operand
524  static inline typename DisableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
525  selectAddAssignKernel( MT3& C, const MT4& A, const MT5& B )
526  {
527  typedef typename MT4::ConstIterator LeftIterator;
528  typedef typename MT5::ConstIterator RightIterator;
529 
530  for( size_t j=0UL; j<A.columns(); ++j ) {
531  const LeftIterator lend( A.end(j) );
532  for( LeftIterator lelem=A.begin(j); lelem!=lend; ++lelem ) {
533  const RightIterator rend( B.end(j) );
534  for( RightIterator relem=B.begin(j); relem!=rend; ++relem ) {
535  C(lelem->index(),relem->index()) += lelem->value() * relem->value();
536  }
537  }
538  }
539  }
541  //**********************************************************************************************
542 
543  //**SMP addition assignment to dense matrices***************************************************
557  template< typename MT3 // Type of the left-hand side target matrix
558  , typename MT4 // Type of the left-hand side matrix operand
559  , typename MT5 > // Type of the right-hand side matrix operand
560  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
561  selectAddAssignKernel( MT3& C, const MT4& A, const MT5& B )
562  {
563  smpAddAssign( C, A * B );
564  }
566  //**********************************************************************************************
567 
568  //**Addition assignment to sparse matrices******************************************************
569  // No special implementation for the addition assignment to sparse matrices.
570  //**********************************************************************************************
571 
572  //**Subtraction assignment to dense matrices****************************************************
585  template< typename MT // Type of the target dense matrix
586  , bool SO > // Storage order of the target dense matrix
587  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const TSMatSMatMultExpr& rhs )
588  {
590 
591  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
592  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
593 
594  CT1 A( rhs.lhs_ ); // Evaluation of the left-hand side sparse matrix operand
595  CT2 B( rhs.rhs_ ); // Evaluation of the right-hand side sparse matrix operand
596 
597  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
598  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
599  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
600  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
601  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
602  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
603 
604  TSMatSMatMultExpr::selectSubAssignKernel( ~lhs, A, B );
605  }
607  //**********************************************************************************************
608 
609  //**Serial subtraction assignment to dense matrices*********************************************
623  template< typename MT3 // Type of the left-hand side target matrix
624  , typename MT4 // Type of the left-hand side matrix operand
625  , typename MT5 > // Type of the right-hand side matrix operand
626  static inline typename DisableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
627  selectSubAssignKernel( MT3& C, const MT4& A, const MT5& B )
628  {
629  typedef typename MT4::ConstIterator LeftIterator;
630  typedef typename MT5::ConstIterator RightIterator;
631 
632  for( size_t j=0UL; j<A.columns(); ++j ) {
633  const LeftIterator lend( A.end(j) );
634  for( LeftIterator lelem=A.begin(j); lelem!=lend; ++lelem ) {
635  const RightIterator rend( B.end(j) );
636  for( RightIterator relem=B.begin(j); relem!=rend; ++relem ) {
637  C(lelem->index(),relem->index()) -= lelem->value() * relem->value();
638  }
639  }
640  }
641  }
643  //**********************************************************************************************
644 
645  //**SMP subtraction assignment to dense matrices************************************************
659  template< typename MT3 // Type of the left-hand side target matrix
660  , typename MT4 // Type of the left-hand side matrix operand
661  , typename MT5 > // Type of the right-hand side matrix operand
662  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
663  selectSubAssignKernel( MT3& C, const MT4& A, const MT5& B )
664  {
665  smpSubAssign( C, A * B );
666  }
668  //**********************************************************************************************
669 
670  //**Subtraction assignment to sparse matrices***************************************************
671  // No special implementation for the subtraction assignment to sparse matrices.
672  //**********************************************************************************************
673 
674  //**Multiplication assignment to dense matrices*************************************************
675  // No special implementation for the multiplication assignment to dense matrices.
676  //**********************************************************************************************
677 
678  //**Multiplication assignment to sparse matrices************************************************
679  // No special implementation for the multiplication assignment to sparse matrices.
680  //**********************************************************************************************
681 
682  //**Compile time checks*************************************************************************
689  //**********************************************************************************************
690 };
691 //*************************************************************************************************
692 
693 
694 
695 
696 //=================================================================================================
697 //
698 // GLOBAL BINARY ARITHMETIC OPERATORS
699 //
700 //=================================================================================================
701 
702 //*************************************************************************************************
732 template< typename T1 // Type of the left-hand side sparse matrix
733  , typename T2 > // Type of the right-hand side sparse matrix
734 inline const TSMatSMatMultExpr<T1,T2>
736 {
738 
739  if( (~lhs).columns() != (~rhs).rows() )
740  throw std::invalid_argument( "Matrix sizes do not match" );
741 
742  return TSMatSMatMultExpr<T1,T2>( ~lhs, ~rhs );
743 }
744 //*************************************************************************************************
745 
746 
747 
748 
749 //=================================================================================================
750 //
751 // EXPRESSION TRAIT SPECIALIZATIONS
752 //
753 //=================================================================================================
754 
755 //*************************************************************************************************
757 template< typename MT1, typename MT2, typename VT >
758 struct TSMatDVecMultExprTrait< TSMatSMatMultExpr<MT1,MT2>, VT >
759 {
760  public:
761  //**********************************************************************************************
762  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
763  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
764  IsDenseVector<VT>::value && IsColumnVector<VT>::value
765  , typename TSMatDVecMultExprTrait< MT1, typename SMatDVecMultExprTrait<MT2,VT>::Type >::Type
766  , INVALID_TYPE >::Type Type;
767  //**********************************************************************************************
768 };
770 //*************************************************************************************************
771 
772 
773 //*************************************************************************************************
775 template< typename MT1, typename MT2, typename VT >
776 struct TSMatSVecMultExprTrait< TSMatSMatMultExpr<MT1,MT2>, VT >
777 {
778  public:
779  //**********************************************************************************************
780  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
781  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
782  IsSparseVector<VT>::value && IsColumnVector<VT>::value
783  , typename TSMatDVecMultExprTrait< MT1, typename SMatDVecMultExprTrait<MT2,VT>::Type >::Type
784  , INVALID_TYPE >::Type Type;
785  //**********************************************************************************************
786 };
788 //*************************************************************************************************
789 
790 
791 //*************************************************************************************************
793 template< typename VT, typename MT1, typename MT2 >
794 struct TDVecTSMatMultExprTrait< VT, TSMatSMatMultExpr<MT1,MT2> >
795 {
796  public:
797  //**********************************************************************************************
798  typedef typename SelectType< IsDenseVector<VT>::value && IsRowVector<VT>::value &&
799  IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
800  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value
801  , typename TDVecSMatMultExprTrait< typename TDVecTSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
802  , INVALID_TYPE >::Type Type;
803  //**********************************************************************************************
804 };
806 //*************************************************************************************************
807 
808 
809 //*************************************************************************************************
811 template< typename VT, typename MT1, typename MT2 >
812 struct TSVecTSMatMultExprTrait< VT, TSMatSMatMultExpr<MT1,MT2> >
813 {
814  public:
815  //**********************************************************************************************
816  typedef typename SelectType< IsSparseVector<VT>::value && IsRowVector<VT>::value &&
817  IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
818  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value
819  , typename TDVecSMatMultExprTrait< typename TDVecTSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
820  , INVALID_TYPE >::Type Type;
821  //**********************************************************************************************
822 };
824 //*************************************************************************************************
825 
826 
827 //*************************************************************************************************
829 template< typename MT1, typename MT2, bool AF >
830 struct SubmatrixExprTrait< TSMatSMatMultExpr<MT1,MT2>, AF >
831 {
832  public:
833  //**********************************************************************************************
834  typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
835  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
836  //**********************************************************************************************
837 };
839 //*************************************************************************************************
840 
841 
842 //*************************************************************************************************
844 template< typename MT1, typename MT2 >
845 struct RowExprTrait< TSMatSMatMultExpr<MT1,MT2> >
846 {
847  public:
848  //**********************************************************************************************
849  typedef typename MultExprTrait< typename RowExprTrait<const MT1>::Type, MT2 >::Type Type;
850  //**********************************************************************************************
851 };
853 //*************************************************************************************************
854 
855 
856 //*************************************************************************************************
858 template< typename MT1, typename MT2 >
859 struct ColumnExprTrait< TSMatSMatMultExpr<MT1,MT2> >
860 {
861  public:
862  //**********************************************************************************************
863  typedef typename MultExprTrait< MT1, typename ColumnExprTrait<const MT2>::Type >::Type Type;
864  //**********************************************************************************************
865 };
867 //*************************************************************************************************
868 
869 } // namespace blaze
870 
871 #endif
size_t rows() const
Returns the current number of rows of the matrix.
Definition: TSMatSMatMultExpr.h:210
RightOperand rhs_
Right-hand side sparse matrix of the multiplication expression.
Definition: TSMatSMatMultExpr.h:304
Header file for the SMatDVecMultExprTrait class template.
RightOperand rightOperand() const
Returns the right-hand side sparse matrix operand.
Definition: TSMatSMatMultExpr.h:262
Header file for the UNUSED_PARAMETER function template.
const DMatDMatMultExpr< T1, T2 > operator*(const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:4075
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatSMatMultExpr.h:149
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatSMatMultExpr.h:188
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TSMatSMatMultExpr.h:150
void smpSubAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:151
Header file for the IsSparseMatrix type trait.
bool isDefault(const DynamicMatrix< Type, SO > &m)
Returns whether the given dense matrix is in default state.
Definition: DynamicMatrix.h:4622
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:197
Header file for the ColumnExprTrait class template.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TSMatSMatMultExpr.h:286
Header file for the IsColumnMajorMatrix type trait.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TSMatSMatMultExpr.h:274
Header file for the TSVecTSMatMultExprTrait class template.
Header file for the sparse matrix SMP implementation.
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: TSMatSMatMultExpr.h:118
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2384
Header file for the IsRowVector type trait.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:249
void UNUSED_PARAMETER(const T1 &)
Suppression of unused parameter warnings.
Definition: Unused.h:84
Header file for the TDVecSMatMultExprTrait class template.
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatSMatMultExpr.h:156
Header file for the Computation base class.
Header file for the MatMatMultExpr base class.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: TSMatSMatMultExpr.h:296
Header file for the RequiresEvaluation type trait.
Header file for the TSVecSMatMultExprTrait class template.
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatSMatMultExpr.h:153
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2380
MT2::CompositeType CT2
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatSMatMultExpr.h:120
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:104
Header file for the SparseMatrix base class.
LeftOperand lhs_
Left-hand side sparse matrix of the multiplication expression.
Definition: TSMatSMatMultExpr.h:303
Constraint on the data type.
const size_t SMP_TSMATSMATMULT_THRESHOLD
SMP column-major sparse matrix/row-major sparse matrix multiplication threshold.This threshold repres...
Definition: Thresholds.h:615
Header file for the MultExprTrait class template.
void smpAddAssign(DenseMatrix< 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:121
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:90
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatSMatMultExpr.h:117
TSMatSMatMultExpr< MT1, MT2 > This
Type of this TSMatSMatMultExpr instance.
Definition: TSMatSMatMultExpr.h:147
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.
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSMatSMatMultExpr.h:152
Header file for the multiplication 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:2388
Header file for the TDVecTSMatMultExprTrait class template.
Header file for the dense matrix SMP implementation.
Header file for the TSMatDVecMultExprTrait class template.
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:179
Constraint on the data type.
Header file for the SMatSVecMultExprTrait class template.
Constraints on the storage order of matrix types.
Constraint on the data type.
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Constraint on the data type.
Header file for the complete DynamicVector implementation.
Header file for the EnableIf class template.
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: TSMatSMatMultExpr.h:230
void smpAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:91
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatSMatMultExpr.h:159
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
Header file for the IsSparseVector type trait.
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
Header file for run time assertion macros.
Utility type for generic codes.
Base template for the MultTrait class.
Definition: MultTrait.h:141
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:209
size_t columns() const
Returns the current number of columns of the matrix.
Definition: TSMatSMatMultExpr.h:220
TSMatSMatMultExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the TSMatSMatMultExpr class.
Definition: TSMatSMatMultExpr.h:173
Header file for the reset shim.
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:239
MultTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: TSMatSMatMultExpr.h:148
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: TSMatSMatMultExpr.h:241
Header file for the isDefault shim.
LeftOperand leftOperand() const
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatSMatMultExpr.h:252
ResultType::ElementType ElementType
Resulting element type.
Definition: TSMatSMatMultExpr.h:151
Expression object for transpose sparse matrix-sparse matrix multiplications.The TSMatSMatMultExpr cla...
Definition: Forward.h:136
Substitution Failure Is Not An Error (SFINAE) class.The DisableIf class template is an auxiliary tool...
Definition: DisableIf.h:184
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatSMatMultExpr.h:119
Header file for the IsDenseVector type trait.
Header file for the IsRowMajorMatrix type trait.
Header file for the IsComputation type trait class.
#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:2379
size_t columns(const Matrix< MT, SO > &m)
Returns the current number of columns of the matrix.
Definition: Matrix.h:154
Header file for basic type definitions.
Header file for the IsColumnVector type trait.
Header file for the IsResizable type trait.
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
size_t rows(const Matrix< MT, SO > &m)
Returns the current number of rows of the matrix.
Definition: Matrix.h:138
#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 TSMatSVecMultExprTrait class template.
Header file for the FunctionTrace class.