TDVecTSMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TDVECTSMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TDVECTSMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
49 #include <blaze/math/Exception.h>
54 #include <blaze/math/shims/Reset.h>
68 #include <blaze/util/Assert.h>
70 #include <blaze/util/DisableIf.h>
71 #include <blaze/util/EnableIf.h>
74 #include <blaze/util/mpl/If.h>
75 #include <blaze/util/Types.h>
77 
78 
79 namespace blaze {
80 
81 //=================================================================================================
82 //
83 // CLASS TDVECSMATMULTEXPR
84 //
85 //=================================================================================================
86 
87 //*************************************************************************************************
94 template< typename VT // Type of the left-hand side dense vector
95  , typename MT > // Type of the right-hand side sparse matrix
96 class TDVecTSMatMultExpr : public DenseVector< TDVecTSMatMultExpr<VT,MT>, true >
97  , private TVecMatMultExpr
98  , private Computation
99 {
100  private:
101  //**Type definitions****************************************************************************
106  //**********************************************************************************************
107 
108  //**********************************************************************************************
110  enum : bool { evaluateVector = IsComputation<VT>::value || RequiresEvaluation<VT>::value };
111  //**********************************************************************************************
112 
113  //**********************************************************************************************
115  enum : bool { evaluateMatrix = RequiresEvaluation<MT>::value };
116  //**********************************************************************************************
117 
118  //**********************************************************************************************
120 
126  enum : bool { useAssign = ( evaluateVector || evaluateMatrix ) };
127  //**********************************************************************************************
128 
129  //**********************************************************************************************
131  template< typename VT2 >
133  struct UseAssign {
134  enum : bool { value = useAssign };
135  };
137  //**********************************************************************************************
138 
139  //**********************************************************************************************
141 
145  template< typename T1 >
146  struct UseSMPAssign {
147  enum : bool { value = useAssign };
148  };
150  //**********************************************************************************************
151 
152  public:
153  //**Type definitions****************************************************************************
158  typedef const ElementType ReturnType;
159 
162 
164  typedef If_< IsExpression<VT>, const VT, const VT& > LeftOperand;
165 
167  typedef If_< IsExpression<MT>, const MT, const MT& > RightOperand;
168 
171 
174  //**********************************************************************************************
175 
176  //**Compilation flags***************************************************************************
178  enum : bool { simdEnabled = false };
179 
181  enum : bool { smpAssignable = !evaluateVector && VT::smpAssignable &&
182  !evaluateMatrix && MT::smpAssignable };
183  //**********************************************************************************************
184 
185  //**Constructor*********************************************************************************
188  explicit inline TDVecTSMatMultExpr( const VT& vec, const MT& mat ) noexcept
189  : vec_( vec ) // Left-hand side dense vector of the multiplication expression
190  , mat_( mat ) // Right-hand side sparse matrix of the multiplication expression
191  {
192  BLAZE_INTERNAL_ASSERT( vec_.size() == mat.rows(), "Invalid vector and matrix sizes" );
193  }
194  //**********************************************************************************************
195 
196  //**Subscript operator**************************************************************************
202  inline ReturnType operator[]( size_t index ) const {
203  BLAZE_INTERNAL_ASSERT( index < mat_.columns(), "Invalid vector access index" );
204  return vec_ * column( mat_, index );
205  }
206  //**********************************************************************************************
207 
208  //**At function*********************************************************************************
215  inline ReturnType at( size_t index ) const {
216  if( index >= mat_.columns() ) {
217  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
218  }
219  return (*this)[index];
220  }
221  //**********************************************************************************************
222 
223  //**Size function*******************************************************************************
228  inline size_t size() const noexcept {
229  return mat_.columns();
230  }
231  //**********************************************************************************************
232 
233  //**Left operand access*************************************************************************
238  inline LeftOperand leftOperand() const noexcept {
239  return vec_;
240  }
241  //**********************************************************************************************
242 
243  //**Right operand access************************************************************************
248  inline RightOperand rightOperand() const noexcept {
249  return mat_;
250  }
251  //**********************************************************************************************
252 
253  //**********************************************************************************************
259  template< typename T >
260  inline bool canAlias( const T* alias ) const noexcept {
261  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
262  }
263  //**********************************************************************************************
264 
265  //**********************************************************************************************
271  template< typename T >
272  inline bool isAliased( const T* alias ) const noexcept {
273  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
274  }
275  //**********************************************************************************************
276 
277  //**********************************************************************************************
282  inline bool isAligned() const noexcept {
283  return vec_.isAligned();
284  }
285  //**********************************************************************************************
286 
287  //**********************************************************************************************
292  inline bool canSMPAssign() const noexcept {
293  return ( size() > SMP_TDVECTSMATMULT_THRESHOLD );
294  }
295  //**********************************************************************************************
296 
297  private:
298  //**Member variables****************************************************************************
299  LeftOperand vec_;
300  RightOperand mat_;
301  //**********************************************************************************************
302 
303  //**Assignment to dense vectors*****************************************************************
318  template< typename VT2 > // Type of the target dense vector
319  friend inline EnableIf_< UseAssign<VT2> >
321  {
323 
324  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
325 
326  if( rhs.mat_.rows() == 0UL ) {
327  reset( ~lhs );
328  return;
329  }
330 
331  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
332  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
333 
334  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
335  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
336  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
337  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
338 
339  assign( ~lhs, x * A );
340  }
341  //**********************************************************************************************
342 
343  //**Assignment to sparse vectors****************************************************************
358  template< typename VT2 > // Type of the target sparse vector
359  friend inline EnableIf_< UseAssign<VT2> >
361  {
363 
367 
368  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
369 
370  const ResultType tmp( serial( rhs ) );
371  assign( ~lhs, tmp );
372  }
373  //**********************************************************************************************
374 
375  //**Addition assignment to dense vectors********************************************************
390  template< typename VT2 > // Type of the target dense vector
391  friend inline EnableIf_< UseAssign<VT2> >
393  {
395 
396  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
397 
398  if( rhs.mat_.rows() == 0UL ) {
399  return;
400  }
401 
402  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
403  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
404 
405  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
406  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
407  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
408  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
409 
410  addAssign( ~lhs, x * A );
411  }
412  //**********************************************************************************************
413 
414  //**Addition assignment to sparse vectors*******************************************************
415  // No special implementation for the addition assignment to sparse vectors.
416  //**********************************************************************************************
417 
418  //**Subtraction assignment to dense vectors*****************************************************
433  template< typename VT2 > // Type of the target dense vector
434  friend inline EnableIf_< UseAssign<VT2> >
436  {
438 
439  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
440 
441  if( rhs.mat_.rows() == 0UL ) {
442  return;
443  }
444 
445  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
446  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
447 
448  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
449  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
450  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
451  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
452 
453  subAssign( ~lhs, x * A );
454  }
455  //**********************************************************************************************
456 
457  //**Subtraction assignment to sparse vectors****************************************************
458  // No special implementation for the subtraction assignment to sparse vectors.
459  //**********************************************************************************************
460 
461  //**Multiplication assignment to dense vectors**************************************************
476  template< typename VT2 > // Type of the target dense vector
477  friend inline EnableIf_< UseAssign<VT2> >
479  {
481 
485 
486  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
487 
488  const ResultType tmp( serial( rhs ) );
489  multAssign( ~lhs, tmp );
490  }
491  //**********************************************************************************************
492 
493  //**Multiplication assignment to sparse vectors*************************************************
494  // No special implementation for the multiplication assignment to sparse vectors.
495  //**********************************************************************************************
496 
497  //**Division assignment to dense vectors********************************************************
512  template< typename VT2 > // Type of the target dense vector
513  friend inline EnableIf_< UseAssign<VT2> >
515  {
517 
521 
522  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
523 
524  const ResultType tmp( serial( rhs ) );
525  divAssign( ~lhs, tmp );
526  }
527  //**********************************************************************************************
528 
529  //**Division assignment to sparse vectors*******************************************************
530  // No special implementation for the division assignment to sparse vectors.
531  //**********************************************************************************************
532 
533  //**SMP assignment to dense vectors*************************************************************
547  template< typename VT2 > // Type of the target dense vector
548  friend inline EnableIf_< UseSMPAssign<VT2> >
550  {
552 
553  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
554 
555  if( rhs.mat_.rows() == 0UL ) {
556  reset( ~lhs );
557  return;
558  }
559 
560  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
561  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
562 
563  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
564  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
565  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
566  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
567 
568  smpAssign( ~lhs, x * A );
569  }
570  //**********************************************************************************************
571 
572  //**SMP assignment to sparse vectors************************************************************
586  template< typename VT2 > // Type of the target sparse vector
587  friend inline EnableIf_< UseSMPAssign<VT2> >
589  {
591 
595 
596  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
597 
598  const ResultType tmp( rhs );
599  smpAssign( ~lhs, tmp );
600  }
601  //**********************************************************************************************
602 
603  //**SMP addition assignment to dense vectors****************************************************
617  template< typename VT2 > // Type of the target dense vector
618  friend inline EnableIf_< UseSMPAssign<VT2> >
620  {
622 
623  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
624 
625  if( rhs.mat_.rows() == 0UL ) {
626  return;
627  }
628 
629  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
630  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
631 
632  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
633  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
634  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
635  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
636 
637  smpAddAssign( ~lhs, x * A );
638  }
639  //**********************************************************************************************
640 
641  //**SMP addition assignment to sparse vectors***************************************************
642  // No special implementation for the SMP addition assignment to sparse vectors.
643  //**********************************************************************************************
644 
645  //**SMP subtraction assignment to dense vectors*************************************************
659  template< typename VT2 > // Type of the target dense vector
660  friend inline EnableIf_< UseSMPAssign<VT2> >
662  {
664 
665  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
666 
667  if( rhs.mat_.rows() == 0UL ) {
668  return;
669  }
670 
671  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
672  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
673 
674  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
675  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
676  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
677  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
678 
679  smpSubAssign( ~lhs, x * A );
680  }
681  //**********************************************************************************************
682 
683  //**SMP subtraction assignment to sparse vectors************************************************
684  // No special implementation for the SMP subtraction assignment to sparse vectors.
685  //**********************************************************************************************
686 
687  //**SMP multiplication assignment to dense vectors**********************************************
701  template< typename VT2 > // Type of the target dense vector
702  friend inline EnableIf_< UseSMPAssign<VT2> >
704  {
706 
710 
711  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
712 
713  const ResultType tmp( rhs );
714  smpMultAssign( ~lhs, tmp );
715  }
716  //**********************************************************************************************
717 
718  //**SMP multiplication assignment to sparse vectors*********************************************
719  // No special implementation for the SMP multiplication assignment to sparse vectors.
720  //**********************************************************************************************
721 
722  //**SMP division assignment to dense vectors****************************************************
736  template< typename VT2 > // Type of the target dense vector
737  friend inline EnableIf_< UseSMPAssign<VT2> >
739  {
741 
745 
746  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
747 
748  const ResultType tmp( rhs );
749  smpDivAssign( ~lhs, tmp );
750  }
751  //**********************************************************************************************
752 
753  //**SMP division assignment to sparse vectors***************************************************
754  // No special implementation for the SMP division assignment to sparse vectors.
755  //**********************************************************************************************
756 
757  //**Compile time checks*************************************************************************
765  //**********************************************************************************************
766 };
767 //*************************************************************************************************
768 
769 
770 
771 
772 //=================================================================================================
773 //
774 // GLOBAL BINARY ARITHMETIC OPERATORS
775 //
776 //=================================================================================================
777 
778 //*************************************************************************************************
809 template< typename T1 // Type of the left-hand side dense vector
810  , typename T2 > // Type of the right-hand side sparse matrix
811 inline const DisableIf_< IsMatMatMultExpr<T2>, TDVecTSMatMultExpr<T1,T2> >
813 {
815 
816  if( (~vec).size() != (~mat).rows() ) {
817  BLAZE_THROW_INVALID_ARGUMENT( "Vector and matrix sizes do not match" );
818  }
819 
820  return TDVecTSMatMultExpr<T1,T2>( ~vec, ~mat );
821 }
822 //*************************************************************************************************
823 
824 
825 
826 
827 //=================================================================================================
828 //
829 // SIZE SPECIALIZATIONS
830 //
831 //=================================================================================================
832 
833 //*************************************************************************************************
835 template< typename VT, typename MT >
836 struct Size< TDVecTSMatMultExpr<VT,MT> > : public Columns<MT>
837 {};
839 //*************************************************************************************************
840 
841 
842 
843 
844 //=================================================================================================
845 //
846 // ISALIGNED SPECIALIZATIONS
847 //
848 //=================================================================================================
849 
850 //*************************************************************************************************
852 template< typename VT, typename MT >
853 struct IsAligned< TDVecTSMatMultExpr<VT,MT> >
854  : public BoolConstant< IsAligned<VT>::value >
855 {};
857 //*************************************************************************************************
858 
859 
860 
861 
862 //=================================================================================================
863 //
864 // EXPRESSION TRAIT SPECIALIZATIONS
865 //
866 //=================================================================================================
867 
868 //*************************************************************************************************
870 template< typename VT, typename MT, bool AF >
871 struct SubvectorExprTrait< TDVecTSMatMultExpr<VT,MT>, AF >
872 {
873  public:
874  //**********************************************************************************************
875  using Type = MultExprTrait_< SubvectorExprTrait_<const VT,AF>
876  , SubmatrixExprTrait_<const MT,AF> >;
877  //**********************************************************************************************
878 };
880 //*************************************************************************************************
881 
882 } // namespace blaze
883 
884 #endif
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
IfTrue_< useAssign, const ResultType, const TDVecTSMatMultExpr & > CompositeType
Data type for composite expression templates.
Definition: TDVecTSMatMultExpr.h:161
friend EnableIf_< UseAssign< VT2 > > multAssign(DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
Multiplication assignment of a transpose dense vector-transpose sparse matrix multiplication to a den...
Definition: TDVecTSMatMultExpr.h:478
Header file for auxiliary alias declarations.
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:72
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense vector operand.
Definition: TDVecTSMatMultExpr.h:238
const DMatDMatMultExpr< T1, T2 > operator*(const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:7800
Header file for basic type definitions.
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: TDVecTSMatMultExpr.h:228
Header file for the serial shim.
ElementType_< ResultType > ElementType
Resulting element type.
Definition: TDVecTSMatMultExpr.h:157
MultTrait_< VRT, MRT > ResultType
Result type for expression template evaluations.
Definition: TDVecTSMatMultExpr.h:155
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TDVecTSMatMultExpr.h:158
Expression object for transpose dense vector-transpose sparse matrix multiplications.The TDVecTSMatMultExpr class represents the compile time expression for multiplications between transpose dense vectors and column-major sparse matrices.
Definition: Forward.h:139
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TDVecTSMatMultExpr.h:260
TDVecTSMatMultExpr(const VT &vec, const MT &mat) noexcept
Constructor for the TDVecTSMatMultExpr class.
Definition: TDVecTSMatMultExpr.h:188
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
RightOperand mat_
Right-hand side sparse matrix of the multiplication expression.
Definition: TDVecTSMatMultExpr.h:300
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: TDVecTSMatMultExpr.h:282
Header file for the DenseVector base class.
TDVecTSMatMultExpr< VT, MT > This
Type of this TDVecTSMatMultExpr instance.
Definition: TDVecTSMatMultExpr.h:154
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:723
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:245
Header file for the Computation base class.
Header file for the RequiresEvaluation type trait.
friend EnableIf_< UseSMPAssign< VT2 > > smpAssign(SparseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
SMP assignment of a transpose dense vector-transpose sparse matrix multiplication to a sparse vector ...
Definition: TDVecTSMatMultExpr.h:588
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, ColumnExprTrait_< MT > > column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:126
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: TDVecTSMatMultExpr.h:292
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:109
Constraint on the data type.
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
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TDVecTSMatMultExpr.h:202
Constraint on the data type.
Header file for the MultExprTrait class template.
friend EnableIf_< UseSMPAssign< VT2 > > smpAddAssign(DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
SMP addition assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense...
Definition: TDVecTSMatMultExpr.h:619
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
friend EnableIf_< UseAssign< VT2 > > addAssign(DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
Addition assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vec...
Definition: TDVecTSMatMultExpr.h:392
Header file for the DisableIf class template.
Header file for the multiplication trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a column-major dense or sparse matri...
Definition: ColumnMajorMatrix.h:61
friend EnableIf_< UseAssign< VT2 > > subAssign(DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
Subtraction assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense ...
Definition: TDVecTSMatMultExpr.h:435
Header file for the IsMatMatMultExpr type trait class.
#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.
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
Header file for the IsAligned type trait.
LeftOperand vec_
Left-hand side dense vector of the multiplication expression.
Definition: TDVecTSMatMultExpr.h:299
RightOperand rightOperand() const noexcept
Returns the right-hand side transpose sparse matrix operand.
Definition: TDVecTSMatMultExpr.h:248
#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:60
Constraint on the data type.
Header file for the exception macros of the math module.
If_< IsExpression< VT >, const VT, const VT & > LeftOperand
Composite type of the left-hand side dense vector expression.
Definition: TDVecTSMatMultExpr.h:164
friend EnableIf_< UseSMPAssign< VT2 > > smpMultAssign(DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
SMP multiplication assignment of a transpose dense vector-transpose sparse matrix multiplication to a...
Definition: TDVecTSMatMultExpr.h:703
Header file for all forward declarations for expression class templates.
friend EnableIf_< UseAssign< VT2 > > divAssign(DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
Division assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vec...
Definition: TDVecTSMatMultExpr.h:514
Header file for the EnableIf class template.
friend EnableIf_< UseSMPAssign< VT2 > > smpDivAssign(DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
SMP division assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense...
Definition: TDVecTSMatMultExpr.h:738
friend EnableIf_< UseAssign< VT2 > > assign(DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
Assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( )...
Definition: TDVecTSMatMultExpr.h:320
If_< IsExpression< MT >, const MT, const MT & > RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TDVecTSMatMultExpr.h:167
ResultType_< MT > MRT
Result type of the right-hand side sparse matrix expression.
Definition: TDVecTSMatMultExpr.h:103
Header file for the SubmatrixExprTrait class template.
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:160
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TDVecTSMatMultExpr.h:272
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: TDVecTSMatMultExpr.h:215
Header file for the reset shim.
Constraint on the data type.
Header file for the TVecMatMultExpr base class.
Constraints on the storage order of matrix types.
friend EnableIf_< UseSMPAssign< VT2 > > smpSubAssign(DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
SMP subtraction assignment of a transpose dense vector-transpose sparse matrix multiplication to a de...
Definition: TDVecTSMatMultExpr.h:661
IfTrue_< evaluateMatrix, const MRT, MCT > RT
Composite type of the right-hand side sparse matrix expression.
Definition: TDVecTSMatMultExpr.h:173
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents ...
Definition: IntegralConstant.h:100
Header file for the RemoveReference type trait.
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
friend EnableIf_< UseAssign< VT2 > > assign(SparseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
Assignment of a transpose dense vector-transpose sparse matrix multiplication to a sparse vector ( )...
Definition: TDVecTSMatMultExpr.h:360
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:314
#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:110
Header file for the IsComputation type trait class.
CompositeType_< VT > VCT
Composite type of the left-hand side dense vector expression.
Definition: TDVecTSMatMultExpr.h:104
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:110
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
Header file for the IntegralConstant class template.
friend EnableIf_< UseSMPAssign< VT2 > > smpAssign(DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
SMP assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector (...
Definition: TDVecTSMatMultExpr.h:549
#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
Header file for the SubvectorExprTrait class template.
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TDVecTSMatMultExpr.h:156
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
IfTrue_< evaluateVector, const VRT, VCT > LT
Composite type of the left-hand side dense vector expression.
Definition: TDVecTSMatMultExpr.h:170
Constraint on the transpose flag of vector types.
ResultType_< VT > VRT
Result type of the left-hand side dense vector expression.
Definition: TDVecTSMatMultExpr.h:102
CompositeType_< MT > MCT
Composite type of the right-hand side sparse matrix expression.
Definition: TDVecTSMatMultExpr.h:105
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.