TSMatSVecMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATSVECMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATSVECMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
50 #include <blaze/math/Exception.h>
56 #include <blaze/math/shims/Reset.h>
72 #include <blaze/util/Assert.h>
74 #include <blaze/util/DisableIf.h>
75 #include <blaze/util/EnableIf.h>
77 #include <blaze/util/mpl/If.h>
78 #include <blaze/util/Types.h>
80 
81 
82 namespace blaze {
83 
84 //=================================================================================================
85 //
86 // CLASS SMATDVECMULTEXPR
87 //
88 //=================================================================================================
89 
90 //*************************************************************************************************
97 template< typename MT // Type of the left-hand side sparse matrix
98  , typename VT > // Type of the right-hand side sparse vector
99 class TSMatSVecMultExpr : public SparseVector< TSMatSVecMultExpr<MT,VT>, false >
100  , private MatVecMultExpr
101  , private Computation
102 {
103  private:
104  //**Type definitions****************************************************************************
109  //**********************************************************************************************
110 
111  //**********************************************************************************************
113  enum : bool { evaluateMatrix = RequiresEvaluation<MT>::value };
114  //**********************************************************************************************
115 
116  //**********************************************************************************************
118  enum : bool { evaluateVector = RequiresEvaluation<VT>::value || IsComputation<VT>::value };
119  //**********************************************************************************************
120 
121  //**********************************************************************************************
123 
127  template< typename T1 >
128  struct UseSMPAssign {
129  enum : bool { value = ( evaluateMatrix || evaluateVector ) };
130  };
132  //**********************************************************************************************
133 
134  public:
135  //**Type definitions****************************************************************************
140  typedef const ElementType ReturnType;
141 
143  typedef const ResultType CompositeType;
144 
146  typedef If_< IsExpression<MT>, const MT, const MT& > LeftOperand;
147 
149  typedef If_< IsExpression<VT>, const VT, const VT& > RightOperand;
150 
153 
156  //**********************************************************************************************
157 
158  //**Compilation flags***************************************************************************
160  enum : bool { smpAssignable = !evaluateMatrix && MT::smpAssignable &&
161  !evaluateVector && VT::smpAssignable };
162  //**********************************************************************************************
163 
164  //**Constructor*********************************************************************************
170  explicit inline TSMatSVecMultExpr( const MT& mat, const VT& vec ) noexcept
171  : mat_( mat ) // Left-hand side sparse matrix of the multiplication expression
172  , vec_( vec ) // Right-hand side sparse 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 
188  {
189  return mat_(index,index) * vec_[index];
190  }
191  else if( IsLower<MT>::value )
192  {
193  const size_t n( IsStrictlyLower<MT>::value ? index : index+1UL );
194  return subvector( row( mat_, index ), 0UL, n ) * subvector( vec_, 0UL, n );
195  }
196  else if( IsUpper<MT>::value )
197  {
198  const size_t begin( IsStrictlyUpper<MT>::value ? index+1UL : index );
199  const size_t n ( mat_.columns() - begin );
200  return subvector( row( mat_, index ), begin, n ) * subvector( vec_, begin, n );
201  }
202  else
203  {
204  return row( mat_, index ) * vec_;
205  }
206  }
207  //**********************************************************************************************
208 
209  //**At function*********************************************************************************
216  inline ReturnType at( size_t index ) const {
217  if( index >= mat_.rows() ) {
218  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
219  }
220  return (*this)[index];
221  }
222  //**********************************************************************************************
223 
224  //**Size function*******************************************************************************
229  inline size_t size() const noexcept {
230  return mat_.rows();
231  }
232  //**********************************************************************************************
233 
234  //**NonZeros function***************************************************************************
239  inline size_t nonZeros() const {
240  return mat_.rows();
241  }
242  //**********************************************************************************************
243 
244  //**Left operand access*************************************************************************
249  inline LeftOperand leftOperand() const noexcept {
250  return mat_;
251  }
252  //**********************************************************************************************
253 
254  //**Right operand function**********************************************************************
259  inline RightOperand rightOperand() const noexcept {
260  return vec_;
261  }
262  //**********************************************************************************************
263 
264  //**********************************************************************************************
270  template< typename T >
271  inline bool canAlias( const T* alias ) const noexcept {
272  return ( mat_.isAliased( alias ) || vec_.isAliased( alias ) );
273  }
274  //**********************************************************************************************
275 
276  //**********************************************************************************************
282  template< typename T >
283  inline bool isAliased( const T* alias ) const noexcept {
284  return ( mat_.isAliased( alias ) || vec_.isAliased( alias ) );
285  }
286  //**********************************************************************************************
287 
288  //**********************************************************************************************
293  inline bool canSMPAssign() const noexcept {
294  return ( size() > SMP_SMATSVECMULT_THRESHOLD );
295  }
296  //**********************************************************************************************
297 
298  private:
299  //**Member variables****************************************************************************
300  LeftOperand mat_;
301  RightOperand vec_;
302  //**********************************************************************************************
303 
304  //**Assignment to dense vectors*****************************************************************
317  template< typename VT1 > // Type of the target dense vector
318  friend inline void assign( DenseVector<VT1,false>& lhs, const TSMatSVecMultExpr& rhs )
319  {
321 
322  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
323 
324  // Resetting the left-hand side target dense vector
325  reset( ~lhs );
326 
327  // Evaluation of the right-hand side sparse vector operand
328  RT x( serial( rhs.vec_ ) );
329  if( x.nonZeros() == 0UL ) return;
330 
331  // Evaluation of the left-hand side sparse matrix operand
332  LT A( serial( rhs.mat_ ) );
333 
334  // Checking the evaluated operators
335  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
336  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
337  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
338  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
339 
340  // Performing the transpose sparse matrix-sparse vector multiplication
341  TSMatSVecMultExpr::selectAssignKernel( ~lhs, A, x );
342  }
344  //**********************************************************************************************
345 
346  //**Default assignment to dense vectors*********************************************************
360  template< typename VT1 // Type of the left-hand side target vector
361  , typename MT1 // Type of the left-hand side matrix operand
362  , typename VT2 > // Type of the right-hand side vector operand
363  static inline void selectAssignKernel( VT1& y, const MT1& A, const VT2& x )
364  {
365  typedef ConstIterator_< RemoveReference_<MT1> > MatrixIterator;
366  typedef ConstIterator_< RemoveReference_<VT2> > VectorIterator;
367 
368  const VectorIterator vend ( x.end() );
369  VectorIterator velem( x.begin() );
370 
371  for( ; velem!=vend; ++velem )
372  {
373  const MatrixIterator mend ( A.end ( velem->index() ) );
374  MatrixIterator melem( A.begin( velem->index() ) );
375 
376  for( ; melem!=mend; ++melem ) {
377  if( IsResizable< ElementType_<VT1> >::value &&
378  isDefault( y[melem->index()] ) )
379  y[melem->index()] = melem->value() * velem->value();
380  else
381  y[melem->index()] += melem->value() * velem->value();
382  }
383  }
384  }
386  //**********************************************************************************************
387 
388  //**Assignment to sparse vectors****************************************************************
400  template< typename VT1 > // Type of the target sparse vector
401  friend inline void assign( SparseVector<VT1,false>& lhs, const TSMatSVecMultExpr& rhs )
402  {
404 
405  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
406 
407  const DynamicVector<ElementType_<VT1>,false> tmp( serial( rhs ) );
408  assign( ~lhs, tmp );
409  }
411  //**********************************************************************************************
412 
413  //**Addition assignment to dense vectors********************************************************
426  template< typename VT1 > // Type of the target dense vector
427  friend inline void addAssign( DenseVector<VT1,false>& lhs, const TSMatSVecMultExpr& rhs )
428  {
430 
431  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
432 
433  // Evaluation of the right-hand side sparse vector operand
434  RT x( serial( rhs.vec_ ) );
435  if( x.nonZeros() == 0UL ) return;
436 
437  // Evaluation of the left-hand side sparse matrix operand
438  LT A( serial( rhs.mat_ ) );
439 
440  // Checking the evaluated operators
441  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
442  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
443  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
444  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
445 
446  // Performing the transpose sparse matrix-sparse vector multiplication
447  TSMatSVecMultExpr::selectAddAssignKernel( ~lhs, A, x );
448  }
450  //**********************************************************************************************
451 
452  //**Default addition assignment to dense vectors************************************************
466  template< typename VT1 // Type of the left-hand side target vector
467  , typename MT1 // Type of the left-hand side matrix operand
468  , typename VT2 > // Type of the right-hand side vector operand
469  static inline void selectAddAssignKernel( VT1& y, const MT1& A, const VT2& x )
470  {
471  typedef ConstIterator_< RemoveReference_<MT1> > MatrixIterator;
472  typedef ConstIterator_< RemoveReference_<VT2> > VectorIterator;
473 
474  const VectorIterator vend ( x.end() );
475  VectorIterator velem( x.begin() );
476 
477  for( ; velem!=vend; ++velem )
478  {
479  const MatrixIterator mend ( A.end ( velem->index() ) );
480  MatrixIterator melem( A.begin( velem->index() ) );
481 
482  for( ; melem!=mend; ++melem ) {
483  y[melem->index()] += melem->value() * velem->value();
484  }
485  }
486  }
488  //**********************************************************************************************
489 
490  //**Addition assignment to sparse vectors*******************************************************
491  // No special implementation for the addition assignment to sparse vectors.
492  //**********************************************************************************************
493 
494  //**Subtraction assignment to dense vectors*****************************************************
507  template< typename VT1 > // Type of the target dense vector
508  friend inline void subAssign( DenseVector<VT1,false>& lhs, const TSMatSVecMultExpr& rhs )
509  {
511 
512  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
513 
514  // Evaluation of the right-hand side sparse vector operand
515  RT x( serial( rhs.vec_ ) );
516  if( x.nonZeros() == 0UL ) return;
517 
518  // Evaluation of the left-hand side sparse matrix operand
519  LT A( serial( rhs.mat_ ) );
520 
521  // Checking the evaluated operators
522  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
523  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
524  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
525  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
526 
527  // Performing the transpose sparse matrix-sparse vector multiplication
528  TSMatSVecMultExpr::selectSubAssignKernel( ~lhs, A, x );
529  }
531  //**********************************************************************************************
532 
533  //**Default subtraction assignment to dense vectors*********************************************
547  template< typename VT1 // Type of the left-hand side target vector
548  , typename MT1 // Type of the left-hand side matrix operand
549  , typename VT2 > // Type of the right-hand side vector operand
550  static inline void selectSubAssignKernel( VT1& y, const MT1& A, const VT2& x )
551  {
552  typedef ConstIterator_< RemoveReference_<MT1> > MatrixIterator;
553  typedef ConstIterator_< RemoveReference_<VT2> > VectorIterator;
554 
555  const VectorIterator vend ( x.end() );
556  VectorIterator velem( x.begin() );
557 
558  for( ; velem!=vend; ++velem )
559  {
560  const MatrixIterator mend ( A.end ( velem->index() ) );
561  MatrixIterator melem( A.begin( velem->index() ) );
562 
563  for( ; melem!=mend; ++melem ) {
564  y[melem->index()] -= melem->value() * velem->value();
565  }
566  }
567  }
569  //**********************************************************************************************
570 
571  //**Subtraction assignment to sparse vectors****************************************************
572  // No special implementation for the subtraction assignment to sparse vectors.
573  //**********************************************************************************************
574 
575  //**Multiplication assignment to dense vectors**************************************************
588  template< typename VT1 > // Type of the target dense vector
589  friend inline void multAssign( DenseVector<VT1,false>& lhs, const TSMatSVecMultExpr& rhs )
590  {
592 
596 
597  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
598 
599  const ResultType tmp( serial( rhs ) );
600  multAssign( ~lhs, tmp );
601  }
603  //**********************************************************************************************
604 
605  //**Multiplication assignment to sparse vectors*************************************************
606  // No special implementation for the multiplication assignment to sparse vectors.
607  //**********************************************************************************************
608 
609  //**SMP assignment to dense vectors*************************************************************
624  template< typename VT1 > // Type of the target dense vector
625  friend inline EnableIf_< UseSMPAssign<VT1> >
627  {
629 
630  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
631 
632  // Resetting the left-hand side target dense vector
633  reset( ~lhs );
634 
635  // Evaluation of the right-hand side sparse vector operand
636  RT x( rhs.vec_ );
637  if( x.nonZeros() == 0UL ) return;
638 
639  // Evaluation of the left-hand side sparse matrix operand
640  LT A( rhs.mat_ );
641 
642  // Checking the evaluated operators
643  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
644  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
645  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
646  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
647 
648  // Performing the transpose sparse matrix-sparse vector multiplication
649  smpAssign( ~lhs, A * x );
650  }
652  //**********************************************************************************************
653 
654  //**SMP assignment to sparse vectors************************************************************
655  // No special implementation for the SMP assignment to sparse vectors.
656  //**********************************************************************************************
657 
658  //**SMP addition assignment to dense vectors****************************************************
673  template< typename VT1 > // Type of the target dense vector
674  friend inline EnableIf_< UseSMPAssign<VT1> >
676  {
678 
679  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
680 
681  // Evaluation of the right-hand side sparse vector operand
682  RT x( rhs.vec_ );
683  if( x.nonZeros() == 0UL ) return;
684 
685  // Evaluation of the left-hand side sparse matrix operand
686  LT A( rhs.mat_ );
687 
688  // Checking the evaluated operators
689  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
690  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
691  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
692  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
693 
694  // Performing the transpose sparse matrix-sparse vector multiplication
695  smpAddAssign( ~lhs, A * x );
696  }
698  //**********************************************************************************************
699 
700  //**SMP addition assignment to sparse vectors***************************************************
701  // No special implementation for the SMP addition assignment to sparse vectors.
702  //**********************************************************************************************
703 
704  //**SMP subtraction assignment to dense vectors*************************************************
719  template< typename VT1 > // Type of the target dense vector
720  friend inline EnableIf_< UseSMPAssign<VT1> >
722  {
724 
725  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
726 
727  // Evaluation of the right-hand side sparse vector operand
728  RT x( rhs.vec_ );
729  if( x.nonZeros() == 0UL ) return;
730 
731  // Evaluation of the left-hand side sparse matrix operand
732  LT A( rhs.mat_ );
733 
734  // Checking the evaluated operators
735  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
736  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
737  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
738  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
739 
740  // Performing the transpose sparse matrix-sparse vector multiplication
741  smpSubAssign( ~lhs, A * x );
742  }
744  //**********************************************************************************************
745 
746  //**SMP subtraction assignment to sparse vectors************************************************
747  // No special implementation for the SMP subtraction assignment to sparse vectors.
748  //**********************************************************************************************
749 
750  //**SMP multiplication assignment to dense vectors**********************************************
765  template< typename VT1 > // Type of the target dense vector
766  friend inline EnableIf_< UseSMPAssign<VT1> >
768  {
770 
774 
775  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
776 
777  const ResultType tmp( rhs );
778  smpMultAssign( ~lhs, tmp );
779  }
781  //**********************************************************************************************
782 
783  //**SMP multiplication assignment to sparse vectors*********************************************
784  // No special implementation for the SMP multiplication assignment to sparse vectors.
785  //**********************************************************************************************
786 
787  //**Compile time checks*************************************************************************
795  //**********************************************************************************************
796 };
797 //*************************************************************************************************
798 
799 
800 
801 
802 //=================================================================================================
803 //
804 // GLOBAL BINARY ARITHMETIC OPERATORS
805 //
806 //=================================================================================================
807 
808 //*************************************************************************************************
839 template< typename T1 // Type of the left-hand side sparse matrix
840  , typename T2 > // Type of the right-hand side sparse vector
843 {
845 
846  if( (~mat).columns() != (~vec).size() ) {
847  BLAZE_THROW_INVALID_ARGUMENT( "Matrix and vector sizes do not match" );
848  }
849 
850  return TSMatSVecMultExpr<T1,T2>( ~mat, ~vec );
851 }
852 //*************************************************************************************************
853 
854 
855 
856 
857 //=================================================================================================
858 //
859 // SIZE SPECIALIZATIONS
860 //
861 //=================================================================================================
862 
863 //*************************************************************************************************
865 template< typename MT, typename VT >
866 struct Size< TSMatSVecMultExpr<MT,VT> > : public Rows<MT>
867 {};
869 //*************************************************************************************************
870 
871 
872 
873 
874 //=================================================================================================
875 //
876 // EXPRESSION TRAIT SPECIALIZATIONS
877 //
878 //=================================================================================================
879 
880 //*************************************************************************************************
882 template< typename MT, typename VT, bool AF >
883 struct SubvectorExprTrait< TSMatSVecMultExpr<MT,VT>, AF >
884 {
885  public:
886  //**********************************************************************************************
889  //**********************************************************************************************
890 };
892 //*************************************************************************************************
893 
894 } // namespace blaze
895 
896 #endif
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for auxiliary alias declarations.
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:72
Evaluation of the expression type type of a subvector operation.Via this type trait it is possible to...
Definition: SubvectorExprTrait.h:79
Header file for the Rows type trait.
Header file for basic type definitions.
Header file for the SparseVector base class.
#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: ColumnVector.h:61
EnableIf_< IsDenseMatrix< MT1 > > smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
Header file for the serial shim.
Header file for the IsDiagonal type trait.
LeftOperand leftOperand() const noexcept
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatSVecMultExpr.h:249
CompositeType_< VT > VCT
Composite type of the right-hand side sparse vector expression.
Definition: TSMatSVecMultExpr.h:108
BLAZE_ALWAYS_INLINE MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:194
size_t nonZeros() const
Returns an estimation for the number of non-zero elements in the sparse vector.
Definition: TSMatSVecMultExpr.h:239
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: TSMatSVecMultExpr.h:229
If_< IsExpression< MT >, const MT, const MT &> LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatSVecMultExpr.h:146
EnableIf_< IsDenseVector< VT1 > > 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:193
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:223
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
ElementType_< ResultType > ElementType
Resulting element type.
Definition: TSMatSVecMultExpr.h:139
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:245
Header file for the Computation base class.
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
Efficient implementation of an arbitrary sized vector.The DynamicVector class template is the represe...
Definition: DynamicVector.h:177
Header file for the RequiresEvaluation type trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
EnableIf_< IsDenseMatrix< MT1 > > 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
Header file for the implementation of an arbitrarily sized vector.
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:119
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSMatSVecMultExpr.h:140
Constraint on the data type.
typename IfTrue< Condition, T1, T2 >::Type IfTrue_
Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a co...
Definition: If.h:109
Constraint on the transpose flag of vector types.
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: TSMatSVecMultExpr.h:216
Constraint on the data type.
typename MultExprTrait< T1, T2 >::Type MultExprTrait_
Auxiliary alias declaration for the MultExprTrait class template.The MultExprTrait_ alias declaration...
Definition: MultExprTrait.h:344
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:72
SubvectorExprTrait_< VT, unaligned > subvector(Vector< VT, TF > &vector, size_t index, size_t size)
Creating a view on a specific subvector of the given vector.
Definition: Subvector.h:152
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
CompositeType_< MT > MCT
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatSVecMultExpr.h:107
If_< IsExpression< VT >, const VT, const VT &> RightOperand
Composite type of the right-hand side sparse vector expression.
Definition: TSMatSVecMultExpr.h:149
Header file for the DisableIf class template.
Header file for the multiplication trait.
Header file for the IsStrictlyUpper type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Expression object for sparse matrix-sparse vector multiplications.The TSMatSVecMultExpr class represe...
Definition: Forward.h:155
Header file for the If class template.
#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: ColumnMajorMatrix.h:61
EnableIf_< IsDenseMatrix< MT1 > > 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
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatSVecMultExpr.h:143
Header file for the IsMatMatMultExpr type trait class.
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
RightOperand vec_
Right-hand side sparse vector of the multiplication expression.
Definition: TSMatSVecMultExpr.h:301
typename SubvectorExprTrait< VT, AF >::Type SubvectorExprTrait_
Auxiliary alias declaration for the SubvectorExprTrait type trait.The SubvectorExprTrait_ alias decla...
Definition: SubvectorExprTrait.h:133
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: TSMatSVecMultExpr.h:293
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
TSMatSVecMultExpr< MT, VT > This
Type of this TSMatSVecMultExpr instance.
Definition: TSMatSVecMultExpr.h:136
Header file for the IsLower type trait.
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional vector type...
Definition: SparseVector.h:61
Compile time check for diagonal matrices.This type trait tests whether or not the given template para...
Definition: IsDiagonal.h:90
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:336
ResultType_< VT > VRT
Result type of the right-hand side sparse vector expression.
Definition: TSMatSVecMultExpr.h:106
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT >, IsDeclExpr< MT > >, RowExprTrait_< MT > > row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:128
#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:60
#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:110
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse vector operand.
Definition: TSMatSVecMultExpr.h:259
Header file for the exception macros of the math module.
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
Header file for all forward declarations for expression class templates.
Constraint on the data type.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TSMatSVecMultExpr.h:283
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
ResultType_< MT > MRT
Result type of the left-hand side sparse matrix expression.
Definition: TSMatSVecMultExpr.h:105
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TSMatSVecMultExpr.h:271
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TSMatSVecMultExpr.h:184
LeftOperand mat_
Left-hand side sparse matrix of the multiplication expression.
Definition: TSMatSVecMultExpr.h:300
Header file for run time assertion macros.
TSMatSVecMultExpr(const MT &mat, const VT &vec) noexcept
Constructor for the TSMatSVecMultExpr class.
Definition: TSMatSVecMultExpr.h:170
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:160
Header file for the reset shim.
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:93
Header file for the isDefault shim.
MultTrait_< MRT, VRT > ResultType
Result type for expression template evaluations.
Definition: TSMatSVecMultExpr.h:137
Constraints on the storage order of matrix types.
Header file for the RemoveReference type trait.
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TSMatSVecMultExpr.h:138
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
IfTrue_< evaluateVector, const VRT, VCT > RT
Type for the assignment of the right-hand side sparse vector operand.
Definition: TSMatSVecMultExpr.h:155
Header file for the IsComputation type trait class.
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:120
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
Constraint on the data type.
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:573
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
Header file for the IsUpper type trait.
Header file for the MatVecMultExpr base class.
IfTrue_< evaluateMatrix, const MRT, MCT > LT
Type for the assignment of the left-hand side sparse matrix operand.
Definition: TSMatSVecMultExpr.h:152
Header file for the IsResizable type trait.
const DMatDMatMultExpr< T1, T2, false, false, false, false > 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:7505
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:61
Header file for the IsExpression type trait class.
Header file for the function trace functionality.