TSVecSMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSVECSMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSVECSMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
52 #include <blaze/math/Exception.h>
58 #include <blaze/math/shims/Reset.h>
68 #include <blaze/util/Assert.h>
69 #include <blaze/util/DisableIf.h>
70 #include <blaze/util/EnableIf.h>
72 #include <blaze/util/mpl/If.h>
73 #include <blaze/util/Types.h>
75 
76 
77 namespace blaze {
78 
79 //=================================================================================================
80 //
81 // CLASS TSVECSMATMULTEXPR
82 //
83 //=================================================================================================
84 
85 //*************************************************************************************************
92 template< typename VT // Type of the left-hand side sparse vector
93  , typename MT > // Type of the right-hand side sparse matrix
94 class TSVecSMatMultExpr
95  : public TVecMatMultExpr< SparseVector< TSVecSMatMultExpr<VT,MT>, true > >
96  , private Computation
97 {
98  private:
99  //**Type definitions****************************************************************************
104  //**********************************************************************************************
105 
106  //**********************************************************************************************
108  enum : bool { evaluateVector = IsComputation<VT>::value };
109  //**********************************************************************************************
110 
111  //**********************************************************************************************
113  enum : bool { evaluateMatrix = RequiresEvaluation<MT>::value };
114  //**********************************************************************************************
115 
116  //**********************************************************************************************
118 
122  template< typename T1 >
123  struct UseSMPAssign {
124  enum : bool { value = ( evaluateVector || evaluateMatrix ) };
125  };
127  //**********************************************************************************************
128 
129  public:
130  //**Type definitions****************************************************************************
135  using ReturnType = const ElementType;
136  using CompositeType = const ResultType;
137 
139  using LeftOperand = If_< IsExpression<VT>, const VT, const VT& >;
140 
142  using RightOperand = If_< IsExpression<MT>, const MT, const MT& >;
143 
146 
149  //**********************************************************************************************
150 
151  //**Compilation flags***************************************************************************
153  enum : bool { smpAssignable = !evaluateVector && VT::smpAssignable &&
154  !evaluateMatrix && MT::smpAssignable };
155  //**********************************************************************************************
156 
157  //**Constructor*********************************************************************************
163  explicit inline TSVecSMatMultExpr( const VT& vec, const MT& mat ) noexcept
164  : vec_( vec ) // Left-hand side sparse vector of the multiplication expression
165  , mat_( mat ) // Right-hand side sparse matrix of the multiplication expression
166  {
167  BLAZE_INTERNAL_ASSERT( vec_.size() == mat_.rows(), "Invalid vector and matrix sizes" );
168  }
169  //**********************************************************************************************
170 
171  //**Subscript operator**************************************************************************
177  inline ReturnType operator[]( size_t index ) const {
178  BLAZE_INTERNAL_ASSERT( index < mat_.columns(), "Invalid vector access index" );
179 
181  {
182  return vec_[index] * mat_(index,index);
183  }
184  else if( IsLower<MT>::value )
185  {
186  const size_t begin( IsStrictlyLower<MT>::value ? index+1UL : index );
187  const size_t n ( mat_.rows() - begin );
188  return subvector( vec_, begin, n ) * subvector( column( mat_, index ), begin, n );
189  }
190  else if( IsUpper<MT>::value )
191  {
192  const size_t n( IsStrictlyUpper<MT>::value ? index : index+1UL );
193  return subvector( vec_, 0UL, n ) * subvector( column( mat_, index ), 0UL, n );
194  }
195  else
196  {
197  return vec_ * column( mat_, index );
198  }
199  }
200  //**********************************************************************************************
201 
202  //**At function*********************************************************************************
209  inline ReturnType at( size_t index ) const {
210  if( index >= mat_.columns() ) {
211  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
212  }
213  return (*this)[index];
214  }
215  //**********************************************************************************************
216 
217  //**Size function*******************************************************************************
222  inline size_t size() const noexcept {
223  return mat_.columns();
224  }
225  //**********************************************************************************************
226 
227  //**NonZeros function***************************************************************************
232  inline size_t nonZeros() const {
233  return mat_.columns();
234  }
235  //**********************************************************************************************
236 
237  //**Left operand access*************************************************************************
242  inline LeftOperand leftOperand() const noexcept {
243  return vec_;
244  }
245  //**********************************************************************************************
246 
247  //**Right operand access************************************************************************
252  inline RightOperand rightOperand() const noexcept {
253  return mat_;
254  }
255  //**********************************************************************************************
256 
257  //**********************************************************************************************
263  template< typename T >
264  inline bool canAlias( const T* alias ) const noexcept {
265  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
266  }
267  //**********************************************************************************************
268 
269  //**********************************************************************************************
275  template< typename T >
276  inline bool isAliased( const T* alias ) const noexcept {
277  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
278  }
279  //**********************************************************************************************
280 
281  //**********************************************************************************************
286  inline bool canSMPAssign() const noexcept {
287  return ( size() > SMP_TSVECSMATMULT_THRESHOLD );
288  }
289  //**********************************************************************************************
290 
291  private:
292  //**Member variables****************************************************************************
295  //**********************************************************************************************
296 
297  //**Assignment to dense vectors*****************************************************************
310  template< typename VT1 > // Type of the target dense vector
311  friend inline void assign( DenseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
312  {
314 
315  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
316 
317  // Resetting the left-hand side target dense vector
318  reset( ~lhs );
319 
320  // Evaluation of the left-hand side sparse vector operand
321  LT x( serial( rhs.vec_ ) );
322  if( x.nonZeros() == 0UL ) return;
323 
324  // Evaluation of the right-hand side sparse matrix operand
325  RT A( serial( rhs.mat_ ) );
326 
327  // Checking the evaluated operands
328  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
329  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
330  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
331  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
332 
333  // Performing the sparse vector-sparse matrix multiplication
334  TSVecSMatMultExpr::selectAssignKernel( ~lhs, x, A );
335  }
337  //**********************************************************************************************
338 
339  //**Default assignment to dense vectors*********************************************************
353  template< typename VT1 // Type of the left-hand side target vector
354  , typename VT2 // Type of the left-hand side vector operand
355  , typename MT1 > // Type of the right-hand side matrix operand
356  static inline void selectAssignKernel( VT1& y, const VT2& x, const MT1& A )
357  {
358  using VectorIterator = ConstIterator_< RemoveReference_<VT2> >;
359  using MatrixIterator = ConstIterator_< RemoveReference_<MT1> >;
360 
361  const VectorIterator vend( x.end() );
362  VectorIterator velem( x.begin() );
363 
364  for( ; velem!=vend; ++velem )
365  {
366  const MatrixIterator mend( A.end( velem->index() ) );
367  MatrixIterator melem( A.begin( velem->index() ) );
368 
369  for( ; melem!=mend; ++melem ) {
370  if( IsResizable< ElementType_<VT1> >::value &&
371  isDefault( y[melem->index()] ) )
372  y[melem->index()] = velem->value() * melem->value();
373  else
374  y[melem->index()] += velem->value() * melem->value();
375  }
376  }
377  }
379  //**********************************************************************************************
380 
381  //**Assignment to sparse vectors****************************************************************
393  template< typename VT1 > // Type of the target sparse vector
394  friend inline void assign( SparseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
395  {
397 
398  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
399 
400  const DynamicVector<ElementType_<VT1>,true> tmp( serial( rhs ) );
401  assign( ~lhs, tmp );
402  }
404  //**********************************************************************************************
405 
406  //**Addition assignment to dense vectors********************************************************
419  template< typename VT1 > // Type of the target dense vector
420  friend inline void addAssign( DenseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
421  {
423 
424  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
425 
426  // Evaluation of the left-hand side sparse vector operand
427  LT x( serial( rhs.vec_ ) );
428  if( x.nonZeros() == 0UL ) return;
429 
430  // Evaluation of the right-hand side sparse matrix operand
431  RT A( serial( rhs.mat_ ) );
432 
433  // Checking the evaluated operands
434  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
435  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
436  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
437  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
438 
439  // Performing the sparse vector-sparse matrix multiplication
440  TSVecSMatMultExpr::selectAddAssignKernel( ~lhs, x, A );
441  }
443  //**********************************************************************************************
444 
445  //**Default addition assignment to dense vectors************************************************
459  template< typename VT1 // Type of the left-hand side target vector
460  , typename VT2 // Type of the left-hand side vector operand
461  , typename MT1 > // Type of the right-hand side matrix operand
462  static inline void selectAddAssignKernel( VT1& y, const VT2& x, const MT1& A )
463  {
464  using VectorIterator = ConstIterator_< RemoveReference_<VT2> >;
465  using MatrixIterator = ConstIterator_< RemoveReference_<MT1> >;
466 
467  const VectorIterator vend( x.end() );
468  VectorIterator velem( x.begin() );
469 
470  for( ; velem!=vend; ++velem )
471  {
472  const MatrixIterator mend( A.end( velem->index() ) );
473  MatrixIterator melem( A.begin( velem->index() ) );
474 
475  for( ; melem!=mend; ++melem ) {
476  y[melem->index()] += velem->value() * melem->value();
477  }
478  }
479  }
481  //**********************************************************************************************
482 
483  //**Addition assignment to sparse vectors*******************************************************
484  // No special implementation for the addition assignment to sparse vectors.
485  //**********************************************************************************************
486 
487  //**Subtraction assignment to dense vectors*****************************************************
500  template< typename VT1 > // Type of the target dense vector
501  friend inline void subAssign( DenseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
502  {
504 
505  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
506 
507  // Evaluation of the left-hand side sparse vector operand
508  LT x( serial( rhs.vec_ ) );
509  if( x.nonZeros() == 0UL ) return;
510 
511  // Evaluation of the right-hand side sparse matrix operand
512  RT A( serial( rhs.mat_ ) );
513 
514  // Checking the evaluated operands
515  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
516  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
517  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
518  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
519 
520  // Performing the sparse vector-sparse matrix multiplication
521  TSVecSMatMultExpr::selectSubAssignKernel( ~lhs, x, A );
522  }
524  //**********************************************************************************************
525 
526  //**Default subtraction assignment to dense vectors*********************************************
540  template< typename VT1 // Type of the left-hand side target vector
541  , typename VT2 // Type of the left-hand side vector operand
542  , typename MT1 > // Type of the right-hand side matrix operand
543  static inline void selectSubAssignKernel( VT1& y, const VT2& x, const MT1& A )
544  {
545  using VectorIterator = ConstIterator_< RemoveReference_<VT2> >;
546  using MatrixIterator = ConstIterator_< RemoveReference_<MT1> >;
547 
548  const VectorIterator vend( x.end() );
549  VectorIterator velem( x.begin() );
550 
551  for( ; velem!=vend; ++velem )
552  {
553  const MatrixIterator mend( A.end( velem->index() ) );
554  MatrixIterator melem( A.begin( velem->index() ) );
555 
556  for( ; melem!=mend; ++melem ) {
557  y[melem->index()] -= velem->value() * melem->value();
558  }
559  }
560  }
562  //**********************************************************************************************
563 
564  //**Subtraction assignment to sparse vectors****************************************************
565  // No special implementation for the subtraction assignment to sparse vectors.
566  //**********************************************************************************************
567 
568  //**Multiplication assignment to dense vectors**************************************************
581  template< typename VT1 > // Type of the target dense vector
582  friend inline void multAssign( DenseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
583  {
585 
589 
590  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
591 
592  const ResultType tmp( serial( rhs ) );
593  multAssign( ~lhs, tmp );
594  }
596  //**********************************************************************************************
597 
598  //**Multiplication assignment to sparse vectors*************************************************
599  // No special implementation for the multiplication assignment to sparse vectors.
600  //**********************************************************************************************
601 
602  //**SMP assignment to dense vectors*************************************************************
617  template< typename VT1 > // Type of the target dense vector
618  friend inline EnableIf_< UseSMPAssign<VT1> >
620  {
622 
623  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
624 
625  // Resetting the left-hand side target dense vector
626  reset( ~lhs );
627 
628  // Evaluation of the left-hand side sparse vector operand
629  LT x( rhs.vec_ );
630  if( x.nonZeros() == 0UL ) return;
631 
632  // Evaluation of the right-hand side sparse matrix operand
633  RT A( rhs.mat_ );
634 
635  // Checking the evaluated operands
636  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
637  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
638  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
639  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
640 
641  // Performing the sparse vector-sparse matrix multiplication
642  smpAssign( ~lhs, x * A );
643  }
645  //**********************************************************************************************
646 
647  //**SMP assignment to sparse vectors************************************************************
648  // No special implementation for the SMP assignment to sparse vectors.
649  //**********************************************************************************************
650 
651  //**SMP addition assignment to dense vectors****************************************************
666  template< typename VT1 > // Type of the target dense vector
667  friend inline EnableIf_< UseSMPAssign<VT1> >
669  {
671 
672  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
673 
674  // Evaluation of the left-hand side sparse vector operand
675  LT x( rhs.vec_ );
676  if( x.nonZeros() == 0UL ) return;
677 
678  // Evaluation of the right-hand side sparse matrix operand
679  RT A( rhs.mat_ );
680 
681  // Checking the evaluated operands
682  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
683  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
684  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
685  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
686 
687  // Performing the sparse vector-sparse matrix multiplication
688  smpAddAssign( ~lhs, x * A );
689  }
691  //**********************************************************************************************
692 
693  //**SMP addition assignment to sparse vectors***************************************************
694  // No special implementation for the SMP addition assignment to sparse vectors.
695  //**********************************************************************************************
696 
697  //**SMP subtraction assignment to dense vectors*************************************************
712  template< typename VT1 > // Type of the target dense vector
713  friend inline EnableIf_< UseSMPAssign<VT1> >
715  {
717 
718  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
719 
720  // Evaluation of the left-hand side sparse vector operand
721  LT x( rhs.vec_ );
722  if( x.nonZeros() == 0UL ) return;
723 
724  // Evaluation of the right-hand side sparse matrix operand
725  RT A( rhs.mat_ );
726 
727  // Checking the evaluated operands
728  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
729  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
730  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
731  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
732 
733  // Performing the sparse vector-sparse matrix multiplication
734  smpSubAssign( ~lhs, x * A );
735  }
737  //**********************************************************************************************
738 
739  //**SMP subtraction assignment to sparse vectors************************************************
740  // No special implementation for the SMP subtraction assignment to sparse vectors.
741  //**********************************************************************************************
742 
743  //**SMP multiplication assignment to dense vectors**********************************************
758  template< typename VT1 > // Type of the target dense vector
759  friend inline EnableIf_< UseSMPAssign<VT1> >
761  {
763 
767 
768  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
769 
770  const ResultType tmp( rhs );
771  smpMultAssign( ~lhs, tmp );
772  }
774  //**********************************************************************************************
775 
776  //**SMP multiplication assignment to sparse vectors*********************************************
777  // No special implementation for the SMP multiplication assignment to sparse vectors.
778  //**********************************************************************************************
779 
780  //**Compile time checks*************************************************************************
788  //**********************************************************************************************
789 };
790 //*************************************************************************************************
791 
792 
793 
794 
795 //=================================================================================================
796 //
797 // GLOBAL BINARY ARITHMETIC OPERATORS
798 //
799 //=================================================================================================
800 
801 //*************************************************************************************************
832 template< typename VT // Type of the left-hand side sparse vector
833  , typename MT > // Type of the right-hand side sparse matrix
834 inline decltype(auto)
835  operator*( const SparseVector<VT,true>& vec, const SparseMatrix<MT,false>& mat )
836 {
838 
840 
841  if( (~vec).size() != (~mat).rows() ) {
842  BLAZE_THROW_INVALID_ARGUMENT( "Vector and matrix sizes do not match" );
843  }
844 
845  using ReturnType = const TSVecSMatMultExpr<VT,MT>;
846  return ReturnType( ~vec, ~mat );
847 }
848 //*************************************************************************************************
849 
850 
851 
852 
853 //=================================================================================================
854 //
855 // SIZE SPECIALIZATIONS
856 //
857 //=================================================================================================
858 
859 //*************************************************************************************************
861 template< typename VT, typename MT >
862 struct Size< TSVecSMatMultExpr<VT,MT> >
863  : public Columns<MT>
864 {};
866 //*************************************************************************************************
867 
868 } // namespace blaze
869 
870 #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
MultTrait_< VRT, MRT > ResultType
Result type for expression template evaluations.
Definition: TSVecSMatMultExpr.h:132
Header file for basic type definitions.
Header file for the SparseVector base class.
Subvector< VT, AF > 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:322
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:164
Header file for the serial shim.
IfTrue_< evaluateMatrix, const MRT, MCT > RT
Type for the assignment of the right-hand side sparse matrix operand.
Definition: TSVecSMatMultExpr.h:148
IfTrue_< evaluateVector, const VRT, VCT > LT
Type for the assignment of the left-hand side sparse vector operand.
Definition: TSVecSMatMultExpr.h:145
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:198
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSVecSMatMultExpr.h:135
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:560
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
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TSVecSMatMultExpr.h:133
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:250
LeftOperand leftOperand() const noexcept
Returns the left-hand side sparse vector operand.
Definition: TSVecSMatMultExpr.h:242
Column< MT > column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:124
Header file for the Computation base class.
CompositeType_< MT > MCT
Composite type of the right-hand side sparse matrix expression.
Definition: TSVecSMatMultExpr.h:103
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: TSVecSMatMultExpr.h:222
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
Constraints on the storage order of matrix types.
Efficient implementation of an arbitrary sized vector.The DynamicVector class template is the represe...
Definition: DynamicVector.h:183
RightOperand mat_
Right-hand side sparse matrix of the multiplication expression.
Definition: TSVecSMatMultExpr.h:294
Header file for the RequiresEvaluation type trait.
If_< IsExpression< VT >, const VT, const VT &> LeftOperand
Composite type of the left-hand side sparse vector expression.
Definition: TSVecSMatMultExpr.h:139
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TSVecSMatMultExpr.h:177
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:343
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:133
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TSVecSMatMultExpr.h:264
Header file for the implementation of an arbitrarily sized vector.
TSVecSMatMultExpr(const VT &vec, const MT &mat) noexcept
Constructor for the TSVecSMatMultExpr class.
Definition: TSVecSMatMultExpr.h:163
ElementType_< ResultType > ElementType
Resulting element type.
Definition: TSVecSMatMultExpr.h:134
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
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 data type.
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:72
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Header file for the DisableIf class template.
Header file for the multiplication trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
Expression object for sparse vector-sparse matrix multiplications.The TSVecSMatMultExpr class represe...
Definition: Forward.h:174
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:102
#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
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: TSVecSMatMultExpr.h:209
Header file for the Columns type trait.
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
size_t nonZeros() const
Returns an estimation for the number of non-zero elements in the sparse vector.
Definition: TSVecSMatMultExpr.h:232
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
#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
#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:88
Header file for the exception macros of the math module.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TSVecSMatMultExpr.h:276
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
Constraint on the data type.
Header file for all forward declarations for expression class templates.
Constraint on the data type.
If_< IsExpression< MT >, const MT, const MT &> RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TSVecSMatMultExpr.h:142
Header file for the EnableIf class template.
LeftOperand vec_
Left-hand side sparse vector of the multiplication expression.
Definition: TSVecSMatMultExpr.h:293
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
#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: RowMajorMatrix.h:61
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: TSVecSMatMultExpr.h:286
Header file for run time assertion macros.
CompositeType_< VT > VCT
Composite type of the left-hand side sparse vector expression.
Definition: TSVecSMatMultExpr.h:102
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:154
ResultType_< MT > MRT
Result type of the right-hand side sparse matrix expression.
Definition: TSVecSMatMultExpr.h:101
Header file for the reset shim.
Constraint on the data type.
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
Header file for the isDefault shim.
Header file for the TVecMatMultExpr base class.
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:819
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.In case the given data type T requires an intermediate evaluation within ...
Definition: RequiresEvaluation.h:81
ResultType_< VT > VRT
Result type of the left-hand side sparse vector expression.
Definition: TSVecSMatMultExpr.h:100
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:224
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:324
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3082
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_TVECMATMULTEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/matrix ...
Definition: TVecMatMultExpr.h:109
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse matrix operand.
Definition: TSVecSMatMultExpr.h:252
Header file for the IsComputation type trait class.
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSVecSMatMultExpr.h:136
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:74
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:130
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:75
#define BLAZE_CONSTRAINT_MUST_BE_ROW_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a row dense or sparse vector type (i...
Definition: RowVector.h:61
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:600
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:423
Constraint on the data type.
Header file for the IsResizable type trait.
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
Constraint on the transpose flag of vector types.
Header file for the IsExpression type trait class.
Header file for the function trace functionality.