All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TSMatTDMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATTDMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATTDMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
51 #include <blaze/math/shims/Reset.h>
77 #include <blaze/util/Assert.h>
78 #include <blaze/util/EnableIf.h>
79 #include <blaze/util/DisableIf.h>
80 #include <blaze/util/InvalidType.h>
82 #include <blaze/util/SelectType.h>
83 #include <blaze/util/Types.h>
85 
86 
87 namespace blaze {
88 
89 //=================================================================================================
90 //
91 // CLASS SMATDMATMULTEXPR
92 //
93 //=================================================================================================
94 
95 //*************************************************************************************************
102 template< typename MT1 // Type of the left-hand side dense matrix
103  , typename MT2 > // Type of the right-hand side sparse matrix
104 class TSMatTDMatMultExpr : public DenseMatrix< TSMatTDMatMultExpr<MT1,MT2>, true >
105  , private MatMatMultExpr
106  , private Computation
107 {
108  private:
109  //**Type definitions****************************************************************************
110  typedef typename MT1::ResultType RT1;
111  typedef typename MT2::ResultType RT2;
112  typedef typename RT1::ElementType ET1;
113  typedef typename RT2::ElementType ET2;
114  typedef typename MT1::CompositeType CT1;
115  typedef typename MT2::CompositeType CT2;
116  //**********************************************************************************************
117 
118  //**********************************************************************************************
121  //**********************************************************************************************
122 
123  //**********************************************************************************************
125  enum { evaluateRight = IsComputation<MT2>::value || RequiresEvaluation<MT2>::value };
126  //**********************************************************************************************
127 
128  //**********************************************************************************************
130 
133  template< typename T1, typename T2, typename T3 >
134  struct UseSMPAssignKernel {
135  enum { value = evaluateLeft || evaluateRight };
136  };
138  //**********************************************************************************************
139 
140  //**********************************************************************************************
142 
146  template< typename T1, typename T2, typename T3 >
147  struct UseOptimizedKernel {
148  enum { value = !UseSMPAssignKernel<T1,T2,T3>::value &&
149  !IsResizable<typename T1::ElementType>::value };
150  };
152  //**********************************************************************************************
153 
154  //**********************************************************************************************
156 
159  template< typename T1, typename T2, typename T3 >
160  struct UseDefaultKernel {
161  enum { value = !UseSMPAssignKernel<T1,T2,T3>::value &&
162  !UseOptimizedKernel<T1,T2,T3>::value };
163  };
165  //**********************************************************************************************
166 
167  public:
168  //**Type definitions****************************************************************************
174  typedef const ElementType ReturnType;
175  typedef const ResultType CompositeType;
176 
178  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
179 
181  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
182 
185 
188  //**********************************************************************************************
189 
190  //**Compilation flags***************************************************************************
192  enum { vectorizable = 0 };
193 
195  enum { smpAssignable = !evaluateLeft && !evaluateRight };
196  //**********************************************************************************************
197 
198  //**Constructor*********************************************************************************
204  explicit inline TSMatTDMatMultExpr( const MT1& lhs, const MT2& rhs )
205  : lhs_( lhs ) // Left-hand side sparse matrix of the multiplication expression
206  , rhs_( rhs ) // Right-hand side dense matrix of the multiplication expression
207  {
208  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.rows(), "Invalid matrix sizes" );
209  }
210  //**********************************************************************************************
211 
212  //**Access operator*****************************************************************************
219  inline ReturnType operator()( size_t i, size_t j ) const {
220  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
221  BLAZE_INTERNAL_ASSERT( j < rhs_.columns(), "Invalid column access index" );
222 
223  ElementType tmp;
224 
225  if( lhs_.columns() != 0UL ) {
226  tmp = lhs_(i,0UL) * rhs_(0UL,j);
227  for( size_t k=1UL; k<lhs_.columns(); ++k ) {
228  tmp += lhs_(i,k) * rhs_(k,j);
229  }
230  }
231  else {
232  reset( tmp );
233  }
234 
235  return tmp;
236  }
237  //**********************************************************************************************
238 
239  //**Rows function*******************************************************************************
244  inline size_t rows() const {
245  return lhs_.rows();
246  }
247  //**********************************************************************************************
248 
249  //**Columns function****************************************************************************
254  inline size_t columns() const {
255  return rhs_.columns();
256  }
257  //**********************************************************************************************
258 
259  //**Left operand access*************************************************************************
264  inline LeftOperand leftOperand() const {
265  return lhs_;
266  }
267  //**********************************************************************************************
268 
269  //**Right operand access************************************************************************
274  inline RightOperand rightOperand() const {
275  return rhs_;
276  }
277  //**********************************************************************************************
278 
279  //**********************************************************************************************
285  template< typename T >
286  inline bool canAlias( const T* alias ) const {
287  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
288  }
289  //**********************************************************************************************
290 
291  //**********************************************************************************************
297  template< typename T >
298  inline bool isAliased( const T* alias ) const {
299  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
300  }
301  //**********************************************************************************************
302 
303  //**********************************************************************************************
308  inline bool isAligned() const {
309  return rhs_.isAligned();
310  }
311  //**********************************************************************************************
312 
313  //**********************************************************************************************
318  inline bool canSMPAssign() const {
319  return ( columns() > SMP_TSMATTDMATMULT_THRESHOLD );
320  }
321  //**********************************************************************************************
322 
323  private:
324  //**Member variables****************************************************************************
327  //**********************************************************************************************
328 
329  //**Assignment to dense matrices****************************************************************
342  template< typename MT // Type of the target dense matrix
343  , bool SO > // Storage order of the target dense matrix
344  friend inline void assign( DenseMatrix<MT,SO>& lhs, const TSMatTDMatMultExpr& rhs )
345  {
347 
348  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
349  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
350 
351  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
352  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
353 
354  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
355  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
356  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
357  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
358  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
359  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
360 
361  TSMatTDMatMultExpr::selectAssignKernel( ~lhs, A, B );
362  }
364  //**********************************************************************************************
365 
366  //**Default assignment to dense matrices********************************************************
381  template< typename MT3 // Type of the left-hand side target matrix
382  , typename MT4 // Type of the left-hand side matrix operand
383  , typename MT5 > // Type of the right-hand side matrix operand
384  static inline typename EnableIf< UseDefaultKernel<MT3,MT4,MT5> >::Type
385  selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
386  {
387  typedef typename MT4::ConstIterator ConstIterator;
388 
389  reset( C );
390 
391  const size_t block( 64UL );
392 
393  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
394  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
395  for( size_t i=0UL; i<A.columns(); ++i ) {
396  const ConstIterator end( A.end(i) );
397  ConstIterator element( A.begin(i) );
398  for( ; element!=end; ++element ) {
399  for( size_t j=jj; j<jend; ++j ) {
400  if( isDefault( C(element->index(),j) ) )
401  C(element->index(),j) = element->value() * B(i,j);
402  else
403  C(element->index(),j) += element->value() * B(i,j);
404  }
405  }
406  }
407  }
408  }
410  //**********************************************************************************************
411 
412  //**Optimized assignment to dense matrices******************************************************
427  template< typename MT3 // Type of the left-hand side target matrix
428  , typename MT4 // Type of the left-hand side matrix operand
429  , typename MT5 > // Type of the right-hand side matrix operand
430  static inline typename EnableIf< UseOptimizedKernel<MT3,MT4,MT5> >::Type
431  selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
432  {
433  typedef typename MT4::ConstIterator ConstIterator;
434 
435  const size_t block( IsRowMajorMatrix<MT3>::value ? 128UL : 64UL );
436 
437  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
438  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
439  for( size_t i=0UL; i<A.rows(); ++i ) {
440  for( size_t j=jj; j<jend; ++j ) {
441  reset( C(i,j) );
442  }
443  }
444  for( size_t i=0UL; i<A.columns(); ++i )
445  {
446  const ConstIterator end( A.end(i) );
447  ConstIterator element( A.begin(i) );
448 
449  const size_t nonzeros( A.nonZeros(i) );
450 
451  const size_t kend( nonzeros & size_t(-4) );
452  BLAZE_INTERNAL_ASSERT( ( nonzeros - ( nonzeros % 4UL ) ) == kend, "Invalid end calculation" );
453 
454  for( size_t k=0UL; k<kend; k+=4UL ) {
455  const size_t i1( element->index() );
456  const ET1 v1( element->value() );
457  ++element;
458  const size_t i2( element->index() );
459  const ET1 v2( element->value() );
460  ++element;
461  const size_t i3( element->index() );
462  const ET1 v3( element->value() );
463  ++element;
464  const size_t i4( element->index() );
465  const ET1 v4( element->value() );
466  ++element;
467 
468  for( size_t j=jj; j<jend; ++j ) {
469  C(i1,j) += v1 * B(i,j);
470  C(i2,j) += v2 * B(i,j);
471  C(i3,j) += v3 * B(i,j);
472  C(i4,j) += v4 * B(i,j);
473  }
474  }
475 
476  for( ; element!=end; ++element ) {
477  for( size_t j=jj; j<jend; ++j ) {
478  C(element->index(),j) += element->value() * B(i,j);
479  }
480  }
481  }
482  }
483  }
485  //**********************************************************************************************
486 
487  //**SMP assignment to dense matrices************************************************************
501  template< typename MT3 // Type of the left-hand side target matrix
502  , typename MT4 // Type of the left-hand side matrix operand
503  , typename MT5 > // Type of the right-hand side matrix operand
504  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
505  selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
506  {
507  smpAssign( C, A * B );
508  }
510  //**********************************************************************************************
511 
512  //**Assignment to sparse matrices***************************************************************
525  template< typename MT // Type of the target sparse matrix
526  , bool SO > // Storage order of the target sparse matrix
527  friend inline void assign( SparseMatrix<MT,SO>& lhs, const TSMatTDMatMultExpr& rhs )
528  {
530 
531  typedef typename SelectType< SO, ResultType, OppositeType >::Type TmpType;
532 
539 
540  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
541  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
542 
543  const TmpType tmp( rhs );
544  smpAssign( ~lhs, tmp );
545  }
547  //**********************************************************************************************
548 
549  //**Addition assignment to dense matrices*******************************************************
562  template< typename MT // Type of the target dense matrix
563  , bool SO > // Storage order of the target dense matrix
564  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const TSMatTDMatMultExpr& rhs )
565  {
567 
568  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
569  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
570 
571  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
572  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
573 
574  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
575  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
576  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
577  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
578  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
579  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
580 
581  TSMatTDMatMultExpr::selectAddAssignKernel( ~lhs, A, B );
582  }
584  //**********************************************************************************************
585 
586  //**Optimized addition assignment to dense matrices*********************************************
600  template< typename MT3 // Type of the left-hand side target matrix
601  , typename MT4 // Type of the left-hand side matrix operand
602  , typename MT5 > // Type of the right-hand side matrix operand
603  static inline typename DisableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
604  selectAddAssignKernel( MT3& C, const MT4& A, const MT5& B )
605  {
606  typedef typename MT4::ConstIterator ConstIterator;
607 
608  const size_t block( IsRowMajorMatrix<MT3>::value ? 128UL : 64UL );
609 
610  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
611  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
612  for( size_t i=0UL; i<A.columns(); ++i )
613  {
614  const ConstIterator end( A.end(i) );
615  ConstIterator element( A.begin(i) );
616 
617  const size_t nonzeros( A.nonZeros(i) );
618 
619  const size_t kend( nonzeros & size_t(-4) );
620  BLAZE_INTERNAL_ASSERT( ( nonzeros - ( nonzeros % 4UL ) ) == kend, "Invalid end calculation" );
621 
622  for( size_t k=0UL; k<kend; k+=4UL ) {
623  const size_t i1( element->index() );
624  const ET1 v1( element->value() );
625  ++element;
626  const size_t i2( element->index() );
627  const ET1 v2( element->value() );
628  ++element;
629  const size_t i3( element->index() );
630  const ET1 v3( element->value() );
631  ++element;
632  const size_t i4( element->index() );
633  const ET1 v4( element->value() );
634  ++element;
635 
636  for( size_t j=jj; j<jend; ++j ) {
637  C(i1,j) += v1 * B(i,j);
638  C(i2,j) += v2 * B(i,j);
639  C(i3,j) += v3 * B(i,j);
640  C(i4,j) += v4 * B(i,j);
641  }
642  }
643 
644  for( ; element!=end; ++element ) {
645  for( size_t j=jj; j<jend; ++j ) {
646  C(element->index(),j) += element->value() * B(i,j);
647  }
648  }
649  }
650  }
651  }
653  //**********************************************************************************************
654 
655  //**SMP addition assignment to dense matrices***************************************************
669  template< typename MT3 // Type of the left-hand side target matrix
670  , typename MT4 // Type of the left-hand side matrix operand
671  , typename MT5 > // Type of the right-hand side matrix operand
672  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
673  selectAddAssignKernel( MT3& C, const MT4& A, const MT5& B )
674  {
675  smpAddAssign( C, A * B );
676  }
678  //**********************************************************************************************
679 
680  //**Addition assignment to sparse matrices******************************************************
681  // No special implementation for the addition assignment to sparse matrices.
682  //**********************************************************************************************
683 
684  //**Subtraction assignment to dense matrices****************************************************
697  template< typename MT // Type of the target dense matrix
698  , bool SO > // Storage order of the target dense matrix
699  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const TSMatTDMatMultExpr& rhs )
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  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
707  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
708 
709  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
710  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
711  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
712  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
713  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
714  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
715 
716  TSMatTDMatMultExpr::selectSubAssignKernel( ~lhs, A, B );
717  }
719  //**********************************************************************************************
720 
721  //**Optimized subtraction assignment to dense matrices******************************************
735  template< typename MT3 // Type of the left-hand side target matrix
736  , typename MT4 // Type of the left-hand side matrix operand
737  , typename MT5 > // Type of the right-hand side matrix operand
738  static inline typename DisableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
739  selectSubAssignKernel( MT3& C, const MT4& A, const MT5& B )
740  {
741  typedef typename MT4::ConstIterator ConstIterator;
742 
743  const size_t block( IsRowMajorMatrix<MT3>::value ? 128UL : 64UL );
744 
745  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
746  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
747  for( size_t i=0UL; i<A.columns(); ++i )
748  {
749  const ConstIterator end( A.end(i) );
750  ConstIterator element( A.begin(i) );
751 
752  const size_t nonzeros( A.nonZeros(i) );
753 
754  const size_t kend( nonzeros & size_t(-4) );
755  BLAZE_INTERNAL_ASSERT( ( nonzeros - ( nonzeros % 4UL ) ) == kend, "Invalid end calculation" );
756 
757  for( size_t k=0UL; k<kend; k+=4UL ) {
758  const size_t i1( element->index() );
759  const ET1 v1( element->value() );
760  ++element;
761  const size_t i2( element->index() );
762  const ET1 v2( element->value() );
763  ++element;
764  const size_t i3( element->index() );
765  const ET1 v3( element->value() );
766  ++element;
767  const size_t i4( element->index() );
768  const ET1 v4( element->value() );
769  ++element;
770 
771  for( size_t j=jj; j<jend; ++j ) {
772  C(i1,j) -= v1 * B(i,j);
773  C(i2,j) -= v2 * B(i,j);
774  C(i3,j) -= v3 * B(i,j);
775  C(i4,j) -= v4 * B(i,j);
776  }
777  }
778 
779  for( ; element!=end; ++element ) {
780  for( size_t j=jj; j<jend; ++j ) {
781  C(element->index(),j) -= element->value() * B(i,j);
782  }
783  }
784  }
785  }
786  }
788  //**********************************************************************************************
789 
790  //**SMP subtraction assignment to dense matrices************************************************
804  template< typename MT3 // Type of the left-hand side target matrix
805  , typename MT4 // Type of the left-hand side matrix operand
806  , typename MT5 > // Type of the right-hand side matrix operand
807  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
808  selectSubAssignKernel( MT3& C, const MT4& A, const MT5& B )
809  {
810  smpSubAssign( C, A * B );
811  }
813  //**********************************************************************************************
814 
815  //**Subtraction assignment to sparse matrices***************************************************
816  // No special implementation for the subtraction assignment to sparse matrices.
817  //**********************************************************************************************
818 
819  //**Multiplication assignment to dense matrices*************************************************
820  // No special implementation for the multiplication assignment to dense matrices.
821  //**********************************************************************************************
822 
823  //**Multiplication assignment to sparse matrices************************************************
824  // No special implementation for the multiplication assignment to sparse matrices.
825  //**********************************************************************************************
826 
827  //**Compile time checks*************************************************************************
834  //**********************************************************************************************
835 };
836 //*************************************************************************************************
837 
838 
839 
840 
841 //=================================================================================================
842 //
843 // GLOBAL BINARY ARITHMETIC OPERATORS
844 //
845 //=================================================================================================
846 
847 //*************************************************************************************************
876 template< typename T1 // Type of the left-hand side sparse matrix
877  , typename T2 > // Type of the right-hand side dense matrix
878 inline const TSMatTDMatMultExpr<T1,T2>
880 {
882 
883  if( (~lhs).columns() != (~rhs).rows() )
884  throw std::invalid_argument( "Matrix sizes do not match" );
885 
886  return TSMatTDMatMultExpr<T1,T2>( ~lhs, ~rhs );
887 }
888 //*************************************************************************************************
889 
890 
891 
892 
893 //=================================================================================================
894 //
895 // EXPRESSION TRAIT SPECIALIZATIONS
896 //
897 //=================================================================================================
898 
899 //*************************************************************************************************
901 template< typename MT1, typename MT2, typename VT >
902 struct TDMatDVecMultExprTrait< TSMatTDMatMultExpr<MT1,MT2>, VT >
903 {
904  public:
905  //**********************************************************************************************
906  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
907  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
908  IsDenseVector<VT>::value && IsColumnVector<VT>::value
909  , typename TSMatDVecMultExprTrait< MT1, typename TDMatDVecMultExprTrait<MT2,VT>::Type >::Type
910  , INVALID_TYPE >::Type Type;
911  //**********************************************************************************************
912 };
914 //*************************************************************************************************
915 
916 
917 //*************************************************************************************************
919 template< typename MT1, typename MT2, typename VT >
920 struct TDMatSVecMultExprTrait< TSMatTDMatMultExpr<MT1,MT2>, VT >
921 {
922  public:
923  //**********************************************************************************************
924  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
925  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
926  IsSparseVector<VT>::value && IsColumnVector<VT>::value
927  , typename TSMatDVecMultExprTrait< MT1, typename TDMatSVecMultExprTrait<MT2,VT>::Type >::Type
928  , INVALID_TYPE >::Type Type;
929  //**********************************************************************************************
930 };
932 //*************************************************************************************************
933 
934 
935 //*************************************************************************************************
937 template< typename VT, typename MT1, typename MT2 >
938 struct TDVecTDMatMultExprTrait< VT, TSMatTDMatMultExpr<MT1,MT2> >
939 {
940  public:
941  //**********************************************************************************************
942  typedef typename SelectType< IsDenseVector<VT>::value && IsRowVector<VT>::value &&
943  IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
944  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
945  , typename TDVecTDMatMultExprTrait< typename TDVecTSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
946  , INVALID_TYPE >::Type Type;
947  //**********************************************************************************************
948 };
950 //*************************************************************************************************
951 
952 
953 //*************************************************************************************************
955 template< typename VT, typename MT1, typename MT2 >
956 struct TSVecTDMatMultExprTrait< VT, TSMatTDMatMultExpr<MT1,MT2> >
957 {
958  public:
959  //**********************************************************************************************
960  typedef typename SelectType< IsSparseVector<VT>::value && IsRowVector<VT>::value &&
961  IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
962  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
963  , typename TSVecTDMatMultExprTrait< typename TSVecTSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
964  , INVALID_TYPE >::Type Type;
965  //**********************************************************************************************
966 };
968 //*************************************************************************************************
969 
970 
971 //*************************************************************************************************
973 template< typename MT1, typename MT2, bool AF >
974 struct SubmatrixExprTrait< TSMatTDMatMultExpr<MT1,MT2>, AF >
975 {
976  public:
977  //**********************************************************************************************
978  typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
979  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
980  //**********************************************************************************************
981 };
983 //*************************************************************************************************
984 
985 
986 //*************************************************************************************************
988 template< typename MT1, typename MT2 >
989 struct RowExprTrait< TSMatTDMatMultExpr<MT1,MT2> >
990 {
991  public:
992  //**********************************************************************************************
993  typedef typename MultExprTrait< typename RowExprTrait<const MT1>::Type, MT2 >::Type Type;
994  //**********************************************************************************************
995 };
997 //*************************************************************************************************
998 
999 
1000 //*************************************************************************************************
1002 template< typename MT1, typename MT2 >
1003 struct ColumnExprTrait< TSMatTDMatMultExpr<MT1,MT2> >
1004 {
1005  public:
1006  //**********************************************************************************************
1007  typedef typename MultExprTrait< MT1, typename ColumnExprTrait<const MT2>::Type >::Type Type;
1008  //**********************************************************************************************
1009 };
1011 //*************************************************************************************************
1012 
1013 } // namespace blaze
1014 
1015 #endif
size_t columns() const
Returns the current number of columns of the matrix.
Definition: TSMatTDMatMultExpr.h:254
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:89
size_t rows() const
Returns the current number of rows of the matrix.
Definition: TSMatTDMatMultExpr.h:244
void reset(DynamicMatrix< Type, SO > &m)
Resetting the given dense matrix.
Definition: DynamicMatrix.h:4579
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
Expression object for transpose sparse matrix-transpose dense matrix multiplications.The TSMatTDMatMultExpr class represents the compile time expression for multiplications between a column-major sparse matrix and a column-major dense matrix.
Definition: Forward.h:139
TSMatTDMatMultExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the TSMatTDMatMultExpr class.
Definition: TSMatTDMatMultExpr.h:204
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
#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.
LeftOperand leftOperand() const
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatTDMatMultExpr.h:264
Header file for the IsColumnMajorMatrix type trait.
Header file for the TSVecTSMatMultExprTrait class template.
Header file for the sparse matrix SMP implementation.
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
TSMatTDMatMultExpr< MT1, MT2 > This
Type of this TSMatTDMatMultExpr instance.
Definition: TSMatTDMatMultExpr.h:169
Header file for the Computation base class.
Header file for the MatMatMultExpr base class.
MultTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: TSMatTDMatMultExpr.h:170
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
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatTDMatMultExpr.h:171
SelectType< evaluateRight, const RT2, CT2 >::Type RT
Type for the assignment of the right-hand side dense matrix operand.
Definition: TSMatTDMatMultExpr.h:187
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSMatTDMatMultExpr.h:174
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatTDMatMultExpr.h:110
Constraint on the data type.
Constraint on the data type.
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
RT1::ElementType ET1
Element type of the left-hand side dense matrix expression.
Definition: TSMatTDMatMultExpr.h:112
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.
#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
Header file for the TSVecTDMatMultExprTrait class template.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2388
Header file for the TDMatSVecMultExprTrait class template.
Header file for the TDVecTSMatMultExprTrait class template.
Header file for the dense matrix SMP implementation.
Header file for the DenseMatrix base class.
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
SelectType< evaluateLeft, const RT1, CT1 >::Type LT
Type for the assignment of the left-hand side sparse matrix operand.
Definition: TSMatTDMatMultExpr.h:184
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TSMatTDMatMultExpr.h:286
#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
ResultType::ElementType ElementType
Resulting element type.
Definition: TSMatTDMatMultExpr.h:173
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: TSMatTDMatMultExpr.h:111
RightOperand rhs_
Right-hand side dense matrix of the multiplication expression.
Definition: TSMatTDMatMultExpr.h:326
Constraints on the storage order of matrix types.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2382
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.
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTDMatMultExpr.h:114
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTDMatMultExpr.h:178
Header file for the EnableIf class template.
RightOperand rightOperand() const
Returns the right-hand side transpose dense matrix operand.
Definition: TSMatTDMatMultExpr.h:274
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
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
MT2::CompositeType CT2
Composite type of the right-hand side dense matrix expression.
Definition: TSMatTDMatMultExpr.h:115
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatTDMatMultExpr.h:219
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
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
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
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: TSMatTDMatMultExpr.h:318
Header file for the RemoveReference type trait.
#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.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TSMatTDMatMultExpr.h:298
RT2::ElementType ET2
Element type of the right-hand side sparse matrix expression.
Definition: TSMatTDMatMultExpr.h:113
const size_t SMP_TSMATTDMATMULT_THRESHOLD
SMP column-major sparse matrix/column-major dense matrix multiplication threshold.This threshold represents the system-specific threshold for a parallel column-major sparse matrix/column-major dense matrix multiplication. In case the number of rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded.
Definition: Thresholds.h:576
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatTDMatMultExpr.h:175
Header file for the IsComputation type trait class.
Header file for the TDMatDVecMultExprTrait class template.
#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.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TSMatTDMatMultExpr.h:172
Header file for the IsColumnVector type trait.
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side dense matrix expression.
Definition: TSMatTDMatMultExpr.h:181
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: TSMatTDMatMultExpr.h:308
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
Header file for the TDVecTDMatMultExprTrait class template.
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type...
Definition: SparseMatrix.h:79
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
LeftOperand lhs_
Left-hand side sparse matrix of the multiplication expression.
Definition: TSMatTDMatMultExpr.h:325