DMatTSMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATTSMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATTSMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
52 #include <blaze/math/shims/Reset.h>
88 #include <blaze/util/Assert.h>
90 #include <blaze/util/DisableIf.h>
91 #include <blaze/util/EnableIf.h>
92 #include <blaze/util/InvalidType.h>
94 #include <blaze/util/mpl/And.h>
95 #include <blaze/util/mpl/Or.h>
96 #include <blaze/util/SelectType.h>
97 #include <blaze/util/Types.h>
100 
101 
102 namespace blaze {
103 
104 //=================================================================================================
105 //
106 // CLASS DMATTSMATMULTEXPR
107 //
108 //=================================================================================================
109 
110 //*************************************************************************************************
117 template< typename MT1 // Type of the left-hand side dense matrix
118  , typename MT2 > // Type of the right-hand side sparse matrix
119 class DMatTSMatMultExpr : public DenseMatrix< DMatTSMatMultExpr<MT1,MT2>, false >
120  , private MatMatMultExpr
121  , private Computation
122 {
123  private:
124  //**Type definitions****************************************************************************
125  typedef typename MT1::ResultType RT1;
126  typedef typename MT2::ResultType RT2;
127  typedef typename RT1::ElementType ET1;
128  typedef typename RT2::ElementType ET2;
129  typedef typename MT1::CompositeType CT1;
130  typedef typename MT2::CompositeType CT2;
131  //**********************************************************************************************
132 
133  //**********************************************************************************************
136  //**********************************************************************************************
137 
138  //**********************************************************************************************
140  enum { evaluateRight = IsComputation<MT2>::value || RequiresEvaluation<MT2>::value };
141  //**********************************************************************************************
142 
143  //**********************************************************************************************
145 
152  template< typename T1, typename T2, typename T3 >
153  struct CanExploitSymmetry {
154  enum { value = ( IsRowMajorMatrix<T1>::value && IsSymmetric<T3>::value ) ||
155  ( IsColumnMajorMatrix<T1>::value && IsSymmetric<T2>::value ) };
156  };
158  //**********************************************************************************************
159 
160  //**********************************************************************************************
162 
166  template< typename T1, typename T2, typename T3 >
167  struct IsEvaluationRequired {
168  enum { value = ( evaluateLeft || evaluateRight ) &&
169  !CanExploitSymmetry<T1,T2,T3>::value };
170  };
172  //**********************************************************************************************
173 
174  public:
175  //**Type definitions****************************************************************************
181  typedef const ElementType ReturnType;
182  typedef const ResultType CompositeType;
183 
185  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
186 
188  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
189 
192 
195  //**********************************************************************************************
196 
197  //**Compilation flags***************************************************************************
199  enum { vectorizable = 0 };
200 
202  enum { smpAssignable = !evaluateLeft && MT1::smpAssignable &&
203  !evaluateRight && MT2::smpAssignable };
204  //**********************************************************************************************
205 
206  //**Constructor*********************************************************************************
212  explicit inline DMatTSMatMultExpr( const MT1& lhs, const MT2& rhs )
213  : lhs_( lhs ) // Left-hand side dense matrix of the multiplication expression
214  , rhs_( rhs ) // Right-hand side sparse matrix of the multiplication expression
215  {
216  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.rows(), "Invalid matrix sizes" );
217  }
218  //**********************************************************************************************
219 
220  //**Access operator*****************************************************************************
227  inline ReturnType operator()( size_t i, size_t j ) const {
228  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
229  BLAZE_INTERNAL_ASSERT( j < rhs_.columns(), "Invalid column access index" );
230 
232 
233  ElementType tmp = ElementType();
234 
235  // Early exit
236  if( lhs_.columns() == 0UL )
237  return tmp;
238 
239  // Fast computation in case the right-hand side sparse matrix directly provides iterators
241  {
242  CT2 B( rhs_ ); // Evaluation of the right-hand side sparse matrix operand
243 
244  const ConstIterator end( ( IsLower<MT1>::value )
245  ?( IsStrictlyLower<MT1>::value ? B.lowerBound(i,j) : B.upperBound(i,j) )
246  :( B.end(j) ) );
247  ConstIterator element( ( IsUpper<MT1>::value )
248  ?( IsStrictlyUpper<MT1>::value ? B.upperBound(i,j) : B.lowerBound(i,j) )
249  :( B.begin(j) ) );
250 
251  if( element != end ) {
252  tmp = lhs_(i,element->index()) * element->value();
253  ++element;
254  for( ; element!=end; ++element ) {
255  tmp += lhs_(i,element->index()) * element->value();
256  }
257  }
258  }
259 
260  // Default computation in case the right-hand side sparse matrix doesn't provide iterators
261  else
262  {
263  const size_t kbegin( ( IsUpper<MT1>::value )
264  ?( ( IsLower<MT2>::value )
265  ?( max( ( IsStrictlyUpper<MT1>::value ? i+1UL : i )
266  , ( IsStrictlyLower<MT2>::value ? j+1UL : j ) ) )
267  :( IsStrictlyUpper<MT1>::value ? i+1UL : i ) )
268  :( ( IsLower<MT2>::value )
269  ?( IsStrictlyLower<MT2>::value ? j+1UL : j )
270  :( 0UL ) ) );
271  const size_t kend( ( IsLower<MT1>::value )
272  ?( ( IsUpper<MT2>::value )
273  ?( min( ( IsStrictlyLower<MT1>::value ? i : i+1UL )
274  , ( IsStrictlyUpper<MT2>::value ? j : j+1UL ) ) )
275  :( IsStrictlyLower<MT1>::value ? i : i+1UL ) )
276  :( ( IsUpper<MT2>::value )
277  ?( IsStrictlyUpper<MT2>::value ? j : j+1UL )
278  :( lhs_.columns() ) ) );
279 
280  if( ( !IsTriangular<MT1>::value && !IsTriangular<MT2>::value ) || kbegin < kend ) {
281  tmp = lhs_(i,kbegin) * rhs_(kbegin,j);
282  for( size_t k=kbegin+1UL; k<kend; ++k ) {
283  tmp += lhs_(i,k) * rhs_(k,j);
284  }
285  }
286  }
287 
288  return tmp;
289  }
290  //**********************************************************************************************
291 
292  //**Rows function*******************************************************************************
297  inline size_t rows() const {
298  return lhs_.rows();
299  }
300  //**********************************************************************************************
301 
302  //**Columns function****************************************************************************
307  inline size_t columns() const {
308  return rhs_.columns();
309  }
310  //**********************************************************************************************
311 
312  //**Left operand access*************************************************************************
317  inline LeftOperand leftOperand() const {
318  return lhs_;
319  }
320  //**********************************************************************************************
321 
322  //**Right operand access************************************************************************
327  inline RightOperand rightOperand() const {
328  return rhs_;
329  }
330  //**********************************************************************************************
331 
332  //**********************************************************************************************
338  template< typename T >
339  inline bool canAlias( const T* alias ) const {
340  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
341  }
342  //**********************************************************************************************
343 
344  //**********************************************************************************************
350  template< typename T >
351  inline bool isAliased( const T* alias ) const {
352  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
353  }
354  //**********************************************************************************************
355 
356  //**********************************************************************************************
361  inline bool isAligned() const {
362  return lhs_.isAligned();
363  }
364  //**********************************************************************************************
365 
366  //**********************************************************************************************
371  inline bool canSMPAssign() const {
372  return ( rows() > SMP_DMATTSMATMULT_THRESHOLD );
373  }
374  //**********************************************************************************************
375 
376  private:
377  //**Member variables****************************************************************************
378  LeftOperand lhs_;
379  RightOperand rhs_;
380  //**********************************************************************************************
381 
382  //**Assignment to dense matrices****************************************************************
395  template< typename MT // Type of the target dense matrix
396  , bool SO > // Storage order of the target dense matrix
397  friend inline typename DisableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
398  assign( DenseMatrix<MT,SO>& lhs, const DMatTSMatMultExpr& rhs )
399  {
401 
402  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
403  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
404 
405  LT A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side dense matrix operand
406  RT B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
407 
408  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
409  BLAZE_INTERNAL_ASSERT( A.columns() == B.rows() , "Invalid matrix sizes" );
410  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns(), "Invalid number of columns" );
411 
412  DMatTSMatMultExpr::selectAssignKernel( ~lhs, A, B );
413  }
415  //**********************************************************************************************
416 
417  //**Default assignment to dense matrices********************************************************
431  template< typename MT3 // Type of the left-hand side target matrix
432  , typename MT4 // Type of the left-hand side matrix operand
433  , typename MT5 > // Type of the right-hand side matrix operand
434  static inline void selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
435  {
436  typedef typename MT5::ConstIterator ConstIterator;
437 
438  const size_t block( 4UL );
439 
440  for( size_t ii=0UL; ii<C.rows(); ii+=block ) {
441  const size_t iend( ( ii+block > C.rows() )?( C.rows() ):( ii+block ) );
442  for( size_t j=0UL; j<C.columns(); ++j )
443  {
444  const ConstIterator begin( ( IsUpper<MT4>::value )
445  ?( IsStrictlyUpper<MT4>::value ? B.upperBound(ii,j) : B.lowerBound(ii,j) )
446  :( B.begin(j) ) );
447  const ConstIterator end( ( IsLower<MT4>::value )
448  ?( IsStrictlyLower<MT4>::value ? B.lowerBound(ii+block,j) : B.upperBound(ii+block,j) )
449  :( B.end(j) ) );
450 
451  for( size_t i=ii; i<iend; ++i )
452  {
453  if( begin == end ) {
454  reset( C(i,j) );
455  continue;
456  }
457 
458  ConstIterator element( begin );
459 
460  C(i,j) = A(i,element->index()) * element->value();
461  ++element;
462  for( ; element!=end; ++element )
463  C(i,j) += A(i,element->index()) * element->value();
464  }
465  }
466  }
467  }
469  //**********************************************************************************************
470 
471  //**Assignment to sparse matrices***************************************************************
484  template< typename MT // Type of the target sparse matrix
485  , bool SO > // Storage order of the target sparse matrix
486  friend inline typename DisableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
487  assign( SparseMatrix<MT,SO>& lhs, const DMatTSMatMultExpr& rhs )
488  {
490 
491  typedef typename SelectType< SO, OppositeType, ResultType >::Type TmpType;
492 
499 
500  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
501  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
502 
503  const TmpType tmp( serial( rhs ) );
504  assign( ~lhs, tmp );
505  }
507  //**********************************************************************************************
508 
509  //**Restructuring assignment to row-major matrices**********************************************
524  template< typename MT > // Type of the target matrix
525  friend inline typename EnableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
526  assign( Matrix<MT,false>& lhs, const DMatTSMatMultExpr& rhs )
527  {
529 
530  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
531  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
532 
533  assign( ~lhs, rhs.lhs_ * trans( rhs.rhs_ ) );
534  }
536  //**********************************************************************************************
537 
538  //**Restructuring assignment to column-major matrices*******************************************
553  template< typename MT > // Type of the target matrix
554  friend inline typename EnableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
555  assign( Matrix<MT,true>& lhs, const DMatTSMatMultExpr& rhs )
556  {
558 
560 
561  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
562  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
563 
564  assign( ~lhs, trans( rhs.lhs_ ) * rhs.rhs_ );
565  }
567  //**********************************************************************************************
568 
569  //**Addition assignment to dense matrices*******************************************************
582  template< typename MT // Type of the target dense matrix
583  , bool SO > // Storage order of the target dense matrix
584  friend inline typename DisableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
585  addAssign( DenseMatrix<MT,SO>& lhs, const DMatTSMatMultExpr& rhs )
586  {
588 
589  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
590  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
591 
592  LT A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side dense matrix operand
593  RT B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
594 
595  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
596  BLAZE_INTERNAL_ASSERT( A.columns() == B.rows() , "Invalid matrix sizes" );
597  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns(), "Invalid number of columns" );
598 
599  DMatTSMatMultExpr::selectAddAssignKernel( ~lhs, A, B );
600  }
602  //**********************************************************************************************
603 
604  //**Default addition assignment to dense matrices***********************************************
618  template< typename MT3 // Type of the left-hand side target matrix
619  , typename MT4 // Type of the left-hand side matrix operand
620  , typename MT5 > // Type of the right-hand side matrix operand
621  static inline void selectAddAssignKernel( MT3& C, const MT4& A, const MT5& B )
622  {
623  typedef typename MT5::ConstIterator ConstIterator;
624 
625  const size_t block( 4UL );
626 
627  for( size_t ii=0UL; ii<C.rows(); ii+=block ) {
628  const size_t iend( ( ii+block > C.rows() )?( C.rows() ):( ii+block ) );
629  for( size_t j=0UL; j<C.columns(); ++j )
630  {
631  const ConstIterator begin( ( IsUpper<MT4>::value )
632  ?( IsStrictlyUpper<MT4>::value ? B.upperBound(ii,j) : B.lowerBound(ii,j) )
633  :( B.begin(j) ) );
634  const ConstIterator end( ( IsLower<MT4>::value )
635  ?( IsStrictlyLower<MT4>::value ? B.lowerBound(ii+block,j) : B.upperBound(ii+block,j) )
636  :( B.end(j) ) );
637 
638  if( begin == end )
639  continue;
640 
641  for( size_t i=ii; i<iend; ++i ) {
642  for( ConstIterator element=begin; element!=end; ++element )
643  C(i,j) += A(i,element->index()) * element->value();
644  }
645  }
646  }
647  }
649  //**********************************************************************************************
650 
651  //**Restructuring addition assignment to row-major matrices*************************************
666  template< typename MT > // Type of the target matrix
667  friend inline typename EnableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
668  addAssign( Matrix<MT,false>& lhs, const DMatTSMatMultExpr& rhs )
669  {
671 
672  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
673  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
674 
675  addAssign( ~lhs, rhs.lhs_ * trans( rhs.rhs_ ) );
676  }
678  //**********************************************************************************************
679 
680  //**Restructuring addition assignment to column-major matrices**********************************
695  template< typename MT > // Type of the target matrix
696  friend inline typename EnableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
697  addAssign( Matrix<MT,true>& lhs, const DMatTSMatMultExpr& rhs )
698  {
700 
702 
703  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
704  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
705 
706  addAssign( ~lhs, trans( rhs.lhs_ ) * rhs.rhs_ );
707  }
709  //**********************************************************************************************
710 
711  //**Addition assignment to sparse matrices******************************************************
712  // No special implementation for the addition assignment to sparse matrices.
713  //**********************************************************************************************
714 
715  //**Subtraction assignment to dense matrices****************************************************
728  template< typename MT // Type of the target dense matrix
729  , bool SO > // Storage order of the target dense matrix
730  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const DMatTSMatMultExpr& rhs )
731  {
733 
734  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
735  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
736 
737  LT A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side dense matrix operand
738  RT B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
739 
740  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
741  BLAZE_INTERNAL_ASSERT( A.columns() == B.rows() , "Invalid matrix sizes" );
742  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns(), "Invalid number of columns" );
743 
744  DMatTSMatMultExpr::selectSubAssignKernel( ~lhs, A, B );
745  }
747  //**********************************************************************************************
748 
749  //**Default subtraction assignment to dense matrices***********************************************
763  template< typename MT3 // Type of the left-hand side target matrix
764  , typename MT4 // Type of the left-hand side matrix operand
765  , typename MT5 > // Type of the right-hand side matrix operand
766  static inline void selectSubAssignKernel( MT3& C, const MT4& A, const MT5& B )
767  {
768  typedef typename MT5::ConstIterator ConstIterator;
769 
770  const size_t block( 4UL );
771 
772  for( size_t ii=0UL; ii<C.rows(); ii+=block ) {
773  const size_t iend( ( ii+block > C.rows() )?( C.rows() ):( ii+block ) );
774  for( size_t j=0UL; j<C.columns(); ++j )
775  {
776  const ConstIterator begin( ( IsUpper<MT4>::value )
777  ?( IsStrictlyUpper<MT4>::value ? B.upperBound(ii,j) : B.lowerBound(ii,j) )
778  :( B.begin(j) ) );
779  const ConstIterator end( ( IsLower<MT4>::value )
780  ?( IsStrictlyLower<MT4>::value ? B.lowerBound(ii+block,j) : B.upperBound(ii+block,j) )
781  :( B.end(j) ) );
782 
783  if( begin == end )
784  continue;
785 
786  for( size_t i=ii; i<iend; ++i ) {
787  for( ConstIterator element=begin; element!=end; ++element )
788  C(i,j) -= A(i,element->index()) * element->value();
789  }
790  }
791  }
792  }
794  //**********************************************************************************************
795 
796  //**Restructuring subtraction assignment to row-major matrices**********************************
811  template< typename MT > // Type of the target matrix
812  friend inline typename EnableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
813  subAssign( Matrix<MT,false>& lhs, const DMatTSMatMultExpr& rhs )
814  {
816 
817  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
818  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
819 
820  subAssign( ~lhs, rhs.lhs_ * trans( rhs.rhs_ ) );
821  }
823  //**********************************************************************************************
824 
825  //**Restructuring subtraction assignment to column-major matrices*******************************
840  template< typename MT > // Type of the target matrix
841  friend inline typename EnableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
842  subAssign( Matrix<MT,true>& lhs, const DMatTSMatMultExpr& rhs )
843  {
845 
847 
848  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
849  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
850 
851  subAssign( ~lhs, trans( rhs.lhs_ ) * rhs.rhs_ );
852  }
854  //**********************************************************************************************
855 
856  //**Subtraction assignment to sparse matrices***************************************************
857  // No special implementation for the subtraction assignment to sparse matrices.
858  //**********************************************************************************************
859 
860  //**Multiplication assignment to dense matrices*************************************************
861  // No special implementation for the multiplication assignment to dense matrices.
862  //**********************************************************************************************
863 
864  //**Multiplication assignment to sparse matrices************************************************
865  // No special implementation for the multiplication assignment to sparse matrices.
866  //**********************************************************************************************
867 
868  //**SMP assignment to dense matrices************************************************************
883  template< typename MT // Type of the target dense matrix
884  , bool SO > // Storage order of the target dense matrix
885  friend inline typename EnableIf< IsEvaluationRequired<MT,MT1,MT2> >::Type
886  smpAssign( DenseMatrix<MT,SO>& lhs, const DMatTSMatMultExpr& rhs )
887  {
889 
890  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
891  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
892 
893  LT A( rhs.lhs_ ); // Evaluation of the left-hand side dense matrix operand
894  RT B( rhs.rhs_ ); // Evaluation of the right-hand side sparse matrix operand
895 
896  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
897  BLAZE_INTERNAL_ASSERT( A.columns() == B.rows() , "Invalid matrix sizes" );
898  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns(), "Invalid number of columns" );
899 
900  smpAssign( ~lhs, A * B );
901  }
903  //**********************************************************************************************
904 
905  //**SMP assignment to sparse matrices***********************************************************
920  template< typename MT // Type of the target sparse matrix
921  , bool SO > // Storage order of the target sparse matrix
922  friend inline typename EnableIf< IsEvaluationRequired<MT,MT1,MT2> >::Type
923  smpAssign( SparseMatrix<MT,SO>& lhs, const DMatTSMatMultExpr& rhs )
924  {
926 
927  typedef typename SelectType< SO, OppositeType, ResultType >::Type TmpType;
928 
935 
936  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
937  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
938 
939  const TmpType tmp( rhs );
940  smpAssign( ~lhs, tmp );
941  }
943  //**********************************************************************************************
944 
945  //**Restructuring SMP assignment to row-major matrices******************************************
960  template< typename MT > // Type of the target matrix
961  friend inline typename EnableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
962  smpAssign( Matrix<MT,false>& lhs, const DMatTSMatMultExpr& rhs )
963  {
965 
966  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
967  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
968 
969  smpAssign( ~lhs, rhs.lhs_ * trans( rhs.rhs_ ) );
970  }
972  //**********************************************************************************************
973 
974  //**Restructuring SMP assignment to column-major matrices***************************************
989  template< typename MT > // Type of the target matrix
990  friend inline typename EnableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
991  smpAssign( Matrix<MT,true>& lhs, const DMatTSMatMultExpr& rhs )
992  {
994 
996 
997  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
998  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
999 
1000  smpAssign( ~lhs, trans( rhs.lhs_ ) * rhs.rhs_ );
1001  }
1003  //**********************************************************************************************
1004 
1005  //**SMP addition assignment to dense matrices***************************************************
1021  template< typename MT // Type of the target dense matrix
1022  , bool SO > // Storage order of the target dense matrix
1023  friend inline typename EnableIf< IsEvaluationRequired<MT,MT1,MT2> >::Type
1024  smpAddAssign( DenseMatrix<MT,SO>& lhs, const DMatTSMatMultExpr& rhs )
1025  {
1027 
1028  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
1029  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
1030 
1031  LT A( rhs.lhs_ ); // Evaluation of the left-hand side dense matrix operand
1032  RT B( rhs.rhs_ ); // Evaluation of the right-hand side sparse matrix operand
1033 
1034  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
1035  BLAZE_INTERNAL_ASSERT( A.columns() == B.rows() , "Invalid matrix sizes" );
1036  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns(), "Invalid number of columns" );
1037 
1038  smpAddAssign( ~lhs, A * B );
1039  }
1041  //**********************************************************************************************
1042 
1043  //**Restructuring SMP addition assignment to row-major matrices*********************************
1058  template< typename MT > // Type of the target matrix
1059  friend inline typename EnableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
1060  smpAddAssign( Matrix<MT,false>& lhs, const DMatTSMatMultExpr& rhs )
1061  {
1063 
1064  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
1065  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
1066 
1067  smpAddAssign( ~lhs, rhs.lhs_ * trans( rhs.rhs_ ) );
1068  }
1070  //**********************************************************************************************
1071 
1072  //**Restructuring SMP addition assignment to column-major matrices******************************
1087  template< typename MT > // Type of the target matrix
1088  friend inline typename EnableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
1089  smpAddAssign( Matrix<MT,true>& lhs, const DMatTSMatMultExpr& rhs )
1090  {
1092 
1094 
1095  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
1096  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
1097 
1098  smpAddAssign( ~lhs, trans( rhs.lhs_ ) * rhs.rhs_ );
1099  }
1101  //**********************************************************************************************
1102 
1103  //**SMP addition assignment to sparse matrices**************************************************
1104  // No special implementation for the SMP addition assignment to sparse matrices.
1105  //**********************************************************************************************
1106 
1107  //**SMP subtraction assignment to dense matrices************************************************
1123  template< typename MT // Type of the target dense matrix
1124  , bool SO > // Storage order of the target dense matrix
1125  friend inline typename EnableIf< IsEvaluationRequired<MT,MT1,MT2> >::Type
1126  smpSubAssign( DenseMatrix<MT,SO>& lhs, const DMatTSMatMultExpr& rhs )
1127  {
1129 
1130  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
1131  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
1132 
1133  LT A( rhs.lhs_ ); // Evaluation of the left-hand side dense matrix operand
1134  RT B( rhs.rhs_ ); // Evaluation of the right-hand side sparse matrix operand
1135 
1136  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
1137  BLAZE_INTERNAL_ASSERT( A.columns() == B.rows() , "Invalid matrix sizes" );
1138  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns(), "Invalid number of columns" );
1139 
1140  smpSubAssign( ~lhs, A * B );
1141  }
1143  //**********************************************************************************************
1144 
1145  //**Restructuring SMP subtraction assignment to row-major matrices******************************
1160  template< typename MT > // Type of the target matrix
1161  friend inline typename EnableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
1162  smpSubAssign( Matrix<MT,false>& lhs, const DMatTSMatMultExpr& rhs )
1163  {
1165 
1166  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
1167  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
1168 
1169  smpSubAssign( ~lhs, rhs.lhs_ * trans( rhs.rhs_ ) );
1170  }
1172  //**********************************************************************************************
1173 
1174  //**Restructuring SMP subtraction assignment to column-major matrices***************************
1189  template< typename MT > // Type of the target matrix
1190  friend inline typename EnableIf< CanExploitSymmetry<MT,MT1,MT2> >::Type
1191  smpSubAssign( Matrix<MT,true>& lhs, const DMatTSMatMultExpr& rhs )
1192  {
1194 
1196 
1197  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
1198  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
1199 
1200  smpSubAssign( ~lhs, trans( rhs.lhs_ ) * rhs.rhs_ );
1201  }
1203  //**********************************************************************************************
1204 
1205  //**SMP subtraction assignment to sparse matrices***********************************************
1206  // No special implementation for the SMP subtraction assignment to sparse matrices.
1207  //**********************************************************************************************
1208 
1209  //**SMP multiplication assignment to dense matrices*********************************************
1210  // No special implementation for the SMP multiplication assignment to dense matrices.
1211  //**********************************************************************************************
1212 
1213  //**SMP multiplication assignment to sparse matrices********************************************
1214  // No special implementation for the SMP multiplication assignment to sparse matrices.
1215  //**********************************************************************************************
1216 
1217  //**Compile time checks*************************************************************************
1225  //**********************************************************************************************
1226 };
1227 //*************************************************************************************************
1228 
1229 
1230 
1231 
1232 //=================================================================================================
1233 //
1234 // GLOBAL BINARY ARITHMETIC OPERATORS
1235 //
1236 //=================================================================================================
1237 
1238 //*************************************************************************************************
1268 template< typename T1 // Type of the left-hand side dense matrix
1269  , typename T2 > // Type of the right-hand side sparse matrix
1270 inline const DMatTSMatMultExpr<T1,T2>
1272 {
1274 
1275  if( (~lhs).columns() != (~rhs).rows() )
1276  throw std::invalid_argument( "Matrix sizes do not match" );
1277 
1278  return DMatTSMatMultExpr<T1,T2>( ~lhs, ~rhs );
1279 }
1280 //*************************************************************************************************
1281 
1282 
1283 
1284 
1285 //=================================================================================================
1286 //
1287 // ROWS SPECIALIZATIONS
1288 //
1289 //=================================================================================================
1290 
1291 //*************************************************************************************************
1293 template< typename MT1, typename MT2 >
1294 struct Rows< DMatTSMatMultExpr<MT1,MT2> >
1295  : public Rows<MT1>
1296 {};
1298 //*************************************************************************************************
1299 
1300 
1301 
1302 
1303 //=================================================================================================
1304 //
1305 // COLUMNS SPECIALIZATIONS
1306 //
1307 //=================================================================================================
1308 
1309 //*************************************************************************************************
1311 template< typename MT1, typename MT2 >
1312 struct Columns< DMatTSMatMultExpr<MT1,MT2> >
1313  : public Columns<MT2>
1314 {};
1316 //*************************************************************************************************
1317 
1318 
1319 
1320 
1321 //=================================================================================================
1322 //
1323 // ISLOWER SPECIALIZATIONS
1324 //
1325 //=================================================================================================
1326 
1327 //*************************************************************************************************
1329 template< typename MT1, typename MT2 >
1330 struct IsLower< DMatTSMatMultExpr<MT1,MT2> >
1331  : public IsTrue< IsLower<MT1>::value && IsLower<MT2>::value >
1332 {};
1334 //*************************************************************************************************
1335 
1336 
1337 
1338 
1339 //=================================================================================================
1340 //
1341 // ISUNILOWER SPECIALIZATIONS
1342 //
1343 //=================================================================================================
1344 
1345 //*************************************************************************************************
1347 template< typename MT1, typename MT2 >
1348 struct IsUniLower< DMatTSMatMultExpr<MT1,MT2> >
1349  : public IsTrue< IsUniLower<MT1>::value && IsUniLower<MT2>::value >
1350 {};
1352 //*************************************************************************************************
1353 
1354 
1355 
1356 
1357 //=================================================================================================
1358 //
1359 // ISSTRICTLYLOWER SPECIALIZATIONS
1360 //
1361 //=================================================================================================
1362 
1363 //*************************************************************************************************
1365 template< typename MT1, typename MT2 >
1366 struct IsStrictlyLower< DMatTSMatMultExpr<MT1,MT2> >
1367  : public IsTrue< Or< And< IsStrictlyLower<MT1>, IsLower<MT2> >
1368  , And< IsStrictlyLower<MT2>, IsLower<MT1> > >::value >
1369 {};
1371 //*************************************************************************************************
1372 
1373 
1374 
1375 
1376 //=================================================================================================
1377 //
1378 // ISUPPER SPECIALIZATIONS
1379 //
1380 //=================================================================================================
1381 
1382 //*************************************************************************************************
1384 template< typename MT1, typename MT2 >
1385 struct IsUpper< DMatTSMatMultExpr<MT1,MT2> >
1386  : public IsTrue< IsUpper<MT1>::value && IsUpper<MT2>::value >
1387 {};
1389 //*************************************************************************************************
1390 
1391 
1392 
1393 
1394 //=================================================================================================
1395 //
1396 // ISUNIUPPER SPECIALIZATIONS
1397 //
1398 //=================================================================================================
1399 
1400 //*************************************************************************************************
1402 template< typename MT1, typename MT2 >
1403 struct IsUniUpper< DMatTSMatMultExpr<MT1,MT2> >
1404  : public IsTrue< IsUniUpper<MT1>::value && IsUniUpper<MT2>::value >
1405 {};
1407 //*************************************************************************************************
1408 
1409 
1410 
1411 
1412 //=================================================================================================
1413 //
1414 // ISSTRICTLYUPPER SPECIALIZATIONS
1415 //
1416 //=================================================================================================
1417 
1418 //*************************************************************************************************
1420 template< typename MT1, typename MT2 >
1421 struct IsStrictlyUpper< DMatTSMatMultExpr<MT1,MT2> >
1422  : public IsTrue< Or< And< IsStrictlyUpper<MT1>, IsUpper<MT2> >
1423  , And< IsStrictlyUpper<MT2>, IsUpper<MT1> > >::value >
1424 {};
1426 //*************************************************************************************************
1427 
1428 
1429 
1430 
1431 //=================================================================================================
1432 //
1433 // EXPRESSION TRAIT SPECIALIZATIONS
1434 //
1435 //=================================================================================================
1436 
1437 //*************************************************************************************************
1439 template< typename MT1, typename MT2, typename VT >
1440 struct DMatDVecMultExprTrait< DMatTSMatMultExpr<MT1,MT2>, VT >
1441 {
1442  public:
1443  //**********************************************************************************************
1444  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
1445  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
1446  IsDenseVector<VT>::value && IsColumnVector<VT>::value
1447  , typename DMatDVecMultExprTrait< MT1, typename TSMatDVecMultExprTrait<MT2,VT>::Type >::Type
1448  , INVALID_TYPE >::Type Type;
1449  //**********************************************************************************************
1450 };
1452 //*************************************************************************************************
1453 
1454 
1455 //*************************************************************************************************
1457 template< typename MT1, typename MT2, typename VT >
1458 struct DMatSVecMultExprTrait< DMatTSMatMultExpr<MT1,MT2>, VT >
1459 {
1460  public:
1461  //**********************************************************************************************
1462  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
1463  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
1464  IsSparseVector<VT>::value && IsColumnVector<VT>::value
1465  , typename DMatSVecMultExprTrait< MT1, typename TSMatSVecMultExprTrait<MT2,VT>::Type >::Type
1466  , INVALID_TYPE >::Type Type;
1467  //**********************************************************************************************
1468 };
1470 //*************************************************************************************************
1471 
1472 
1473 //*************************************************************************************************
1475 template< typename VT, typename MT1, typename MT2 >
1476 struct TDVecDMatMultExprTrait< VT, DMatTSMatMultExpr<MT1,MT2> >
1477 {
1478  public:
1479  //**********************************************************************************************
1480  typedef typename SelectType< IsDenseVector<VT>::value && IsRowVector<VT>::value &&
1481  IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
1482  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
1483  , typename TDVecTSMatMultExprTrait< typename TDVecDMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
1484  , INVALID_TYPE >::Type Type;
1485  //**********************************************************************************************
1486 };
1488 //*************************************************************************************************
1489 
1490 
1491 //*************************************************************************************************
1493 template< typename VT, typename MT1, typename MT2 >
1494 struct TSVecDMatMultExprTrait< VT, DMatTSMatMultExpr<MT1,MT2> >
1495 {
1496  public:
1497  //**********************************************************************************************
1498  typedef typename SelectType< IsSparseVector<VT>::value && IsRowVector<VT>::value &&
1499  IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
1500  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
1501  , typename TDVecTSMatMultExprTrait< typename TSVecDMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
1502  , INVALID_TYPE >::Type Type;
1503  //**********************************************************************************************
1504 };
1506 //*************************************************************************************************
1507 
1508 
1509 //*************************************************************************************************
1511 template< typename MT1, typename MT2, bool AF >
1512 struct SubmatrixExprTrait< DMatTSMatMultExpr<MT1,MT2>, AF >
1513 {
1514  public:
1515  //**********************************************************************************************
1516  typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
1517  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
1518  //**********************************************************************************************
1519 };
1521 //*************************************************************************************************
1522 
1523 
1524 //*************************************************************************************************
1526 template< typename MT1, typename MT2 >
1527 struct RowExprTrait< DMatTSMatMultExpr<MT1,MT2> >
1528 {
1529  public:
1530  //**********************************************************************************************
1531  typedef typename MultExprTrait< typename RowExprTrait<const MT1>::Type, MT2 >::Type Type;
1532  //**********************************************************************************************
1533 };
1535 //*************************************************************************************************
1536 
1537 
1538 //*************************************************************************************************
1540 template< typename MT1, typename MT2 >
1541 struct ColumnExprTrait< DMatTSMatMultExpr<MT1,MT2> >
1542 {
1543  public:
1544  //**********************************************************************************************
1545  typedef typename MultExprTrait< MT1, typename ColumnExprTrait<const MT2>::Type >::Type Type;
1546  //**********************************************************************************************
1547 };
1549 //*************************************************************************************************
1550 
1551 } // namespace blaze
1552 
1553 #endif
ResultType::ElementType ElementType
Resulting element type.
Definition: DMatTSMatMultExpr.h:180
const MT::ElementType max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1649
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:89
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatTSMatMultExpr.h:227
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
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:8247
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatTSMatMultExpr.h:185
Compile time check for triangular matrix types.This type trait tests whether or not the given templat...
Definition: IsTriangular.h:105
Header file for basic type definitions.
MT2::CompositeType CT2
Composite type of the right-hand side sparse matrix expression.
Definition: DMatTSMatMultExpr.h:130
const size_t SMP_DMATTSMATMULT_THRESHOLD
SMP row-major dense matrix/column-major sparse matrix multiplication threshold.This threshold specifi...
Definition: Thresholds.h:949
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
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatTSMatMultExpr.h:339
Header file for the IsSparseMatrix type trait.
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:209
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:79
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:821
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatTSMatMultExpr.h:179
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2507
Header file for the IsRowVector type trait.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:261
Header file for the And class template.
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:90
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:699
Header file for the Computation base class.
Header file for the MatMatMultExpr base class.
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:90
Header file for the RequiresEvaluation type trait.
LeftOperand leftOperand() const
Returns the left-hand side dense matrix operand.
Definition: DMatTSMatMultExpr.h:317
Header file for the IsUniLower type trait.
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:107
Constraint on the data type.
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatTSMatMultExpr.h:182
Constraint on the data type.
Constraint on the data type.
Header file for the MultExprTrait class template.
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:90
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatTSMatMultExpr.h:361
DMatTSMatMultExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the DMatTSMatMultExpr class.
Definition: DMatTSMatMultExpr.h:212
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 multiplication trait.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatTSMatMultExpr.h:297
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#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
MT1::CompositeType CT1
Composite type of the left-hand side dense matrix expression.
Definition: DMatTSMatMultExpr.h:129
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2511
Header file for the Or class template.
Header file for the TDVecTSMatMultExprTrait class template.
const MT::ElementType min(const DenseMatrix< MT, SO > &dm)
Returns the smallest element of the dense matrix.
Definition: DenseMatrix.h:1602
Header file for the DenseMatrix base class.
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.
Header file for the TSMatDVecMultExprTrait class template.
RT2::ElementType ET2
Element type of the right-hand side sparse matrix expression.
Definition: DMatTSMatMultExpr.h:128
SelectType< evaluateLeft, const RT1, CT1 >::Type LT
Type for the assignment of the left-hand side dense matrix operand.
Definition: DMatTSMatMultExpr.h:191
Header file for the DMatDVecMultExprTrait class template.
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatTSMatMultExpr.h:125
Header file for the IsLower type trait.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTSMatMultExpr.h:178
#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:78
Header file for the IsTriangular type trait.
Constraints on the storage order of matrix types.
RT1::ElementType ET1
Element type of the left-hand side dense matrix expression.
Definition: DMatTSMatMultExpr.h:127
BLAZE_ALWAYS_INLINE MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:195
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2505
RightOperand rhs_
Right-hand side sparse matrix of the multiplication expression.
Definition: DMatTSMatMultExpr.h:379
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 IsDenseMatrix type trait.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Header file for the serial shim.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATMULTEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix ...
Definition: MatMatMultExpr.h:165
Base class for all matrix/matrix multiplication expression templates.The MatMatMultExpr class serves ...
Definition: MatMatMultExpr.h:65
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
Header file for the IsSparseVector type trait.
#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
Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given...
Definition: RemoveReference.h:69
Header file for run time assertion macros.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:98
Utility type for generic codes.
Base template for the MultTrait class.
Definition: MultTrait.h:150
const ElementType ReturnType
Return type for expression template evaluations.
Definition: DMatTSMatMultExpr.h:181
MultTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DMatTSMatMultExpr.h:177
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
RightOperand rightOperand() const
Returns the right-hand side transpose sparse matrix operand.
Definition: DMatTSMatMultExpr.h:327
Header file for the reset shim.
SelectType< evaluateRight, const RT2, CT2 >::Type RT
Type for the assignment of the right-hand side sparse matrix operand.
Definition: DMatTSMatMultExpr.h:194
Expression object for dense matrix-transpose sparse matrix multiplications.The DMatTSMatMultExpr clas...
Definition: DMatTSMatMultExpr.h:119
Header file for the RemoveReference type trait.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatTSMatMultExpr.h:351
Substitution Failure Is Not An Error (SFINAE) class.The DisableIf class template is an auxiliary tool...
Definition: DisableIf.h:184
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_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:283
Header file for the IsDenseVector type trait.
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DMatTSMatMultExpr.h:371
LeftOperand lhs_
Left-hand side dense matrix of the multiplication expression.
Definition: DMatTSMatMultExpr.h:378
Header file for the IsRowMajorMatrix type trait.
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:937
Header file for the IsComputation type trait class.
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
Header file for the TDVecDMatMultExprTrait class template.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2502
Header file for the IsTrue value trait.
Header file for the TSVecDMatMultExprTrait class template.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatTSMatMultExpr.h:307
Header file for the IsUpper type trait.
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: DMatTSMatMultExpr.h:126
Header file for the DMatSVecMultExprTrait class template.
Header file for the IsColumnVector type trait.
Constraint on the data type.
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
#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
DMatTSMatMultExpr< MT1, MT2 > This
Type of this DMatTSMatMultExpr instance.
Definition: DMatTSMatMultExpr.h:176
#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
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: DMatTSMatMultExpr.h:188
Header file for the IsExpression type trait class.
Header file for the TSMatSVecMultExprTrait class template.
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