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/mpl/If.h>
80 #include <blaze/util/Types.h>
81 #include <blaze/util/Unused.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 =
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  UNUSED_PARAMETER( 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  UNUSED_PARAMETER( 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
decltype(auto) subvector(Vector< VT, TF > &, RSAs...)
Creating a view on a specific subvector of the given vector.
Definition: Subvector.h:329
#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 the UNUSED_PARAMETER function template.
Header file for basic type definitions.
Header file for the SparseVector base class.
typename If< Condition, T1, T2 >::Type If_t
Auxiliary alias declaration for the If class template.The If_t alias declaration provides a convenien...
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:591
static constexpr bool smpAssignable
Compilation flag for SMP assignments.
Definition: CompressedMatrix.h:3113
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.
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.
constexpr void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
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:137
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.
Header file for the DisableIf class template.
Header file for the multiplication trait.
Header file for the IsStrictlyUpper type trait.
constexpr bool IsResizable_v
Auxiliary variable template for the IsResizable type trait.The IsResizable_v variable template provid...
Definition: IsResizable.h:134
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:183
#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.
#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.
Header file for all forward declarations for expression class templates.
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 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
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3081
#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:138
#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:631
Header file for the IsUpper type trait.
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, 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
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.