TSMatDVecMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATDVECMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATDVECMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
55 #include <blaze/math/shims/Reset.h>
70 #include <blaze/util/Assert.h>
72 #include <blaze/util/DisableIf.h>
73 #include <blaze/util/EnableIf.h>
75 #include <blaze/util/mpl/Or.h>
76 #include <blaze/util/SelectType.h>
77 #include <blaze/util/Types.h>
79 
80 
81 namespace blaze {
82 
83 //=================================================================================================
84 //
85 // CLASS TSMATDVECMULTEXPR
86 //
87 //=================================================================================================
88 
89 //*************************************************************************************************
96 template< typename MT // Type of the left-hand side sparse matrix
97  , typename VT > // Type of the right-hand side dense vector
98 class TSMatDVecMultExpr : public DenseVector< TSMatDVecMultExpr<MT,VT>, false >
99  , private MatVecMultExpr
100  , private Computation
101 {
102  private:
103  //**Type definitions****************************************************************************
104  typedef typename MT::ResultType MRT;
105  typedef typename VT::ResultType VRT;
106  typedef typename MT::CompositeType MCT;
107  typedef typename VT::CompositeType VCT;
108  //**********************************************************************************************
109 
110  //**********************************************************************************************
112  enum { evaluateMatrix = RequiresEvaluation<MT>::value };
113  //**********************************************************************************************
114 
115  //**********************************************************************************************
117  enum { evaluateVector = IsComputation<VT>::value || RequiresEvaluation<VT>::value };
118  //**********************************************************************************************
119 
120  //**********************************************************************************************
122 
126  template< typename T1 >
127  struct UseSMPAssign {
128  enum { value = ( evaluateMatrix || evaluateVector ) };
129  };
131  //**********************************************************************************************
132 
133  public:
134  //**Type definitions****************************************************************************
139  typedef const ElementType ReturnType;
140  typedef const ResultType CompositeType;
141 
143  typedef typename SelectType< IsExpression<MT>::value, const MT, const MT& >::Type LeftOperand;
144 
146  typedef typename SelectType< IsExpression<VT>::value, const VT, const VT& >::Type RightOperand;
147 
150 
153  //**********************************************************************************************
154 
155  //**Compilation flags***************************************************************************
157  enum { vectorizable = 0 };
158 
160  enum { smpAssignable = !evaluateMatrix && MT::smpAssignable &&
161  !evaluateVector && VT::smpAssignable };
162  //**********************************************************************************************
163 
164  //**Constructor*********************************************************************************
170  explicit inline TSMatDVecMultExpr( const MT& mat, const VT& vec )
171  : mat_( mat ) // Left-hand side sparse matrix of the multiplication expression
172  , vec_( vec ) // Right-hand side dense vector of the multiplication expression
173  {
174  BLAZE_INTERNAL_ASSERT( mat_.columns() == vec_.size(), "Invalid matrix and vector sizes" );
175  }
176  //**********************************************************************************************
177 
178  //**Subscript operator**************************************************************************
184  inline ReturnType operator[]( size_t index ) const {
185  BLAZE_INTERNAL_ASSERT( index < mat_.rows(), "Invalid vector access index" );
186 
187  ElementType res;
188 
189  if( vec_.size() > 0UL ) {
190  res = mat_(index,0UL) * vec_[0UL];
191  for( size_t j=1UL; j<vec_.size(); ++j )
192  res += mat_(index,j) * vec_[j];
193  }
194  else {
195  reset( res );
196  }
197 
198  return res;
199  }
200  //**********************************************************************************************
201 
202  //**Size function*******************************************************************************
207  inline size_t size() const {
208  return mat_.rows();
209  }
210  //**********************************************************************************************
211 
212  //**Left operand access*************************************************************************
217  inline LeftOperand leftOperand() const {
218  return mat_;
219  }
220  //**********************************************************************************************
221 
222  //**Right operand access************************************************************************
227  inline RightOperand rightOperand() const {
228  return vec_;
229  }
230  //**********************************************************************************************
231 
232  //**********************************************************************************************
238  template< typename T >
239  inline bool canAlias( const T* alias ) const {
240  return ( mat_.isAliased( alias ) || vec_.isAliased( alias ) );
241  }
242  //**********************************************************************************************
243 
244  //**********************************************************************************************
250  template< typename T >
251  inline bool isAliased( const T* alias ) const {
252  return ( mat_.isAliased( alias ) || vec_.isAliased( alias ) );
253  }
254  //**********************************************************************************************
255 
256  //**********************************************************************************************
261  inline bool isAligned() const {
262  return vec_.isAligned();
263  }
264  //**********************************************************************************************
265 
266  //**********************************************************************************************
271  inline bool canSMPAssign() const {
272  return ( size() > SMP_TSMATDVECMULT_THRESHOLD );
273  }
274  //**********************************************************************************************
275 
276  private:
277  //**Member variables****************************************************************************
278  LeftOperand mat_;
279  RightOperand vec_;
280  //**********************************************************************************************
281 
282  //**Assignment to dense vectors*****************************************************************
295  template< typename VT2 > // Type of the target dense vector
296  friend inline void assign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
297  {
299 
300  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
301 
302  reset( ~lhs );
303 
304  if( rhs.mat_.columns() == 0UL ) return;
305 
306  LT A( serial( rhs.mat_ ) ); // Evaluation of the left-hand side sparse matrix operand
307  RT x( serial( rhs.vec_ ) ); // Evaluation of the right-hand side dense vector operand
308 
309  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
310  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
311  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
312  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
313 
314  TSMatDVecMultExpr::selectAssignKernel( ~lhs, A, x );
315  }
317  //**********************************************************************************************
318 
319  //**Optimized assignment to dense vectors*******************************************************
333  template< typename VT1 // Type of the left-hand side target vector
334  , typename MT1 // Type of the left-hand side matrix operand
335  , typename VT2 > // Type of the right-hand side vector operand
336  static inline void selectAssignKernel( VT1& y, const MT1& A, const VT2& x )
337  {
339 
340  for( size_t j=0UL; j<A.columns(); ++j )
341  {
342  ConstIterator element( A.begin(j) );
343  const ConstIterator end( A.end(j) );
344 
345  for( ; element!=end; ++element ) {
347  isDefault( y[element->index()] ) )
348  y[element->index()] = element->value() * x[j];
349  else
350  y[element->index()] += element->value() * x[j];
351  }
352  }
353  }
355  //**********************************************************************************************
356 
357  //**Assignment to sparse vectors****************************************************************
370  template< typename VT2 > // Type of the target sparse vector
371  friend inline void assign( SparseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
372  {
374 
378 
379  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
380 
381  const ResultType tmp( serial( rhs ) );
382  assign( ~lhs, tmp );
383  }
385  //**********************************************************************************************
386 
387  //**Addition assignment to dense vectors********************************************************
400  template< typename VT2 > // Type of the target dense vector
401  friend inline void addAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
402  {
404 
405  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
406 
407  if( rhs.mat_.columns() == 0UL ) return;
408 
409  LT A( serial( rhs.mat_ ) ); // Evaluation of the left-hand side sparse matrix operand
410  RT x( serial( rhs.vec_ ) ); // Evaluation of the right-hand side dense vector operand
411 
412  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
413  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
414  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
415  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
416 
417  TSMatDVecMultExpr::selectAddAssignKernel( ~lhs, A, x );
418  }
420  //**********************************************************************************************
421 
422  //**Optimized addition assignment to dense vectors**********************************************
436  template< typename VT1 // Type of the left-hand side target vector
437  , typename MT1 // Type of the left-hand side matrix operand
438  , typename VT2 > // Type of the right-hand side vector operand
439  static inline void selectAddAssignKernel( VT1& y, const MT1& A, const VT2& x )
440  {
442 
443  for( size_t j=0UL; j<A.columns(); ++j )
444  {
445  ConstIterator element( A.begin(j) );
446  const ConstIterator end( A.end(j) );
447 
448  for( ; element!=end; ++element ) {
449  y[element->index()] += element->value() * x[j];
450  }
451  }
452  }
454  //**********************************************************************************************
455 
456  //**Addition assignment to sparse vectors*******************************************************
457  // No special implementation for the addition assignment to sparse vectors.
458  //**********************************************************************************************
459 
460  //**Subtraction assignment to dense vectors*****************************************************
473  template< typename VT2 > // Type of the target dense vector
474  friend inline void subAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
475  {
477 
478  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
479 
481 
482  if( rhs.mat_.columns() == 0UL ) return;
483 
484  LT A( serial( rhs.mat_ ) ); // Evaluation of the left-hand side sparse matrix operand
485  RT x( serial( rhs.vec_ ) ); // Evaluation of the right-hand side dense vector operand
486 
487  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
488  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
489  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
490  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
491 
492  TSMatDVecMultExpr::selectSubAssignKernel( ~lhs, A, x );
493  }
495  //**********************************************************************************************
496 
497  //**Optimized subtraction assignment to dense vectors*******************************************
511  template< typename VT1 // Type of the left-hand side target vector
512  , typename MT1 // Type of the left-hand side matrix operand
513  , typename VT2 > // Type of the right-hand side vector operand
514  static inline void selectSubAssignKernel( VT1& y, const MT1& A, const VT2& x )
515  {
517 
518  for( size_t j=0UL; j<A.columns(); ++j )
519  {
520  ConstIterator element( A.begin(j) );
521  const ConstIterator end( A.end(j) );
522 
523  for( ; element!=end; ++element ) {
524  y[element->index()] -= element->value() * x[j];
525  }
526  }
527  }
529  //**********************************************************************************************
530 
531  //**Subtraction assignment to sparse vectors****************************************************
532  // No special implementation for the subtraction assignment to sparse vectors.
533  //**********************************************************************************************
534 
535  //**Multiplication assignment to dense vectors**************************************************
548  template< typename VT2 > // Type of the target dense vector
549  friend inline void multAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
550  {
552 
556 
557  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
558 
559  const ResultType tmp( serial( rhs ) );
560  multAssign( ~lhs, tmp );
561  }
563  //**********************************************************************************************
564 
565  //**Multiplication assignment to sparse vectors*************************************************
566  // No special implementation for the multiplication assignment to sparse vectors.
567  //**********************************************************************************************
568 
569  //**SMP assignment to dense vectors*************************************************************
584  template< typename VT2 > // Type of the target dense vector
585  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
586  smpAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
587  {
589 
590  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
591 
592  reset( ~lhs );
593 
594  if( rhs.mat_.columns() == 0UL ) return;
595 
596  LT A( rhs.mat_ ); // Evaluation of the left-hand side sparse matrix operand
597  RT x( rhs.vec_ ); // Evaluation of the right-hand side dense vector operand
598 
599  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
600  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
601  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
602  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
603 
604  smpAssign( ~lhs, A * x );
605  }
607  //**********************************************************************************************
608 
609  //**SMP assignment to sparse vectors************************************************************
624  template< typename VT2 > // Type of the target sparse vector
625  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
626  smpAssign( SparseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
627  {
629 
633 
634  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
635 
636  const ResultType tmp( rhs );
637  smpAssign( ~lhs, tmp );
638  }
640  //**********************************************************************************************
641 
642  //**SMP addition assignment to dense vectors****************************************************
657  template< typename VT2 > // Type of the target dense vector
658  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
659  smpAddAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
660  {
662 
663  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
664 
665  if( rhs.mat_.columns() == 0UL ) return;
666 
667  LT A( rhs.mat_ ); // Evaluation of the left-hand side sparse matrix operand
668  RT x( rhs.vec_ ); // Evaluation of the right-hand side dense vector operand
669 
670  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
671  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
672  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
673  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
674 
675  smpAddAssign( ~lhs, A * x );
676  }
678  //**********************************************************************************************
679 
680  //**SMP addition assignment to sparse vectors***************************************************
681  // No special implementation for the SMP addition assignment to sparse vectors.
682  //**********************************************************************************************
683 
684  //**SMP subtraction assignment to dense vectors*************************************************
699  template< typename VT2 > // Type of the target dense vector
700  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
701  smpSubAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
702  {
704 
705  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
706 
708 
709  if( rhs.mat_.columns() == 0UL ) return;
710 
711  LT A( rhs.mat_ ); // Evaluation of the left-hand side sparse matrix operand
712  RT x( rhs.vec_ ); // Evaluation of the right-hand side dense vector operand
713 
714  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
715  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
716  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
717  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
718 
719  smpSubAssign( ~lhs, A * x );
720  }
722  //**********************************************************************************************
723 
724  //**SMP subtraction assignment to sparse vectors************************************************
725  // No special implementation for the SMP subtraction assignment to sparse vectors.
726  //**********************************************************************************************
727 
728  //**SMP multiplication assignment to dense vectors**********************************************
743  template< typename VT2 > // Type of the target dense vector
744  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
745  smpMultAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
746  {
748 
752 
753  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
754 
755  const ResultType tmp( rhs );
756  smpMultAssign( ~lhs, tmp );
757  }
759  //**********************************************************************************************
760 
761  //**SMP multiplication assignment to sparse vectors*********************************************
762  // No special implementation for the SMP multiplication assignment to sparse vectors.
763  //**********************************************************************************************
764 
765  //**Compile time checks*************************************************************************
774  //**********************************************************************************************
775 };
776 //*************************************************************************************************
777 
778 
779 
780 
781 //=================================================================================================
782 //
783 // GLOBAL BINARY ARITHMETIC OPERATORS
784 //
785 //=================================================================================================
786 
787 //*************************************************************************************************
818 template< typename T1 // Type of the left-hand side sparse matrix
819  , typename T2 > // Type of the right-hand side dense vector
820 inline const typename DisableIf< Or< IsSymmetric<T1>, IsMatMatMultExpr<T1> >
821  , TSMatDVecMultExpr<T1,T2> >::Type
823 {
825 
826  if( (~mat).columns() != (~vec).size() )
827  throw std::invalid_argument( "Matrix and vector sizes do not match" );
828 
829  return TSMatDVecMultExpr<T1,T2>( ~mat, ~vec );
830 }
831 //*************************************************************************************************
832 
833 
834 
835 
836 //=================================================================================================
837 //
838 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
839 //
840 //=================================================================================================
841 
842 //*************************************************************************************************
857 template< typename T1 // Type of the left-hand side sparse matrix
858  , typename T2 > // Type of the right-hand side dense vector
859 inline const typename EnableIf< IsSymmetric<T1>, typename MultExprTrait<T1,T2>::Type >::Type
860  operator*( const SparseMatrix<T1,true>& mat, const DenseVector<T2,false>& vec )
861 {
863 
865 
866  if( (~mat).columns() != (~vec).size() )
867  throw std::invalid_argument( "Matrix and vector sizes do not match" );
868 
869  return trans( ~mat ) * (~vec);
870 }
872 //*************************************************************************************************
873 
874 
875 
876 
877 //=================================================================================================
878 //
879 // SIZE SPECIALIZATIONS
880 //
881 //=================================================================================================
882 
883 //*************************************************************************************************
885 template< typename MT, typename VT >
886 struct Size< TSMatDVecMultExpr<MT,VT> >
887  : public Rows<MT>
888 {};
890 //*************************************************************************************************
891 
892 
893 
894 
895 //=================================================================================================
896 //
897 // EXPRESSION TRAIT SPECIALIZATIONS
898 //
899 //=================================================================================================
900 
901 //*************************************************************************************************
903 template< typename MT, typename VT, bool AF >
904 struct SubvectorExprTrait< TSMatDVecMultExpr<MT,VT>, AF >
905 {
906  public:
907  //**********************************************************************************************
908  typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type
909  , typename SubvectorExprTrait<const VT,AF>::Type >::Type Type;
910  //**********************************************************************************************
911 };
913 //*************************************************************************************************
914 
915 } // namespace blaze
916 
917 #endif
LeftOperand mat_
Left-hand side sparse matrix of the multiplication expression.
Definition: TSMatDVecMultExpr.h:278
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:89
BLAZE_ALWAYS_INLINE void multAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the multiplication assignment of a matrix to a matrix.
Definition: Matrix.h:879
Expression object for transpose sparse matrix-dense vector multiplications.The TSMatDVecMultExpr clas...
Definition: Forward.h:139
Header file for the Rows type trait.
const DMatDMatMultExpr< T1, T2 > operator*(const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:8247
Header file for basic type definitions.
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:258
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a column dense or sparse vector type...
Definition: TransposeFlag.h:159
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:209
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatDVecMultExpr.h:140
TSMatDVecMultExpr< MT, VT > This
Type of this TSMatDVecMultExpr instance.
Definition: TSMatDVecMultExpr.h:135
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:821
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2507
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TSMatDVecMultExpr.h:137
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:261
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TSMatDVecMultExpr.h:239
Header file for the DenseVector base class.
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:699
Header file for the Computation base class.
MT::ResultType MRT
Result type of the left-hand side sparse matrix expression.
Definition: TSMatDVecMultExpr.h:104
Header file for the RequiresEvaluation type trait.
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TSMatDVecMultExpr.h:184
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:107
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:861
SelectType< evaluateVector, const VRT, VCT >::Type RT
Type for the assignment of the right-hand side dense vector operand.
Definition: TSMatDVecMultExpr.h:152
Constraint on the data type.
Constraint on the data type.
RightOperand vec_
Right-hand side dense vector of the multiplication expression.
Definition: TSMatDVecMultExpr.h:279
Header file for the MultExprTrait class template.
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:90
SelectType< IsExpression< VT >::value, const VT, const VT & >::Type RightOperand
Composite type of the right-hand side dense vector expression.
Definition: TSMatDVecMultExpr.h:146
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:263
TSMatDVecMultExpr(const MT &mat, const VT &vec)
Constructor for the TSMatDVecMultExpr class.
Definition: TSMatDVecMultExpr.h:170
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.
size_t size() const
Returns the current size/dimension of the vector.
Definition: TSMatDVecMultExpr.h:207
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a column-major dense or sparse matri...
Definition: StorageOrder.h:161
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2511
Header file for the Or class template.
Header file for the IsMatMatMultExpr type trait class.
BLAZE_ALWAYS_INLINE void assign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the assignment of a matrix to a matrix.
Definition: Matrix.h:635
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATMULTEXPR_TYPE(T)
Constraint on the data type.In case the given data type T is a matrix/matrix multiplication expressio...
Definition: MatMatMultExpr.h:126
#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
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATVECMULTEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/vector ...
Definition: MatVecMultExpr.h:166
LeftOperand leftOperand() const
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatDVecMultExpr.h:217
Constraints on the storage order of matrix types.
Constraint on the data type.
Header file for the SelectType class template.
Header file for all forward declarations for expression class templates.
VT::ResultType VRT
Result type of the right-hand side dense vector expression.
Definition: TSMatDVecMultExpr.h:105
Header file for the EnableIf class template.
Header file for the serial shim.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TSMatDVecMultExpr.h:251
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
VT::CompositeType VCT
Composite type of the right-hand side dense vector expression.
Definition: TSMatDVecMultExpr.h:107
EnableIf< IsDenseMatrix< MT1 > >::Type smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:116
Header file for the SubmatrixExprTrait class template.
Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given...
Definition: RemoveReference.h:69
Header file for run time assertion macros.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:98
Base template for the MultTrait class.
Definition: MultTrait.h:150
BLAZE_ALWAYS_INLINE void addAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the addition assignment of a matrix to a matrix.
Definition: Matrix.h:742
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: TSMatDVecMultExpr.h:261
Header file for the reset shim.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: TSMatDVecMultExpr.h:271
Header file for the isDefault shim.
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDVecMultExpr.h:143
MultTrait< MRT, VRT >::Type ResultType
Result type for expression template evaluations.
Definition: TSMatDVecMultExpr.h:136
const size_t SMP_TSMATDVECMULT_THRESHOLD
SMP column-major sparse matrix/dense vector multiplication threshold.This threshold specifies when a ...
Definition: Thresholds.h:529
ResultType::ElementType ElementType
Resulting element type.
Definition: TSMatDVecMultExpr.h:138
Header file for the RemoveReference type trait.
MT::CompositeType MCT
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDVecMultExpr.h:106
SelectType< evaluateMatrix, const MRT, MCT >::Type LT
Type for the assignment of the left-hand side sparse matrix operand.
Definition: TSMatDVecMultExpr.h:149
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional vector type...
Definition: DenseVector.h:79
RightOperand rightOperand() const
Returns the right-hand side dense vector operand.
Definition: TSMatDVecMultExpr.h:227
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:937
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSMatDVecMultExpr.h:139
Header file for the IsComputation type trait class.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2502
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:332
Header file for the SubvectorExprTrait class template.
Constraint on the data type.
Header file for the MatVecMultExpr base class.
Constraint on the data type.
Header file for the IsResizable type trait.
EnableIf< IsDenseVector< VT1 > >::Type smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
Default implementation of the SMP multiplication assignment of a vector to a dense vector...
Definition: DenseVector.h:189
Header file for the Size type trait.
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
#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.
BLAZE_ALWAYS_INLINE void subAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the subtraction assignment of a matrix to matrix.
Definition: Matrix.h:849