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 
55 #include <blaze/math/shims/Reset.h>
71 #include <blaze/util/Assert.h>
73 #include <blaze/util/DisableIf.h>
74 #include <blaze/util/EnableIf.h>
75 #include <blaze/util/Exception.h>
77 #include <blaze/util/mpl/Or.h>
78 #include <blaze/util/SelectType.h>
79 #include <blaze/util/Types.h>
81 
82 
83 namespace blaze {
84 
85 //=================================================================================================
86 //
87 // CLASS TSMATDVECMULTEXPR
88 //
89 //=================================================================================================
90 
91 //*************************************************************************************************
98 template< typename MT // Type of the left-hand side sparse matrix
99  , typename VT > // Type of the right-hand side dense vector
100 class TSMatDVecMultExpr : public DenseVector< TSMatDVecMultExpr<MT,VT>, false >
101  , private MatVecMultExpr
102  , private Computation
103 {
104  private:
105  //**Type definitions****************************************************************************
106  typedef typename MT::ResultType MRT;
107  typedef typename VT::ResultType VRT;
108  typedef typename MT::CompositeType MCT;
109  typedef typename VT::CompositeType VCT;
110  //**********************************************************************************************
111 
112  //**********************************************************************************************
114  enum { evaluateMatrix = RequiresEvaluation<MT>::value };
115  //**********************************************************************************************
116 
117  //**********************************************************************************************
119  enum { evaluateVector = IsComputation<VT>::value || RequiresEvaluation<VT>::value };
120  //**********************************************************************************************
121 
122  //**********************************************************************************************
124 
128  template< typename T1 >
129  struct UseSMPAssign {
130  enum { value = ( evaluateMatrix || evaluateVector ) };
131  };
133  //**********************************************************************************************
134 
135  public:
136  //**Type definitions****************************************************************************
141  typedef const ElementType ReturnType;
142  typedef const ResultType CompositeType;
143 
145  typedef typename SelectType< IsExpression<MT>::value, const MT, const MT& >::Type LeftOperand;
146 
148  typedef typename SelectType< IsExpression<VT>::value, const VT, const VT& >::Type RightOperand;
149 
152 
155  //**********************************************************************************************
156 
157  //**Compilation flags***************************************************************************
159  enum { vectorizable = 0 };
160 
162  enum { smpAssignable = !evaluateMatrix && MT::smpAssignable &&
163  !evaluateVector && VT::smpAssignable };
164  //**********************************************************************************************
165 
166  //**Constructor*********************************************************************************
172  explicit inline TSMatDVecMultExpr( const MT& mat, const VT& vec )
173  : mat_( mat ) // Left-hand side sparse matrix of the multiplication expression
174  , vec_( vec ) // Right-hand side dense vector of the multiplication expression
175  {
176  BLAZE_INTERNAL_ASSERT( mat_.columns() == vec_.size(), "Invalid matrix and vector sizes" );
177  }
178  //**********************************************************************************************
179 
180  //**Subscript operator**************************************************************************
186  inline ReturnType operator[]( size_t index ) const {
187  BLAZE_INTERNAL_ASSERT( index < mat_.rows(), "Invalid vector access index" );
188 
189  ElementType res;
190 
191  if( vec_.size() > 0UL ) {
192  res = mat_(index,0UL) * vec_[0UL];
193  for( size_t j=1UL; j<vec_.size(); ++j )
194  res += mat_(index,j) * vec_[j];
195  }
196  else {
197  reset( res );
198  }
199 
200  return res;
201  }
202  //**********************************************************************************************
203 
204  //**At function*********************************************************************************
211  inline ReturnType at( size_t index ) const {
212  if( index >= mat_.rows() ) {
213  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
214  }
215  return (*this)[index];
216  }
217  //**********************************************************************************************
218 
219  //**Size function*******************************************************************************
224  inline size_t size() const {
225  return mat_.rows();
226  }
227  //**********************************************************************************************
228 
229  //**Left operand access*************************************************************************
234  inline LeftOperand leftOperand() const {
235  return mat_;
236  }
237  //**********************************************************************************************
238 
239  //**Right operand access************************************************************************
244  inline RightOperand rightOperand() const {
245  return vec_;
246  }
247  //**********************************************************************************************
248 
249  //**********************************************************************************************
255  template< typename T >
256  inline bool canAlias( const T* alias ) const {
257  return ( mat_.isAliased( alias ) || vec_.isAliased( alias ) );
258  }
259  //**********************************************************************************************
260 
261  //**********************************************************************************************
267  template< typename T >
268  inline bool isAliased( const T* alias ) const {
269  return ( mat_.isAliased( alias ) || vec_.isAliased( alias ) );
270  }
271  //**********************************************************************************************
272 
273  //**********************************************************************************************
278  inline bool isAligned() const {
279  return vec_.isAligned();
280  }
281  //**********************************************************************************************
282 
283  //**********************************************************************************************
288  inline bool canSMPAssign() const {
289  return ( size() > SMP_TSMATDVECMULT_THRESHOLD );
290  }
291  //**********************************************************************************************
292 
293  private:
294  //**Member variables****************************************************************************
295  LeftOperand mat_;
296  RightOperand vec_;
297  //**********************************************************************************************
298 
299  //**Assignment to dense vectors*****************************************************************
312  template< typename VT2 > // Type of the target dense vector
313  friend inline void assign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
314  {
316 
317  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
318 
319  reset( ~lhs );
320 
321  if( rhs.mat_.columns() == 0UL ) return;
322 
323  LT A( serial( rhs.mat_ ) ); // Evaluation of the left-hand side sparse matrix operand
324  RT x( serial( rhs.vec_ ) ); // Evaluation of the right-hand side dense vector operand
325 
326  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
327  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
328  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
329  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
330 
331  TSMatDVecMultExpr::selectAssignKernel( ~lhs, A, x );
332  }
334  //**********************************************************************************************
335 
336  //**Optimized assignment to dense vectors*******************************************************
350  template< typename VT1 // Type of the left-hand side target vector
351  , typename MT1 // Type of the left-hand side matrix operand
352  , typename VT2 > // Type of the right-hand side vector operand
353  static inline void selectAssignKernel( VT1& y, const MT1& A, const VT2& x )
354  {
356 
357  for( size_t j=0UL; j<A.columns(); ++j )
358  {
359  ConstIterator element( A.begin(j) );
360  const ConstIterator end( A.end(j) );
361 
362  for( ; element!=end; ++element ) {
364  isDefault( y[element->index()] ) )
365  y[element->index()] = element->value() * x[j];
366  else
367  y[element->index()] += element->value() * x[j];
368  }
369  }
370  }
372  //**********************************************************************************************
373 
374  //**Assignment to sparse vectors****************************************************************
387  template< typename VT2 > // Type of the target sparse vector
388  friend inline void assign( SparseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
389  {
391 
395 
396  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
397 
398  const ResultType tmp( serial( rhs ) );
399  assign( ~lhs, tmp );
400  }
402  //**********************************************************************************************
403 
404  //**Addition assignment to dense vectors********************************************************
417  template< typename VT2 > // Type of the target dense vector
418  friend inline void addAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
419  {
421 
422  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
423 
424  if( rhs.mat_.columns() == 0UL ) return;
425 
426  LT A( serial( rhs.mat_ ) ); // Evaluation of the left-hand side sparse matrix operand
427  RT x( serial( rhs.vec_ ) ); // Evaluation of the right-hand side dense vector operand
428 
429  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
430  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
431  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
432  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
433 
434  TSMatDVecMultExpr::selectAddAssignKernel( ~lhs, A, x );
435  }
437  //**********************************************************************************************
438 
439  //**Optimized addition assignment to dense vectors**********************************************
453  template< typename VT1 // Type of the left-hand side target vector
454  , typename MT1 // Type of the left-hand side matrix operand
455  , typename VT2 > // Type of the right-hand side vector operand
456  static inline void selectAddAssignKernel( VT1& y, const MT1& A, const VT2& x )
457  {
459 
460  for( size_t j=0UL; j<A.columns(); ++j )
461  {
462  ConstIterator element( A.begin(j) );
463  const ConstIterator end( A.end(j) );
464 
465  for( ; element!=end; ++element ) {
466  y[element->index()] += element->value() * x[j];
467  }
468  }
469  }
471  //**********************************************************************************************
472 
473  //**Addition assignment to sparse vectors*******************************************************
474  // No special implementation for the addition assignment to sparse vectors.
475  //**********************************************************************************************
476 
477  //**Subtraction assignment to dense vectors*****************************************************
490  template< typename VT2 > // Type of the target dense vector
491  friend inline void subAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
492  {
494 
495  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
496 
498 
499  if( rhs.mat_.columns() == 0UL ) return;
500 
501  LT A( serial( rhs.mat_ ) ); // Evaluation of the left-hand side sparse matrix operand
502  RT x( serial( rhs.vec_ ) ); // Evaluation of the right-hand side dense vector operand
503 
504  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
505  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
506  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
507  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
508 
509  TSMatDVecMultExpr::selectSubAssignKernel( ~lhs, A, x );
510  }
512  //**********************************************************************************************
513 
514  //**Optimized subtraction assignment to dense vectors*******************************************
528  template< typename VT1 // Type of the left-hand side target vector
529  , typename MT1 // Type of the left-hand side matrix operand
530  , typename VT2 > // Type of the right-hand side vector operand
531  static inline void selectSubAssignKernel( VT1& y, const MT1& A, const VT2& x )
532  {
534 
535  for( size_t j=0UL; j<A.columns(); ++j )
536  {
537  ConstIterator element( A.begin(j) );
538  const ConstIterator end( A.end(j) );
539 
540  for( ; element!=end; ++element ) {
541  y[element->index()] -= element->value() * x[j];
542  }
543  }
544  }
546  //**********************************************************************************************
547 
548  //**Subtraction assignment to sparse vectors****************************************************
549  // No special implementation for the subtraction assignment to sparse vectors.
550  //**********************************************************************************************
551 
552  //**Multiplication assignment to dense vectors**************************************************
565  template< typename VT2 > // Type of the target dense vector
566  friend inline void multAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
567  {
569 
573 
574  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
575 
576  const ResultType tmp( serial( rhs ) );
577  multAssign( ~lhs, tmp );
578  }
580  //**********************************************************************************************
581 
582  //**Multiplication assignment to sparse vectors*************************************************
583  // No special implementation for the multiplication assignment to sparse vectors.
584  //**********************************************************************************************
585 
586  //**SMP assignment to dense vectors*************************************************************
601  template< typename VT2 > // Type of the target dense vector
602  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
603  smpAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
604  {
606 
607  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
608 
609  reset( ~lhs );
610 
611  if( rhs.mat_.columns() == 0UL ) return;
612 
613  LT A( rhs.mat_ ); // Evaluation of the left-hand side sparse matrix operand
614  RT x( rhs.vec_ ); // Evaluation of the right-hand side dense vector operand
615 
616  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
617  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
618  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
619  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
620 
621  smpAssign( ~lhs, A * x );
622  }
624  //**********************************************************************************************
625 
626  //**SMP assignment to sparse vectors************************************************************
641  template< typename VT2 > // Type of the target sparse vector
642  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
643  smpAssign( SparseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
644  {
646 
650 
651  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
652 
653  const ResultType tmp( rhs );
654  smpAssign( ~lhs, tmp );
655  }
657  //**********************************************************************************************
658 
659  //**SMP addition assignment to dense vectors****************************************************
674  template< typename VT2 > // Type of the target dense vector
675  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
676  smpAddAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
677  {
679 
680  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
681 
682  if( rhs.mat_.columns() == 0UL ) return;
683 
684  LT A( rhs.mat_ ); // Evaluation of the left-hand side sparse matrix operand
685  RT x( rhs.vec_ ); // Evaluation of the right-hand side dense vector operand
686 
687  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
688  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
689  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
690  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
691 
692  smpAddAssign( ~lhs, A * x );
693  }
695  //**********************************************************************************************
696 
697  //**SMP addition assignment to sparse vectors***************************************************
698  // No special implementation for the SMP addition assignment to sparse vectors.
699  //**********************************************************************************************
700 
701  //**SMP subtraction assignment to dense vectors*************************************************
716  template< typename VT2 > // Type of the target dense vector
717  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
718  smpSubAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
719  {
721 
722  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
723 
725 
726  if( rhs.mat_.columns() == 0UL ) return;
727 
728  LT A( rhs.mat_ ); // Evaluation of the left-hand side sparse matrix operand
729  RT x( rhs.vec_ ); // Evaluation of the right-hand side dense vector operand
730 
731  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
732  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
733  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
734  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
735 
736  smpSubAssign( ~lhs, A * x );
737  }
739  //**********************************************************************************************
740 
741  //**SMP subtraction assignment to sparse vectors************************************************
742  // No special implementation for the SMP subtraction assignment to sparse vectors.
743  //**********************************************************************************************
744 
745  //**SMP multiplication assignment to dense vectors**********************************************
760  template< typename VT2 > // Type of the target dense vector
761  friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
762  smpMultAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
763  {
765 
769 
770  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
771 
772  const ResultType tmp( rhs );
773  smpMultAssign( ~lhs, tmp );
774  }
776  //**********************************************************************************************
777 
778  //**SMP multiplication assignment to sparse vectors*********************************************
779  // No special implementation for the SMP multiplication assignment to sparse vectors.
780  //**********************************************************************************************
781 
782  //**Compile time checks*************************************************************************
791  //**********************************************************************************************
792 };
793 //*************************************************************************************************
794 
795 
796 
797 
798 //=================================================================================================
799 //
800 // GLOBAL BINARY ARITHMETIC OPERATORS
801 //
802 //=================================================================================================
803 
804 //*************************************************************************************************
835 template< typename T1 // Type of the left-hand side sparse matrix
836  , typename T2 > // Type of the right-hand side dense vector
837 inline const typename DisableIf< Or< IsSymmetric<T1>, IsMatMatMultExpr<T1> >
838  , TSMatDVecMultExpr<T1,T2> >::Type
840 {
842 
843  if( (~mat).columns() != (~vec).size() ) {
844  BLAZE_THROW_INVALID_ARGUMENT( "Matrix and vector sizes do not match" );
845  }
846 
847  return TSMatDVecMultExpr<T1,T2>( ~mat, ~vec );
848 }
849 //*************************************************************************************************
850 
851 
852 
853 
854 //=================================================================================================
855 //
856 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
857 //
858 //=================================================================================================
859 
860 //*************************************************************************************************
875 template< typename T1 // Type of the left-hand side sparse matrix
876  , typename T2 > // Type of the right-hand side dense vector
877 inline const typename EnableIf< IsSymmetric<T1>, typename MultExprTrait<T1,T2>::Type >::Type
878  operator*( const SparseMatrix<T1,true>& mat, const DenseVector<T2,false>& vec )
879 {
881 
883 
884  if( (~mat).columns() != (~vec).size() ) {
885  BLAZE_THROW_INVALID_ARGUMENT( "Matrix and vector sizes do not match" );
886  }
887 
888  return trans( ~mat ) * (~vec);
889 }
891 //*************************************************************************************************
892 
893 
894 
895 
896 //=================================================================================================
897 //
898 // SIZE SPECIALIZATIONS
899 //
900 //=================================================================================================
901 
902 //*************************************************************************************************
904 template< typename MT, typename VT >
905 struct Size< TSMatDVecMultExpr<MT,VT> > : public Rows<MT>
906 {};
908 //*************************************************************************************************
909 
910 
911 
912 
913 //=================================================================================================
914 //
915 // ISALIGNED SPECIALIZATIONS
916 //
917 //=================================================================================================
918 
919 //*************************************************************************************************
921 template< typename MT, typename VT >
922 struct IsAligned< TSMatDVecMultExpr<MT,VT> > : public IsTrue< IsAligned<VT>::value >
923 {};
925 //*************************************************************************************************
926 
927 
928 
929 
930 //=================================================================================================
931 //
932 // EXPRESSION TRAIT SPECIALIZATIONS
933 //
934 //=================================================================================================
935 
936 //*************************************************************************************************
938 template< typename MT, typename VT, bool AF >
939 struct SubvectorExprTrait< TSMatDVecMultExpr<MT,VT>, AF >
940 {
941  public:
942  //**********************************************************************************************
943  typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type
944  , typename SubvectorExprTrait<const VT,AF>::Type >::Type Type;
945  //**********************************************************************************************
946 };
948 //*************************************************************************************************
949 
950 } // namespace blaze
951 
952 #endif
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exceptionThis macro encapsulates the default way of...
Definition: Exception.h:187
LeftOperand mat_
Left-hand side sparse matrix of the multiplication expression.
Definition: TSMatDVecMultExpr.h:295
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:89
Expression object for transpose sparse matrix-dense vector multiplications.The TSMatDVecMultExpr clas...
Definition: Forward.h:152
Header file for the Rows type trait.
const DMatDMatMultExpr< T1, T2 > operator*(const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:7820
Header file for basic type definitions.
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:250
#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: ColumnVector.h:79
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:207
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatDVecMultExpr.h:142
TSMatDVecMultExpr< MT, VT > This
Type of this TSMatDVecMultExpr instance.
Definition: TSMatDVecMultExpr.h:137
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:507
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2588
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TSMatDVecMultExpr.h:139
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:259
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TSMatDVecMultExpr.h:256
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:721
Header file for the Computation base class.
MT::ResultType MRT
Result type of the left-hand side sparse matrix expression.
Definition: TSMatDVecMultExpr.h:106
Header file for the RequiresEvaluation type trait.
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TSMatDVecMultExpr.h:186
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:117
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:547
SelectType< evaluateVector, const VRT, VCT >::Type RT
Type for the assignment of the right-hand side dense vector operand.
Definition: TSMatDVecMultExpr.h:154
Constraint on the data type.
Constraint on the transpose flag of vector types.
Constraint on the data type.
RightOperand vec_
Right-hand side dense vector of the multiplication expression.
Definition: TSMatDVecMultExpr.h:296
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
SelectType< IsExpression< VT >::value, const VT, const VT & >::Type RightOperand
Composite type of the right-hand side dense vector expression.
Definition: TSMatDVecMultExpr.h:148
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:261
TSMatDVecMultExpr(const MT &mat, const VT &vec)
Constructor for the TSMatDVecMultExpr class.
Definition: TSMatDVecMultExpr.h:172
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.
size_t size() const
Returns the current size/dimension of the vector.
Definition: TSMatDVecMultExpr.h:224
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: ColumnMajorMatrix.h:79
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2592
Header file for the Or class template.
Header file for the IsMatMatMultExpr type trait class.
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exceptionThis macro encapsulates the default way of Bla...
Definition: Exception.h:331
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
Header file for the IsAligned type trait.
#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
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATVECMULTEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/vector ...
Definition: MatVecMultExpr.h:166
LeftOperand leftOperand() const
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatDVecMultExpr.h:234
Constraint on the data type.
Header file for the SelectType class template.
Header file for all forward declarations for expression class templates.
VT::ResultType VRT
Result type of the right-hand side dense vector expression.
Definition: TSMatDVecMultExpr.h:107
Header file for the EnableIf class template.
Header file for the serial shim.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TSMatDVecMultExpr.h:268
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
VT::CompositeType VCT
Composite type of the right-hand side dense vector expression.
Definition: TSMatDVecMultExpr.h:109
EnableIf< IsDenseMatrix< MT1 > >::Type smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
#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
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
Base template for the MultTrait class.
Definition: MultTrait.h:138
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: TSMatDVecMultExpr.h:278
Header file for the reset shim.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: TSMatDVecMultExpr.h:288
Header file for the isDefault shim.
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDVecMultExpr.h:145
MultTrait< MRT, VRT >::Type ResultType
Result type for expression template evaluations.
Definition: TSMatDVecMultExpr.h:138
Constraints on the storage order of matrix types.
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: TSMatDVecMultExpr.h:211
ResultType::ElementType ElementType
Resulting element type.
Definition: TSMatDVecMultExpr.h:140
Header file for the RemoveReference type trait.
MT::CompositeType MCT
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDVecMultExpr.h:108
SelectType< evaluateMatrix, const MRT, MCT >::Type LT
Type for the assignment of the left-hand side sparse matrix operand.
Definition: TSMatDVecMultExpr.h:151
#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
RightOperand rightOperand() const
Returns the right-hand side dense vector operand.
Definition: TSMatDVecMultExpr.h:244
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:944
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSMatDVecMultExpr.h:141
Header file for the IsComputation type trait class.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2583
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:324
Header file for the SubvectorExprTrait class template.
Constraint on the data type.
Header file for exception macros.
Header file for the MatVecMultExpr base class.
Constraint on the data type.
Header file for the IsResizable type trait.
EnableIf< IsDenseVector< VT1 > >::Type smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
Default implementation of the SMP multiplication assignment of a vector to a dense vector...
Definition: DenseVector.h:189
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.