All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TSMatDMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATDMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATDMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
51 #include <blaze/math/shims/Reset.h>
82 #include <blaze/util/Assert.h>
83 #include <blaze/util/DisableIf.h>
84 #include <blaze/util/EnableIf.h>
85 #include <blaze/util/InvalidType.h>
87 #include <blaze/util/SelectType.h>
88 #include <blaze/util/Types.h>
90 
91 
92 namespace blaze {
93 
94 //=================================================================================================
95 //
96 // CLASS SMATDMATMULTEXPR
97 //
98 //=================================================================================================
99 
100 //*************************************************************************************************
107 template< typename MT1 // Type of the left-hand side dense matrix
108  , typename MT2 > // Type of the right-hand side sparse matrix
109 class TSMatDMatMultExpr : public DenseMatrix< TSMatDMatMultExpr<MT1,MT2>, true >
110  , private MatMatMultExpr
111  , private Computation
112 {
113  private:
114  //**Type definitions****************************************************************************
115  typedef typename MT1::ResultType RT1;
116  typedef typename MT2::ResultType RT2;
117  typedef typename RT1::ElementType ET1;
118  typedef typename RT2::ElementType ET2;
119  typedef typename MT1::CompositeType CT1;
120  typedef typename MT2::CompositeType CT2;
121  //**********************************************************************************************
122 
123  //**********************************************************************************************
126  //**********************************************************************************************
127 
128  //**********************************************************************************************
130  enum { evaluateRight = IsComputation<MT2>::value || RequiresEvaluation<MT2>::value };
131  //**********************************************************************************************
132 
133  //**********************************************************************************************
135 
138  template< typename T1, typename T2, typename T3 >
139  struct UseSMPAssignKernel {
140  enum { value = evaluateLeft || evaluateRight };
141  };
143  //**********************************************************************************************
144 
145  //**********************************************************************************************
147 
151  template< typename T1, typename T2, typename T3 >
152  struct UseOptimizedKernel {
153  enum { value = !UseSMPAssignKernel<T1,T2,T3>::value &&
154  !IsResizable<typename T1::ElementType>::value };
155  };
157  //**********************************************************************************************
158 
159  //**********************************************************************************************
161 
164  template< typename T1, typename T2, typename T3 >
165  struct UseDefaultKernel {
166  enum { value = !UseSMPAssignKernel<T1,T2,T3>::value &&
167  !UseOptimizedKernel<T1,T2,T3>::value };
168  };
170  //**********************************************************************************************
171 
172  public:
173  //**Type definitions****************************************************************************
179  typedef const ElementType ReturnType;
180  typedef const ResultType CompositeType;
181 
183  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
184 
186  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
187 
190 
193  //**********************************************************************************************
194 
195  //**Compilation flags***************************************************************************
197  enum { vectorizable = 0 };
198 
200  enum { smpAssignable = !evaluateLeft && !evaluateRight };
201  //**********************************************************************************************
202 
203  //**Constructor*********************************************************************************
209  explicit inline TSMatDMatMultExpr( const MT1& lhs, const MT2& rhs )
210  : lhs_( lhs ) // Left-hand side sparse matrix of the multiplication expression
211  , rhs_( rhs ) // Right-hand side dense matrix of the multiplication expression
212  {
213  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.rows(), "Invalid matrix sizes" );
214  }
215  //**********************************************************************************************
216 
217  //**Access operator*****************************************************************************
224  inline ReturnType operator()( size_t i, size_t j ) const {
225  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
226  BLAZE_INTERNAL_ASSERT( j < rhs_.columns(), "Invalid column access index" );
227 
228  ElementType tmp;
229 
230  if( lhs_.columns() != 0UL ) {
231  tmp = lhs_(i,0UL) * rhs_(0UL,j);
232  for( size_t k=1UL; k<lhs_.columns(); ++k ) {
233  tmp += lhs_(i,k) * rhs_(k,j);
234  }
235  }
236  else {
237  reset( tmp );
238  }
239 
240  return tmp;
241  }
242  //**********************************************************************************************
243 
244  //**Rows function*******************************************************************************
249  inline size_t rows() const {
250  return lhs_.rows();
251  }
252  //**********************************************************************************************
253 
254  //**Columns function****************************************************************************
259  inline size_t columns() const {
260  return rhs_.columns();
261  }
262  //**********************************************************************************************
263 
264  //**Left operand access*************************************************************************
269  inline LeftOperand leftOperand() const {
270  return lhs_;
271  }
272  //**********************************************************************************************
273 
274  //**Right operand access************************************************************************
279  inline RightOperand rightOperand() const {
280  return rhs_;
281  }
282  //**********************************************************************************************
283 
284  //**********************************************************************************************
290  template< typename T >
291  inline bool canAlias( const T* alias ) const {
292  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
293  }
294  //**********************************************************************************************
295 
296  //**********************************************************************************************
302  template< typename T >
303  inline bool isAliased( const T* alias ) const {
304  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
305  }
306  //**********************************************************************************************
307 
308  //**********************************************************************************************
313  inline bool isAligned() const {
314  return rhs_.isAligned();
315  }
316  //**********************************************************************************************
317 
318  //**********************************************************************************************
323  inline bool canSMPAssign() const {
324  return ( columns() > SMP_TSMATDMATMULT_THRESHOLD );
325  }
326  //**********************************************************************************************
327 
328  private:
329  //**Member variables****************************************************************************
332  //**********************************************************************************************
333 
334  //**Assignment to dense matrices****************************************************************
347  template< typename MT // Type of the target dense matrix
348  , bool SO > // Storage order of the target dense matrix
349  friend inline void assign( DenseMatrix<MT,SO>& lhs, const TSMatDMatMultExpr& rhs )
350  {
352 
353  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
354  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
355 
356  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
357  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
358 
359  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
360  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
361  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
362  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
363  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
364  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
365 
366  TSMatDMatMultExpr::selectAssignKernel( ~lhs, A, B );
367  }
369  //**********************************************************************************************
370 
371  //**Default assignment to dense matrices********************************************************
386  template< typename MT3 // Type of the left-hand side target matrix
387  , typename MT4 // Type of the left-hand side matrix operand
388  , typename MT5 > // Type of the right-hand side matrix operand
389  static inline typename EnableIf< UseDefaultKernel<MT3,MT4,MT5> >::Type
390  selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
391  {
392  typedef typename MT4::ConstIterator ConstIterator;
393 
394  reset( C );
395 
396  const size_t block( IsRowMajorMatrix<MT3>::value ? 256UL : 8UL );
397 
398  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
399  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
400  for( size_t i=0UL; i<A.columns(); ++i ) {
401  const ConstIterator end( A.end(i) );
402  ConstIterator element( A.begin(i) );
403  for( ; element!=end; ++element ) {
404  for( size_t j=jj; j<jend; ++j ) {
405  if( isDefault( C(element->index(),j) ) )
406  C(element->index(),j) = element->value() * B(i,j);
407  else
408  C(element->index(),j) += element->value() * B(i,j);
409  }
410  }
411  }
412  }
413  }
415  //**********************************************************************************************
416 
417  //**Optimized assignment to dense matrices******************************************************
432  template< typename MT3 // Type of the left-hand side target matrix
433  , typename MT4 // Type of the left-hand side matrix operand
434  , typename MT5 > // Type of the right-hand side matrix operand
435  static inline typename EnableIf< UseOptimizedKernel<MT3,MT4,MT5> >::Type
436  selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
437  {
438  typedef typename MT4::ConstIterator ConstIterator;
439 
440  const size_t block( IsRowMajorMatrix<MT3>::value ? 256UL : 8UL );
441 
442  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
443  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
444  for( size_t i=0UL; i<A.rows(); ++i ) {
445  for( size_t j=jj; j<jend; ++j ) {
446  reset( C(i,j) );
447  }
448  }
449  for( size_t i=0UL; i<A.columns(); ++i )
450  {
451  const ConstIterator end( A.end(i) );
452  ConstIterator element( A.begin(i) );
453 
454  const size_t nonzeros( A.nonZeros(i) );
455 
456  const size_t kend( nonzeros & size_t(-4) );
457  BLAZE_INTERNAL_ASSERT( ( nonzeros - ( nonzeros % 4UL ) ) == kend, "Invalid end calculation" );
458 
459  for( size_t k=0UL; k<kend; k+=4UL ) {
460  const size_t i1( element->index() );
461  const ET1 v1( element->value() );
462  ++element;
463  const size_t i2( element->index() );
464  const ET1 v2( element->value() );
465  ++element;
466  const size_t i3( element->index() );
467  const ET1 v3( element->value() );
468  ++element;
469  const size_t i4( element->index() );
470  const ET1 v4( element->value() );
471  ++element;
472 
473  for( size_t j=jj; j<jend; ++j ) {
474  C(i1,j) += v1 * B(i,j);
475  C(i2,j) += v2 * B(i,j);
476  C(i3,j) += v3 * B(i,j);
477  C(i4,j) += v4 * B(i,j);
478  }
479  }
480 
481  for( ; element!=end; ++element ) {
482  for( size_t j=jj; j<jend; ++j ) {
483  C(element->index(),j) += element->value() * B(i,j);
484  }
485  }
486  }
487  }
488  }
490  //**********************************************************************************************
491 
492  //**SMP assignment to dense matrices************************************************************
506  template< typename MT3 // Type of the left-hand side target matrix
507  , typename MT4 // Type of the left-hand side matrix operand
508  , typename MT5 > // Type of the right-hand side matrix operand
509  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
510  selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
511  {
512  smpAssign( C, A * B );
513  }
515  //**********************************************************************************************
516 
517  //**Assignment to sparse matrices***************************************************************
530  template< typename MT // Type of the target sparse matrix
531  , bool SO > // Storage order of the target sparse matrix
532  friend inline void assign( SparseMatrix<MT,SO>& lhs, const TSMatDMatMultExpr& rhs )
533  {
535 
536  typedef typename SelectType< SO, ResultType, OppositeType >::Type TmpType;
537 
544 
545  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
546  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
547 
548  const TmpType tmp( rhs );
549  smpAssign( ~lhs, tmp );
550  }
552  //**********************************************************************************************
553 
554  //**Addition assignment to dense matrices*******************************************************
567  template< typename MT // Type of the target dense matrix
568  , bool SO > // Storage order of the target dense matrix
569  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const TSMatDMatMultExpr& rhs )
570  {
572 
573  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
574  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
575 
576  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
577  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
578 
579  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
580  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
581  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
582  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
583  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
584  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
585 
586  TSMatDMatMultExpr::selectAddAssignKernel( ~lhs, A, B );
587  }
589  //**********************************************************************************************
590 
591  //**Optimized addition assignment to dense matrices*********************************************
605  template< typename MT3 // Type of the left-hand side target matrix
606  , typename MT4 // Type of the left-hand side matrix operand
607  , typename MT5 > // Type of the right-hand side matrix operand
608  static inline typename DisableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
609  selectAddAssignKernel( MT3& C, const MT4& A, const MT5& B )
610  {
611  typedef typename MT4::ConstIterator ConstIterator;
612 
613  const size_t block( IsRowMajorMatrix<MT3>::value ? 256UL : 8UL );
614 
615  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
616  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
617  for( size_t i=0UL; i<A.columns(); ++i )
618  {
619  const ConstIterator end( A.end(i) );
620  ConstIterator element( A.begin(i) );
621 
622  const size_t nonzeros( A.nonZeros(i) );
623 
624  const size_t kend( nonzeros & size_t(-4) );
625  BLAZE_INTERNAL_ASSERT( ( nonzeros - ( nonzeros % 4UL ) ) == kend, "Invalid end calculation" );
626 
627  for( size_t k=0UL; k<kend; k+=4UL ) {
628  const size_t i1( element->index() );
629  const ET1 v1( element->value() );
630  ++element;
631  const size_t i2( element->index() );
632  const ET1 v2( element->value() );
633  ++element;
634  const size_t i3( element->index() );
635  const ET1 v3( element->value() );
636  ++element;
637  const size_t i4( element->index() );
638  const ET1 v4( element->value() );
639  ++element;
640 
641  for( size_t j=jj; j<jend; ++j ) {
642  C(i1,j) += v1 * B(i,j);
643  C(i2,j) += v2 * B(i,j);
644  C(i3,j) += v3 * B(i,j);
645  C(i4,j) += v4 * B(i,j);
646  }
647  }
648 
649  for( ; element!=end; ++element ) {
650  for( size_t j=jj; j<jend; ++j ) {
651  C(element->index(),j) += element->value() * B(i,j);
652  }
653  }
654  }
655  }
656  }
658  //**********************************************************************************************
659 
660  //**SMP addition assignment to dense matrices***************************************************
674  template< typename MT3 // Type of the left-hand side target matrix
675  , typename MT4 // Type of the left-hand side matrix operand
676  , typename MT5 > // Type of the right-hand side matrix operand
677  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
678  selectAddAssignKernel( MT3& C, const MT4& A, const MT5& B )
679  {
680  smpAddAssign( C, A * B );
681  }
683  //**********************************************************************************************
684 
685  //**Addition assignment to sparse matrices******************************************************
686  // No special implementation for the addition assignment to sparse matrices.
687  //**********************************************************************************************
688 
689  //**Subtraction assignment to dense matrices****************************************************
702  template< typename MT // Type of the target dense matrix
703  , bool SO > // Storage order of the target dense matrix
704  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const TSMatDMatMultExpr& rhs )
705  {
707 
708  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
709  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
710 
711  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
712  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
713 
714  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
715  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
716  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
717  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
718  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
719  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
720 
721  TSMatDMatMultExpr::selectSubAssignKernel( ~lhs, A, B );
722  }
724  //**********************************************************************************************
725 
726  //**Optimized subtraction assignment to dense matrices******************************************
740  template< typename MT3 // Type of the left-hand side target matrix
741  , typename MT4 // Type of the left-hand side matrix operand
742  , typename MT5 > // Type of the right-hand side matrix operand
743  static inline typename DisableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
744  selectSubAssignKernel( MT3& C, const MT4& A, const MT5& B )
745  {
746  typedef typename MT4::ConstIterator ConstIterator;
747 
748  const size_t block( IsRowMajorMatrix<MT3>::value ? 256UL : 8UL );
749 
750  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
751  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
752  for( size_t i=0UL; i<A.columns(); ++i )
753  {
754  const ConstIterator end( A.end(i) );
755  ConstIterator element( A.begin(i) );
756 
757  const size_t nonzeros( A.nonZeros(i) );
758 
759  const size_t kend( nonzeros & size_t(-4) );
760  BLAZE_INTERNAL_ASSERT( ( nonzeros - ( nonzeros % 4UL ) ) == kend, "Invalid end calculation" );
761 
762  for( size_t k=0UL; k<kend; k+=4UL ) {
763  const size_t i1( element->index() );
764  const ET1 v1( element->value() );
765  ++element;
766  const size_t i2( element->index() );
767  const ET1 v2( element->value() );
768  ++element;
769  const size_t i3( element->index() );
770  const ET1 v3( element->value() );
771  ++element;
772  const size_t i4( element->index() );
773  const ET1 v4( element->value() );
774  ++element;
775 
776  for( size_t j=jj; j<jend; ++j ) {
777  C(i1,j) -= v1 * B(i,j);
778  C(i2,j) -= v2 * B(i,j);
779  C(i3,j) -= v3 * B(i,j);
780  C(i4,j) -= v4 * B(i,j);
781  }
782  }
783 
784  for( ; element!=end; ++element ) {
785  for( size_t j=jj; j<jend; ++j ) {
786  C(element->index(),j) -= element->value() * B(i,j);
787  }
788  }
789  }
790  }
791  }
793  //**********************************************************************************************
794 
795  //**SMP subtraction assignment to dense matrices************************************************
809  template< typename MT3 // Type of the left-hand side target matrix
810  , typename MT4 // Type of the left-hand side matrix operand
811  , typename MT5 > // Type of the right-hand side matrix operand
812  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
813  selectSubAssignKernel( MT3& C, const MT4& A, const MT5& B )
814  {
815  smpSubAssign( C, A * B );
816  }
818  //**********************************************************************************************
819 
820  //**Subtraction assignment to sparse matrices***************************************************
821  // No special implementation for the subtraction assignment to sparse matrices.
822  //**********************************************************************************************
823 
824  //**Multiplication assignment to dense matrices*************************************************
825  // No special implementation for the multiplication assignment to dense matrices.
826  //**********************************************************************************************
827 
828  //**Multiplication assignment to sparse matrices************************************************
829  // No special implementation for the multiplication assignment to sparse matrices.
830  //**********************************************************************************************
831 
832  //**Compile time checks*************************************************************************
839  //**********************************************************************************************
840 };
841 //*************************************************************************************************
842 
843 
844 
845 
846 //=================================================================================================
847 //
848 // GLOBAL BINARY ARITHMETIC OPERATORS
849 //
850 //=================================================================================================
851 
852 //*************************************************************************************************
883 template< typename T1 // Type of the left-hand side sparse matrix
884  , typename T2 > // Type of the right-hand side dense matrix
885 inline const TSMatDMatMultExpr<T1,T2>
887 {
889 
890  if( (~lhs).columns() != (~rhs).rows() )
891  throw std::invalid_argument( "Matrix sizes do not match" );
892 
893  return TSMatDMatMultExpr<T1,T2>( ~lhs, ~rhs );
894 }
895 //*************************************************************************************************
896 
897 
898 
899 
900 //=================================================================================================
901 //
902 // EXPRESSION TRAIT SPECIALIZATIONS
903 //
904 //=================================================================================================
905 
906 //*************************************************************************************************
908 template< typename MT1, typename MT2, typename VT >
909 struct TDMatDVecMultExprTrait< TSMatDMatMultExpr<MT1,MT2>, VT >
910 {
911  public:
912  //**********************************************************************************************
913  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
914  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
915  IsDenseVector<VT>::value && IsColumnVector<VT>::value
916  , typename TSMatDVecMultExprTrait< MT1, typename DMatDVecMultExprTrait<MT2,VT>::Type >::Type
917  , INVALID_TYPE >::Type Type;
918  //**********************************************************************************************
919 };
921 //*************************************************************************************************
922 
923 
924 //*************************************************************************************************
926 template< typename MT1, typename MT2, typename VT >
927 struct TDMatSVecMultExprTrait< TSMatDMatMultExpr<MT1,MT2>, VT >
928 {
929  public:
930  //**********************************************************************************************
931  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
932  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
933  IsSparseVector<VT>::value && IsColumnVector<VT>::value
934  , typename TSMatDVecMultExprTrait< MT1, typename DMatSVecMultExprTrait<MT2,VT>::Type >::Type
935  , INVALID_TYPE >::Type Type;
936  //**********************************************************************************************
937 };
939 //*************************************************************************************************
940 
941 
942 //*************************************************************************************************
944 template< typename VT, typename MT1, typename MT2 >
945 struct TDVecTDMatMultExprTrait< VT, TSMatDMatMultExpr<MT1,MT2> >
946 {
947  public:
948  //**********************************************************************************************
949  typedef typename SelectType< IsDenseVector<VT>::value && IsRowVector<VT>::value &&
950  IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
951  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value
952  , typename TDVecDMatMultExprTrait< typename TDVecTSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
953  , INVALID_TYPE >::Type Type;
954  //**********************************************************************************************
955 };
957 //*************************************************************************************************
958 
959 
960 //*************************************************************************************************
962 template< typename VT, typename MT1, typename MT2 >
963 struct TSVecTDMatMultExprTrait< VT, TSMatDMatMultExpr<MT1,MT2> >
964 {
965  public:
966  //**********************************************************************************************
967  typedef typename SelectType< IsSparseVector<VT>::value && IsRowVector<VT>::value &&
968  IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
969  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value
970  , typename TDVecDMatMultExprTrait< typename TDVecTSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
971  , INVALID_TYPE >::Type Type;
972  //**********************************************************************************************
973 };
975 //*************************************************************************************************
976 
977 
978 //*************************************************************************************************
980 template< typename MT1, typename MT2, bool AF >
981 struct SubmatrixExprTrait< TSMatDMatMultExpr<MT1,MT2>, AF >
982 {
983  public:
984  //**********************************************************************************************
985  typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
986  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
987  //**********************************************************************************************
988 };
990 //*************************************************************************************************
991 
992 
993 //*************************************************************************************************
995 template< typename MT1, typename MT2 >
996 struct RowExprTrait< TSMatDMatMultExpr<MT1,MT2> >
997 {
998  public:
999  //**********************************************************************************************
1000  typedef typename MultExprTrait< typename RowExprTrait<const MT1>::Type, MT2 >::Type Type;
1001  //**********************************************************************************************
1002 };
1004 //*************************************************************************************************
1005 
1006 
1007 //*************************************************************************************************
1009 template< typename MT1, typename MT2 >
1010 struct ColumnExprTrait< TSMatDMatMultExpr<MT1,MT2> >
1011 {
1012  public:
1013  //**********************************************************************************************
1014  typedef typename MultExprTrait< MT1, typename ColumnExprTrait<const MT2>::Type >::Type Type;
1015  //**********************************************************************************************
1016 };
1018 //*************************************************************************************************
1019 
1020 } // namespace blaze
1021 
1022 #endif
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:89
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatDMatMultExpr.h:176
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
MultTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: TSMatDMatMultExpr.h:175
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.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: TSMatDMatMultExpr.h:259
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TSMatDMatMultExpr.h:291
TSMatDMatMultExpr< MT1, MT2 > This
Type of this TSMatDMatMultExpr instance.
Definition: TSMatDMatMultExpr.h:174
Header file for the IsColumnMajorMatrix type trait.
Header file for the TSVecTSMatMultExprTrait class template.
Header file for the sparse matrix SMP implementation.
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: TSMatDMatMultExpr.h:313
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
LeftOperand leftOperand() const
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatDMatMultExpr.h:269
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TSMatDMatMultExpr.h:177
Header file for the Computation base class.
Header file for the MatMatMultExpr base class.
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDMatMultExpr.h:119
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
LeftOperand lhs_
Left-hand side sparse matrix of the multiplication expression.
Definition: TSMatDMatMultExpr.h:330
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TSMatDMatMultExpr.h:303
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
SelectType< evaluateLeft, const RT1, CT1 >::Type LT
Type for the assignment of the left-hand side sparse matrix operand.
Definition: TSMatDMatMultExpr.h:189
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.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: TSMatDMatMultExpr.h:323
RT2::ElementType ET2
Element type of the right-hand side sparse matrix expression.
Definition: TSMatDMatMultExpr.h:118
Header file for the multiplication trait.
RightOperand rhs_
Right-hand side dense matrix of the multiplication expression.
Definition: TSMatDMatMultExpr.h:331
MT2::CompositeType CT2
Composite type of the right-hand side dense matrix expression.
Definition: TSMatDMatMultExpr.h:120
Compile time check for row-major matrix types.This type trait tests whether or not the given template...
Definition: IsRowMajorMatrix.h:104
#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
RightOperand rightOperand() const
Returns the right-hand side dense matrix operand.
Definition: TSMatDMatMultExpr.h:279
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.
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatDMatMultExpr.h:115
Header file for the DenseMatrix base class.
Header file for the TSMatDVecMultExprTrait class template.
TSMatDMatMultExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the TSMatDMatMultExpr class.
Definition: TSMatDMatMultExpr.h:209
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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatDMatMultExpr.h:224
SelectType< evaluateRight, const RT2, CT2 >::Type RT
Type for the assignment of the right-hand side dense matrix operand.
Definition: TSMatDMatMultExpr.h:192
Header file for the DMatDVecMultExprTrait class template.
#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
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: TSMatDMatMultExpr.h:116
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side dense matrix expression.
Definition: TSMatDMatMultExpr.h:186
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.
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDMatMultExpr.h:183
Header file for the IsDenseMatrix type trait.
Header file for the EnableIf class template.
RT1::ElementType ET1
Element type of the left-hand side dense matrix expression.
Definition: TSMatDMatMultExpr.h:117
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
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatDMatMultExpr.h:180
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
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSMatDMatMultExpr.h:179
Header file for run time assertion macros.
Utility type for generic codes.
Base template for the MultTrait class.
Definition: MultTrait.h:141
void addAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the addition assignment of a matrix to a matrix.
Definition: Matrix.h:209
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
const size_t SMP_TSMATDMATMULT_THRESHOLD
SMP column-major sparse matrix/row-major dense matrix multiplication threshold.This threshold represe...
Definition: Thresholds.h:563
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.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: TSMatDMatMultExpr.h:249
Header file for the IsRowMajorMatrix type trait.
Header file for the IsComputation type trait class.
Expression object for transpose sparse matrix-dense matrix multiplications.The TSMatDMatMultExpr clas...
Definition: Forward.h:133
Header file for the TDVecDMatMultExprTrait class template.
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
ResultType::ElementType ElementType
Resulting element type.
Definition: TSMatDMatMultExpr.h:178
size_t columns(const Matrix< MT, SO > &m)
Returns the current number of columns of the matrix.
Definition: Matrix.h:154
Header file for basic type definitions.
Header file for the TSVecDMatMultExprTrait class template.
Header file for the DMatSVecMultExprTrait class template.
Header file for the IsColumnVector type trait.
Header file for the IsResizable type trait.
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
size_t rows(const Matrix< MT, SO > &m)
Returns the current number of rows of the matrix.
Definition: Matrix.h:138
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
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.