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>
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>
82 
83 
84 namespace blaze {
85 
86 //=================================================================================================
87 //
88 // CLASS TDVECSMATMULTEXPR
89 //
90 //=================================================================================================
91 
92 //*************************************************************************************************
99 template< typename VT // Type of the left-hand side dense vector
100  , typename MT > // Type of the right-hand side sparse matrix
101 class TDVecSMatMultExpr
102  : public TVecMatMultExpr< DenseVector< TDVecSMatMultExpr<VT,MT>, true > >
103  , private Computation
104 {
105  private:
106  //**Type definitions****************************************************************************
111  //**********************************************************************************************
112 
113  //**********************************************************************************************
115  enum : bool { evaluateVector = IsComputation<VT>::value || RequiresEvaluation<VT>::value };
116  //**********************************************************************************************
117 
118  //**********************************************************************************************
120  enum : bool { evaluateMatrix = RequiresEvaluation<MT>::value };
121  //**********************************************************************************************
122 
123  //**********************************************************************************************
125 
129  template< typename T1 >
130  struct UseSMPAssign {
131  enum : bool { value = ( evaluateVector || evaluateMatrix ) };
132  };
134  //**********************************************************************************************
135 
136  public:
137  //**Type definitions****************************************************************************
142  using ReturnType = const ElementType;
143  using CompositeType = const ResultType;
144 
146  using LeftOperand = If_< IsExpression<VT>, const VT, const VT& >;
147 
149  using RightOperand = If_< IsExpression<MT>, const MT, const MT& >;
150 
153 
156  //**********************************************************************************************
157 
158  //**Compilation flags***************************************************************************
160  enum : bool { simdEnabled = false };
161 
163  enum : bool { smpAssignable = !evaluateVector && VT::smpAssignable &&
164  !evaluateMatrix && MT::smpAssignable };
165  //**********************************************************************************************
166 
167  //**Constructor*********************************************************************************
170  explicit inline TDVecSMatMultExpr( const VT& vec, const MT& mat ) noexcept
171  : vec_( vec ) // Left-hand side dense vector of the multiplication expression
172  , mat_( mat ) // Right-hand side sparse matrix of the multiplication expression
173  {
174  BLAZE_INTERNAL_ASSERT( vec_.size() == mat_.rows(), "Invalid vector and matrix sizes" );
175  }
176  //**********************************************************************************************
177 
178  //**Subscript operator**************************************************************************
184  inline ReturnType operator[]( size_t index ) const {
185  BLAZE_INTERNAL_ASSERT( index < mat_.columns(), "Invalid vector access index" );
186 
188  {
189  return vec_[index] * mat_(index,index);
190  }
191  else if( IsLower<MT>::value )
192  {
193  const size_t begin( IsStrictlyLower<MT>::value ? index+1UL : index );
194  const size_t n ( mat_.rows() - begin );
195  return subvector( vec_, begin, n, unchecked ) *
196  subvector( column( mat_, index, unchecked ), begin, n, unchecked );
197  }
198  else if( IsUpper<MT>::value )
199  {
200  const size_t n( IsStrictlyUpper<MT>::value ? index : index+1UL );
201  return subvector( vec_, 0UL, n, unchecked ) *
202  subvector( column( mat_, index, unchecked ), 0UL, n, unchecked );
203  }
204  else
205  {
206  return vec_ * column( mat_, index, unchecked );
207  }
208  }
209  //**********************************************************************************************
210 
211  //**At function*********************************************************************************
218  inline ReturnType at( size_t index ) const {
219  if( index >= mat_.columns() ) {
220  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
221  }
222  return (*this)[index];
223  }
224  //**********************************************************************************************
225 
226  //**Size function*******************************************************************************
231  inline size_t size() const noexcept {
232  return mat_.columns();
233  }
234  //**********************************************************************************************
235 
236  //**Left operand access*************************************************************************
241  inline LeftOperand leftOperand() const noexcept {
242  return vec_;
243  }
244  //**********************************************************************************************
245 
246  //**Right operand access************************************************************************
251  inline RightOperand rightOperand() const noexcept {
252  return mat_;
253  }
254  //**********************************************************************************************
255 
256  //**********************************************************************************************
262  template< typename T >
263  inline bool canAlias( const T* alias ) const noexcept {
264  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
265  }
266  //**********************************************************************************************
267 
268  //**********************************************************************************************
274  template< typename T >
275  inline bool isAliased( const T* alias ) const noexcept {
276  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
277  }
278  //**********************************************************************************************
279 
280  //**********************************************************************************************
285  inline bool isAligned() const noexcept {
286  return vec_.isAligned();
287  }
288  //**********************************************************************************************
289 
290  //**********************************************************************************************
295  inline bool canSMPAssign() const noexcept {
296  return ( size() > SMP_TDVECSMATMULT_THRESHOLD );
297  }
298  //**********************************************************************************************
299 
300  private:
301  //**Member variables****************************************************************************
304  //**********************************************************************************************
305 
306  //**Assignment to dense vectors*****************************************************************
318  template< typename VT2 > // Type of the target dense vector
319  friend inline void assign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
320  {
322 
323  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
324 
325  reset( ~lhs );
326 
327  if( rhs.mat_.rows() == 0UL ) return;
328 
329  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
330  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
331 
332  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
333  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
334  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
335  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
336 
337  TDVecSMatMultExpr::selectAssignKernel( ~lhs, x, A );
338  }
339  //**********************************************************************************************
340 
341  //**Optimized assignment to dense vectors*******************************************************
355  template< typename VT1 // Type of the left-hand side target vector
356  , typename VT2 // Type of the left-hand side vector operand
357  , typename MT1 > // Type of the right-hand side matrix operand
358  static inline void selectAssignKernel( VT1& y, const VT2& x, const MT1& A )
359  {
361 
362  for( size_t i=0UL; i<x.size(); ++i )
363  {
364  const ConstIterator end( A.end(i) );
365  ConstIterator element( A.begin(i) );
366 
367  for( ; element!=end; ++element ) {
368  if( IsResizable< ElementType_<VT1> >::value &&
369  isDefault( y[element->index()] ) )
370  y[element->index()] = x[i] * element->value();
371  else
372  y[element->index()] += x[i] * element->value();
373  }
374  }
375  }
377  //**********************************************************************************************
378 
379  //**Assignment to sparse vectors****************************************************************
391  template< typename VT2 > // Type of the target sparse vector
392  friend inline void assign( SparseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
393  {
395 
399 
400  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
401 
402  const ResultType tmp( serial( rhs ) );
403  assign( ~lhs, tmp );
404  }
405  //**********************************************************************************************
406 
407  //**Addition assignment to dense vectors********************************************************
419  template< typename VT2 > // Type of the target dense vector
420  friend inline void addAssign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
421  {
423 
424  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
425 
426  if( rhs.mat_.rows() == 0UL ) {
427  return;
428  }
429 
430  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
431  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
432 
433  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
434  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
435  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
436  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
437 
438  TDVecSMatMultExpr::selectAddAssignKernel( ~lhs, x, A );
439  }
440  //**********************************************************************************************
441 
442  //**Optimized addition assignment to dense vectors*************************************************
456  template< typename VT1 // Type of the left-hand side target vector
457  , typename VT2 // Type of the left-hand side vector operand
458  , typename MT1 > // Type of the right-hand side matrix operand
459  static inline void selectAddAssignKernel( VT1& y, const VT2& x, const MT1& A )
460  {
462 
463  for( size_t i=0UL; i<x.size(); ++i )
464  {
465  const ConstIterator end( A.end(i) );
466  ConstIterator element( A.begin(i) );
467 
468  for( ; element!=end; ++element ) {
469  y[element->index()] += x[i] * element->value();
470  }
471  }
472  }
474  //**********************************************************************************************
475 
476  //**Addition assignment to sparse vectors*******************************************************
477  // No special implementation for the addition assignment to sparse vectors.
478  //**********************************************************************************************
479 
480  //**Subtraction assignment to dense vectors*****************************************************
492  template< typename VT2 > // Type of the target dense vector
493  friend inline void subAssign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
494  {
496 
497  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
498 
499  if( rhs.mat_.rows() == 0UL ) {
500  return;
501  }
502 
503  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
504  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
505 
506  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
507  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
508  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
509  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
510 
511  TDVecSMatMultExpr::selectSubAssignKernel( ~lhs, x, A );
512  }
513  //**********************************************************************************************
514 
515  //**Optimized subtraction assignment to dense vectors**********************************************
529  template< typename VT1 // Type of the left-hand side target vector
530  , typename VT2 // Type of the left-hand side vector operand
531  , typename MT1 > // Type of the right-hand side matrix operand
532  static inline void selectSubAssignKernel( VT1& y, const VT2& x, const MT1& A )
533  {
535 
536  for( size_t i=0UL; i<x.size(); ++i )
537  {
538  const ConstIterator end( A.end(i) );
539  ConstIterator element( A.begin(i) );
540 
541  for( ; element!=end; ++element ) {
542  y[element->index()] -= x[i] * element->value();
543  }
544  }
545  }
547  //**********************************************************************************************
548 
549  //**Subtraction assignment to sparse vectors****************************************************
550  // No special implementation for the subtraction assignment to sparse vectors.
551  //**********************************************************************************************
552 
553  //**Multiplication assignment to dense vectors**************************************************
565  template< typename VT2 > // Type of the target dense vector
566  friend inline void multAssign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
567  {
569 
573 
574  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
575 
576  const ResultType tmp( serial( rhs ) );
577  multAssign( ~lhs, tmp );
578  }
579  //**********************************************************************************************
580 
581  //**Multiplication assignment to sparse vectors*************************************************
582  // No special implementation for the multiplication assignment to sparse vectors.
583  //**********************************************************************************************
584 
585  //**Division assignment to dense vectors********************************************************
597  template< typename VT2 > // Type of the target dense vector
598  friend inline void divAssign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
599  {
601 
605 
606  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
607 
608  const ResultType tmp( serial( rhs ) );
609  divAssign( ~lhs, tmp );
610  }
611  //**********************************************************************************************
612 
613  //**Division assignment to sparse vectors*******************************************************
614  // No special implementation for the division assignment to sparse vectors.
615  //**********************************************************************************************
616 
617  //**SMP assignment to dense vectors*************************************************************
631  template< typename VT2 > // Type of the target dense vector
632  friend inline EnableIf_< UseSMPAssign<VT2> >
634  {
636 
637  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
638 
639  reset( ~lhs );
640 
641  if( rhs.mat_.rows() == 0UL ) return;
642 
643  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
644  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
645 
646  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
647  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
648  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
649  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
650 
651  smpAssign( ~lhs, x * A );
652  }
653  //**********************************************************************************************
654 
655  //**SMP assignment to sparse vectors************************************************************
669  template< typename VT2 > // Type of the target sparse vector
670  friend inline EnableIf_< UseSMPAssign<VT2> >
672  {
674 
678 
679  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
680 
681  const ResultType tmp( rhs );
682  smpAssign( ~lhs, tmp );
683  }
684  //**********************************************************************************************
685 
686  //**SMP addition assignment to dense vectors****************************************************
700  template< typename VT2 > // Type of the target dense vector
701  friend inline EnableIf_< UseSMPAssign<VT2> >
703  {
705 
706  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
707 
708  if( rhs.mat_.rows() == 0UL ) {
709  return;
710  }
711 
712  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
713  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
714 
715  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
716  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
717  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
718  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
719 
720  smpAddAssign( ~lhs, x * A );
721  }
722  //**********************************************************************************************
723 
724  //**SMP addition assignment to sparse vectors***************************************************
725  // No special implementation for the SMP addition assignment to sparse vectors.
726  //**********************************************************************************************
727 
728  //**SMP subtraction assignment to dense vectors*************************************************
742  template< typename VT2 > // Type of the target dense vector
743  friend inline EnableIf_< UseSMPAssign<VT2> >
745  {
747 
748  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
749 
750  if( rhs.mat_.rows() == 0UL ) {
751  return;
752  }
753 
754  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
755  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
756 
757  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
758  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
759  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
760  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
761 
762  smpSubAssign( ~lhs, x * A );
763  }
764  //**********************************************************************************************
765 
766  //**SMP subtraction assignment to sparse vectors************************************************
767  // No special implementation for the SMP subtraction assignment to sparse vectors.
768  //**********************************************************************************************
769 
770  //**SMP multiplication assignment to dense vectors**********************************************
784  template< typename VT2 > // Type of the target dense vector
785  friend inline EnableIf_< UseSMPAssign<VT2> >
787  {
789 
793 
794  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
795 
796  const ResultType tmp( rhs );
797  smpMultAssign( ~lhs, tmp );
798  }
799  //**********************************************************************************************
800 
801  //**SMP multiplication assignment to sparse vectors*********************************************
802  // No special implementation for the SMP multiplication assignment to sparse vectors.
803  //**********************************************************************************************
804 
805  //**SMP division assignment to dense vectors****************************************************
819  template< typename VT2 > // Type of the target dense vector
820  friend inline EnableIf_< UseSMPAssign<VT2> >
822  {
824 
828 
829  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
830 
831  const ResultType tmp( rhs );
832  smpDivAssign( ~lhs, tmp );
833  }
834  //**********************************************************************************************
835 
836  //**SMP division assignment to sparse vectors***************************************************
837  // No special implementation for the SMP division assignment to sparse vectors.
838  //**********************************************************************************************
839 
840  //**Compile time checks*************************************************************************
849  //**********************************************************************************************
850 };
851 //*************************************************************************************************
852 
853 
854 
855 
856 //=================================================================================================
857 //
858 // GLOBAL BINARY ARITHMETIC OPERATORS
859 //
860 //=================================================================================================
861 
862 //*************************************************************************************************
876 template< typename VT // Type of the left-hand side dense vector
877  , typename MT // Type of the right-hand side sparse matrix
878  , typename = DisableIf_< IsSymmetric<MT> > >
879 inline const TDVecSMatMultExpr<VT,MT>
880  tdvecsmatmult( const DenseVector<VT,true>& vec, const SparseMatrix<MT,false>& mat )
881 {
883 
884  BLAZE_INTERNAL_ASSERT( (~vec).size() == (~mat).rows(), "Invalid vector and matrix sizes" );
885 
886  return TDVecSMatMultExpr<VT,MT>( ~vec, ~mat );
887 }
889 //*************************************************************************************************
890 
891 
892 //*************************************************************************************************
906 template< typename VT // Type of the left-hand side dense vector
907  , typename MT // Type of the right-hand side sparse matrix
908  , typename = EnableIf_< IsSymmetric<MT> > >
909 inline decltype(auto)
910  tdvecsmatmult( const DenseVector<VT,true>& vec, const SparseMatrix<MT,false>& mat )
911 {
913 
914  BLAZE_INTERNAL_ASSERT( (~vec).size() == (~mat).rows(), "Invalid vector and matrix sizes" );
915 
916  return (~vec) * trans( ~mat );
917 }
919 //*************************************************************************************************
920 
921 
922 //*************************************************************************************************
953 template< typename VT // Type of the left-hand side dense vector
954  , typename MT > // Type of the right-hand side sparse matrix
955 inline decltype(auto)
956  operator*( const DenseVector<VT,true>& vec, const SparseMatrix<MT,false>& mat )
957 {
959 
961 
962  if( (~vec).size() != (~mat).rows() ) {
963  BLAZE_THROW_INVALID_ARGUMENT( "Vector and matrix sizes do not match" );
964  }
965 
966  return tdvecsmatmult( ~vec, ~mat );
967 }
968 //*************************************************************************************************
969 
970 
971 
972 
973 //=================================================================================================
974 //
975 // SIZE SPECIALIZATIONS
976 //
977 //=================================================================================================
978 
979 //*************************************************************************************************
981 template< typename VT, typename MT >
982 struct Size< TDVecSMatMultExpr<VT,MT>, 0UL >
983  : public Size<MT,1UL>
984 {};
986 //*************************************************************************************************
987 
988 
989 
990 
991 //=================================================================================================
992 //
993 // ISALIGNED SPECIALIZATIONS
994 //
995 //=================================================================================================
996 
997 //*************************************************************************************************
999 template< typename VT, typename MT >
1000 struct IsAligned< TDVecSMatMultExpr<VT,MT> >
1001  : public IsAligned<VT>
1002 {};
1004 //*************************************************************************************************
1005 
1006 } // namespace blaze
1007 
1008 #endif
CompositeType_< VT > VCT
Composite type of the left-hand side dense vector expression.
Definition: TDVecSMatMultExpr.h:109
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.
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:821
decltype(auto) column(Matrix< MT, SO > &matrix, RCAs... args)
Creating a view on a specific column of the given matrix.
Definition: Column.h:131
Header file for the blaze::checked and blaze::unchecked instances.
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:71
Header file for basic type definitions.
Expression object for transpose dense vector-sparse matrix multiplications.The TDVecSMatMultExpr clas...
Definition: Forward.h:157
Header file for the serial shim.
Header file for the IsDiagonal type trait.
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:364
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:588
constexpr Unchecked unchecked
Global Unchecked instance.The blaze::unchecked instance is an optional token for the creation of view...
Definition: Check.h:138
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:87
TDVecSMatMultExpr(const VT &vec, const MT &mat) noexcept
Constructor for the TDVecSMatMultExpr class.
Definition: TDVecSMatMultExpr.h:170
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:291
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:87
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:155
Header file for the RequiresEvaluation type trait.
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse matrix operand.
Definition: TDVecSMatMultExpr.h:251
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:392
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:598
RightOperand mat_
Right-hand side sparse matrix of the multiplication expression.
Definition: TDVecSMatMultExpr.h:303
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:302
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:744
If_< IsExpression< VT >, const VT, const VT &> LeftOperand
Composite type of the left-hand side dense vector expression.
Definition: TDVecSMatMultExpr.h:146
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:152
MultTrait_< VRT, MRT > ResultType
Result type for expression template evaluations.
Definition: TDVecSMatMultExpr.h:139
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:71
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:285
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:184
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:493
Header file for the multiplication trait.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
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:149
CompositeType_< MT > MCT
Composite type of the right-hand side sparse matrix expression.
Definition: TDVecSMatMultExpr.h:110
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:566
#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
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3085
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:633
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:76
const ResultType CompositeType
Data type for composite expression templates.
Definition: TDVecSMatMultExpr.h:143
Header file for the IsLower type trait.
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:89
#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:87
ElementType_< ResultType > ElementType
Resulting element type.
Definition: TDVecSMatMultExpr.h:141
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:430
Constraint on the data type.
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TDVecSMatMultExpr.h:142
Header file for all forward declarations for expression class templates.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
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:241
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:420
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:816
#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:231
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:263
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:490
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:319
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:108
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:789
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:786
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:671
Compile time evaluation of the size of vectors and matrices.The Size type trait evaluates the size of...
Definition: Size.h:80
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:218
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TDVecSMatMultExpr.h:140
ResultType_< VT > VRT
Result type of the left-hand side dense vector expression.
Definition: TDVecSMatMultExpr.h:107
#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:108
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:628
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: TDVecSMatMultExpr.h:295
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:423
Header file for the IsUpper type trait.
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:275
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:702