TDVecSMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TDVECSMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TDVECSMATMULTEXPR_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>
70 #include <blaze/util/Assert.h>
71 #include <blaze/util/DisableIf.h>
72 #include <blaze/util/EnableIf.h>
75 #include <blaze/util/mpl/If.h>
76 #include <blaze/util/Types.h>
78 
79 
80 namespace blaze {
81 
82 //=================================================================================================
83 //
84 // CLASS TDVECSMATMULTEXPR
85 //
86 //=================================================================================================
87 
88 //*************************************************************************************************
95 template< typename VT // Type of the left-hand side dense vector
96  , typename MT > // Type of the right-hand side sparse matrix
97 class TDVecSMatMultExpr
98  : public TVecMatMultExpr< DenseVector< TDVecSMatMultExpr<VT,MT>, true > >
99  , private Computation
100 {
101  private:
102  //**Type definitions****************************************************************************
107  //**********************************************************************************************
108 
109  //**********************************************************************************************
111  enum : bool { evaluateVector = IsComputation<VT>::value || RequiresEvaluation<VT>::value };
112  //**********************************************************************************************
113 
114  //**********************************************************************************************
116  enum : bool { evaluateMatrix = RequiresEvaluation<MT>::value };
117  //**********************************************************************************************
118 
119  //**********************************************************************************************
121 
125  template< typename T1 >
126  struct UseSMPAssign {
127  enum : bool { value = ( evaluateVector || evaluateMatrix ) };
128  };
130  //**********************************************************************************************
131 
132  public:
133  //**Type definitions****************************************************************************
138  using ReturnType = const ElementType;
139  using CompositeType = const ResultType;
140 
142  using LeftOperand = If_< IsExpression<VT>, const VT, const VT& >;
143 
145  using RightOperand = If_< IsExpression<MT>, const MT, const MT& >;
146 
149 
152  //**********************************************************************************************
153 
154  //**Compilation flags***************************************************************************
156  enum : bool { simdEnabled = false };
157 
159  enum : bool { smpAssignable = !evaluateVector && VT::smpAssignable &&
160  !evaluateMatrix && MT::smpAssignable };
161  //**********************************************************************************************
162 
163  //**Constructor*********************************************************************************
166  explicit inline TDVecSMatMultExpr( const VT& vec, const MT& mat ) noexcept
167  : vec_( vec ) // Left-hand side dense vector of the multiplication expression
168  , mat_( mat ) // Right-hand side sparse matrix of the multiplication expression
169  {
170  BLAZE_INTERNAL_ASSERT( vec_.size() == mat_.rows(), "Invalid vector and matrix sizes" );
171  }
172  //**********************************************************************************************
173 
174  //**Subscript operator**************************************************************************
180  inline ReturnType operator[]( size_t index ) const {
181  BLAZE_INTERNAL_ASSERT( index < mat_.columns(), "Invalid vector access index" );
182 
184  {
185  return vec_[index] * mat_(index,index);
186  }
187  else if( IsLower<MT>::value )
188  {
189  const size_t begin( IsStrictlyLower<MT>::value ? index+1UL : index );
190  const size_t n ( mat_.rows() - begin );
191  return subvector( vec_, begin, n ) * subvector( column( mat_, index ), begin, n );
192  }
193  else if( IsUpper<MT>::value )
194  {
195  const size_t n( IsStrictlyUpper<MT>::value ? index : index+1UL );
196  return subvector( vec_, 0UL, n ) * subvector( column( mat_, index ), 0UL, n );
197  }
198  else
199  {
200  return vec_ * column( mat_, index );
201  }
202  }
203  //**********************************************************************************************
204 
205  //**At function*********************************************************************************
212  inline ReturnType at( size_t index ) const {
213  if( index >= mat_.columns() ) {
214  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
215  }
216  return (*this)[index];
217  }
218  //**********************************************************************************************
219 
220  //**Size function*******************************************************************************
225  inline size_t size() const noexcept {
226  return mat_.columns();
227  }
228  //**********************************************************************************************
229 
230  //**Left operand access*************************************************************************
235  inline LeftOperand leftOperand() const noexcept {
236  return vec_;
237  }
238  //**********************************************************************************************
239 
240  //**Right operand access************************************************************************
245  inline RightOperand rightOperand() const noexcept {
246  return mat_;
247  }
248  //**********************************************************************************************
249 
250  //**********************************************************************************************
256  template< typename T >
257  inline bool canAlias( const T* alias ) const noexcept {
258  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
259  }
260  //**********************************************************************************************
261 
262  //**********************************************************************************************
268  template< typename T >
269  inline bool isAliased( const T* alias ) const noexcept {
270  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
271  }
272  //**********************************************************************************************
273 
274  //**********************************************************************************************
279  inline bool isAligned() const noexcept {
280  return vec_.isAligned();
281  }
282  //**********************************************************************************************
283 
284  //**********************************************************************************************
289  inline bool canSMPAssign() const noexcept {
290  return ( size() > SMP_TDVECSMATMULT_THRESHOLD );
291  }
292  //**********************************************************************************************
293 
294  private:
295  //**Member variables****************************************************************************
298  //**********************************************************************************************
299 
300  //**Assignment to dense vectors*****************************************************************
312  template< typename VT2 > // Type of the target dense vector
313  friend inline void assign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
314  {
316 
317  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
318 
319  reset( ~lhs );
320 
321  if( rhs.mat_.rows() == 0UL ) return;
322 
323  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
324  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
325 
326  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
327  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
328  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
329  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
330 
331  TDVecSMatMultExpr::selectAssignKernel( ~lhs, x, A );
332  }
333  //**********************************************************************************************
334 
335  //**Optimized assignment to dense vectors*******************************************************
349  template< typename VT1 // Type of the left-hand side target vector
350  , typename VT2 // Type of the left-hand side vector operand
351  , typename MT1 > // Type of the right-hand side matrix operand
352  static inline void selectAssignKernel( VT1& y, const VT2& x, const MT1& A )
353  {
355 
356  for( size_t i=0UL; i<x.size(); ++i )
357  {
358  const ConstIterator end( A.end(i) );
359  ConstIterator element( A.begin(i) );
360 
361  for( ; element!=end; ++element ) {
362  if( IsResizable< ElementType_<VT1> >::value &&
363  isDefault( y[element->index()] ) )
364  y[element->index()] = x[i] * element->value();
365  else
366  y[element->index()] += x[i] * element->value();
367  }
368  }
369  }
371  //**********************************************************************************************
372 
373  //**Assignment to sparse vectors****************************************************************
385  template< typename VT2 > // Type of the target sparse vector
386  friend inline void assign( SparseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
387  {
389 
393 
394  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
395 
396  const ResultType tmp( serial( rhs ) );
397  assign( ~lhs, tmp );
398  }
399  //**********************************************************************************************
400 
401  //**Addition assignment to dense vectors********************************************************
413  template< typename VT2 > // Type of the target dense vector
414  friend inline void addAssign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
415  {
417 
418  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
419 
420  if( rhs.mat_.rows() == 0UL ) {
421  return;
422  }
423 
424  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
425  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
426 
427  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
428  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
429  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
430  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
431 
432  TDVecSMatMultExpr::selectAddAssignKernel( ~lhs, x, A );
433  }
434  //**********************************************************************************************
435 
436  //**Optimized addition assignment to dense vectors*************************************************
450  template< typename VT1 // Type of the left-hand side target vector
451  , typename VT2 // Type of the left-hand side vector operand
452  , typename MT1 > // Type of the right-hand side matrix operand
453  static inline void selectAddAssignKernel( VT1& y, const VT2& x, const MT1& A )
454  {
456 
457  for( size_t i=0UL; i<x.size(); ++i )
458  {
459  const ConstIterator end( A.end(i) );
460  ConstIterator element( A.begin(i) );
461 
462  for( ; element!=end; ++element ) {
463  y[element->index()] += x[i] * element->value();
464  }
465  }
466  }
468  //**********************************************************************************************
469 
470  //**Addition assignment to sparse vectors*******************************************************
471  // No special implementation for the addition assignment to sparse vectors.
472  //**********************************************************************************************
473 
474  //**Subtraction assignment to dense vectors*****************************************************
486  template< typename VT2 > // Type of the target dense vector
487  friend inline void subAssign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
488  {
490 
491  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
492 
493  if( rhs.mat_.rows() == 0UL ) {
494  return;
495  }
496 
497  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
498  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
499 
500  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
501  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
502  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
503  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
504 
505  TDVecSMatMultExpr::selectSubAssignKernel( ~lhs, x, A );
506  }
507  //**********************************************************************************************
508 
509  //**Optimized subtraction assignment to dense vectors**********************************************
523  template< typename VT1 // Type of the left-hand side target vector
524  , typename VT2 // Type of the left-hand side vector operand
525  , typename MT1 > // Type of the right-hand side matrix operand
526  static inline void selectSubAssignKernel( VT1& y, const VT2& x, const MT1& A )
527  {
529 
530  for( size_t i=0UL; i<x.size(); ++i )
531  {
532  const ConstIterator end( A.end(i) );
533  ConstIterator element( A.begin(i) );
534 
535  for( ; element!=end; ++element ) {
536  y[element->index()] -= x[i] * element->value();
537  }
538  }
539  }
541  //**********************************************************************************************
542 
543  //**Subtraction assignment to sparse vectors****************************************************
544  // No special implementation for the subtraction assignment to sparse vectors.
545  //**********************************************************************************************
546 
547  //**Multiplication assignment to dense vectors**************************************************
559  template< typename VT2 > // Type of the target dense vector
560  friend inline void multAssign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
561  {
563 
567 
568  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
569 
570  const ResultType tmp( serial( rhs ) );
571  multAssign( ~lhs, tmp );
572  }
573  //**********************************************************************************************
574 
575  //**Multiplication assignment to sparse vectors*************************************************
576  // No special implementation for the multiplication assignment to sparse vectors.
577  //**********************************************************************************************
578 
579  //**Division assignment to dense vectors********************************************************
591  template< typename VT2 > // Type of the target dense vector
592  friend inline void divAssign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
593  {
595 
599 
600  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
601 
602  const ResultType tmp( serial( rhs ) );
603  divAssign( ~lhs, tmp );
604  }
605  //**********************************************************************************************
606 
607  //**Division assignment to sparse vectors*******************************************************
608  // No special implementation for the division assignment to sparse vectors.
609  //**********************************************************************************************
610 
611  //**SMP assignment to dense vectors*************************************************************
625  template< typename VT2 > // Type of the target dense vector
626  friend inline EnableIf_< UseSMPAssign<VT2> >
628  {
630 
631  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
632 
633  reset( ~lhs );
634 
635  if( rhs.mat_.rows() == 0UL ) return;
636 
637  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
638  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
639 
640  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
641  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
642  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
643  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
644 
645  smpAssign( ~lhs, x * A );
646  }
647  //**********************************************************************************************
648 
649  //**SMP assignment to sparse vectors************************************************************
663  template< typename VT2 > // Type of the target sparse vector
664  friend inline EnableIf_< UseSMPAssign<VT2> >
666  {
668 
672 
673  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
674 
675  const ResultType tmp( rhs );
676  smpAssign( ~lhs, tmp );
677  }
678  //**********************************************************************************************
679 
680  //**SMP addition assignment to dense vectors****************************************************
694  template< typename VT2 > // Type of the target dense vector
695  friend inline EnableIf_< UseSMPAssign<VT2> >
697  {
699 
700  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
701 
702  if( rhs.mat_.rows() == 0UL ) {
703  return;
704  }
705 
706  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
707  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
708 
709  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
710  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
711  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
712  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
713 
714  smpAddAssign( ~lhs, x * A );
715  }
716  //**********************************************************************************************
717 
718  //**SMP addition assignment to sparse vectors***************************************************
719  // No special implementation for the SMP addition assignment to sparse vectors.
720  //**********************************************************************************************
721 
722  //**SMP subtraction assignment to dense vectors*************************************************
736  template< typename VT2 > // Type of the target dense vector
737  friend inline EnableIf_< UseSMPAssign<VT2> >
739  {
741 
742  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
743 
744  if( rhs.mat_.rows() == 0UL ) {
745  return;
746  }
747 
748  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
749  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
750 
751  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
752  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
753  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
754  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
755 
756  smpSubAssign( ~lhs, x * A );
757  }
758  //**********************************************************************************************
759 
760  //**SMP subtraction assignment to sparse vectors************************************************
761  // No special implementation for the SMP subtraction assignment to sparse vectors.
762  //**********************************************************************************************
763 
764  //**SMP multiplication assignment to dense vectors**********************************************
778  template< typename VT2 > // Type of the target dense vector
779  friend inline EnableIf_< UseSMPAssign<VT2> >
781  {
783 
787 
788  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
789 
790  const ResultType tmp( rhs );
791  smpMultAssign( ~lhs, tmp );
792  }
793  //**********************************************************************************************
794 
795  //**SMP multiplication assignment to sparse vectors*********************************************
796  // No special implementation for the SMP multiplication assignment to sparse vectors.
797  //**********************************************************************************************
798 
799  //**SMP division assignment to dense vectors****************************************************
813  template< typename VT2 > // Type of the target dense vector
814  friend inline EnableIf_< UseSMPAssign<VT2> >
816  {
818 
822 
823  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
824 
825  const ResultType tmp( rhs );
826  smpDivAssign( ~lhs, tmp );
827  }
828  //**********************************************************************************************
829 
830  //**SMP division assignment to sparse vectors***************************************************
831  // No special implementation for the SMP division assignment to sparse vectors.
832  //**********************************************************************************************
833 
834  //**Compile time checks*************************************************************************
843  //**********************************************************************************************
844 };
845 //*************************************************************************************************
846 
847 
848 
849 
850 //=================================================================================================
851 //
852 // GLOBAL BINARY ARITHMETIC OPERATORS
853 //
854 //=================================================================================================
855 
856 //*************************************************************************************************
870 template< typename VT // Type of the left-hand side dense vector
871  , typename MT // Type of the right-hand side sparse matrix
872  , typename = DisableIf_< IsSymmetric<MT> > >
873 inline const TDVecSMatMultExpr<VT,MT>
874  tdvecsmatmult( const DenseVector<VT,true>& vec, const SparseMatrix<MT,false>& mat )
875 {
877 
878  BLAZE_INTERNAL_ASSERT( (~vec).size() == (~mat).rows(), "Invalid vector and matrix sizes" );
879 
880  return TDVecSMatMultExpr<VT,MT>( ~vec, ~mat );
881 }
883 //*************************************************************************************************
884 
885 
886 //*************************************************************************************************
900 template< typename VT // Type of the left-hand side dense vector
901  , typename MT // Type of the right-hand side sparse matrix
902  , typename = EnableIf_< IsSymmetric<MT> > >
903 inline decltype(auto)
904  tdvecsmatmult( const DenseVector<VT,true>& vec, const SparseMatrix<MT,false>& mat )
905 {
907 
908  BLAZE_INTERNAL_ASSERT( (~vec).size() == (~mat).rows(), "Invalid vector and matrix sizes" );
909 
910  return (~vec) * trans( ~mat );
911 }
913 //*************************************************************************************************
914 
915 
916 //*************************************************************************************************
947 template< typename VT // Type of the left-hand side dense vector
948  , typename MT > // Type of the right-hand side sparse matrix
949 inline decltype(auto)
950  operator*( const DenseVector<VT,true>& vec, const SparseMatrix<MT,false>& mat )
951 {
953 
955 
956  if( (~vec).size() != (~mat).rows() ) {
957  BLAZE_THROW_INVALID_ARGUMENT( "Vector and matrix sizes do not match" );
958  }
959 
960  return tdvecsmatmult( ~vec, ~mat );
961 }
962 //*************************************************************************************************
963 
964 
965 
966 
967 //=================================================================================================
968 //
969 // SIZE SPECIALIZATIONS
970 //
971 //=================================================================================================
972 
973 //*************************************************************************************************
975 template< typename VT, typename MT >
976 struct Size< TDVecSMatMultExpr<VT,MT> >
977  : public Columns<MT>
978 {};
980 //*************************************************************************************************
981 
982 
983 
984 
985 //=================================================================================================
986 //
987 // ISALIGNED SPECIALIZATIONS
988 //
989 //=================================================================================================
990 
991 //*************************************************************************************************
993 template< typename VT, typename MT >
994 struct IsAligned< TDVecSMatMultExpr<VT,MT> >
995  : public BoolConstant< IsAligned<VT>::value >
996 {};
998 //*************************************************************************************************
999 
1000 } // namespace blaze
1001 
1002 #endif
CompositeType_< VT > VCT
Composite type of the left-hand side dense vector expression.
Definition: TDVecSMatMultExpr.h:105
#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.
friend EnableIf_< UseSMPAssign< VT2 > > smpDivAssign(DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
SMP division assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( ...
Definition: TDVecSMatMultExpr.h:815
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:72
Header file for basic type definitions.
Expression object for transpose dense vector-sparse matrix multiplications.The TDVecSMatMultExpr clas...
Definition: Forward.h:157
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
Header file for the serial shim.
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
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
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:560
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:224
Header file for the DenseVector base class.
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
TDVecSMatMultExpr(const VT &vec, const MT &mat) noexcept
Constructor for the TDVecSMatMultExpr class.
Definition: TDVecSMatMultExpr.h:166
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:250
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.
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.
IfTrue_< evaluateMatrix, const MRT, MCT > RT
Composite type of the right-hand side sparse matrix expression.
Definition: TDVecSMatMultExpr.h:151
Header file for the RequiresEvaluation type trait.
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse matrix operand.
Definition: TDVecSMatMultExpr.h:245
friend void assign(SparseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
Assignment of a transpose dense vector-sparse matrix multiplication to a sparse vector ( )...
Definition: TDVecSMatMultExpr.h:386
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:343
friend void divAssign(DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
Division assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( )...
Definition: TDVecSMatMultExpr.h:592
RightOperand mat_
Right-hand side sparse matrix of the multiplication expression.
Definition: TDVecSMatMultExpr.h:297
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
LeftOperand vec_
Left-hand side dense vector of the multiplication expression.
Definition: TDVecSMatMultExpr.h:296
friend EnableIf_< UseSMPAssign< VT2 > > smpSubAssign(DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
SMP subtraction assignment of a transpose dense vector-sparse matrix multiplication to a dense vector...
Definition: TDVecSMatMultExpr.h:738
If_< IsExpression< VT >, const VT, const VT &> LeftOperand
Composite type of the left-hand side dense vector expression.
Definition: TDVecSMatMultExpr.h:142
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
IfTrue_< evaluateVector, const VRT, VCT > LT
Composite type of the left-hand side dense vector expression.
Definition: TDVecSMatMultExpr.h:148
MultTrait_< VRT, MRT > ResultType
Result type for expression template evaluations.
Definition: TDVecSMatMultExpr.h:135
Compile time check for the alignment of data types.This type trait tests whether the given data type ...
Definition: IsAligned.h:87
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
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: TDVecSMatMultExpr.h:279
Header file for the DisableIf class template.
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TDVecSMatMultExpr.h:180
friend void subAssign(DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
Subtraction assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( )...
Definition: TDVecSMatMultExpr.h:487
Header file for the multiplication trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
If_< IsExpression< MT >, const MT, const MT &> RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TDVecSMatMultExpr.h:145
CompositeType_< MT > MCT
Composite type of the right-hand side sparse matrix expression.
Definition: TDVecSMatMultExpr.h:106
friend void multAssign(DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
Multiplication assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ...
Definition: TDVecSMatMultExpr.h:560
#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
Header file for the Columns type trait.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3087
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
friend EnableIf_< UseSMPAssign< VT2 > > smpAssign(DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
SMP assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( )...
Definition: TDVecSMatMultExpr.h:627
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
const ResultType CompositeType
Data type for composite expression templates.
Definition: TDVecSMatMultExpr.h:139
Header file for the IsAligned type trait.
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
ElementType_< ResultType > ElementType
Resulting element type.
Definition: TDVecSMatMultExpr.h:137
Constraint on the data type.
Header file for the exception macros of the math module.
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:264
Constraint on the data type.
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TDVecSMatMultExpr.h:138
Header file for all forward declarations for expression class templates.
Header file for the EnableIf class template.
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_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:79
#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
Header file for run time assertion macros.
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
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense vector operand.
Definition: TDVecSMatMultExpr.h:235
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.
Constraint on the data type.
friend void addAssign(DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
Addition assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( )...
Definition: TDVecSMatMultExpr.h:414
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
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: TDVecSMatMultExpr.h:225
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
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TDVecSMatMultExpr.h:257
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
friend void assign(DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
Assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( )...
Definition: TDVecSMatMultExpr.h:313
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional vector type...
Definition: DenseVector.h:61
#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
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:790
friend EnableIf_< UseSMPAssign< VT2 > > smpMultAssign(DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
SMP multiplication assignment of a transpose dense vector-sparse matrix multiplication to a dense vec...
Definition: TDVecSMatMultExpr.h:780
Header file for the IsComputation type trait class.
friend EnableIf_< UseSMPAssign< VT2 > > smpAssign(SparseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
SMP assignment of a transpose dense vector-sparse matrix multiplication to a sparse vector ( )...
Definition: TDVecSMatMultExpr.h:665
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
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: TDVecSMatMultExpr.h:212
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TDVecSMatMultExpr.h:136
Header file for the IntegralConstant class template.
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:75
ResultType_< VT > VRT
Result type of the left-hand side dense vector expression.
Definition: TDVecSMatMultExpr.h:103
#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
ResultType_< MT > MRT
Result type of the right-hand side sparse matrix expression.
Definition: TDVecSMatMultExpr.h:104
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:600
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: TDVecSMatMultExpr.h:289
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.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TDVecSMatMultExpr.h:269
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.
friend EnableIf_< UseSMPAssign< VT2 > > smpAddAssign(DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
Addition assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( )...
Definition: TDVecSMatMultExpr.h:696