All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TSMatDVecMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATDVECMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATDVECMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
53 #include <blaze/math/shims/Reset.h>
63 #include <blaze/util/Assert.h>
65 #include <blaze/util/DisableIf.h>
66 #include <blaze/util/EnableIf.h>
68 #include <blaze/util/SelectType.h>
69 #include <blaze/util/Types.h>
71 
72 
73 namespace blaze {
74 
75 //=================================================================================================
76 //
77 // CLASS TSMATDVECMULTEXPR
78 //
79 //=================================================================================================
80 
81 //*************************************************************************************************
88 template< typename MT // Type of the left-hand side sparse matrix
89  , typename VT > // Type of the right-hand side dense vector
90 class TSMatDVecMultExpr : public DenseVector< TSMatDVecMultExpr<MT,VT>, false >
91  , private MatVecMultExpr
92  , private Computation
93 {
94  private:
95  //**Type definitions****************************************************************************
96  typedef typename MT::ResultType MRT;
97  typedef typename VT::ResultType VRT;
98  typedef typename MT::CompositeType MCT;
99  typedef typename VT::CompositeType VCT;
100  //**********************************************************************************************
101 
102  //**********************************************************************************************
104  enum { evaluateMatrix = RequiresEvaluation<MT>::value };
105  //**********************************************************************************************
106 
107  //**********************************************************************************************
109  enum { evaluateVector = IsComputation<VT>::value };
110  //**********************************************************************************************
111 
112  public:
113  //**Type definitions****************************************************************************
118  typedef const ElementType ReturnType;
119  typedef const ResultType CompositeType;
120 
122  typedef typename SelectType< IsExpression<MT>::value, const MT, const MT& >::Type LeftOperand;
123 
125  typedef typename SelectType< IsExpression<VT>::value, const VT, const VT& >::Type RightOperand;
126 
128  typedef MCT LT;
129 
132  //**********************************************************************************************
133 
134  //**Compilation flags***************************************************************************
136  enum { vectorizable = 0 };
137 
139  enum { smpAssignable = 0 };
140  //**********************************************************************************************
141 
142  //**Constructor*********************************************************************************
148  explicit inline TSMatDVecMultExpr( const MT& mat, const VT& vec )
149  : mat_( mat ) // Left-hand side sparse matrix of the multiplication expression
150  , vec_( vec ) // Right-hand side dense vector of the multiplication expression
151  {
152  BLAZE_INTERNAL_ASSERT( mat_.columns() == vec_.size(), "Invalid matrix and vector sizes" );
153  }
154  //**********************************************************************************************
155 
156  //**Subscript operator**************************************************************************
162  inline ReturnType operator[]( size_t index ) const {
163  BLAZE_INTERNAL_ASSERT( index < mat_.rows(), "Invalid vector access index" );
164 
165  ElementType res;
166 
167  if( vec_.size() > 0UL ) {
168  res = mat_(index,0UL) * vec_[0UL];
169  for( size_t j=1UL; j<vec_.size(); ++j )
170  res += mat_(index,j) * vec_[j];
171  }
172  else {
173  reset( res );
174  }
175 
176  return res;
177  }
178  //**********************************************************************************************
179 
180  //**Size function*******************************************************************************
185  inline size_t size() const {
186  return mat_.rows();
187  }
188  //**********************************************************************************************
189 
190  //**Left operand access*************************************************************************
195  inline LeftOperand leftOperand() const {
196  return mat_;
197  }
198  //**********************************************************************************************
199 
200  //**Right operand access************************************************************************
205  inline RightOperand rightOperand() const {
206  return vec_;
207  }
208  //**********************************************************************************************
209 
210  //**********************************************************************************************
216  template< typename T >
217  inline bool canAlias( const T* alias ) const {
218  return ( mat_.isAliased( alias ) || vec_.isAliased( alias ) );
219  }
220  //**********************************************************************************************
221 
222  //**********************************************************************************************
228  template< typename T >
229  inline bool isAliased( const T* alias ) const {
230  return ( mat_.isAliased( alias ) || vec_.isAliased( alias ) );
231  }
232  //**********************************************************************************************
233 
234  private:
235  //**Member variables****************************************************************************
238  //**********************************************************************************************
239 
240  //**Default assignment to dense vectors*********************************************************
254  template< typename VT1 > // Type of the target dense vector
255  friend inline typename EnableIf< IsResizable<typename VT1::ElementType> >::Type
257  {
259 
260  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
261 
263 
264  reset( ~lhs );
265 
266  if( rhs.mat_.columns() == 0UL ) return;
267 
268  LT A( rhs.mat_ ); // Evaluation of the left-hand side sparse matrix operand
269  RT x( rhs.vec_ ); // Evaluation of the right-hand side dense vector operand
270 
271  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
272  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
273  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
274  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
275 
276  for( size_t j=0UL; j<A.columns(); ++j )
277  {
278  ConstIterator element( A.begin(j) );
279  const ConstIterator end( A.end(j) );
280 
281  for( ; element!=end; ++element ) {
282  if( isDefault( (~lhs)[element->index()] ) )
283  (~lhs)[element->index()] = element->value() * x[j];
284  else
285  (~lhs)[element->index()] += element->value() * x[j];
286  }
287  }
288  }
290  //**********************************************************************************************
291 
292  //**Optimized assignment to dense vectors*******************************************************
306  template< typename VT1 > // Type of the target dense vector
307  friend inline typename DisableIf< IsResizable<typename VT1::ElementType> >::Type
309  {
311 
312  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
313 
315 
316  reset( ~lhs );
317 
318  if( rhs.mat_.columns() == 0UL ) return;
319 
320  LT A( rhs.mat_ ); // Evaluation of the left-hand side sparse matrix operand
321  RT x( rhs.vec_ ); // Evaluation of the right-hand side dense vector operand
322 
323  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
324  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
325  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
326  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
327 
328  for( size_t j=0UL; j<A.columns(); ++j )
329  {
330  ConstIterator element( A.begin(j) );
331  const ConstIterator end( A.end(j) );
332 
333  for( ; element!=end; ++element ) {
334  (~lhs)[element->index()] += element->value() * x[j];
335  }
336  }
337  }
339  //**********************************************************************************************
340 
341  //**Assignment to sparse vectors****************************************************************
354  template< typename VT1 > // Type of the target sparse vector
355  friend inline void assign( SparseVector<VT1,false>& lhs, const TSMatDVecMultExpr& rhs )
356  {
358 
362 
363  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
364 
365  const ResultType tmp( rhs );
366  assign( ~lhs, tmp );
367  }
369  //**********************************************************************************************
370 
371  //**Addition assignment to dense vectors********************************************************
387  template< typename VT1 > // Type of the target dense vector
388  friend inline void addAssign( DenseVector<VT1,false>& lhs, const TSMatDVecMultExpr& rhs )
389  {
391 
392  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
393 
395 
396  if( rhs.mat_.columns() == 0UL ) return;
397 
398  LT A( rhs.mat_ ); // Evaluation of the left-hand side sparse matrix operand
399  RT x( rhs.vec_ ); // Evaluation of the right-hand side dense vector operand
400 
401  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
402  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
403  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
404  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
405 
406  for( size_t j=0UL; j<A.columns(); ++j )
407  {
408  ConstIterator element( A.begin(j) );
409  const ConstIterator end( A.end(j) );
410 
411  for( ; element!=end; ++element ) {
412  (~lhs)[element->index()] += element->value() * x[j];
413  }
414  }
415  }
417  //**********************************************************************************************
418 
419  //**Addition assignment to sparse vectors*******************************************************
420  // No special implementation for the addition assignment to sparse vectors.
421  //**********************************************************************************************
422 
423  //**Subtraction assignment to dense vectors*****************************************************
439  template< typename VT1 > // Type of the target dense vector
440  friend inline void subAssign( DenseVector<VT1,false>& lhs, const TSMatDVecMultExpr& rhs )
441  {
443 
444  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
445 
447 
448  if( rhs.mat_.columns() == 0UL ) return;
449 
450  LT A( rhs.mat_ ); // Evaluation of the left-hand side sparse matrix operand
451  RT x( rhs.vec_ ); // Evaluation of the right-hand side dense vector operand
452 
453  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
454  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
455  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
456  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
457 
458  for( size_t j=0UL; j<A.columns(); ++j )
459  {
460  ConstIterator element( A.begin(j) );
461  const ConstIterator end( A.end(j) );
462 
463  for( ; element!=end; ++element ) {
464  (~lhs)[element->index()] -= element->value() * x[j];
465  }
466  }
467  }
469  //**********************************************************************************************
470 
471  //**Subtraction assignment to sparse vectors****************************************************
472  // No special implementation for the subtraction assignment to sparse vectors.
473  //**********************************************************************************************
474 
475  //**Multiplication assignment to dense vectors**************************************************
491  template< typename VT1 > // Type of the target dense vector
492  friend inline void multAssign( DenseVector<VT1,false>& lhs, const TSMatDVecMultExpr& rhs )
493  {
495 
499 
500  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
501 
502  const ResultType tmp( rhs );
503  multAssign( ~lhs, tmp );
504  }
506  //**********************************************************************************************
507 
508  //**Multiplication assignment to sparse vectors*************************************************
509  // No special implementation for the multiplication assignment to sparse vectors.
510  //**********************************************************************************************
511 
512  //**Compile time checks*************************************************************************
519  //**********************************************************************************************
520 };
521 //*************************************************************************************************
522 
523 
524 
525 
526 //=================================================================================================
527 //
528 // GLOBAL BINARY ARITHMETIC OPERATORS
529 //
530 //=================================================================================================
531 
532 //*************************************************************************************************
563 template< typename T1 // Type of the left-hand side sparse matrix
564  , typename T2 > // Type of the right-hand side dense vector
565 inline const typename DisableIf< IsMatMatMultExpr<T1>, TSMatDVecMultExpr<T1,T2> >::Type
567 {
569 
570  if( (~mat).columns() != (~vec).size() )
571  throw std::invalid_argument( "Matrix and vector sizes do not match" );
572 
573  return TSMatDVecMultExpr<T1,T2>( ~mat, ~vec );
574 }
575 //*************************************************************************************************
576 
577 
578 
579 
580 //=================================================================================================
581 //
582 // EXPRESSION TRAIT SPECIALIZATIONS
583 //
584 //=================================================================================================
585 
586 //*************************************************************************************************
588 template< typename MT, typename VT >
589 struct SubvectorExprTrait< TSMatDVecMultExpr<MT,VT> >
590 {
591  public:
592  //**********************************************************************************************
593  typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT>::Type, VT >::Type Type;
594  //**********************************************************************************************
595 };
597 //*************************************************************************************************
598 
599 } // namespace blaze
600 
601 #endif
RightOperand vec_
Right-hand side dense vector of the multiplication expression.
Definition: TSMatDVecMultExpr.h:237
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:89
VT::CompositeType VCT
Composite type of the right-hand side dense vector expression.
Definition: TSMatDVecMultExpr.h:99
void reset(DynamicMatrix< Type, SO > &m)
Resetting the given dense matrix.
Definition: DynamicMatrix.h:4512
size_t size() const
Returns the current size/dimension of the vector.
Definition: TSMatDVecMultExpr.h:185
Expression object for transpose sparse matrix-dense vector multiplications.The TSMatDVecMultExpr clas...
Definition: Forward.h:135
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:3703
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a column dense or sparse vector type...
Definition: TransposeFlag.h:159
bool isDefault(const DynamicMatrix< Type, SO > &m)
Returns whether the given dense matrix is in default state.
Definition: DynamicMatrix.h:4555
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:196
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2375
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:248
Header file for the DenseVector base class.
LeftOperand mat_
Left-hand side sparse matrix of the multiplication expression.
Definition: TSMatDVecMultExpr.h:236
Header file for the Computation base class.
Header file for the RequiresEvaluation type trait.
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:104
Constraint on the data type.
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
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:250
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.
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatDVecMultExpr.h:119
#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
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2379
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TSMatDVecMultExpr.h:217
MultTrait< MRT, VRT >::Type ResultType
Result type for expression template evaluations.
Definition: TSMatDVecMultExpr.h:115
Header file for the IsMatMatMultExpr type trait class.
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:179
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
Constraint on the data type.
#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.
void multAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the multiplication assignment of a matrix to a matrix.
Definition: Matrix.h:269
SelectType< evaluateVector, const VRT, VCT >::Type RT
Type for the assignment of the right-hand side dense vector operand.
Definition: TSMatDVecMultExpr.h:131
Header file for the SelectType class template.
Header file for all forward declarations for expression class templates.
TSMatDVecMultExpr(const MT &mat, const VT &vec)
Constructor for the TSMatDVecMultExpr class.
Definition: TSMatDVecMultExpr.h:148
Header file for the EnableIf class template.
SelectType< IsExpression< VT >::value, const VT, const VT & >::Type RightOperand
Composite type of the right-hand side dense vector expression.
Definition: TSMatDVecMultExpr.h:125
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TSMatDVecMultExpr.h:229
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:141
void addAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the addition assignment of a matrix to a matrix.
Definition: Matrix.h:209
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.
void subAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the subtraction assignment of a matrix to matrix.
Definition: Matrix.h:239
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSMatDVecMultExpr.h:118
Header file for the isDefault shim.
VT::ResultType VRT
Result type of the right-hand side dense vector expression.
Definition: TSMatDVecMultExpr.h:97
TSMatDVecMultExpr< MT, VT > This
Type of this TSMatDVecMultExpr instance.
Definition: TSMatDVecMultExpr.h:114
MT::ResultType MRT
Result type of the left-hand side sparse matrix expression.
Definition: TSMatDVecMultExpr.h:96
Header file for the RemoveReference type trait.
Substitution Failure Is Not An Error (SFINAE) class.The DisableIf class template is an auxiliary tool...
Definition: DisableIf.h:184
ResultType::ElementType ElementType
Resulting element type.
Definition: TSMatDVecMultExpr.h:117
LeftOperand leftOperand() const
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatDVecMultExpr.h:195
#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
MT::CompositeType MCT
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDVecMultExpr.h:98
Header file for the IsComputation type trait class.
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TSMatDVecMultExpr.h:162
MCT LT
Type for the assignment of the left-hand side sparse matrix operand.
Definition: TSMatDVecMultExpr.h:128
#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:2370
size_t columns(const Matrix< MT, SO > &m)
Returns the current number of columns of the matrix.
Definition: Matrix.h:154
RightOperand rightOperand() const
Returns the right-hand side dense vector operand.
Definition: TSMatDVecMultExpr.h:205
Header file for basic type definitions.
Header file for the SubvectorExprTrait class template.
Header file for the MatVecMultExpr base class.
Header file for the IsResizable type trait.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TSMatDVecMultExpr.h:116
#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.
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDVecMultExpr.h:122