TSVecTDMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSVECTDMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSVECTDMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
55 #include <blaze/math/shims/Reset.h>
73 #include <blaze/util/Assert.h>
75 #include <blaze/util/DisableIf.h>
76 #include <blaze/util/EnableIf.h>
78 #include <blaze/util/mpl/Or.h>
79 #include <blaze/util/SelectType.h>
80 #include <blaze/util/Types.h>
82 
83 
84 namespace blaze {
85 
86 //=================================================================================================
87 //
88 // CLASS TSVECDMATMULTEXPR
89 //
90 //=================================================================================================
91 
92 //*************************************************************************************************
99 template< typename VT // Type of the left-hand side sparse vector
100  , typename MT > // Type of the right-hand side dense matrix
101 class TSVecTDMatMultExpr : public DenseVector< TSVecTDMatMultExpr<VT,MT>, true >
102  , private TVecMatMultExpr
103  , private Computation
104 {
105  private:
106  //**Type definitions****************************************************************************
107  typedef typename VT::ResultType VRT;
108  typedef typename MT::ResultType MRT;
109  typedef typename VT::CompositeType VCT;
110  typedef typename MT::CompositeType MCT;
111  //**********************************************************************************************
112 
113  //**********************************************************************************************
115  enum { evaluateVector = IsComputation<VT>::value || RequiresEvaluation<VT>::value };
116  //**********************************************************************************************
117 
118  //**********************************************************************************************
120  enum { evaluateMatrix = RequiresEvaluation<MT>::value };
121  //**********************************************************************************************
122 
123  //**********************************************************************************************
125 
131  enum { useAssign = ( evaluateVector || evaluateMatrix ) };
132  //**********************************************************************************************
133 
134  //**********************************************************************************************
136  template< typename VT2 >
138  struct UseAssign {
139  enum { value = useAssign };
140  };
142  //**********************************************************************************************
143 
144  //**********************************************************************************************
146 
150  template< typename T1 >
151  struct UseSMPAssign {
152  enum { value = useAssign };
153  };
155  //**********************************************************************************************
156 
157  public:
158  //**Type definitions****************************************************************************
163  typedef const ElementType ReturnType;
164 
167 
169  typedef typename SelectType< IsExpression<VT>::value, const VT, const VT& >::Type LeftOperand;
170 
172  typedef typename SelectType< IsExpression<MT>::value, const MT, const MT& >::Type RightOperand;
173 
176 
179  //**********************************************************************************************
180 
181  //**Compilation flags***************************************************************************
183  enum { vectorizable = 0 };
184 
186  enum { smpAssignable = !evaluateVector && VT::smpAssignable &&
187  !evaluateMatrix && MT::smpAssignable };
188  //**********************************************************************************************
189 
190  //**Constructor*********************************************************************************
196  explicit inline TSVecTDMatMultExpr( const VT& vec, const MT& mat )
197  : vec_( vec ) // Left-hand side sparse vector of the multiplication expression
198  , mat_( mat ) // Right-hand side dense matrix of the multiplication expression
199  {
200  BLAZE_INTERNAL_ASSERT( vec_.size() == mat_.rows(), "Invalid vector and matrix sizes" );
201  }
202  //**********************************************************************************************
203 
204  //**Subscript operator**************************************************************************
210  inline ReturnType operator[]( size_t index ) const {
211  BLAZE_INTERNAL_ASSERT( index < mat_.columns(), "Invalid vector access index" );
212 
214 
215  VCT x( vec_ ); // Evaluation of the left-hand side sparse vector operand
216 
217  BLAZE_INTERNAL_ASSERT( x.size() == vec_.size(), "Invalid vector size" );
218 
219  const ConstIterator end( ( IsUpper<MT>::value )
220  ?( IsStrictlyUpper<MT>::value ? x.lowerBound( index ) : x.upperBound( index ) )
221  :( x.end() ) );
222  ConstIterator element( ( IsLower<MT>::value )
223  ?( IsStrictlyLower<MT>::value ? x.upperBound( index ) : x.lowerBound( index ) )
224  :( x.begin() ) );
225 
226  ElementType res = ElementType();
227 
228  if( element != end ) {
229  res = element->value() * mat_( element->index(), index );
230  ++element;
231  for( ; element!=end; ++element ) {
232  res += element->value() * mat_( element->index(), index );
233  }
234  }
235 
236  return res;
237  }
238  //**********************************************************************************************
239 
240  //**Size function*******************************************************************************
245  inline size_t size() const {
246  return mat_.columns();
247  }
248  //**********************************************************************************************
249 
250  //**Left operand access*************************************************************************
255  inline LeftOperand leftOperand() const {
256  return vec_;
257  }
258  //**********************************************************************************************
259 
260  //**Right operand access************************************************************************
265  inline RightOperand rightOperand() const {
266  return mat_;
267  }
268  //**********************************************************************************************
269 
270  //**********************************************************************************************
276  template< typename T >
277  inline bool canAlias( const T* alias ) const {
278  return vec_.isAliased( alias ) || mat_.isAliased( alias );
279  }
280  //**********************************************************************************************
281 
282  //**********************************************************************************************
288  template< typename T >
289  inline bool isAliased( const T* alias ) const {
290  return vec_.isAliased( alias ) || mat_.isAliased( alias );
291  }
292  //**********************************************************************************************
293 
294  //**********************************************************************************************
299  inline bool isAligned() const {
300  return mat_.isAligned();
301  }
302  //**********************************************************************************************
303 
304  //**********************************************************************************************
309  inline bool canSMPAssign() const {
310  return ( size() > SMP_TSVECTDMATMULT_THRESHOLD );
311  }
312  //**********************************************************************************************
313 
314  private:
315  //**Member variables****************************************************************************
316  LeftOperand vec_;
317  RightOperand mat_;
318  //**********************************************************************************************
319 
320  //**Assignment to dense vectors*****************************************************************
336  template< typename VT2 > // Type of the target dense vector
337  friend inline typename EnableIf< UseAssign<VT2> >::Type
339  {
341 
342  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
343 
345 
346  // Evaluation of the left-hand side sparse vector operand
347  LT x( serial( rhs.vec_ ) );
348  if( x.nonZeros() == 0UL ) {
349  reset( ~lhs );
350  return;
351  }
352 
353  // Evaluation of the right-hand side dense matrix operand
354  RT A( serial( rhs.mat_ ) );
355 
356  // Checking the evaluated operands
357  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
358  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
359  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
360  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
361 
362  // Performing the sparse vector-dense matrix multiplication
363  assign( ~lhs, x * A );
364  }
366  //**********************************************************************************************
367 
368  //**Assignment to sparse vectors****************************************************************
384  template< typename VT2 > // Type of the target sparse vector
385  friend inline typename EnableIf< UseAssign<VT2> >::Type
387  {
389 
393 
394  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
395 
396  const ResultType tmp( serial( rhs ) );
397  assign( ~lhs, tmp );
398  }
400  //**********************************************************************************************
401 
402  //**Addition assignment to dense vectors********************************************************
417  template< typename VT2 > // Type of the target dense vector
418  friend inline typename EnableIf< UseAssign<VT2> >::Type
420  {
422 
423  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
424 
426 
427  // Evaluation of the left-hand side sparse vector operand
428  LT x( serial( rhs.vec_ ) );
429  if( x.nonZeros() == 0UL ) return;
430 
431  // Evaluation of the right-hand side dense matrix operand
432  RT A( serial( rhs.mat_ ) );
433 
434  // Checking the evaluated operands
435  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
436  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
437  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
438  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
439 
440  // Performing the sparse vector-dense matrix multiplication
441  addAssign( ~lhs, x * A );
442  }
443  //**********************************************************************************************
444 
445  //**Addition assignment to sparse vectors*******************************************************
446  // No special implementation for the addition assignment to sparse vectors.
447  //**********************************************************************************************
448 
449  //**Subtraction assignment to dense vectors*****************************************************
464  template< typename VT2 > // Type of the target dense vector
465  friend inline typename EnableIf< UseAssign<VT2> >::Type
467  {
469 
470  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
471 
473 
474  // Evaluation of the left-hand side sparse vector operand
475  LT x( serial( rhs.vec_ ) );
476  if( x.nonZeros() == 0UL ) return;
477 
478  // Evaluation of the right-hand side dense matrix operand
479  RT A( serial( rhs.mat_ ) );
480 
481  // Checking the evaluated operands
482  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
483  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
484  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
485  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
486 
487  // Performing the sparse vector-dense matrix multiplication
488  subAssign( ~lhs, x * A );
489  }
490  //**********************************************************************************************
491 
492  //**Subtraction assignment to sparse vectors****************************************************
493  // No special implementation for the subtraction assignment to sparse vectors.
494  //**********************************************************************************************
495 
496  //**Multiplication assignment to dense vectors**************************************************
511  template< typename VT2 > // Type of the target dense vector
512  friend inline typename EnableIf< UseAssign<VT2> >::Type
514  {
516 
520 
521  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
522 
523  const ResultType tmp( serial( rhs ) );
524  multAssign( ~lhs, tmp );
525  }
526  //**********************************************************************************************
527 
528  //**Multiplication assignment to sparse vectors*************************************************
529  // No special implementation for the multiplication assignment to sparse vectors.
530  //**********************************************************************************************
531 
532  //**SMP assignment to dense vectors*************************************************************
547  template< typename VT2 > // Type of the target dense vector
548  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
550  {
552 
553  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
554 
556 
557  // Evaluation of the left-hand side sparse vector operand
558  LT x( rhs.vec_ );
559  if( x.nonZeros() == 0UL ) {
560  reset( ~lhs );
561  return;
562  }
563 
564  // Evaluation of the right-hand side dense matrix operand
565  RT A( rhs.mat_ );
566 
567  // Checking the evaluated operands
568  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
569  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
570  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
571  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
572 
573  // Performing the sparse vector-dense matrix multiplication
574  smpAssign( ~lhs, x * A );
575  }
577  //**********************************************************************************************
578 
579  //**SMP assignment to sparse vectors************************************************************
594  template< typename VT2 > // Type of the target sparse vector
595  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
596  smpAssign( SparseVector<VT2,true>& lhs, const TSVecTDMatMultExpr& rhs )
597  {
599 
603 
604  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
605 
606  const ResultType tmp( rhs );
607  smpAssign( ~lhs, tmp );
608  }
610  //**********************************************************************************************
611 
612  //**SMP addition assignment to dense vectors****************************************************
626  template< typename VT2 > // Type of the target dense vector
627  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
629  {
631 
632  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
633 
635 
636  // Evaluation of the left-hand side sparse vector operand
637  LT x( rhs.vec_ );
638  if( x.nonZeros() == 0UL ) return;
639 
640  // Evaluation of the right-hand side dense matrix operand
641  RT A( rhs.mat_ );
642 
643  // Checking the evaluated operands
644  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
645  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
646  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
647  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
648 
649  // Performing the sparse vector-dense matrix multiplication
650  smpAddAssign( ~lhs, x * A );
651  }
652  //**********************************************************************************************
653 
654  //**SMP addition assignment to sparse vectors***************************************************
655  // No special implementation for the SMP addition assignment to sparse vectors.
656  //**********************************************************************************************
657 
658  //**SMP subtraction assignment to dense vectors*************************************************
672  template< typename VT2 > // Type of the target dense vector
673  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
675  {
677 
678  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
679 
681 
682  // Evaluation of the left-hand side sparse vector operand
683  LT x( rhs.vec_ );
684  if( x.nonZeros() == 0UL ) return;
685 
686  // Evaluation of the right-hand side dense matrix operand
687  RT A( rhs.mat_ );
688 
689  // Checking the evaluated operands
690  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
691  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
692  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
693  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
694 
695  // Performing the sparse vector-dense matrix multiplication
696  smpSubAssign( ~lhs, x * A );
697  }
698  //**********************************************************************************************
699 
700  //**SMP subtraction assignment to sparse vectors************************************************
701  // No special implementation for the SMP subtraction assignment to sparse vectors.
702  //**********************************************************************************************
703 
704  //**SMP multiplication assignment to dense vectors**********************************************
719  template< typename VT2 > // Type of the target dense vector
720  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
722  {
724 
728 
729  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
730 
731  const ResultType tmp( rhs );
732  smpMultAssign( ~lhs, tmp );
733  }
734  //**********************************************************************************************
735 
736  //**SMP multiplication assignment to sparse vectors*********************************************
737  // No special implementation for the SMP multiplication assignment to sparse vectors.
738  //**********************************************************************************************
739 
740  //**Compile time checks*************************************************************************
749  //**********************************************************************************************
750 };
751 //*************************************************************************************************
752 
753 
754 
755 
756 //=================================================================================================
757 //
758 // GLOBAL BINARY ARITHMETIC OPERATORS
759 //
760 //=================================================================================================
761 
762 //*************************************************************************************************
793 template< typename T1, typename T2 >
794 inline const typename DisableIf< Or< IsSymmetric<T2>, IsMatMatMultExpr<T2> >
795  , TSVecTDMatMultExpr<T1,T2> >::Type
797 {
799 
800  if( (~vec).size() != (~mat).rows() )
801  throw std::invalid_argument( "Vector and matrix sizes do not match" );
802 
803  return TSVecTDMatMultExpr<T1,T2>( ~vec, ~mat );
804 }
805 //*************************************************************************************************
806 
807 
808 
809 
810 //=================================================================================================
811 //
812 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
813 //
814 //=================================================================================================
815 
816 //*************************************************************************************************
831 template< typename T1 // Type of the left-hand side sparse vector
832  , typename T2 > // Type of the right-hand side dense matrix
833 inline const typename EnableIf< IsSymmetric<T2>, typename MultExprTrait<T1,T2>::Type >::Type
834  operator*( const SparseVector<T1,true>& vec, const DenseMatrix<T2,true>& mat )
835 {
837 
839 
840  if( (~vec).size() != (~mat).rows() )
841  throw std::invalid_argument( "Vector and matrix sizes do not match" );
842 
843  return (~vec) * trans( ~mat );
844 }
846 //*************************************************************************************************
847 
848 
849 
850 
851 //=================================================================================================
852 //
853 // SIZE SPECIALIZATIONS
854 //
855 //=================================================================================================
856 
857 //*************************************************************************************************
859 template< typename MT, typename VT >
860 struct Size< TSVecTDMatMultExpr<MT,VT> >
861  : public Columns<MT>
862 {};
864 //*************************************************************************************************
865 
866 
867 
868 
869 //=================================================================================================
870 //
871 // EXPRESSION TRAIT SPECIALIZATIONS
872 //
873 //=================================================================================================
874 
875 //*************************************************************************************************
877 template< typename VT, typename MT, bool AF >
878 struct SubvectorExprTrait< TSVecTDMatMultExpr<VT,MT>, AF >
879 {
880  public:
881  //**********************************************************************************************
882  typedef typename MultExprTrait< typename SubvectorExprTrait<const VT,AF>::Type
883  , typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
884  //**********************************************************************************************
885 };
887 //*************************************************************************************************
888 
889 } // namespace blaze
890 
891 #endif
LeftOperand vec_
Left-hand side sparse vector of the multiplication expression.
Definition: TSVecTDMatMultExpr.h:316
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSVecTDMatMultExpr.h:163
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.
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
SelectType< evaluateVector, const VRT, VCT >::Type LT
Type for the assignment of the left-hand side sparse vector operand.
Definition: TSVecTDMatMultExpr.h:175
size_t size() const
Returns the current size/dimension of the vector.
Definition: TSVecTDMatMultExpr.h:245
SelectType< evaluateMatrix, const MRT, MCT >::Type RT
Type for the assignment of the left-hand side dense matrix operand.
Definition: TSVecTDMatMultExpr.h:178
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:209
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:79
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
RightOperand rightOperand() const
Returns the right-hand side transpose dense matrix operand.
Definition: TSVecTDMatMultExpr.h:265
Header file for the DenseVector base class.
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:90
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
Header file for the Computation base class.
MT::ResultType MRT
Result type of the right-hand side dense matrix expression.
Definition: TSVecTDMatMultExpr.h:108
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:90
Header file for the RequiresEvaluation type trait.
ResultType::ElementType ElementType
Resulting element type.
Definition: TSVecTDMatMultExpr.h:162
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Constraint on the data type.
VT::CompositeType VCT
Composite type of the left-hand side sparse vector expression.
Definition: TSVecTDMatMultExpr.h:109
Constraint on the data type.
friend EnableIf< UseSMPAssign< VT2 > >::Type smpMultAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
SMP multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication to a...
Definition: TSVecTDMatMultExpr.h:721
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
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:263
friend EnableIf< UseSMPAssign< VT2 > >::Type smpSubAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
SMP subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication to a de...
Definition: TSVecTDMatMultExpr.h:674
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.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#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: StorageOrder.h:161
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: TSVecTDMatMultExpr.h:299
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2511
Header file for the Or class template.
friend EnableIf< UseAssign< VT2 > >::Type multAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
Multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication to a den...
Definition: TSVecTDMatMultExpr.h:513
Header file for the IsMatMatMultExpr type trait class.
BLAZE_ALWAYS_INLINE void assign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the assignment of a matrix to a matrix.
Definition: Matrix.h:635
const size_t SMP_TSVECTDMATMULT_THRESHOLD
SMP sparse vector/column-major dense matrix multiplication threshold.This threshold specifies when a ...
Definition: Thresholds.h:483
Header file for the Columns type trait.
SelectType< useAssign, const ResultType, const TSVecTDMatMultExpr & >::Type CompositeType
Data type for composite expression templates.
Definition: TSVecTDMatMultExpr.h:166
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 IsLower type trait.
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional vector type...
Definition: SparseVector.h:79
Constraint on the data type.
#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.
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
Header file for the SelectType class template.
Header file for all forward declarations for expression class templates.
Constraint on the data type.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Header file for the serial shim.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TSVecTDMatMultExpr.h:277
TSVecTDMatMultExpr< VT, MT > This
Type of this TSVecTDMatMultExpr instance.
Definition: TSVecTDMatMultExpr.h:159
#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.
Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given...
Definition: RemoveReference.h:69
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TSVecTDMatMultExpr.h:161
Header file for run time assertion macros.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:98
friend EnableIf< UseAssign< VT2 > >::Type subAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
Subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense ...
Definition: TSVecTDMatMultExpr.h:466
MultTrait< VRT, MRT >::Type ResultType
Result type for expression template evaluations.
Definition: TSVecTDMatMultExpr.h:160
friend EnableIf< UseAssign< VT2 > >::Type addAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
Addition assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vec...
Definition: TSVecTDMatMultExpr.h:419
Base template for the MultTrait class.
Definition: MultTrait.h:150
MT::CompositeType MCT
Composite type of the right-hand side dense matrix expression.
Definition: TSVecTDMatMultExpr.h:110
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.
TSVecTDMatMultExpr(const VT &vec, const MT &mat)
Constructor for the TSVecTDMatMultExpr class.
Definition: TSVecTDMatMultExpr.h:196
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TSVecTDMatMultExpr.h:289
Header file for the TVecMatMultExpr base class.
RightOperand mat_
Right-hand side dense matrix of the multiplication expression.
Definition: TSVecTDMatMultExpr.h:317
Header file for the RemoveReference type trait.
Expression object for transpose sparse vector-transpose dense matrix multiplications.The TSVecTDMatMultExpr class represents the compile time expression for multiplications between transpose sparse vectors and column-major dense matrices.
Definition: Forward.h:149
LeftOperand leftOperand() const
Returns the left-hand side sparse vector operand.
Definition: TSVecTDMatMultExpr.h:255
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
#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
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TSVecTDMatMultExpr.h:210
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.
friend EnableIf< UseSMPAssign< VT2 > >::Type smpAddAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
SMP addition assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense...
Definition: TSVecTDMatMultExpr.h:628
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.
Header file for the IsUpper type trait.
Constraint on the data type.
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TSVecTDMatMultExpr.h:172
SelectType< IsExpression< VT >::value, const VT, const VT & >::Type LeftOperand
Composite type of the left-hand side sparse vector expression.
Definition: TSVecTDMatMultExpr.h:169
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
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: TSVecTDMatMultExpr.h:309
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
VT::ResultType VRT
Result type of the left-hand side sparse vector expression.
Definition: TSVecTDMatMultExpr.h:107