DMatSVecMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATSVECMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATSVECMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
52 #include <blaze/math/Exception.h>
57 #include <blaze/math/shims/Reset.h>
77 #include <blaze/util/Assert.h>
79 #include <blaze/util/DisableIf.h>
80 #include <blaze/util/EnableIf.h>
83 #include <blaze/util/mpl/If.h>
84 #include <blaze/util/mpl/Or.h>
85 #include <blaze/util/Types.h>
87 
88 
89 namespace blaze {
90 
91 //=================================================================================================
92 //
93 // CLASS DMATSVECMULTEXPR
94 //
95 //=================================================================================================
96 
97 //*************************************************************************************************
104 template< typename MT // Type of the left-hand side dense matrix
105  , typename VT > // Type of the right-hand side sparse vector
106 class DMatSVecMultExpr : public DenseVector< DMatSVecMultExpr<MT,VT>, false >
107  , private MatVecMultExpr
108  , private Computation
109 {
110  private:
111  //**Type definitions****************************************************************************
116  //**********************************************************************************************
117 
118  //**********************************************************************************************
120  enum : bool { evaluateMatrix = RequiresEvaluation<MT>::value };
121  //**********************************************************************************************
122 
123  //**********************************************************************************************
125  enum : bool { evaluateVector = IsComputation<VT>::value || RequiresEvaluation<VT>::value };
126  //**********************************************************************************************
127 
128  //**********************************************************************************************
130 
136  enum : bool { useAssign = evaluateMatrix || evaluateVector };
137  //**********************************************************************************************
138 
139  //**********************************************************************************************
141  template< typename VT2 >
143  struct UseAssign {
144  enum : bool { value = useAssign };
145  };
147  //**********************************************************************************************
148 
149  //**********************************************************************************************
151 
155  template< typename T1 >
156  struct UseSMPAssign {
157  enum : bool { value = useAssign };
158  };
160  //**********************************************************************************************
161 
162  public:
163  //**Type definitions****************************************************************************
168  typedef const ElementType ReturnType;
169 
172 
174  typedef If_< IsExpression<MT>, const MT, const MT& > LeftOperand;
175 
177  typedef If_< IsExpression<VT>, const VT, const VT& > RightOperand;
178 
181 
184  //**********************************************************************************************
185 
186  //**Compilation flags***************************************************************************
188  enum : bool { simdEnabled = false };
189 
191  enum : bool { smpAssignable = !evaluateMatrix && MT::smpAssignable &&
192  !evaluateVector && VT::smpAssignable };
193  //**********************************************************************************************
194 
195  //**Constructor*********************************************************************************
201  explicit inline DMatSVecMultExpr( const MT& mat, const VT& vec ) noexcept
202  : mat_( mat ) // Left-hand side dense matrix of the multiplication expression
203  , vec_( vec ) // Right-hand side sparse vector of the multiplication expression
204  {
205  BLAZE_INTERNAL_ASSERT( mat_.columns() == vec_.size(), "Invalid matrix and vector sizes" );
206  }
207  //**********************************************************************************************
208 
209  //**Subscript operator**************************************************************************
215  inline ReturnType operator[]( size_t index ) const {
216  BLAZE_INTERNAL_ASSERT( index < mat_.rows(), "Invalid vector access index" );
217 
219  {
220  return mat_(index,index) * vec_[index];
221  }
222  else if( IsLower<MT>::value )
223  {
224  const size_t n( IsStrictlyLower<MT>::value ? index : index+1UL );
225  return subvector( row( mat_, index ), 0UL, n ) * subvector( vec_, 0UL, n );
226  }
227  else if( IsUpper<MT>::value )
228  {
229  const size_t begin( IsStrictlyUpper<MT>::value ? index+1UL : index );
230  const size_t n ( mat_.columns() - begin );
231  return subvector( row( mat_, index ), begin, n ) * subvector( vec_, begin, n );
232  }
233  else
234  {
235  return row( mat_, index ) * vec_;
236  }
237  }
238  //**********************************************************************************************
239 
240  //**At function*********************************************************************************
247  inline ReturnType at( size_t index ) const {
248  if( index >= mat_.rows() ) {
249  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
250  }
251  return (*this)[index];
252  }
253  //**********************************************************************************************
254 
255  //**Size function*******************************************************************************
260  inline size_t size() const noexcept {
261  return mat_.rows();
262  }
263  //**********************************************************************************************
264 
265  //**Left operand access*************************************************************************
270  inline LeftOperand leftOperand() const noexcept {
271  return mat_;
272  }
273  //**********************************************************************************************
274 
275  //**Right operand access************************************************************************
280  inline RightOperand rightOperand() const noexcept {
281  return vec_;
282  }
283  //**********************************************************************************************
284 
285  //**********************************************************************************************
291  template< typename T >
292  inline bool canAlias( const T* alias ) const noexcept {
293  return mat_.isAliased( alias ) || vec_.isAliased( alias );
294  }
295  //**********************************************************************************************
296 
297  //**********************************************************************************************
303  template< typename T >
304  inline bool isAliased( const T* alias ) const noexcept {
305  return mat_.isAliased( alias ) || vec_.isAliased( alias );
306  }
307  //**********************************************************************************************
308 
309  //**********************************************************************************************
314  inline bool isAligned() const noexcept {
315  return mat_.isAligned();
316  }
317  //**********************************************************************************************
318 
319  //**********************************************************************************************
324  inline bool canSMPAssign() const noexcept {
325  return ( size() > SMP_DMATSVECMULT_THRESHOLD );
326  }
327  //**********************************************************************************************
328 
329  private:
330  //**Member variables****************************************************************************
331  LeftOperand mat_;
332  RightOperand vec_;
333  //**********************************************************************************************
334 
335  //**Assignment to dense vectors*****************************************************************
351  template< typename VT1 > // Type of the target dense vector
352  friend inline EnableIf_< UseAssign<VT1> >
353  assign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
354  {
356 
357  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
358 
359  // Evaluation of the right-hand side sparse vector operand
360  RT x( serial( rhs.vec_ ) );
361  if( x.nonZeros() == 0UL ) {
362  reset( ~lhs );
363  return;
364  }
365 
366  // Evaluation of the left-hand side dense matrix operand
367  LT A( serial( rhs.mat_ ) );
368 
369  // Checking the evaluated operands
370  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
371  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
372  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
373  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
374 
375  // Performing the dense matrix-sparse vector multiplication
376  assign( ~lhs, A * x );
377  }
379  //**********************************************************************************************
380 
381  //**Assignment to sparse vectors****************************************************************
397  template< typename VT1 > // Type of the target sparse vector
398  friend inline EnableIf_< UseAssign<VT1> >
399  assign( SparseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
400  {
402 
406 
407  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
408 
409  const ResultType tmp( serial( rhs ) );
410  assign( ~lhs, tmp );
411  }
413  //**********************************************************************************************
414 
415  //**Addition assignment to dense vectors********************************************************
431  template< typename VT1 > // Type of the target dense vector
432  friend inline EnableIf_< UseAssign<VT1> >
433  addAssign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
434  {
436 
437  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
438 
439  // Evaluation of the right-hand side sparse vector operand
440  RT x( serial( rhs.vec_ ) );
441  if( x.nonZeros() == 0UL ) return;
442 
443  // Evaluation of the left-hand side dense matrix operand
444  LT A( serial( rhs.mat_ ) );
445 
446  // Checking the evaluated operands
447  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
448  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
449  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
450  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
451 
452  // Performing the dense matrix-sparse vector multiplication
453  addAssign( ~lhs, A * x );
454  }
456  //**********************************************************************************************
457 
458  //**Addition assignment to sparse vectors*******************************************************
459  // No special implementation for the addition assignment to sparse vectors.
460  //**********************************************************************************************
461 
462  //**Subtraction assignment to dense vectors*****************************************************
478  template< typename VT1 > // Type of the target dense vector
479  friend inline EnableIf_< UseAssign<VT1> >
480  subAssign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
481  {
483 
484  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
485 
486  // Evaluation of the right-hand side sparse vector operand
487  RT x( serial( rhs.vec_ ) );
488  if( x.nonZeros() == 0UL ) return;
489 
490  // Evaluation of the left-hand side dense matrix operand
491  LT A( serial( rhs.mat_ ) );
492 
493  // Checking the evaluated operands
494  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
495  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
496  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
497  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
498 
499  // Performing the dense matrix-sparse vector multiplication
500  subAssign( ~lhs, A * x );
501  }
503  //**********************************************************************************************
504 
505  //**Subtraction assignment to sparse vectors****************************************************
506  // No special implementation for the subtraction assignment to sparse vectors.
507  //**********************************************************************************************
508 
509  //**Multiplication assignment to dense vectors**************************************************
525  template< typename VT1 > // Type of the target dense vector
526  friend inline EnableIf_< UseAssign<VT1> >
527  multAssign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
528  {
530 
533  BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE( CompositeType_<ResultType> );
534 
535  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
536 
537  const ResultType tmp( serial( rhs ) );
538  multAssign( ~lhs, tmp );
539  }
541  //**********************************************************************************************
542 
543  //**Multiplication assignment to sparse vectors*************************************************
544  // No special implementation for the multiplication assignment to sparse vectors.
545  //**********************************************************************************************
546 
547  //**Division assignment to dense vectors********************************************************
563  template< typename VT1 > // Type of the target dense vector
564  friend inline EnableIf_< UseAssign<VT1> >
565  divAssign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
566  {
568 
571  BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE( CompositeType_<ResultType> );
572 
573  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
574 
575  const ResultType tmp( serial( rhs ) );
576  divAssign( ~lhs, tmp );
577  }
579  //**********************************************************************************************
580 
581  //**Division assignment to sparse vectors*******************************************************
582  // No special implementation for the division assignment to sparse vectors.
583  //**********************************************************************************************
584 
585  //**SMP assignment to dense vectors*************************************************************
600  template< typename VT1 > // Type of the target dense vector
601  friend inline EnableIf_< UseSMPAssign<VT1> >
602  smpAssign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
603  {
605 
606  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
607 
608  // Evaluation of the right-hand side sparse vector operand
609  RT x( rhs.vec_ );
610  if( x.nonZeros() == 0UL ) {
611  reset( ~lhs );
612  return;
613  }
614 
615  // Evaluation of the left-hand side dense matrix operand
616  LT A( rhs.mat_ );
617 
618  // Checking the evaluated operands
619  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
620  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
621  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
622  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
623 
624  // Performing the dense matrix-sparse vector multiplication
625  smpAssign( ~lhs, A * x );
626  }
628  //**********************************************************************************************
629 
630  //**SMP assignment to sparse vectors************************************************************
645  template< typename VT1 > // Type of the target sparse vector
646  friend inline EnableIf_< UseSMPAssign<VT1> >
647  smpAssign( SparseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
648  {
650 
653  BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE( CompositeType_<ResultType> );
654 
655  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
656 
657  const ResultType tmp( rhs );
658  smpAssign( ~lhs, tmp );
659  }
661  //**********************************************************************************************
662 
663  //**SMP addition assignment to dense vectors****************************************************
678  template< typename VT1 > // Type of the target dense vector
679  friend inline EnableIf_< UseSMPAssign<VT1> >
680  smpAddAssign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
681  {
683 
684  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
685 
686  // Evaluation of the right-hand side sparse vector operand
687  RT x( rhs.vec_ );
688  if( x.nonZeros() == 0UL ) return;
689 
690  // Evaluation of the left-hand side dense matrix operand
691  LT A( rhs.mat_ );
692 
693  // Checking the evaluated operands
694  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
695  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
696  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
697  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
698 
699  // Performing the dense matrix-sparse vector multiplication
700  smpAddAssign( ~lhs, A * x );
701  }
703  //**********************************************************************************************
704 
705  //**SMP addition assignment to sparse vectors***************************************************
706  // No special implementation for the SMP addition assignment to sparse vectors.
707  //**********************************************************************************************
708 
709  //**SMP subtraction assignment to dense vectors*************************************************
724  template< typename VT1 > // Type of the target dense vector
725  friend inline EnableIf_< UseSMPAssign<VT1> >
726  smpSubAssign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
727  {
729 
730  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
731 
732  // Evaluation of the right-hand side sparse vector operand
733  RT x( rhs.vec_ );
734  if( x.nonZeros() == 0UL ) return;
735 
736  // Evaluation of the left-hand side dense matrix operand
737  LT A( rhs.mat_ );
738 
739  // Checking the evaluated operands
740  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
741  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
742  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
743  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
744 
745  // Performing the dense matrix-sparse vector multiplication
746  smpSubAssign( ~lhs, A * x );
747  }
749  //**********************************************************************************************
750 
751  //**SMP subtraction assignment to sparse vectors************************************************
752  // No special implementation for the SMP subtraction assignment to sparse vectors.
753  //**********************************************************************************************
754 
755  //**SMP multiplication assignment to dense vectors**********************************************
770  template< typename VT1 > // Type of the target dense vector
771  friend inline EnableIf_< UseSMPAssign<VT1> >
772  smpMultAssign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
773  {
775 
778  BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE( CompositeType_<ResultType> );
779 
780  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
781 
782  const ResultType tmp( rhs );
783  smpMultAssign( ~lhs, tmp );
784  }
786  //**********************************************************************************************
787 
788  //**SMP multiplication assignment to sparse vectors*********************************************
789  // No special implementation for the SMP multiplication assignment to sparse vectors.
790  //**********************************************************************************************
791 
792  //**SMP division assignment to dense vectors****************************************************
807  template< typename VT1 > // Type of the target dense vector
808  friend inline EnableIf_< UseSMPAssign<VT1> >
809  smpDivAssign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
810  {
812 
815  BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE( CompositeType_<ResultType> );
816 
817  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
818 
819  const ResultType tmp( rhs );
820  smpDivAssign( ~lhs, tmp );
821  }
823  //**********************************************************************************************
824 
825  //**SMP division assignment to sparse vectors***************************************************
826  // No special implementation for the SMP division assignment to sparse vectors.
827  //**********************************************************************************************
828 
829  //**Compile time checks*************************************************************************
838  //**********************************************************************************************
839 };
840 //*************************************************************************************************
841 
842 
843 
844 
845 //=================================================================================================
846 //
847 // GLOBAL BINARY ARITHMETIC OPERATORS
848 //
849 //=================================================================================================
850 
851 //*************************************************************************************************
883 template< typename T1 // Type of the left-hand side dense matrix
884  , typename T2 > // Type of the right-hand side sparse vector
885 inline const DisableIf_< Or< IsSymmetric<T1>, IsMatMatMultExpr<T1> >
886  , DMatSVecMultExpr<T1,T2> >
888 {
890 
891  if( (~mat).columns() != (~vec).size() ) {
892  BLAZE_THROW_INVALID_ARGUMENT( "Matrix and vector sizes do not match" );
893  }
894 
895  return DMatSVecMultExpr<T1,T2>( ~mat, ~vec );
896 }
897 //*************************************************************************************************
898 
899 
900 
901 
902 //=================================================================================================
903 //
904 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
905 //
906 //=================================================================================================
907 
908 //*************************************************************************************************
923 template< typename T1 // Type of the left-hand side dense matrix
924  , typename T2 > // Type of the right-hand side sparse vector
925 inline const EnableIf_< IsSymmetric<T1>, MultExprTrait_<T1,T2> >
926  operator*( const DenseMatrix<T1,false>& mat, const SparseVector<T2,false>& vec )
927 {
929 
931 
932  if( (~mat).columns() != (~vec).size() ) {
933  BLAZE_THROW_INVALID_ARGUMENT( "Matrix and vector sizes do not match" );
934  }
935 
936  return trans( ~mat ) * (~vec);
937 }
939 //*************************************************************************************************
940 
941 
942 //*************************************************************************************************
956 template< typename T1 // Type of the left-hand side dense matrix
957  , bool SO // Storage order of the left-hand side dense matrix
958  , typename T2 > // Type of the right-hand side sparse vector
959 inline const EnableIf_< IsMatMatMultExpr<T1>, MultExprTrait_<T1,T2> >
960  operator*( const DenseMatrix<T1,SO>& mat, const SparseVector<T2,false>& vec )
961 {
963 
965 
966  return (~mat).leftOperand() * ( (~mat).rightOperand() * vec );
967 }
969 //*************************************************************************************************
970 
971 
972 
973 
974 //=================================================================================================
975 //
976 // SIZE SPECIALIZATIONS
977 //
978 //=================================================================================================
979 
980 //*************************************************************************************************
982 template< typename MT, typename VT >
983 struct Size< DMatSVecMultExpr<MT,VT> > : public Rows<MT>
984 {};
986 //*************************************************************************************************
987 
988 
989 
990 
991 //=================================================================================================
992 //
993 // ISALIGNED SPECIALIZATIONS
994 //
995 //=================================================================================================
996 
997 //*************************************************************************************************
999 template< typename MT, typename VT >
1000 struct IsAligned< DMatSVecMultExpr<MT,VT> >
1001  : public BoolConstant< IsAligned<MT>::value >
1002 {};
1004 //*************************************************************************************************
1005 
1006 
1007 
1008 
1009 //=================================================================================================
1010 //
1011 // EXPRESSION TRAIT SPECIALIZATIONS
1012 //
1013 //=================================================================================================
1014 
1015 //*************************************************************************************************
1017 template< typename MT, typename VT, bool AF >
1018 struct SubvectorExprTrait< DMatSVecMultExpr<MT,VT>, AF >
1019 {
1020  public:
1021  //**********************************************************************************************
1022  using Type = MultExprTrait_< SubmatrixExprTrait_<const MT,AF>
1023  , SubvectorExprTrait_<const VT,AF> >;
1024  //**********************************************************************************************
1025 };
1027 //*************************************************************************************************
1028 
1029 } // namespace blaze
1030 
1031 #endif
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for auxiliary alias declarations.
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: DMatSVecMultExpr.h:260
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:72
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense matrix operand.
Definition: DMatSVecMultExpr.h:270
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:7800
If_< IsExpression< VT >, const VT, const VT & > RightOperand
Composite type of the right-hand side dense vector expression.
Definition: DMatSVecMultExpr.h:177
Header file for basic type definitions.
DMatSVecMultExpr< MT, VT > This
Type of this DMatSVecMultExpr instance.
Definition: DMatSVecMultExpr.h:164
#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:61
EnableIf_< IsDenseMatrix< MT1 > > 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
Header file for the serial shim.
Header file for the IsDiagonal type trait.
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:258
ResultType_< VT > VRT
Result type of the right-hand side sparse vector expression.
Definition: DMatSVecMultExpr.h:113
#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:61
BLAZE_ALWAYS_INLINE MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:188
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
IfTrue_< evaluateVector, const VRT, VCT > RT
Type for the assignment of the right-hand side dense matrix operand.
Definition: DMatSVecMultExpr.h:183
MultTrait_< MRT, VRT > ResultType
Result type for expression template evaluations.
Definition: DMatSVecMultExpr.h:165
EnableIf_< IsDenseVector< VT1 > > 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:193
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatSVecMultExpr.h:304
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:88
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: DMatSVecMultExpr.h:166
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:723
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:245
Header file for the Computation base class.
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatSVecMultExpr.h:314
Constraints on the storage order of matrix types.
Header file for the RequiresEvaluation type trait.
LeftOperand mat_
Left-hand side dense matrix of the multiplication expression.
Definition: DMatSVecMultExpr.h:331
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
EnableIf_< IsDenseMatrix< MT1 > > 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
ElementType_< ResultType > ElementType
Resulting element type.
Definition: DMatSVecMultExpr.h:167
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: DMatSVecMultExpr.h:247
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatSVecMultExpr.h:324
Constraint on the data type.
typename IfTrue< Condition, T1, T2 >::Type IfTrue_
Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a co...
Definition: If.h:109
Constraint on the transpose flag of vector types.
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:72
SubvectorExprTrait_< VT, unaligned > subvector(Vector< VT, TF > &vector, size_t index, size_t size)
Creating a view on a specific subvector of the given vector.
Definition: Subvector.h:152
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Expression object for dense matrix-sparse vector multiplications.The DMatSVecMultExpr class represent...
Definition: DMatSVecMultExpr.h:106
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
Header file for the If class template.
CompositeType_< MT > MCT
Composite type of the left-hand side dense matrix expression.
Definition: DMatSVecMultExpr.h:114
EnableIf_< IsDenseMatrix< MT1 > > 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
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 exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse vector operand.
Definition: DMatSVecMultExpr.h:280
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
RightOperand vec_
Right-hand side sparse vector of the multiplication expression.
Definition: DMatSVecMultExpr.h:332
CompositeType_< VT > VCT
Composite type of the right-hand side sparse vector expression.
Definition: DMatSVecMultExpr.h:115
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:61
Header file for the IsAligned type trait.
Compile time check for diagonal matrices.This type trait tests whether or not the given template para...
Definition: IsDiagonal.h:90
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:330
If_< IsExpression< MT >, const MT, const MT & > LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatSVecMultExpr.h:174
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatSVecMultExpr.h:292
Base class for all matrix/vector multiplication expression templates.The MatVecMultExpr class serves ...
Definition: MatVecMultExpr.h:66
#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:89
#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:60
#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:110
Constraint on the data type.
Header file for the exception macros of the math module.
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
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.
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, RowExprTrait_< MT > > row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:126
IfTrue_< useAssign, const ResultType, const DMatSVecMultExpr & > CompositeType
Data type for composite expression templates.
Definition: DMatSVecMultExpr.h:171
#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:79
Header file for the SubmatrixExprTrait class template.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: RowMajorMatrix.h:61
Header file for run time assertion macros.
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:160
EnableIf_< IsDenseVector< VT1 > > smpDivAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
Default implementation of the SMP division assignment of a vector to a dense vector.
Definition: DenseVector.h:222
Header file for the reset shim.
Constraint on the data type.
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents ...
Definition: IntegralConstant.h:100
Header file for the RemoveReference type trait.
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
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:61
const ElementType ReturnType
Return type for expression template evaluations.
Definition: DMatSVecMultExpr.h:168
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:950
Header file for the IsComputation type trait class.
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:110
#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
Header file for the IntegralConstant class template.
Header file for the SubvectorExprTrait class template.
Constraint on the data type.
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
Header file for the IsUpper type trait.
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: DMatSVecMultExpr.h:215
Header file for the MatVecMultExpr base class.
Constraint on the data type.
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
ResultType_< MT > MRT
Result type of the left-hand side dense matrix expression.
Definition: DMatSVecMultExpr.h:112
IfTrue_< evaluateMatrix, const MRT, MCT > LT
Type for the assignment of the left-hand side dense matrix operand.
Definition: DMatSVecMultExpr.h:180
DMatSVecMultExpr(const MT &mat, const VT &vec) noexcept
Constructor for the DMatSVecMultExpr class.
Definition: DMatSVecMultExpr.h:201
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.