All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SMatTDMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATTDMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATTDMATMULTEXPR_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 SMATTDMATMULTEXPR
97 //
98 //=================================================================================================
99 
100 //*************************************************************************************************
107 template< typename MT1 // Type of the left-hand side sparse matrix
108  , typename MT2 > // Type of the right-hand side dense matrix
109 class SMatTDMatMultExpr : public DenseMatrix< SMatTDMatMultExpr<MT1,MT2>, false >
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  public:
146  //**Type definitions****************************************************************************
152  typedef const ElementType ReturnType;
153  typedef const ResultType CompositeType;
154 
156  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
157 
159  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
160 
163 
166  //**********************************************************************************************
167 
168  //**Compilation flags***************************************************************************
170  enum { vectorizable = 0 };
171 
173  enum { smpAssignable = !evaluateLeft && !evaluateRight };
174  //**********************************************************************************************
175 
176  //**Constructor*********************************************************************************
182  explicit inline SMatTDMatMultExpr( const MT1& lhs, const MT2& rhs )
183  : lhs_( lhs ) // Left-hand side sparse matrix of the multiplication expression
184  , rhs_( rhs ) // Right-hand side dense matrix of the multiplication expression
185  {
186  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.rows(), "Invalid matrix sizes" );
187  }
188  //**********************************************************************************************
189 
190  //**Access operator*****************************************************************************
197  inline ReturnType operator()( size_t i, size_t j ) const {
198  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
199  BLAZE_INTERNAL_ASSERT( j < rhs_.columns(), "Invalid column access index" );
200 
202 
203  ElementType tmp = ElementType();
204 
205  // Early exit
206  if( lhs_.columns() == 0UL )
207  return tmp;
208 
209  // Fast computation in case the left-hand side sparse matrix directly provides iterators
211  {
212  // Evaluation of the left-hand side sparse matrix operand
213  CT1 A( lhs_ );
214 
215  const ConstIterator end( A.end(i) );
216  ConstIterator element( A.begin(i) );
217 
218  // Early exit in case row i is empty
219  if( element == end )
220  return tmp;
221 
222  // Calculating element (i,j)
223  tmp = element->value() * rhs_(element->index(),j);
224  ++element;
225  for( ; element!=end; ++element )
226  tmp += element->value() * rhs_(element->index(),j);
227  }
228 
229  // Default computation in case the left-hand side sparse matrix doesn't provide iterators
230  else {
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 
237  return tmp;
238  }
239  //**********************************************************************************************
240 
241  //**Rows function*******************************************************************************
246  inline size_t rows() const {
247  return lhs_.rows();
248  }
249  //**********************************************************************************************
250 
251  //**Columns function****************************************************************************
256  inline size_t columns() const {
257  return rhs_.columns();
258  }
259  //**********************************************************************************************
260 
261  //**Left operand access*************************************************************************
266  inline LeftOperand leftOperand() const {
267  return lhs_;
268  }
269  //**********************************************************************************************
270 
271  //**Right operand access************************************************************************
276  inline RightOperand rightOperand() const {
277  return rhs_;
278  }
279  //**********************************************************************************************
280 
281  //**********************************************************************************************
287  template< typename T >
288  inline bool canAlias( const T* alias ) const {
289  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
290  }
291  //**********************************************************************************************
292 
293  //**********************************************************************************************
299  template< typename T >
300  inline bool isAliased( const T* alias ) const {
301  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
302  }
303  //**********************************************************************************************
304 
305  //**********************************************************************************************
310  inline bool isAligned() const {
311  return rhs_.isAligned();
312  }
313  //**********************************************************************************************
314 
315  //**********************************************************************************************
320  inline bool canSMPAssign() const {
321  return ( rows() > SMP_SMATTDMATMULT_THRESHOLD );
322  }
323  //**********************************************************************************************
324 
325  private:
326  //**Member variables****************************************************************************
329  //**********************************************************************************************
330 
331  //**Assignment to dense matrices****************************************************************
343  template< typename MT // Type of the target dense matrix
344  , bool SO > // Storage order of the target dense matrix
345  friend inline void assign( DenseMatrix<MT,SO>& lhs, const SMatTDMatMultExpr& rhs )
346  {
348 
349  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
350  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
351 
352  LT A( rhs.lhs_ ); // Evaluation of the left-hand side sparse matrix operand
353  RT B( rhs.rhs_ ); // Evaluation of the right-hand side dense matrix operand
354 
355  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
356  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
357  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
358  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
359  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
360  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
361 
362  SMatTDMatMultExpr::selectAssignKernel( ~lhs, A, B );
363  }
365  //**********************************************************************************************
366 
367  //**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 DisableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
385  selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
386  {
387  typedef typename MT4::ConstIterator ConstIterator;
388 
389  const size_t block( 256UL );
390 
391  const size_t jend( B.columns() & size_t(-4) );
392  BLAZE_INTERNAL_ASSERT( ( B.columns() - ( B.columns() % 4UL ) ) == jend, "Invalid end calculation" );
393 
394  for( size_t ii=0UL; ii<A.rows(); ii+=block ) {
395  const size_t iend( ( ii+block > A.rows() )?( A.rows() ):( ii+block ) );
396  for( size_t j=0UL; j<jend; j+=4UL ) {
397  for( size_t i=ii; i<iend; ++i ) {
398  const ConstIterator end( A.end(i) );
399  ConstIterator element( A.begin(i) );
400  if( element!=end ) {
401  C(i,j ) = element->value() * B(element->index(),j );
402  C(i,j+1UL) = element->value() * B(element->index(),j+1UL);
403  C(i,j+2UL) = element->value() * B(element->index(),j+2UL);
404  C(i,j+3UL) = element->value() * B(element->index(),j+3UL);
405  ++element;
406  for( ; element!=end; ++element ) {
407  C(i,j ) += element->value() * B(element->index(),j );
408  C(i,j+1UL) += element->value() * B(element->index(),j+1UL);
409  C(i,j+2UL) += element->value() * B(element->index(),j+2UL);
410  C(i,j+3UL) += element->value() * B(element->index(),j+3UL);
411  }
412  }
413  else {
414  reset( C(i,j ) );
415  reset( C(i,j+1UL) );
416  reset( C(i,j+2UL) );
417  reset( C(i,j+3UL) );
418  }
419  }
420  }
421  for( size_t j=jend; j<B.columns(); ++j ) {
422  for( size_t i=ii; i<iend; ++i ) {
423  const ConstIterator end( A.end(i) );
424  ConstIterator element( A.begin(i) );
425  if( element!=end ) {
426  C(i,j) = element->value() * B(element->index(),j);
427  ++element;
428  for( ; element!=end; ++element ) {
429  C(i,j) += element->value() * B(element->index(),j);
430  }
431  }
432  else {
433  reset( C(i,j) );
434  }
435  }
436  }
437  }
438  }
440  //**********************************************************************************************
441 
442  //**SMP assignment to dense matrices************************************************************
456  template< typename MT3 // Type of the left-hand side target matrix
457  , typename MT4 // Type of the left-hand side matrix operand
458  , typename MT5 > // Type of the right-hand side matrix operand
459  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
460  selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
461  {
462  smpAssign( C, A * B );
463  }
465  //**********************************************************************************************
466 
467  //**Assignment to sparse matrices***************************************************************
479  template< typename MT // Type of the target sparse matrix
480  , bool SO > // Storage order of the target sparse matrix
481  friend inline void assign( SparseMatrix<MT,SO>& lhs, const SMatTDMatMultExpr& rhs )
482  {
484 
485  typedef typename SelectType< SO, OppositeType, ResultType >::Type TmpType;
486 
493 
494  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
495  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
496 
497  const TmpType tmp( rhs );
498  smpAssign( ~lhs, tmp );
499  }
501  //**********************************************************************************************
502 
503  //**Addition assignment to dense matrices*******************************************************
516  template< typename MT // Type of the target dense matrix
517  , bool SO > // Storage order of the target dense matrix
518  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const SMatTDMatMultExpr& rhs )
519  {
521 
522  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
523  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
524 
525  LT A( rhs.lhs_ ); // Evaluation of the left-hand side sparse matrix operand
526  RT B( rhs.rhs_ ); // Evaluation of the right-hand side dense matrix operand
527 
528  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
529  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
530  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
531  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
532  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
533  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
534 
535  SMatTDMatMultExpr::selectAddAssignKernel( ~lhs, A, B );
536  }
538  //**********************************************************************************************
539 
540  //**Default addition assignment to dense matrices***********************************************
554  template< typename MT3 // Type of the left-hand side target matrix
555  , typename MT4 // Type of the left-hand side matrix operand
556  , typename MT5 > // Type of the right-hand side matrix operand
557  static inline typename DisableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
558  selectAddAssignKernel( MT3& C, const MT4& A, const MT5& B )
559  {
560  typedef typename MT4::ConstIterator ConstIterator;
561 
562  const size_t block( 256UL );
563 
564  const size_t jend( B.columns() & size_t(-4) );
565  BLAZE_INTERNAL_ASSERT( ( B.columns() - ( B.columns() % 4UL ) ) == jend, "Invalid end calculation" );
566 
567  for( size_t ii=0UL; ii<A.rows(); ii+=block ) {
568  const size_t iend( ( ii+block > A.rows() )?( A.rows() ):( ii+block ) );
569  for( size_t j=0UL; j<jend; j+=4UL ) {
570  for( size_t i=ii; i<iend; ++i ) {
571  const ConstIterator end( A.end(i) );
572  ConstIterator element( A.begin(i) );
573  for( ; element!=end; ++element ) {
574  C(i,j ) += element->value() * B(element->index(),j );
575  C(i,j+1UL) += element->value() * B(element->index(),j+1UL);
576  C(i,j+2UL) += element->value() * B(element->index(),j+2UL);
577  C(i,j+3UL) += element->value() * B(element->index(),j+3UL);
578  }
579  }
580  }
581  for( size_t j=jend; j<B.columns(); ++j ) {
582  for( size_t i=ii; i<iend; ++i ) {
583  const ConstIterator end( A.end(i) );
584  ConstIterator element( A.begin(i) );
585  for( ; element!=end; ++element ) {
586  C(i,j) += element->value() * B(element->index(),j);
587  }
588  }
589  }
590  }
591  }
593  //**********************************************************************************************
594 
595  //**SMP addition assignment to dense matrices***************************************************
609  template< typename MT3 // Type of the left-hand side target matrix
610  , typename MT4 // Type of the left-hand side matrix operand
611  , typename MT5 > // Type of the right-hand side matrix operand
612  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
613  selectAddAssignKernel( MT3& C, const MT4& A, const MT5& B )
614  {
615  smpAddAssign( C, A * B );
616  }
618  //**********************************************************************************************
619 
620  //**Addition assignment to sparse matrices******************************************************
621  // No special implementation for the addition assignment to sparse matrices.
622  //**********************************************************************************************
623 
624  //**Subtraction assignment to dense matrices****************************************************
637  template< typename MT // Type of the target dense matrix
638  , bool SO > // Storage order of the target dense matrix
639  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const SMatTDMatMultExpr& rhs )
640  {
642 
643  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
644  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
645 
646  LT A( rhs.lhs_ ); // Evaluation of the left-hand side sparse matrix operand
647  RT B( rhs.rhs_ ); // Evaluation of the right-hand side dense matrix operand
648 
649  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
650  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
651  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
652  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
653  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
654  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
655 
656  SMatTDMatMultExpr::selectSubAssignKernel( ~lhs, A, B );
657  }
659  //**********************************************************************************************
660 
661  //**Default subtraction assignment to dense matrices********************************************
675  template< typename MT3 // Type of the left-hand side target matrix
676  , typename MT4 // Type of the left-hand side matrix operand
677  , typename MT5 > // Type of the right-hand side matrix operand
678  static inline typename DisableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
679  selectSubAssignKernel( MT3& C, const MT4& A, const MT5& B )
680  {
681  typedef typename MT4::ConstIterator ConstIterator;
682 
683  const size_t block( 256UL );
684 
685  const size_t jend( B.columns() & size_t(-4) );
686  BLAZE_INTERNAL_ASSERT( ( B.columns() - ( B.columns() % 4UL ) ) == jend, "Invalid end calculation" );
687 
688  for( size_t ii=0UL; ii<A.rows(); ii+=block ) {
689  const size_t iend( ( ii+block > A.rows() )?( A.rows() ):( ii+block ) );
690  for( size_t j=0UL; j<jend; j+=4UL ) {
691  for( size_t i=ii; i<iend; ++i ) {
692  const ConstIterator end( A.end(i) );
693  ConstIterator element( A.begin(i) );
694  for( ; element!=end; ++element ) {
695  C(i,j ) -= element->value() * B(element->index(),j );
696  C(i,j+1UL) -= element->value() * B(element->index(),j+1UL);
697  C(i,j+2UL) -= element->value() * B(element->index(),j+2UL);
698  C(i,j+3UL) -= element->value() * B(element->index(),j+3UL);
699  }
700  }
701  }
702  for( size_t j=jend; j<B.columns(); ++j ) {
703  for( size_t i=ii; i<iend; ++i ) {
704  const ConstIterator end( A.end(i) );
705  ConstIterator element( A.begin(i) );
706  for( ; element!=end; ++element ) {
707  C(i,j) -= element->value() * B(element->index(),j);
708  }
709  }
710  }
711  }
712  }
714  //**********************************************************************************************
715 
716  //**SMP subtraction assignment to dense matrices************************************************
730  template< typename MT3 // Type of the left-hand side target matrix
731  , typename MT4 // Type of the left-hand side matrix operand
732  , typename MT5 > // Type of the right-hand side matrix operand
733  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
734  selectSubAssignKernel( MT3& C, const MT4& A, const MT5& B )
735  {
736  smpSubAssign( C, A * B );
737  }
739  //**********************************************************************************************
740 
741  //**Subtraction assignment to sparse matrices***************************************************
742  // No special implementation for the subtraction assignment to sparse matrices.
743  //**********************************************************************************************
744 
745  //**Multiplication assignment to dense matrices*************************************************
746  // No special implementation for the multiplication assignment to dense matrices.
747  //**********************************************************************************************
748 
749  //**Multiplication assignment to sparse matrices************************************************
750  // No special implementation for the multiplication assignment to sparse matrices.
751  //**********************************************************************************************
752 
753  //**Compile time checks*************************************************************************
760  //**********************************************************************************************
761 };
762 //*************************************************************************************************
763 
764 
765 
766 
767 //=================================================================================================
768 //
769 // GLOBAL BINARY ARITHMETIC OPERATORS
770 //
771 //=================================================================================================
772 
773 //*************************************************************************************************
804 template< typename T1 // Type of the left-hand side sparse matrix
805  , typename T2 > // Type of the right-hand side dense matrix
806 inline const SMatTDMatMultExpr<T1,T2>
808 {
810 
811  if( (~lhs).columns() != (~rhs).rows() )
812  throw std::invalid_argument( "Matrix sizes do not match" );
813 
814  return SMatTDMatMultExpr<T1,T2>( ~lhs, ~rhs );
815 }
816 //*************************************************************************************************
817 
818 
819 
820 
821 //=================================================================================================
822 //
823 // EXPRESSION TRAIT SPECIALIZATIONS
824 //
825 //=================================================================================================
826 
827 //*************************************************************************************************
829 template< typename MT1, typename MT2, typename VT >
830 struct DMatDVecMultExprTrait< SMatTDMatMultExpr<MT1,MT2>, VT >
831 {
832  public:
833  //**********************************************************************************************
834  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
835  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
836  IsDenseVector<VT>::value && IsColumnVector<VT>::value
837  , typename SMatDVecMultExprTrait< MT1, typename TDMatDVecMultExprTrait<MT2,VT>::Type >::Type
838  , INVALID_TYPE >::Type Type;
839  //**********************************************************************************************
840 };
842 //*************************************************************************************************
843 
844 
845 //*************************************************************************************************
847 template< typename MT1, typename MT2, typename VT >
848 struct DMatSVecMultExprTrait< SMatTDMatMultExpr<MT1,MT2>, VT >
849 {
850  public:
851  //**********************************************************************************************
852  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
853  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
854  IsSparseVector<VT>::value && IsColumnVector<VT>::value
855  , typename SMatDVecMultExprTrait< MT1, typename TDMatSVecMultExprTrait<MT2,VT>::Type >::Type
856  , INVALID_TYPE >::Type Type;
857  //**********************************************************************************************
858 };
860 //*************************************************************************************************
861 
862 
863 //*************************************************************************************************
865 template< typename VT, typename MT1, typename MT2 >
866 struct TDVecDMatMultExprTrait< VT, SMatTDMatMultExpr<MT1,MT2> >
867 {
868  public:
869  //**********************************************************************************************
870  typedef typename SelectType< IsDenseVector<VT>::value && IsRowVector<VT>::value &&
871  IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
872  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
873  , typename TDVecTDMatMultExprTrait< typename TDVecSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
874  , INVALID_TYPE >::Type Type;
875  //**********************************************************************************************
876 };
878 //*************************************************************************************************
879 
880 
881 //*************************************************************************************************
883 template< typename VT, typename MT1, typename MT2 >
884 struct TSVecDMatMultExprTrait< VT, SMatTDMatMultExpr<MT1,MT2> >
885 {
886  public:
887  //**********************************************************************************************
888  typedef typename SelectType< IsSparseVector<VT>::value && IsRowVector<VT>::value &&
889  IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
890  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
891  , typename TSVecTDMatMultExprTrait< typename TSVecSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
892  , INVALID_TYPE >::Type Type;
893  //**********************************************************************************************
894 };
896 //*************************************************************************************************
897 
898 
899 //*************************************************************************************************
901 template< typename MT1, typename MT2, bool AF >
902 struct SubmatrixExprTrait< SMatTDMatMultExpr<MT1,MT2>, AF >
903 {
904  public:
905  //**********************************************************************************************
906  typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
907  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
908  //**********************************************************************************************
909 };
911 //*************************************************************************************************
912 
913 
914 //*************************************************************************************************
916 template< typename MT1, typename MT2 >
917 struct RowExprTrait< SMatTDMatMultExpr<MT1,MT2> >
918 {
919  public:
920  //**********************************************************************************************
921  typedef typename MultExprTrait< typename RowExprTrait<const MT1>::Type, MT2 >::Type Type;
922  //**********************************************************************************************
923 };
925 //*************************************************************************************************
926 
927 
928 //*************************************************************************************************
930 template< typename MT1, typename MT2 >
931 struct ColumnExprTrait< SMatTDMatMultExpr<MT1,MT2> >
932 {
933  public:
934  //**********************************************************************************************
935  typedef typename MultExprTrait< MT1, typename ColumnExprTrait<const MT2>::Type >::Type Type;
936  //**********************************************************************************************
937 };
939 //*************************************************************************************************
940 
941 } // namespace blaze
942 
943 #endif
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:89
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: SMatTDMatMultExpr.h:156
const ElementType ReturnType
Return type for expression template evaluations.
Definition: SMatTDMatMultExpr.h:152
Header file for the SMatDVecMultExprTrait class template.
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
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: SMatTDMatMultExpr.h:119
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.
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:197
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatTDMatMultExpr.h:288
MultTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SMatTDMatMultExpr.h:148
#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.
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
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatTDMatMultExpr.h:153
Header file for the TDVecSMatMultExprTrait class template.
LeftOperand lhs_
Left-hand side sparse matrix of the multiplication expression.
Definition: SMatTDMatMultExpr.h:327
Header file for the Computation base class.
SelectType< evaluateLeft, const RT1, CT1 >::Type LT
Type for the assignment of the left-hand side sparse matrix operand.
Definition: SMatTDMatMultExpr.h:162
Header file for the MatMatMultExpr base class.
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: SMatTDMatMultExpr.h:115
SMatTDMatMultExpr< MT1, MT2 > This
Type of this SMatTDMatMultExpr instance.
Definition: SMatTDMatMultExpr.h:147
Header file for the RequiresEvaluation type trait.
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: SMatTDMatMultExpr.h:116
Header file for the TSVecSMatMultExprTrait class template.
RightOperand rightOperand() const
Returns the right-hand side transpose dense matrix operand.
Definition: SMatTDMatMultExpr.h:276
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatTDMatMultExpr.h:256
const size_t SMP_SMATTDMATMULT_THRESHOLD
SMP row-major sparse matrix/column-major dense matrix multiplication threshold.This threshold represe...
Definition: Thresholds.h:550
SMatTDMatMultExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the SMatTDMatMultExpr class.
Definition: SMatTDMatMultExpr.h:182
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
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
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.
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: SMatTDMatMultExpr.h:310
#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 dense matrix SMP implementation.
Header file for the DenseMatrix base class.
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
Header file for the DMatDVecMultExprTrait class template.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatTDMatMultExpr.h:246
Expression object for sparse matrix-transpose dense matrix multiplications.The SMatTDMatMultExpr clas...
Definition: Forward.h:97
#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
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.
Header file for the EnableIf class template.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatTDMatMultExpr.h:150
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
RT1::ElementType ET1
Element type of the left-hand side dense matrix expression.
Definition: SMatTDMatMultExpr.h:117
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
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.
RT2::ElementType ET2
Element type of the right-hand side sparse matrix expression.
Definition: SMatTDMatMultExpr.h:118
Utility type for generic codes.
Base template for the MultTrait class.
Definition: MultTrait.h:141
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: SMatTDMatMultExpr.h:320
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side dense matrix expression.
Definition: SMatTDMatMultExpr.h:159
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
LeftOperand leftOperand() const
Returns the left-hand side sparse matrix operand.
Definition: SMatTDMatMultExpr.h:266
Header file for the reset shim.
MT2::CompositeType CT2
Composite type of the right-hand side dense matrix expression.
Definition: SMatTDMatMultExpr.h:120
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
ResultType::ElementType ElementType
Resulting element type.
Definition: SMatTDMatMultExpr.h:151
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatTDMatMultExpr.h:149
Header file for the RemoveReference type trait.
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.
SelectType< evaluateRight, const RT2, CT2 >::Type RT
Type for the assignment of the right-hand side dense matrix operand.
Definition: SMatTDMatMultExpr.h:165
Header file for the IsRowMajorMatrix type trait.
Header file for the IsComputation type trait class.
RightOperand rhs_
Right-hand side dense matrix of the multiplication expression.
Definition: SMatTDMatMultExpr.h:328
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
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.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatTDMatMultExpr.h:197
Header file for the DMatSVecMultExprTrait class template.
Header file for the IsColumnVector type trait.
Size type of the Blaze library.
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
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatTDMatMultExpr.h:300
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.