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 <stdexcept>
56 #include <blaze/math/shims/Reset.h>
71 #include <blaze/util/Assert.h>
73 #include <blaze/util/DisableIf.h>
74 #include <blaze/util/EnableIf.h>
76 #include <blaze/util/mpl/Or.h>
77 #include <blaze/util/SelectType.h>
78 #include <blaze/util/Types.h>
80 
81 
82 namespace blaze {
83 
84 //=================================================================================================
85 //
86 // CLASS TDVECSMATMULTEXPR
87 //
88 //=================================================================================================
89 
90 //*************************************************************************************************
97 template< typename VT // Type of the left-hand side dense vector
98  , typename MT > // Type of the right-hand side sparse matrix
99 class TDVecSMatMultExpr : public DenseVector< TDVecSMatMultExpr<VT,MT>, true >
100  , private TVecMatMultExpr
101  , private Computation
102 {
103  private:
104  //**Type definitions****************************************************************************
105  typedef typename VT::ResultType VRT;
106  typedef typename MT::ResultType MRT;
107  typedef typename VT::CompositeType VCT;
108  typedef typename MT::CompositeType MCT;
109  //**********************************************************************************************
110 
111  //**********************************************************************************************
113  enum { evaluateVector = IsComputation<VT>::value || RequiresEvaluation<VT>::value };
114  //**********************************************************************************************
115 
116  //**********************************************************************************************
118  enum { evaluateMatrix = RequiresEvaluation<MT>::value };
119  //**********************************************************************************************
120 
121  //**********************************************************************************************
123 
127  template< typename T1 >
128  struct UseSMPAssign {
129  enum { value = ( evaluateVector || evaluateMatrix ) };
130  };
132  //**********************************************************************************************
133 
134  public:
135  //**Type definitions****************************************************************************
140  typedef const ElementType ReturnType;
141  typedef const ResultType CompositeType;
142 
144  typedef typename SelectType< IsExpression<VT>::value, const VT, const VT& >::Type LeftOperand;
145 
147  typedef typename SelectType< IsExpression<MT>::value, const MT, const MT& >::Type RightOperand;
148 
151 
154  //**********************************************************************************************
155 
156  //**Compilation flags***************************************************************************
158  enum { vectorizable = 0 };
159 
161  enum { smpAssignable = !evaluateVector && VT::smpAssignable &&
162  !evaluateMatrix && MT::smpAssignable };
163  //**********************************************************************************************
164 
165  //**Constructor*********************************************************************************
168  explicit inline TDVecSMatMultExpr( const VT& vec, const MT& mat )
169  : vec_( vec ) // Left-hand side dense vector of the multiplication expression
170  , mat_( mat ) // Right-hand side sparse matrix of the multiplication expression
171  {
172  BLAZE_INTERNAL_ASSERT( vec_.size() == mat.rows(), "Invalid vector and matrix sizes" );
173  }
174  //**********************************************************************************************
175 
176  //**Subscript operator**************************************************************************
182  inline ReturnType operator[]( size_t index ) const {
183  BLAZE_INTERNAL_ASSERT( index < mat_.columns(), "Invalid vector access index" );
184 
185  ElementType res;
186 
187  if( vec_.size() != 0UL ) {
188  res = vec_[0UL] * mat_(0UL,index);
189  for( size_t i=1UL; i<vec_.size(); ++i ) {
190  res += vec_[i] * mat_(i,index);
191  }
192  }
193  else {
194  reset( res );
195  }
196 
197  return res;
198  }
199  //**********************************************************************************************
200 
201  //**Size function*******************************************************************************
206  inline size_t size() const {
207  return mat_.columns();
208  }
209  //**********************************************************************************************
210 
211  //**Left operand access*************************************************************************
216  inline LeftOperand leftOperand() const {
217  return vec_;
218  }
219  //**********************************************************************************************
220 
221  //**Right operand access************************************************************************
226  inline RightOperand rightOperand() const {
227  return mat_;
228  }
229  //**********************************************************************************************
230 
231  //**********************************************************************************************
237  template< typename T >
238  inline bool canAlias( const T* alias ) const {
239  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
240  }
241  //**********************************************************************************************
242 
243  //**********************************************************************************************
249  template< typename T >
250  inline bool isAliased( const T* alias ) const {
251  return ( vec_.isAliased( alias ) || mat_.isAliased( alias ) );
252  }
253  //**********************************************************************************************
254 
255  //**********************************************************************************************
260  inline bool isAligned() const {
261  return vec_.isAligned();
262  }
263  //**********************************************************************************************
264 
265  //**********************************************************************************************
270  inline bool canSMPAssign() const {
271  return ( size() > SMP_TDVECSMATMULT_THRESHOLD );
272  }
273  //**********************************************************************************************
274 
275  private:
276  //**Member variables****************************************************************************
277  LeftOperand vec_;
278  RightOperand mat_;
279  //**********************************************************************************************
280 
281  //**Assignment to dense vectors*****************************************************************
293  template< typename VT2 > // Type of the target dense vector
294  friend inline void assign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
295  {
297 
298  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
299 
300  reset( ~lhs );
301 
302  if( rhs.mat_.rows() == 0UL ) return;
303 
304  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
305  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
306 
307  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
308  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
309  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
310  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
311 
312  TDVecSMatMultExpr::selectAssignKernel( ~lhs, x, A );
313  }
314  //**********************************************************************************************
315 
316  //**Optimized assignment to dense vectors*******************************************************
330  template< typename VT1 // Type of the left-hand side target vector
331  , typename VT2 // Type of the left-hand side vector operand
332  , typename MT1 > // Type of the right-hand side matrix operand
333  static inline void selectAssignKernel( VT1& y, const VT2& x, const MT1& A )
334  {
336 
337  for( size_t i=0UL; i<x.size(); ++i )
338  {
339  const ConstIterator end( A.end(i) );
340  ConstIterator element( A.begin(i) );
341 
342  for( ; element!=end; ++element ) {
344  isDefault( y[element->index()] ) )
345  y[element->index()] = x[i] * element->value();
346  else
347  y[element->index()] += x[i] * element->value();
348  }
349  }
350  }
352  //**********************************************************************************************
353 
354  //**Assignment to sparse vectors****************************************************************
366  template< typename VT2 > // Type of the target sparse vector
367  friend inline void assign( SparseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
368  {
370 
374 
375  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
376 
377  const ResultType tmp( serial( rhs ) );
378  assign( ~lhs, tmp );
379  }
380  //**********************************************************************************************
381 
382  //**Addition assignment to dense vectors********************************************************
394  template< typename VT2 > // Type of the target dense vector
395  friend inline void addAssign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
396  {
398 
399  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
400 
402 
403  if( rhs.mat_.rows() == 0UL ) {
404  return;
405  }
406 
407  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
408  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
409 
410  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
411  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
412  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
413  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
414 
415  TDVecSMatMultExpr::selectAddAssignKernel( ~lhs, x, A );
416  }
417  //**********************************************************************************************
418 
419  //**Optimized addition assignment to dense vectors*************************************************
433  template< typename VT1 // Type of the left-hand side target vector
434  , typename VT2 // Type of the left-hand side vector operand
435  , typename MT1 > // Type of the right-hand side matrix operand
436  static inline void selectAddAssignKernel( VT1& y, const VT2& x, const MT1& A )
437  {
439 
440  for( size_t i=0UL; i<x.size(); ++i )
441  {
442  const ConstIterator end( A.end(i) );
443  ConstIterator element( A.begin(i) );
444 
445  for( ; element!=end; ++element ) {
446  y[element->index()] += x[i] * element->value();
447  }
448  }
449  }
451  //**********************************************************************************************
452 
453  //**Addition assignment to sparse vectors*******************************************************
454  // No special implementation for the addition assignment to sparse vectors.
455  //**********************************************************************************************
456 
457  //**Subtraction assignment to dense vectors*****************************************************
469  template< typename VT2 > // Type of the target dense vector
470  friend inline void subAssign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
471  {
473 
474  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
475 
477 
478  if( rhs.mat_.rows() == 0UL ) {
479  return;
480  }
481 
482  LT x( serial( rhs.vec_ ) ); // Evaluation of the left-hand side dense vector operator
483  RT A( serial( rhs.mat_ ) ); // Evaluation of the right-hand side sparse matrix operator
484 
485  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
486  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
487  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
488  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
489 
490  TDVecSMatMultExpr::selectSubAssignKernel( ~lhs, x, A );
491  }
492  //**********************************************************************************************
493 
494  //**Optimized subtraction assignment to dense vectors**********************************************
508  template< typename VT1 // Type of the left-hand side target vector
509  , typename VT2 // Type of the left-hand side vector operand
510  , typename MT1 > // Type of the right-hand side matrix operand
511  static inline void selectSubAssignKernel( VT1& y, const VT2& x, const MT1& A )
512  {
514 
515  for( size_t i=0UL; i<x.size(); ++i )
516  {
517  const ConstIterator end( A.end(i) );
518  ConstIterator element( A.begin(i) );
519 
520  for( ; element!=end; ++element ) {
521  y[element->index()] -= x[i] * element->value();
522  }
523  }
524  }
526  //**********************************************************************************************
527 
528  //**Subtraction assignment to sparse vectors****************************************************
529  // No special implementation for the subtraction assignment to sparse vectors.
530  //**********************************************************************************************
531 
532  //**Multiplication assignment to dense vectors**************************************************
544  template< typename VT2 > // Type of the target dense vector
545  friend inline void multAssign( DenseVector<VT2,true>& lhs, const TDVecSMatMultExpr& rhs )
546  {
548 
552 
553  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
554 
555  const ResultType tmp( serial( rhs ) );
556  multAssign( ~lhs, tmp );
557  }
558  //**********************************************************************************************
559 
560  //**Multiplication assignment to sparse vectors*************************************************
561  // No special implementation for the multiplication assignment to sparse vectors.
562  //**********************************************************************************************
563 
564  //**SMP assignment to dense vectors*************************************************************
578  template< typename VT2 > // Type of the target dense vector
579  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
581  {
583 
584  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
585 
586  reset( ~lhs );
587 
588  if( rhs.mat_.rows() == 0UL ) return;
589 
590  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
591  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
592 
593  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
594  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
595  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
596  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
597 
598  smpAssign( ~lhs, x * A );
599  }
600  //**********************************************************************************************
601 
602  //**SMP assignment to sparse vectors************************************************************
616  template< typename VT2 > // Type of the target sparse vector
617  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
619  {
621 
625 
626  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
627 
628  const ResultType tmp( rhs );
629  smpAssign( ~lhs, tmp );
630  }
631  //**********************************************************************************************
632 
633  //**SMP addition assignment to dense vectors****************************************************
647  template< typename VT2 > // Type of the target dense vector
648  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
650  {
652 
653  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
654 
656 
657  if( rhs.mat_.rows() == 0UL ) {
658  return;
659  }
660 
661  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
662  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
663 
664  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
665  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
666  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
667  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
668 
669  smpAddAssign( ~lhs, x * A );
670  }
671  //**********************************************************************************************
672 
673  //**SMP addition assignment to sparse vectors***************************************************
674  // No special implementation for the SMP addition assignment to sparse vectors.
675  //**********************************************************************************************
676 
677  //**SMP subtraction assignment to dense vectors*************************************************
691  template< typename VT2 > // Type of the target dense vector
692  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
694  {
696 
697  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
698 
700 
701  if( rhs.mat_.rows() == 0UL ) {
702  return;
703  }
704 
705  LT x( rhs.vec_ ); // Evaluation of the left-hand side dense vector operator
706  RT A( rhs.mat_ ); // Evaluation of the right-hand side sparse matrix operator
707 
708  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
709  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
710  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
711  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
712 
713  smpSubAssign( ~lhs, x * A );
714  }
715  //**********************************************************************************************
716 
717  //**SMP subtraction assignment to sparse vectors************************************************
718  // No special implementation for the SMP subtraction assignment to sparse vectors.
719  //**********************************************************************************************
720 
721  //**SMP multiplication assignment to dense vectors**********************************************
735  template< typename VT2 > // Type of the target dense vector
736  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
738  {
740 
744 
745  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
746 
747  const ResultType tmp( rhs );
748  smpMultAssign( ~lhs, tmp );
749  }
750  //**********************************************************************************************
751 
752  //**SMP multiplication assignment to sparse vectors*********************************************
753  // No special implementation for the SMP multiplication assignment to sparse vectors.
754  //**********************************************************************************************
755 
756  //**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 typename DisableIf< Or< IsSymmetric<T2>, IsMatMatMultExpr<T2> >
812  , TDVecSMatMultExpr<T1,T2> >::Type
814 {
816 
817  if( (~vec).size() != (~mat).rows() )
818  throw std::invalid_argument( "Vector and matrix sizes do not match" );
819 
820  return TDVecSMatMultExpr<T1,T2>( ~vec, ~mat );
821 }
822 //*************************************************************************************************
823 
824 
825 
826 
827 //=================================================================================================
828 //
829 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
830 //
831 //=================================================================================================
832 
833 //*************************************************************************************************
848 template< typename T1 // Type of the left-hand side dense vector
849  , typename T2 > // Type of the right-hand side sparse matrix
850 inline const typename EnableIf< IsSymmetric<T2>, typename MultExprTrait<T1,T2>::Type >::Type
851  operator*( const DenseVector<T1,true>& vec, const SparseMatrix<T2,false>& mat )
852 {
854 
856 
857  if( (~vec).size() != (~mat).rows() )
858  throw std::invalid_argument( "Vector and matrix sizes do not match" );
859 
860  return (~vec) * trans( ~mat );
861 }
863 //*************************************************************************************************
864 
865 
866 //*************************************************************************************************
879 template< typename T1 // Type of the left-hand side dense vector
880  , typename T2 // Type of the right-hand side sparse matrix
881  , bool SO > // Storage order of the right-hand side sparse matrix
882 inline const typename EnableIf< IsMatMatMultExpr<T2>, typename MultExprTrait<T1,T2>::Type >::Type
884 {
886 
888 
889  return ( vec * (~mat).leftOperand() ) * (~mat).rightOperand();
890 }
891 //*************************************************************************************************
892 
893 
894 
895 
896 //=================================================================================================
897 //
898 // SIZE SPECIALIZATIONS
899 //
900 //=================================================================================================
901 
902 //*************************************************************************************************
904 template< typename MT, typename VT >
905 struct Size< TDVecSMatMultExpr<MT,VT> >
906  : public Columns<MT>
907 {};
909 //*************************************************************************************************
910 
911 
912 
913 
914 //=================================================================================================
915 //
916 // EXPRESSION TRAIT SPECIALIZATIONS
917 //
918 //=================================================================================================
919 
920 //*************************************************************************************************
922 template< typename VT, typename MT, bool AF >
923 struct SubvectorExprTrait< TDVecSMatMultExpr<VT,MT>, AF >
924 {
925  public:
926  //**********************************************************************************************
927  typedef typename MultExprTrait< typename SubvectorExprTrait<const VT,AF>::Type
928  , typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
929  //**********************************************************************************************
930 };
932 //*************************************************************************************************
933 
934 } // namespace blaze
935 
936 #endif
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:8247
Header file for basic type definitions.
SelectType< IsExpression< VT >::value, const VT, const VT & >::Type LeftOperand
Composite type of the left-hand side dense vector expression.
Definition: TDVecSMatMultExpr.h:144
friend EnableIf< UseSMPAssign< VT2 > >::Type 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:737
Expression object for transpose dense vector-sparse matrix multiplications.The TDVecSMatMultExpr clas...
Definition: Forward.h:134
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: TDVecSMatMultExpr.h:260
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:258
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: TDVecSMatMultExpr.h:270
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:209
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:821
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2507
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:261
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:316
Header file for the DenseVector base class.
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:699
TDVecSMatMultExpr< VT, MT > This
Type of this TDVecSMatMultExpr instance.
Definition: TDVecSMatMultExpr.h:136
Header file for the Computation base class.
Header file for the RequiresEvaluation type trait.
friend EnableIf< UseSMPAssign< VT2 > >::Type 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:618
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:367
const ResultType CompositeType
Data type for composite expression templates.
Definition: TDVecSMatMultExpr.h:141
RightOperand mat_
Right-hand side sparse matrix of the multiplication expression.
Definition: TDVecSMatMultExpr.h:278
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:107
LeftOperand vec_
Left-hand side dense vector of the multiplication expression.
Definition: TDVecSMatMultExpr.h:277
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:861
Constraint on the data type.
MultTrait< VRT, MRT >::Type ResultType
Result type for expression template evaluations.
Definition: TDVecSMatMultExpr.h:137
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
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TDVecSMatMultExpr.h:182
LeftOperand leftOperand() const
Returns the left-hand side dense vector operand.
Definition: TDVecSMatMultExpr.h:216
size_t size() const
Returns the current size/dimension of the vector.
Definition: TDVecSMatMultExpr.h:206
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.
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:470
Header file for the multiplication trait.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TDVecSMatMultExpr.h:138
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TDVecSMatMultExpr.h:250
SelectType< evaluateMatrix, const MRT, MCT >::Type RT
Composite type of the right-hand side sparse matrix expression.
Definition: TDVecSMatMultExpr.h:153
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:545
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2511
Header file for the Or class template.
Header file for the IsMatMatMultExpr type trait class.
Header file for the Columns type trait.
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
RightOperand rightOperand() const
Returns the right-hand side sparse matrix operand.
Definition: TDVecSMatMultExpr.h:226
Constraint on the data type.
friend EnableIf< UseSMPAssign< VT2 > >::Type 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:649
#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:126
#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
Constraints on the storage order of matrix types.
Constraint on the data type.
Header file for the SelectType class template.
Header file for all forward declarations for expression class templates.
Header file for the EnableIf class template.
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TDVecSMatMultExpr.h:147
Header file for the serial shim.
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:116
Header file for the SubmatrixExprTrait class template.
#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: StorageOrder.h:81
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.
MT::CompositeType MCT
Composite type of the right-hand side sparse matrix expression.
Definition: TDVecSMatMultExpr.h:108
Base template for the MultTrait class.
Definition: MultTrait.h:150
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
Header file for the reset shim.
Constraint on the data type.
ResultType::ElementType ElementType
Resulting element type.
Definition: TDVecSMatMultExpr.h:139
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:395
VT::ResultType VRT
Result type of the left-hand side dense vector expression.
Definition: TDVecSMatMultExpr.h:105
SelectType< evaluateVector, const VRT, VCT >::Type LT
Composite type of the left-hand side dense vector expression.
Definition: TDVecSMatMultExpr.h:150
Header file for the RemoveReference type trait.
friend EnableIf< UseSMPAssign< VT2 > >::Type 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:580
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TDVecSMatMultExpr.h:140
TDVecSMatMultExpr(const VT &vec, const MT &mat)
Constructor for the TDVecSMatMultExpr class.
Definition: TDVecSMatMultExpr.h:168
friend EnableIf< UseSMPAssign< VT2 > >::Type 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:693
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:294
#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
VT::CompositeType VCT
Composite type of the left-hand side dense vector expression.
Definition: TDVecSMatMultExpr.h:107
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TDVecSMatMultExpr.h:238
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:937
Header file for the IsComputation type trait class.
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:108
#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:2502
#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: TransposeFlag.h:81
Header file for the SubvectorExprTrait class template.
Constraint on the data type.
Header file for the IsResizable type trait.
const size_t SMP_TDVECSMATMULT_THRESHOLD
SMP dense vector/row-major sparse matrix multiplication threshold.This threshold specifies when a den...
Definition: Thresholds.h:552
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
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
MT::ResultType MRT
Result type of the right-hand side sparse matrix expression.
Definition: TDVecSMatMultExpr.h:106