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 
52 #include <blaze/math/shims/Reset.h>
66 #include <blaze/util/Assert.h>
68 #include <blaze/util/DisableIf.h>
69 #include <blaze/util/EnableIf.h>
70 #include <blaze/util/Exception.h>
72 #include <blaze/util/SelectType.h>
73 #include <blaze/util/Types.h>
75 
76 
77 namespace blaze {
78 
79 //=================================================================================================
80 //
81 // CLASS TDVECSMATMULTEXPR
82 //
83 //=================================================================================================
84 
85 //*************************************************************************************************
92 template< typename VT // Type of the left-hand side dense vector
93  , typename MT > // Type of the right-hand side sparse matrix
94 class TDVecTSMatMultExpr : public DenseVector< TDVecTSMatMultExpr<VT,MT>, true >
95  , private TVecMatMultExpr
96  , private Computation
97 {
98  private:
99  //**Type definitions****************************************************************************
100  typedef typename VT::ResultType VRT;
101  typedef typename MT::ResultType MRT;
102  typedef typename VT::CompositeType VCT;
103  typedef typename MT::CompositeType MCT;
104  //**********************************************************************************************
105 
106  //**********************************************************************************************
108  enum { evaluateVector = IsComputation<VT>::value || RequiresEvaluation<VT>::value };
109  //**********************************************************************************************
110 
111  //**********************************************************************************************
113  enum { evaluateMatrix = RequiresEvaluation<MT>::value };
114  //**********************************************************************************************
115 
116  //**********************************************************************************************
118 
124  enum { useAssign = ( evaluateVector || evaluateMatrix ) };
125  //**********************************************************************************************
126 
127  //**********************************************************************************************
129  template< typename VT2 >
131  struct UseAssign {
132  enum { value = useAssign };
133  };
135  //**********************************************************************************************
136 
137  //**********************************************************************************************
139 
143  template< typename T1 >
144  struct UseSMPAssign {
145  enum { value = useAssign };
146  };
148  //**********************************************************************************************
149 
150  public:
151  //**Type definitions****************************************************************************
156  typedef const ElementType ReturnType;
157 
160 
162  typedef typename SelectType< IsExpression<VT>::value, const VT, const VT& >::Type LeftOperand;
163 
165  typedef typename SelectType< IsExpression<MT>::value, const MT, const MT& >::Type RightOperand;
166 
169 
172  //**********************************************************************************************
173 
174  //**Compilation flags***************************************************************************
176  enum { vectorizable = 0 };
177 
179  enum { smpAssignable = !evaluateVector && VT::smpAssignable &&
180  !evaluateMatrix && MT::smpAssignable };
181  //**********************************************************************************************
182 
183  //**Constructor*********************************************************************************
186  explicit inline TDVecTSMatMultExpr( const VT& vec, const MT& mat )
187  : vec_( vec ) // Left-hand side dense vector of the multiplication expression
188  , mat_( mat ) // Right-hand side sparse matrix of the multiplication expression
189  {
190  BLAZE_INTERNAL_ASSERT( vec_.size() == mat.rows(), "Invalid vector and matrix sizes" );
191  }
192  //**********************************************************************************************
193 
194  //**Subscript operator**************************************************************************
200  inline ReturnType operator[]( size_t index ) const {
201  BLAZE_INTERNAL_ASSERT( index < mat_.columns(), "Invalid vector access index" );
202 
204 
205  VCT x( vec_ ); // Evaluation of the left-hand side dense vector operand
206  MCT A( mat_ ); // Evaluation of the right-hand side sparse matrix operand
207 
208  BLAZE_INTERNAL_ASSERT( x.size() == vec_.size() , "Invalid vector size" );
209  BLAZE_INTERNAL_ASSERT( A.rows() == mat_.rows() , "Invalid number of rows" );
210  BLAZE_INTERNAL_ASSERT( A.columns() == mat_.columns(), "Invalid number of columns" );
211 
212  const ConstIterator end( A.end(index) );
213  ConstIterator element( A.begin(index) );
214  ElementType res;
215 
216  if( element != end ) {
217  res = x[element->index()] * element->value();
218  ++element;
219  for( ; element!=end; ++element )
220  res += x[element->index()] * element->value();
221  }
222  else {
223  reset( res );
224  }
225 
226  return res;
227  }
228  //**********************************************************************************************
229 
230  //**At function*********************************************************************************
237  inline ReturnType at( size_t index ) const {
238  if( index >= mat_.columns() ) {
239  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
240  }
241  return (*this)[index];
242  }
243  //**********************************************************************************************
244 
245  //**Size function*******************************************************************************
250  inline size_t size() const {
251  return mat_.columns();
252  }
253  //**********************************************************************************************
254 
255  //**Left operand access*************************************************************************
260  inline LeftOperand leftOperand() const {
261  return vec_;
262  }
263  //**********************************************************************************************
264 
265  //**Right operand access************************************************************************
270  inline RightOperand rightOperand() const {
271  return mat_;
272  }
273  //**********************************************************************************************
274 
275  //**********************************************************************************************
281  template< typename T >
282  inline bool canAlias( const T* alias ) const {
283  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
284  }
285  //**********************************************************************************************
286 
287  //**********************************************************************************************
293  template< typename T >
294  inline bool isAliased( const T* alias ) const {
295  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
296  }
297  //**********************************************************************************************
298 
299  //**********************************************************************************************
304  inline bool isAligned() const {
305  return vec_.isAligned();
306  }
307  //**********************************************************************************************
308 
309  //**********************************************************************************************
314  inline bool canSMPAssign() const {
315  return ( size() > SMP_TDVECTSMATMULT_THRESHOLD );
316  }
317  //**********************************************************************************************
318 
319  private:
320  //**Member variables****************************************************************************
321  LeftOperand vec_;
322  RightOperand mat_;
323  //**********************************************************************************************
324 
325  //**Assignment to dense vectors*****************************************************************
340  template< typename VT2 > // Type of the target dense vector
341  friend inline typename EnableIf< UseAssign<VT2> >::Type
343  {
345 
346  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
347 
349 
350  if( rhs.mat_.rows() == 0UL ) {
351  reset( ~lhs );
352  return;
353  }
354 
355  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
356  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
357 
358  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
359  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
360  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
361  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
362 
363  assign( ~lhs, x * A );
364  }
365  //**********************************************************************************************
366 
367  //**Assignment to sparse vectors****************************************************************
382  template< typename VT2 > // Type of the target sparse vector
383  friend inline typename EnableIf< UseAssign<VT2> >::Type
385  {
387 
391 
392  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
393 
394  const ResultType tmp( serial( rhs ) );
395  assign( ~lhs, tmp );
396  }
397  //**********************************************************************************************
398 
399  //**Addition assignment to dense vectors********************************************************
414  template< typename VT2 > // Type of the target dense vector
415  friend inline typename EnableIf< UseAssign<VT2> >::Type
417  {
419 
420  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
421 
423 
424  if( rhs.mat_.rows() == 0UL ) {
425  return;
426  }
427 
428  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
429  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
430 
431  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
432  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
433  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
434  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
435 
436  addAssign( ~lhs, x * A );
437  }
438  //**********************************************************************************************
439 
440  //**Addition assignment to sparse vectors*******************************************************
441  // No special implementation for the addition assignment to sparse vectors.
442  //**********************************************************************************************
443 
444  //**Subtraction assignment to dense vectors*****************************************************
459  template< typename VT2 > // Type of the target dense vector
460  friend inline typename EnableIf< UseAssign<VT2> >::Type
462  {
464 
465  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
466 
468 
469  if( rhs.mat_.rows() == 0UL ) {
470  return;
471  }
472 
473  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
474  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
475 
476  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
477  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
478  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
479  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
480 
481  subAssign( ~lhs, x * A );
482  }
483  //**********************************************************************************************
484 
485  //**Subtraction assignment to sparse vectors****************************************************
486  // No special implementation for the subtraction assignment to sparse vectors.
487  //**********************************************************************************************
488 
489  //**Multiplication assignment to dense vectors**************************************************
504  template< typename VT2 > // Type of the target dense vector
505  friend inline typename EnableIf< UseAssign<VT2> >::Type
507  {
509 
513 
514  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
515 
516  const ResultType tmp( serial( rhs ) );
517  multAssign( ~lhs, tmp );
518  }
519  //**********************************************************************************************
520 
521  //**Multiplication assignment to sparse vectors*************************************************
522  // No special implementation for the multiplication assignment to sparse vectors.
523  //**********************************************************************************************
524 
525  //**SMP assignment to dense vectors*************************************************************
539  template< typename VT2 > // Type of the target dense vector
540  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
542  {
544 
545  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
546 
548 
549  if( rhs.mat_.rows() == 0UL ) {
550  reset( ~lhs );
551  return;
552  }
553 
554  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
555  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
556 
557  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
558  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
559  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
560  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
561 
562  smpAssign( ~lhs, x * A );
563  }
564  //**********************************************************************************************
565 
566  //**SMP assignment to sparse vectors************************************************************
580  template< typename VT2 > // Type of the target sparse vector
581  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
583  {
585 
589 
590  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
591 
592  const ResultType tmp( rhs );
593  smpAssign( ~lhs, tmp );
594  }
595  //**********************************************************************************************
596 
597  //**SMP addition assignment to dense vectors****************************************************
611  template< typename VT2 > // Type of the target dense vector
612  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
614  {
616 
617  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
618 
620 
621  if( rhs.mat_.rows() == 0UL ) {
622  return;
623  }
624 
625  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
626  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
627 
628  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
629  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
630  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
631  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
632 
633  smpAddAssign( ~lhs, x * A );
634  }
635  //**********************************************************************************************
636 
637  //**SMP addition assignment to sparse vectors***************************************************
638  // No special implementation for the SMP addition assignment to sparse vectors.
639  //**********************************************************************************************
640 
641  //**SMP subtraction assignment to dense vectors*************************************************
655  template< typename VT2 > // Type of the target dense vector
656  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
658  {
660 
661  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
662 
664 
665  if( rhs.mat_.rows() == 0UL ) {
666  return;
667  }
668 
669  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
670  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
671 
672  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
673  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
674  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
675  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
676 
677  smpSubAssign( ~lhs, x * A );
678  }
679  //**********************************************************************************************
680 
681  //**SMP subtraction assignment to sparse vectors************************************************
682  // No special implementation for the SMP subtraction assignment to sparse vectors.
683  //**********************************************************************************************
684 
685  //**SMP multiplication assignment to dense vectors**********************************************
699  template< typename VT2 > // Type of the target dense vector
700  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
702  {
704 
708 
709  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
710 
711  const ResultType tmp( rhs );
712  smpMultAssign( ~lhs, tmp );
713  }
714  //**********************************************************************************************
715 
716  //**SMP multiplication assignment to sparse vectors*********************************************
717  // No special implementation for the SMP multiplication assignment to sparse vectors.
718  //**********************************************************************************************
719 
720  //**Compile time checks*************************************************************************
728  //**********************************************************************************************
729 };
730 //*************************************************************************************************
731 
732 
733 
734 
735 //=================================================================================================
736 //
737 // GLOBAL BINARY ARITHMETIC OPERATORS
738 //
739 //=================================================================================================
740 
741 //*************************************************************************************************
772 template< typename T1 // Type of the left-hand side dense vector
773  , typename T2 > // Type of the right-hand side sparse matrix
774 inline const typename DisableIf< IsMatMatMultExpr<T2>, TDVecTSMatMultExpr<T1,T2> >::Type
776 {
778 
779  if( (~vec).size() != (~mat).rows() ) {
780  BLAZE_THROW_INVALID_ARGUMENT( "Vector and matrix sizes do not match" );
781  }
782 
783  return TDVecTSMatMultExpr<T1,T2>( ~vec, ~mat );
784 }
785 //*************************************************************************************************
786 
787 
788 
789 
790 //=================================================================================================
791 //
792 // SIZE SPECIALIZATIONS
793 //
794 //=================================================================================================
795 
796 //*************************************************************************************************
798 template< typename VT, typename MT >
799 struct Size< TDVecTSMatMultExpr<VT,MT> > : public Columns<MT>
800 {};
802 //*************************************************************************************************
803 
804 
805 
806 
807 //=================================================================================================
808 //
809 // ISALIGNED SPECIALIZATIONS
810 //
811 //=================================================================================================
812 
813 //*************************************************************************************************
815 template< typename VT, typename MT >
816 struct IsAligned< TDVecTSMatMultExpr<VT,MT> > : public IsTrue< IsAligned<VT>::value >
817 {};
819 //*************************************************************************************************
820 
821 
822 
823 
824 //=================================================================================================
825 //
826 // EXPRESSION TRAIT SPECIALIZATIONS
827 //
828 //=================================================================================================
829 
830 //*************************************************************************************************
832 template< typename VT, typename MT, bool AF >
833 struct SubvectorExprTrait< TDVecTSMatMultExpr<VT,MT>, AF >
834 {
835  public:
836  //**********************************************************************************************
837  typedef typename MultExprTrait< typename SubvectorExprTrait<const VT,AF>::Type
838  , typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
839  //**********************************************************************************************
840 };
842 //*************************************************************************************************
843 
844 } // namespace blaze
845 
846 #endif
SelectType< evaluateVector, const VRT, VCT >::Type LT
Composite type of the left-hand side dense vector expression.
Definition: TDVecTSMatMultExpr.h:168
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exceptionThis macro encapsulates the default way of...
Definition: Exception.h:187
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:89
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:7820
Header file for basic type definitions.
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:250
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:207
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TDVecTSMatMultExpr.h:156
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:149
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:507
RightOperand mat_
Right-hand side sparse matrix of the multiplication expression.
Definition: TDVecTSMatMultExpr.h:322
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2588
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:259
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:308
Header file for the DenseVector base class.
TDVecTSMatMultExpr< VT, MT > This
Type of this TDVecTSMatMultExpr instance.
Definition: TDVecTSMatMultExpr.h:152
friend EnableIf< UseSMPAssign< VT2 > >::Type 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:582
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
Header file for the Computation base class.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TDVecTSMatMultExpr.h:282
Header file for the RequiresEvaluation type trait.
VT::ResultType VRT
Result type of the left-hand side dense vector expression.
Definition: TDVecTSMatMultExpr.h:100
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:117
Constraint on the data type.
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TDVecTSMatMultExpr.h:200
MT::ResultType MRT
Result type of the right-hand side sparse matrix expression.
Definition: TDVecTSMatMultExpr.h:101
friend EnableIf< UseAssign< VT2 > >::Type 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:416
Constraint on the data type.
Header file for the MultExprTrait class template.
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:90
friend EnableIf< UseSMPAssign< VT2 > >::Type 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:701
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
Header file for the DisableIf class template.
Header file for the multiplication trait.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: TDVecTSMatMultExpr.h:314
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
friend EnableIf< UseSMPAssign< VT2 > >::Type 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:541
#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:79
LeftOperand leftOperand() const
Returns the left-hand side dense vector operand.
Definition: TDVecTSMatMultExpr.h:260
size_t size() const
Returns the current size/dimension of the vector.
Definition: TDVecTSMatMultExpr.h:250
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2592
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 exceptionThis macro encapsulates the default way of Bla...
Definition: Exception.h:331
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TDVecTSMatMultExpr.h:294
Header file for the Columns type trait.
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: TDVecTSMatMultExpr.h:304
friend EnableIf< UseAssign< VT2 > >::Type 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:342
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:321
RightOperand rightOperand() const
Returns the right-hand side transpose sparse matrix operand.
Definition: TDVecTSMatMultExpr.h:270
#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:78
SelectType< IsExpression< VT >::value, const VT, const VT & >::Type LeftOperand
Composite type of the left-hand side dense vector expression.
Definition: TDVecTSMatMultExpr.h:162
friend EnableIf< UseSMPAssign< VT2 > >::Type 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:657
Constraint on the data type.
Header file for the SelectType class template.
Header file for all forward declarations for expression class templates.
ResultType::ElementType ElementType
Resulting element type.
Definition: TDVecTSMatMultExpr.h:155
Header file for the EnableIf class template.
Header file for the serial shim.
friend EnableIf< UseAssign< VT2 > >::Type 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:384
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TDVecTSMatMultExpr.h:154
Header file for the SubmatrixExprTrait class template.
Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given...
Definition: RemoveReference.h:69
Header file for run time assertion macros.
Base template for the MultTrait class.
Definition: MultTrait.h:138
friend EnableIf< UseAssign< VT2 > >::Type 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:506
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: TDVecTSMatMultExpr.h:237
Header file for the reset shim.
Constraint on the data type.
friend EnableIf< UseSMPAssign< VT2 > >::Type 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:613
Header file for the TVecMatMultExpr base class.
Constraints on the storage order of matrix types.
MT::CompositeType MCT
Composite type of the right-hand side sparse matrix expression.
Definition: TDVecTSMatMultExpr.h:103
Header file for the RemoveReference type trait.
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TDVecTSMatMultExpr.h:165
TDVecTSMatMultExpr(const VT &vec, const MT &mat)
Constructor for the TDVecTSMatMultExpr class.
Definition: TDVecTSMatMultExpr.h:186
#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:79
#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:166
MultTrait< VRT, MRT >::Type ResultType
Result type for expression template evaluations.
Definition: TDVecTSMatMultExpr.h:153
Header file for the IsComputation type trait class.
SelectType< useAssign, const ResultType, const TDVecTSMatMultExpr & >::Type CompositeType
Data type for composite expression templates.
Definition: TDVecTSMatMultExpr.h:159
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:118
VT::CompositeType VCT
Composite type of the left-hand side dense vector expression.
Definition: TDVecTSMatMultExpr.h:102
#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
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2583
#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:79
Header file for the SubvectorExprTrait class template.
Header file for exception macros.
SelectType< evaluateMatrix, const MRT, MCT >::Type RT
Composite type of the right-hand side sparse matrix expression.
Definition: TDVecTSMatMultExpr.h:171
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:79
Constraint on the transpose flag of vector types.
Header file for the IsExpression type trait class.
friend EnableIf< UseAssign< VT2 > >::Type 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:461
Header file for the FunctionTrace class.