Blaze  3.6
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>
53 #include <blaze/math/Exception.h>
59 #include <blaze/math/shims/Reset.h>
73 #include <blaze/math/views/Check.h>
75 #include <blaze/util/Assert.h>
76 #include <blaze/util/DisableIf.h>
77 #include <blaze/util/EnableIf.h>
79 #include <blaze/util/MaybeUnused.h>
80 #include <blaze/util/mpl/If.h>
81 #include <blaze/util/Types.h>
82 
83 
84 namespace blaze {
85 
86 //=================================================================================================
87 //
88 // CLASS TSVECSMATMULTEXPR
89 //
90 //=================================================================================================
91 
92 //*************************************************************************************************
99 template< typename VT // Type of the left-hand side sparse vector
100  , typename MT > // Type of the right-hand side sparse matrix
101 class TSVecSMatMultExpr
102  : public TVecMatMultExpr< SparseVector< TSVecSMatMultExpr<VT,MT>, true > >
103  , private Computation
104 {
105  private:
106  //**Type definitions****************************************************************************
111  //**********************************************************************************************
112 
113  //**********************************************************************************************
115  static constexpr bool evaluateVector = IsComputation_v<VT>;
116  //**********************************************************************************************
117 
118  //**********************************************************************************************
120  static constexpr bool evaluateMatrix = RequiresEvaluation_v<MT>;
121  //**********************************************************************************************
122 
123  //**********************************************************************************************
125 
129  template< typename T1 >
130  static constexpr bool UseSMPAssign_v = ( evaluateVector || evaluateMatrix );
132  //**********************************************************************************************
133 
134  public:
135  //**Type definitions****************************************************************************
141  using ReturnType = const ElementType;
142  using CompositeType = const ResultType;
143 
145  using LeftOperand = If_t< IsExpression_v<VT>, const VT, const VT& >;
146 
148  using RightOperand = If_t< IsExpression_v<MT>, const MT, const MT& >;
149 
152 
155  //**********************************************************************************************
156 
157  //**Compilation flags***************************************************************************
159  static constexpr bool smpAssignable =
160  ( !evaluateVector && VT::smpAssignable && !evaluateMatrix && MT::smpAssignable );
161  //**********************************************************************************************
162 
163  //**Constructor*********************************************************************************
169  explicit inline TSVecSMatMultExpr( const VT& vec, const MT& mat ) noexcept
170  : vec_( vec ) // Left-hand side sparse vector of the multiplication expression
171  , mat_( mat ) // Right-hand side sparse matrix of the multiplication expression
172  {
173  BLAZE_INTERNAL_ASSERT( vec_.size() == mat_.rows(), "Invalid vector and matrix sizes" );
174  }
175  //**********************************************************************************************
176 
177  //**Subscript operator**************************************************************************
183  inline ReturnType operator[]( size_t index ) const {
184  BLAZE_INTERNAL_ASSERT( index < mat_.columns(), "Invalid vector access index" );
185 
186  if( IsDiagonal_v<MT> )
187  {
188  return vec_[index] * mat_(index,index);
189  }
190  else if( IsLower_v<MT> )
191  {
192  const size_t begin( IsStrictlyLower_v<MT> ? index+1UL : index );
193  const size_t n ( mat_.rows() - begin );
194  return subvector( vec_, begin, n, unchecked ) *
195  subvector( column( mat_, index, unchecked ), begin, n, unchecked );
196  }
197  else if( IsUpper_v<MT> )
198  {
199  const size_t n( IsStrictlyUpper_v<MT> ? index : index+1UL );
200  return subvector( vec_, 0UL, n, unchecked ) *
201  subvector( column( mat_, index, unchecked ), 0UL, n, unchecked );
202  }
203  else
204  {
205  return vec_ * column( mat_, index, unchecked );
206  }
207  }
208  //**********************************************************************************************
209 
210  //**At function*********************************************************************************
217  inline ReturnType at( size_t index ) const {
218  if( index >= mat_.columns() ) {
219  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
220  }
221  return (*this)[index];
222  }
223  //**********************************************************************************************
224 
225  //**Size function*******************************************************************************
230  inline size_t size() const noexcept {
231  return mat_.columns();
232  }
233  //**********************************************************************************************
234 
235  //**NonZeros function***************************************************************************
240  inline size_t nonZeros() const {
241  return mat_.columns();
242  }
243  //**********************************************************************************************
244 
245  //**Left operand access*************************************************************************
250  inline LeftOperand leftOperand() const noexcept {
251  return vec_;
252  }
253  //**********************************************************************************************
254 
255  //**Right operand access************************************************************************
260  inline RightOperand rightOperand() const noexcept {
261  return mat_;
262  }
263  //**********************************************************************************************
264 
265  //**********************************************************************************************
271  template< typename T >
272  inline bool canAlias( const T* alias ) const noexcept {
273  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
274  }
275  //**********************************************************************************************
276 
277  //**********************************************************************************************
283  template< typename T >
284  inline bool isAliased( const T* alias ) const noexcept {
285  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
286  }
287  //**********************************************************************************************
288 
289  //**********************************************************************************************
294  inline bool canSMPAssign() const noexcept {
295  return ( size() > SMP_TSVECSMATMULT_THRESHOLD );
296  }
297  //**********************************************************************************************
298 
299  private:
300  //**Member variables****************************************************************************
303  //**********************************************************************************************
304 
305  //**Assignment to dense vectors*****************************************************************
318  template< typename VT1 > // Type of the target dense vector
319  friend inline void assign( DenseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
320  {
322 
323  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
324 
325  // Resetting the left-hand side target dense vector
326  reset( ~lhs );
327 
328  // Evaluation of the left-hand side sparse vector operand
329  LT x( serial( rhs.vec_ ) );
330  if( x.nonZeros() == 0UL ) return;
331 
332  // Evaluation of the right-hand side sparse matrix operand
333  RT A( serial( rhs.mat_ ) );
334 
335  // Checking the evaluated operands
336  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
337  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
338  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
339  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
340 
341  // Performing the sparse vector-sparse matrix multiplication
342  TSVecSMatMultExpr::selectAssignKernel( ~lhs, x, A );
343  }
345  //**********************************************************************************************
346 
347  //**Default assignment to dense vectors*********************************************************
361  template< typename VT1 // Type of the left-hand side target vector
362  , typename VT2 // Type of the left-hand side vector operand
363  , typename MT1 > // Type of the right-hand side matrix operand
364  static inline void selectAssignKernel( VT1& y, const VT2& x, const MT1& A )
365  {
366  const auto vend( x.end() );
367  auto velem( x.begin() );
368 
369  for( ; velem!=vend; ++velem )
370  {
371  const auto mend( A.end( velem->index() ) );
372  auto melem( A.begin( velem->index() ) );
373 
374  for( ; melem!=mend; ++melem ) {
376  isDefault( y[melem->index()] ) )
377  y[melem->index()] = velem->value() * melem->value();
378  else
379  y[melem->index()] += velem->value() * melem->value();
380  }
381  }
382  }
384  //**********************************************************************************************
385 
386  //**Assignment to sparse vectors****************************************************************
398  template< typename VT1 > // Type of the target sparse vector
399  friend inline void assign( SparseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
400  {
402 
403  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
404 
405  const DynamicVector<ElementType_t<VT1>,true> tmp( serial( rhs ) );
406  assign( ~lhs, tmp );
407  }
409  //**********************************************************************************************
410 
411  //**Addition assignment to dense vectors********************************************************
424  template< typename VT1 > // Type of the target dense vector
425  friend inline void addAssign( DenseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
426  {
428 
429  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
430 
431  // Evaluation of the left-hand side sparse vector operand
432  LT x( serial( rhs.vec_ ) );
433  if( x.nonZeros() == 0UL ) return;
434 
435  // Evaluation of the right-hand side sparse matrix operand
436  RT A( serial( rhs.mat_ ) );
437 
438  // Checking the evaluated operands
439  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
440  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
441  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
442  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
443 
444  // Performing the sparse vector-sparse matrix multiplication
445  TSVecSMatMultExpr::selectAddAssignKernel( ~lhs, x, A );
446  }
448  //**********************************************************************************************
449 
450  //**Default addition assignment to dense vectors************************************************
464  template< typename VT1 // Type of the left-hand side target vector
465  , typename VT2 // Type of the left-hand side vector operand
466  , typename MT1 > // Type of the right-hand side matrix operand
467  static inline void selectAddAssignKernel( VT1& y, const VT2& x, const MT1& A )
468  {
469  const auto vend( x.end() );
470  auto velem( x.begin() );
471 
472  for( ; velem!=vend; ++velem )
473  {
474  const auto mend( A.end( velem->index() ) );
475  auto melem( A.begin( velem->index() ) );
476 
477  for( ; melem!=mend; ++melem ) {
478  y[melem->index()] += velem->value() * melem->value();
479  }
480  }
481  }
483  //**********************************************************************************************
484 
485  //**Addition assignment to sparse vectors*******************************************************
486  // No special implementation for the addition assignment to sparse vectors.
487  //**********************************************************************************************
488 
489  //**Subtraction assignment to dense vectors*****************************************************
502  template< typename VT1 > // Type of the target dense vector
503  friend inline void subAssign( DenseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
504  {
506 
507  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
508 
509  // Evaluation of the left-hand side sparse vector operand
510  LT x( serial( rhs.vec_ ) );
511  if( x.nonZeros() == 0UL ) return;
512 
513  // Evaluation of the right-hand side sparse matrix operand
514  RT A( serial( rhs.mat_ ) );
515 
516  // Checking the evaluated operands
517  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
518  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
519  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
520  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
521 
522  // Performing the sparse vector-sparse matrix multiplication
523  TSVecSMatMultExpr::selectSubAssignKernel( ~lhs, x, A );
524  }
526  //**********************************************************************************************
527 
528  //**Default subtraction assignment to dense vectors*********************************************
542  template< typename VT1 // Type of the left-hand side target vector
543  , typename VT2 // Type of the left-hand side vector operand
544  , typename MT1 > // Type of the right-hand side matrix operand
545  static inline void selectSubAssignKernel( VT1& y, const VT2& x, const MT1& A )
546  {
547  const auto vend( x.end() );
548  auto velem( x.begin() );
549 
550  for( ; velem!=vend; ++velem )
551  {
552  const auto mend( A.end( velem->index() ) );
553  auto melem( A.begin( velem->index() ) );
554 
555  for( ; melem!=mend; ++melem ) {
556  y[melem->index()] -= velem->value() * melem->value();
557  }
558  }
559  }
561  //**********************************************************************************************
562 
563  //**Subtraction assignment to sparse vectors****************************************************
564  // No special implementation for the subtraction assignment to sparse vectors.
565  //**********************************************************************************************
566 
567  //**Multiplication assignment to dense vectors**************************************************
580  template< typename VT1 > // Type of the target dense vector
581  friend inline void multAssign( DenseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
582  {
584 
588 
589  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
590 
591  const ResultType tmp( serial( rhs ) );
592  multAssign( ~lhs, tmp );
593  }
595  //**********************************************************************************************
596 
597  //**Multiplication assignment to sparse vectors*************************************************
598  // No special implementation for the multiplication assignment to sparse vectors.
599  //**********************************************************************************************
600 
601  //**SMP assignment to dense vectors*************************************************************
616  template< typename VT1 > // Type of the target dense vector
617  friend inline auto smpAssign( DenseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
618  -> EnableIf_t< UseSMPAssign_v<VT1> >
619  {
621 
622  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
623 
624  // Resetting the left-hand side target dense vector
625  reset( ~lhs );
626 
627  // Evaluation of the left-hand side sparse vector operand
628  LT x( rhs.vec_ );
629  if( x.nonZeros() == 0UL ) return;
630 
631  // Evaluation of the right-hand side sparse matrix operand
632  RT A( rhs.mat_ );
633 
634  // Checking the evaluated operands
635  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
636  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
637  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
638  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
639 
640  // Performing the sparse vector-sparse matrix multiplication
641  smpAssign( ~lhs, x * A );
642  }
644  //**********************************************************************************************
645 
646  //**SMP assignment to sparse vectors************************************************************
647  // No special implementation for the SMP assignment to sparse vectors.
648  //**********************************************************************************************
649 
650  //**SMP addition assignment to dense vectors****************************************************
665  template< typename VT1 > // Type of the target dense vector
666  friend inline auto smpAddAssign( DenseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
667  -> EnableIf_t< UseSMPAssign_v<VT1> >
668  {
670 
671  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
672 
673  // Evaluation of the left-hand side sparse vector operand
674  LT x( rhs.vec_ );
675  if( x.nonZeros() == 0UL ) return;
676 
677  // Evaluation of the right-hand side sparse matrix operand
678  RT A( rhs.mat_ );
679 
680  // Checking the evaluated operands
681  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
682  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
683  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
684  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
685 
686  // Performing the sparse vector-sparse matrix multiplication
687  smpAddAssign( ~lhs, x * A );
688  }
690  //**********************************************************************************************
691 
692  //**SMP addition assignment to sparse vectors***************************************************
693  // No special implementation for the SMP addition assignment to sparse vectors.
694  //**********************************************************************************************
695 
696  //**SMP subtraction assignment to dense vectors*************************************************
711  template< typename VT1 > // Type of the target dense vector
712  friend inline auto smpSubAssign( DenseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
713  -> EnableIf_t< UseSMPAssign_v<VT1> >
714  {
716 
717  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
718 
719  // Evaluation of the left-hand side sparse vector operand
720  LT x( rhs.vec_ );
721  if( x.nonZeros() == 0UL ) return;
722 
723  // Evaluation of the right-hand side sparse matrix operand
724  RT A( rhs.mat_ );
725 
726  // Checking the evaluated operands
727  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
728  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
729  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
730  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
731 
732  // Performing the sparse vector-sparse matrix multiplication
733  smpSubAssign( ~lhs, x * A );
734  }
736  //**********************************************************************************************
737 
738  //**SMP subtraction assignment to sparse vectors************************************************
739  // No special implementation for the SMP subtraction assignment to sparse vectors.
740  //**********************************************************************************************
741 
742  //**SMP multiplication assignment to dense vectors**********************************************
757  template< typename VT1 > // Type of the target dense vector
758  friend inline auto smpMultAssign( DenseVector<VT1,true>& lhs, const TSVecSMatMultExpr& rhs )
759  -> EnableIf_t< UseSMPAssign_v<VT1> >
760  {
762 
766 
767  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
768 
769  const ResultType tmp( rhs );
770  smpMultAssign( ~lhs, tmp );
771  }
773  //**********************************************************************************************
774 
775  //**SMP multiplication assignment to sparse vectors*********************************************
776  // No special implementation for the SMP multiplication assignment to sparse vectors.
777  //**********************************************************************************************
778 
779  //**Compile time checks*************************************************************************
789  //**********************************************************************************************
790 };
791 //*************************************************************************************************
792 
793 
794 
795 
796 //=================================================================================================
797 //
798 // GLOBAL BINARY ARITHMETIC OPERATORS
799 //
800 //=================================================================================================
801 
802 //*************************************************************************************************
815 template< typename VT // Type of the left-hand side sparse vector
816  , typename MT // Type of the right-hand side sparse matrix
817  , DisableIf_t< ( IsIdentity_v<MT> &&
818  IsSame_v< ElementType_t<VT>, ElementType_t<MT> > ) ||
819  ( IsZero_v<MT> || IsZero_v<VT> ) >* = nullptr >
820 inline const TSVecSMatMultExpr<VT,MT>
821  tsvecsmatmult( const SparseVector<VT,true>& vec, const SparseMatrix<MT,false>& mat )
822 {
824 
825  BLAZE_INTERNAL_ASSERT( (~vec).size() == (~mat).rows(), "Invalid vector and matrix sizes" );
826 
827  return TSVecSMatMultExpr<VT,MT>( ~vec, ~mat );
828 }
830 //*************************************************************************************************
831 
832 
833 //*************************************************************************************************
847 template< typename VT // Type of the left-hand side sparse vector
848  , typename MT // Type of the right-hand side sparse matrix
849  , EnableIf_t< ( IsIdentity_v<MT> &&
850  IsSame_v< ElementType_t<VT>, ElementType_t<MT> > ) &&
851  !IsZero_v<VT> >* = nullptr >
852 inline const VT&
853  tsvecsmatmult( const SparseVector<VT,true>& vec, const SparseMatrix<MT,false>& mat )
854 {
856 
857  MAYBE_UNUSED( mat );
858 
859  BLAZE_INTERNAL_ASSERT( (~vec).size() == (~mat).rows(), "Invalid vector and matrix sizes" );
860 
861  return (~vec);
862 }
864 //*************************************************************************************************
865 
866 
867 //*************************************************************************************************
881 template< typename VT // Type of the left-hand side sparse vector
882  , typename MT // Type of the right-hand side sparse matrix
883  , EnableIf_t< IsZero_v<MT> || IsZero_v<VT> >* = nullptr >
884 inline decltype(auto)
885  tsvecsmatmult( const SparseVector<VT,true>& vec, const SparseMatrix<MT,false>& mat )
886 {
888 
889  MAYBE_UNUSED( vec );
890 
891  BLAZE_INTERNAL_ASSERT( (~vec).size() == (~mat).rows(), "Invalid vector and matrix sizes" );
892 
893  using ReturnType = const MultTrait_t< ResultType_t<VT>, ResultType_t<MT> >;
894 
897 
898  return ReturnType( (~mat).columns() );
899 }
901 //*************************************************************************************************
902 
903 
904 //*************************************************************************************************
935 template< typename VT // Type of the left-hand side sparse vector
936  , typename MT > // Type of the right-hand side sparse matrix
937 inline decltype(auto)
938  operator*( const SparseVector<VT,true>& vec, const SparseMatrix<MT,false>& mat )
939 {
941 
943 
944  if( (~vec).size() != (~mat).rows() ) {
945  BLAZE_THROW_INVALID_ARGUMENT( "Vector and matrix sizes do not match" );
946  }
947 
948  return tsvecsmatmult( ~vec, ~mat );
949 }
950 //*************************************************************************************************
951 
952 } // namespace blaze
953 
954 #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.
decltype(auto) column(Matrix< MT, SO > &matrix, RCAs... args)
Creating a view on a specific column of the given matrix.
Definition: Column.h:133
Header file for the blaze::checked and blaze::unchecked instances.
ElementType_t< ResultType > ElementType
Resulting element type.
Definition: TSVecSMatMultExpr.h:140
Header file for basic type definitions.
Header file for the SparseVector base class.
typename If< Condition, T1, T2 >::Type If_t
Auxiliary alias template for the If class template.The If_t alias template provides a convenient shor...
Definition: If.h:109
typename T::ResultType ResultType_t
Alias declaration for nested ResultType type definitions.The ResultType_t alias declaration provides ...
Definition: Aliases.h:390
Header file for the serial shim.
static constexpr bool evaluateMatrix
Compilation switch for the composite type of the right-hand side sparse matrix expression.
Definition: TSVecSMatMultExpr.h:120
Header file for the IsDiagonal type trait.
ResultType_t< VT > VRT
Result type of the left-hand side sparse vector expression.
Definition: TSVecSMatMultExpr.h:107
MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:372
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSVecSMatMultExpr.h:141
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:595
constexpr Unchecked unchecked
Global Unchecked instance.The blaze::unchecked instance is an optional token for the creation of view...
Definition: Check.h:138
Constraint on the data type.
decltype(auto) subvector(Vector< VT, TF > &, RSAs...)
Creating a view on a specific subvector of the given vector.
Definition: Subvector.h:154
Header file for the MAYBE_UNUSED function template.
Header file for the IsIdentity type trait.
LeftOperand leftOperand() const noexcept
Returns the left-hand side sparse vector operand.
Definition: TSVecSMatMultExpr.h:250
Header file for the Computation base class.
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: TSVecSMatMultExpr.h:230
Header file for the reset shim.
Constraints on the storage order of matrix types.
RightOperand mat_
Right-hand side sparse matrix of the multiplication expression.
Definition: TSVecSMatMultExpr.h:302
Header file for the RequiresEvaluation type trait.
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TSVecSMatMultExpr.h:183
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TSVecSMatMultExpr.h:272
Header file for the implementation of an arbitrarily sized vector.
constexpr size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:514
TransposeType_t< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TSVecSMatMultExpr.h:139
TSVecSMatMultExpr(const VT &vec, const MT &mat) noexcept
Constructor for the TSVecSMatMultExpr class.
Definition: TSVecSMatMultExpr.h:169
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes....
Definition: Forward.h:145
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.The ElementType_t alias declaration provide...
Definition: Aliases.h:170
If_t< evaluateMatrix, const MRT, MCT > RT
Type for the assignment of the right-hand side sparse matrix operand.
Definition: TSVecSMatMultExpr.h:154
Constraint on the data type.
typename EnableIf< Condition, T >::Type EnableIf_t
Auxiliary type for the EnableIf class template.The EnableIf_t alias declaration provides a convenient...
Definition: EnableIf.h:138
constexpr bool IsResizable_v
Auxiliary variable template for the IsResizable type trait.The IsResizable_v variable template provid...
Definition: IsResizable.h:133
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:58
Header file for the If class template.
#define BLAZE_CONSTRAINT_MUST_BE_ZERO_TYPE(T)
Constraint on the data type.In case the given data type T is not a zero vector or matrix type,...
Definition: Zero.h:61
Expression object for sparse vector-sparse matrix multiplications.The TSVecSMatMultExpr class represe...
Definition: Forward.h:195
#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:217
size_t nonZeros() const
Returns an estimation for the number of non-zero elements in the sparse vector.
Definition: TSVecSMatMultExpr.h:240
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:76
ResultType_t< MT > MRT
Result type of the right-hand side sparse matrix expression.
Definition: TSVecSMatMultExpr.h:108
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: TSVecSMatMultExpr.h:159
Header file for the IsLower type trait.
constexpr void MAYBE_UNUSED(const Args &...)
Suppression of unused parameter warnings.
Definition: MaybeUnused.h:81
#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
#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:83
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:284
Constraint on the data type.
Constraint on the data type.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
LeftOperand vec_
Left-hand side sparse vector of the multiplication expression.
Definition: TSVecSMatMultExpr.h:301
CompositeType_t< MT > MCT
Composite type of the right-hand side sparse matrix expression.
Definition: TSVecSMatMultExpr.h:110
If_t< IsExpression_v< MT >, const MT, const MT & > RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TSVecSMatMultExpr.h:148
typename MultTrait< T1, T2 >::Type MultTrait_t
Auxiliary alias declaration for the MultTrait class template.The MultTrait_t alias declaration provid...
Definition: MultTrait.h:240
If_t< evaluateVector, const VRT, VCT > LT
Type for the assignment of the left-hand side sparse vector operand.
Definition: TSVecSMatMultExpr.h:151
#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
CompositeType_t< VT > VCT
Composite type of the left-hand side sparse vector expression.
Definition: TSVecSMatMultExpr.h:109
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: TSVecSMatMultExpr.h:294
typename T::TransposeType TransposeType_t
Alias declaration for nested TransposeType type definitions.The TransposeType_t alias declaration pro...
Definition: Aliases.h:470
Header file for run time assertion macros.
typename T::CompositeType CompositeType_t
Alias declaration for nested CompositeType type definitions.The CompositeType_t alias declaration pro...
Definition: Aliases.h:90
auto smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:131
Header file for the IsZero type trait.
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 all forward declarations for expression class templates.
Header file for the isDefault shim.
constexpr size_t size(const Matrix< MT, SO > &matrix) noexcept
Returns the total number of elements of the matrix.
Definition: Matrix.h:530
auto smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:100
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:808
#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
MultTrait_t< VRT, MRT > ResultType
Result type for expression template evaluations.
Definition: TSVecSMatMultExpr.h:138
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:498
#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:104
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse matrix operand.
Definition: TSVecSMatMultExpr.h:260
Header file for the IsComputation type trait class.
auto smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:162
If_t< IsExpression_v< VT >, const VT, const VT & > LeftOperand
Composite type of the left-hand side sparse vector expression.
Definition: TSVecSMatMultExpr.h:145
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSVecSMatMultExpr.h:142
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:146
#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
static constexpr bool evaluateVector
Compilation switch for the composite type of the left-hand side sparse vector expression.
Definition: TSVecSMatMultExpr.h:115
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:635
Header file for the IsUpper type trait.
typename DisableIf< Condition, T >::Type DisableIf_t
Auxiliary type for the DisableIf class template.The DisableIf_t alias declaration provides a convenie...
Definition: DisableIf.h:138
Constraint on the data type.
Header file for the IsResizable type trait.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ZERO_TYPE(T)
Constraint on the data type.In case the given data type T is a zero vector or matrix type,...
Definition: Zero.h:81
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,...
Definition: Assert.h:101
auto smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > >
Default implementation of the SMP multiplication assignment of a vector to a dense vector.
Definition: DenseVector.h:191
#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.