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>
53 #include <blaze/math/Exception.h>
59 #include <blaze/math/shims/Reset.h>
73 #include <blaze/math/views/Check.h>
75 #include <blaze/util/Assert.h>
76 #include <blaze/util/DisableIf.h>
77 #include <blaze/util/EnableIf.h>
79 #include <blaze/util/mpl/If.h>
80 #include <blaze/util/Types.h>
82 
83 
84 namespace blaze {
85 
86 //=================================================================================================
87 //
88 // CLASS DMATSVECMULTEXPR
89 //
90 //=================================================================================================
91 
92 //*************************************************************************************************
99 template< typename MT // Type of the left-hand side dense matrix
100  , typename VT > // Type of the right-hand side sparse vector
102  : public MatVecMultExpr< DenseVector< DMatSVecMultExpr<MT,VT>, false > >
103  , private Computation
104 {
105  private:
106  //**Type definitions****************************************************************************
111  //**********************************************************************************************
112 
113  //**********************************************************************************************
115  enum : bool { evaluateMatrix = RequiresEvaluation<MT>::value };
116  //**********************************************************************************************
117 
118  //**********************************************************************************************
120  enum : bool { evaluateVector = IsComputation<VT>::value || RequiresEvaluation<VT>::value };
121  //**********************************************************************************************
122 
123  //**********************************************************************************************
125 
131  enum : bool { useAssign = evaluateMatrix || evaluateVector };
132  //**********************************************************************************************
133 
134  //**********************************************************************************************
136  template< typename VT2 >
138  struct UseAssign {
139  enum : bool { value = useAssign };
140  };
142  //**********************************************************************************************
143 
144  //**********************************************************************************************
146 
150  template< typename T1 >
151  struct UseSMPAssign {
152  enum : bool { value = useAssign };
153  };
155  //**********************************************************************************************
156 
157  public:
158  //**Type definitions****************************************************************************
163  using ReturnType = const ElementType;
164 
167 
169  using LeftOperand = If_< IsExpression<MT>, const MT, const MT& >;
170 
172  using RightOperand = If_< IsExpression<VT>, const VT, const VT& >;
173 
176 
179  //**********************************************************************************************
180 
181  //**Compilation flags***************************************************************************
183  enum : bool { simdEnabled = false };
184 
186  enum : bool { smpAssignable = !evaluateMatrix && MT::smpAssignable &&
187  !evaluateVector && VT::smpAssignable };
188  //**********************************************************************************************
189 
190  //**Constructor*********************************************************************************
196  explicit inline DMatSVecMultExpr( const MT& mat, const VT& vec ) noexcept
197  : mat_( mat ) // Left-hand side dense matrix of the multiplication expression
198  , vec_( vec ) // Right-hand side sparse vector of the multiplication expression
199  {
200  BLAZE_INTERNAL_ASSERT( mat_.columns() == vec_.size(), "Invalid matrix and vector sizes" );
201  }
202  //**********************************************************************************************
203 
204  //**Subscript operator**************************************************************************
210  inline ReturnType operator[]( size_t index ) const {
211  BLAZE_INTERNAL_ASSERT( index < mat_.rows(), "Invalid vector access index" );
212 
214  {
215  return mat_(index,index) * vec_[index];
216  }
217  else if( IsLower<MT>::value )
218  {
219  const size_t n( IsStrictlyLower<MT>::value ? index : index+1UL );
220  return subvector( row( mat_, index, unchecked ), 0UL, n, unchecked ) *
221  subvector( vec_, 0UL, n, unchecked );
222  }
223  else if( IsUpper<MT>::value )
224  {
225  const size_t begin( IsStrictlyUpper<MT>::value ? index+1UL : index );
226  const size_t n ( mat_.columns() - begin );
227  return subvector( row( mat_, index, unchecked ), begin, n, unchecked ) *
228  subvector( vec_, begin, n, unchecked );
229  }
230  else
231  {
232  return row( mat_, index, unchecked ) * vec_;
233  }
234  }
235  //**********************************************************************************************
236 
237  //**At function*********************************************************************************
244  inline ReturnType at( size_t index ) const {
245  if( index >= mat_.rows() ) {
246  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
247  }
248  return (*this)[index];
249  }
250  //**********************************************************************************************
251 
252  //**Size function*******************************************************************************
257  inline size_t size() const noexcept {
258  return mat_.rows();
259  }
260  //**********************************************************************************************
261 
262  //**Left operand access*************************************************************************
267  inline LeftOperand leftOperand() const noexcept {
268  return mat_;
269  }
270  //**********************************************************************************************
271 
272  //**Right operand access************************************************************************
277  inline RightOperand rightOperand() const noexcept {
278  return vec_;
279  }
280  //**********************************************************************************************
281 
282  //**********************************************************************************************
288  template< typename T >
289  inline bool canAlias( const T* alias ) const noexcept {
290  return mat_.isAliased( alias ) || vec_.isAliased( alias );
291  }
292  //**********************************************************************************************
293 
294  //**********************************************************************************************
300  template< typename T >
301  inline bool isAliased( const T* alias ) const noexcept {
302  return mat_.isAliased( alias ) || vec_.isAliased( alias );
303  }
304  //**********************************************************************************************
305 
306  //**********************************************************************************************
311  inline bool isAligned() const noexcept {
312  return mat_.isAligned();
313  }
314  //**********************************************************************************************
315 
316  //**********************************************************************************************
321  inline bool canSMPAssign() const noexcept {
322  return ( size() > SMP_DMATSVECMULT_THRESHOLD );
323  }
324  //**********************************************************************************************
325 
326  private:
327  //**Member variables****************************************************************************
330  //**********************************************************************************************
331 
332  //**Assignment to dense vectors*****************************************************************
348  template< typename VT1 > // Type of the target dense vector
349  friend inline EnableIf_< UseAssign<VT1> >
350  assign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
351  {
353 
354  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
355 
356  // Evaluation of the right-hand side sparse vector operand
357  RT x( serial( rhs.vec_ ) );
358  if( x.nonZeros() == 0UL ) {
359  reset( ~lhs );
360  return;
361  }
362 
363  // Evaluation of the left-hand side dense matrix operand
364  LT A( serial( rhs.mat_ ) );
365 
366  // Checking the evaluated operands
367  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
368  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
369  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
370  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
371 
372  // Performing the dense matrix-sparse vector multiplication
373  assign( ~lhs, A * x );
374  }
376  //**********************************************************************************************
377 
378  //**Assignment to sparse vectors****************************************************************
394  template< typename VT1 > // Type of the target sparse vector
395  friend inline EnableIf_< UseAssign<VT1> >
396  assign( SparseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
397  {
399 
403 
404  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
405 
406  const ResultType tmp( serial( rhs ) );
407  assign( ~lhs, tmp );
408  }
410  //**********************************************************************************************
411 
412  //**Addition assignment to dense vectors********************************************************
428  template< typename VT1 > // Type of the target dense vector
429  friend inline EnableIf_< UseAssign<VT1> >
430  addAssign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
431  {
433 
434  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
435 
436  // Evaluation of the right-hand side sparse vector operand
437  RT x( serial( rhs.vec_ ) );
438  if( x.nonZeros() == 0UL ) return;
439 
440  // Evaluation of the left-hand side dense matrix operand
441  LT A( serial( rhs.mat_ ) );
442 
443  // Checking the evaluated operands
444  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
445  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
446  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
447  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
448 
449  // Performing the dense matrix-sparse vector multiplication
450  addAssign( ~lhs, A * x );
451  }
453  //**********************************************************************************************
454 
455  //**Addition assignment to sparse vectors*******************************************************
456  // No special implementation for the addition assignment to sparse vectors.
457  //**********************************************************************************************
458 
459  //**Subtraction assignment to dense vectors*****************************************************
475  template< typename VT1 > // Type of the target dense vector
476  friend inline EnableIf_< UseAssign<VT1> >
477  subAssign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
478  {
480 
481  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
482 
483  // Evaluation of the right-hand side sparse vector operand
484  RT x( serial( rhs.vec_ ) );
485  if( x.nonZeros() == 0UL ) return;
486 
487  // Evaluation of the left-hand side dense matrix operand
488  LT A( serial( rhs.mat_ ) );
489 
490  // Checking the evaluated operands
491  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
492  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
493  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
494  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
495 
496  // Performing the dense matrix-sparse vector multiplication
497  subAssign( ~lhs, A * x );
498  }
500  //**********************************************************************************************
501 
502  //**Subtraction assignment to sparse vectors****************************************************
503  // No special implementation for the subtraction assignment to sparse vectors.
504  //**********************************************************************************************
505 
506  //**Multiplication assignment to dense vectors**************************************************
522  template< typename VT1 > // Type of the target dense vector
523  friend inline EnableIf_< UseAssign<VT1> >
524  multAssign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
525  {
527 
531 
532  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
533 
534  const ResultType tmp( serial( rhs ) );
535  multAssign( ~lhs, tmp );
536  }
538  //**********************************************************************************************
539 
540  //**Multiplication assignment to sparse vectors*************************************************
541  // No special implementation for the multiplication assignment to sparse vectors.
542  //**********************************************************************************************
543 
544  //**Division assignment to dense vectors********************************************************
560  template< typename VT1 > // Type of the target dense vector
561  friend inline EnableIf_< UseAssign<VT1> >
562  divAssign( DenseVector<VT1,false>& lhs, const DMatSVecMultExpr& rhs )
563  {
565 
569 
570  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
571 
572  const ResultType tmp( serial( rhs ) );
573  divAssign( ~lhs, tmp );
574  }
576  //**********************************************************************************************
577 
578  //**Division assignment to sparse vectors*******************************************************
579  // No special implementation for the division assignment to sparse vectors.
580  //**********************************************************************************************
581 
582  //**SMP assignment to dense vectors*************************************************************
597  template< typename VT1 > // Type of the target dense vector
598  friend inline EnableIf_< UseSMPAssign<VT1> >
600  {
602 
603  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
604 
605  // Evaluation of the right-hand side sparse vector operand
606  RT x( rhs.vec_ );
607  if( x.nonZeros() == 0UL ) {
608  reset( ~lhs );
609  return;
610  }
611 
612  // Evaluation of the left-hand side dense matrix operand
613  LT A( rhs.mat_ );
614 
615  // Checking the evaluated operands
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  // Performing the dense matrix-sparse vector multiplication
622  smpAssign( ~lhs, A * x );
623  }
625  //**********************************************************************************************
626 
627  //**SMP assignment to sparse vectors************************************************************
642  template< typename VT1 > // Type of the target sparse vector
643  friend inline EnableIf_< UseSMPAssign<VT1> >
645  {
647 
651 
652  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
653 
654  const ResultType tmp( rhs );
655  smpAssign( ~lhs, tmp );
656  }
658  //**********************************************************************************************
659 
660  //**SMP addition assignment to dense vectors****************************************************
675  template< typename VT1 > // Type of the target dense vector
676  friend inline EnableIf_< UseSMPAssign<VT1> >
678  {
680 
681  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
682 
683  // Evaluation of the right-hand side sparse vector operand
684  RT x( rhs.vec_ );
685  if( x.nonZeros() == 0UL ) return;
686 
687  // Evaluation of the left-hand side dense matrix operand
688  LT A( rhs.mat_ );
689 
690  // Checking the evaluated operands
691  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
692  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
693  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
694  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
695 
696  // Performing the dense matrix-sparse vector multiplication
697  smpAddAssign( ~lhs, A * x );
698  }
700  //**********************************************************************************************
701 
702  //**SMP addition assignment to sparse vectors***************************************************
703  // No special implementation for the SMP addition assignment to sparse vectors.
704  //**********************************************************************************************
705 
706  //**SMP subtraction assignment to dense vectors*************************************************
721  template< typename VT1 > // Type of the target dense vector
722  friend inline EnableIf_< UseSMPAssign<VT1> >
724  {
726 
727  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
728 
729  // Evaluation of the right-hand side sparse vector operand
730  RT x( rhs.vec_ );
731  if( x.nonZeros() == 0UL ) return;
732 
733  // Evaluation of the left-hand side dense matrix operand
734  LT A( rhs.mat_ );
735 
736  // Checking the evaluated operands
737  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
738  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
739  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
740  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
741 
742  // Performing the dense matrix-sparse vector multiplication
743  smpSubAssign( ~lhs, A * x );
744  }
746  //**********************************************************************************************
747 
748  //**SMP subtraction assignment to sparse vectors************************************************
749  // No special implementation for the SMP subtraction assignment to sparse vectors.
750  //**********************************************************************************************
751 
752  //**SMP multiplication assignment to dense vectors**********************************************
767  template< typename VT1 > // Type of the target dense vector
768  friend inline EnableIf_< UseSMPAssign<VT1> >
770  {
772 
776 
777  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
778 
779  const ResultType tmp( rhs );
780  smpMultAssign( ~lhs, tmp );
781  }
783  //**********************************************************************************************
784 
785  //**SMP multiplication assignment to sparse vectors*********************************************
786  // No special implementation for the SMP multiplication assignment to sparse vectors.
787  //**********************************************************************************************
788 
789  //**SMP division assignment to dense vectors****************************************************
804  template< typename VT1 > // Type of the target dense vector
805  friend inline EnableIf_< UseSMPAssign<VT1> >
807  {
809 
813 
814  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
815 
816  const ResultType tmp( rhs );
817  smpDivAssign( ~lhs, tmp );
818  }
820  //**********************************************************************************************
821 
822  //**SMP division assignment to sparse vectors***************************************************
823  // No special implementation for the SMP division assignment to sparse vectors.
824  //**********************************************************************************************
825 
826  //**Compile time checks*************************************************************************
835  //**********************************************************************************************
836 };
837 //*************************************************************************************************
838 
839 
840 
841 
842 //=================================================================================================
843 //
844 // GLOBAL BINARY ARITHMETIC OPERATORS
845 //
846 //=================================================================================================
847 
848 //*************************************************************************************************
862 template< typename MT // Type of the left-hand side dense matrix
863  , typename VT // Type of the right-hand side sparse vector
864  , typename = DisableIf_< IsSymmetric<MT> > >
865 inline const DMatSVecMultExpr<MT,VT>
866  dmatsvecmult( const DenseMatrix<MT,false>& mat, const SparseVector<VT,false>& vec )
867 {
869 
870  BLAZE_INTERNAL_ASSERT( (~mat).columns() == (~vec).size(), "Invalid matrix and vector sizes" );
871 
872  return DMatSVecMultExpr<MT,VT>( ~mat, ~vec );
873 }
875 //*************************************************************************************************
876 
877 
878 //*************************************************************************************************
892 template< typename MT // Type of the left-hand side dense matrix
893  , typename VT // Type of the right-hand side sparse vector
894  , typename = EnableIf_< IsSymmetric<MT> > >
895 inline decltype(auto)
896  dmatsvecmult( const DenseMatrix<MT,false>& mat, const SparseVector<VT,false>& vec )
897 {
899 
900  BLAZE_INTERNAL_ASSERT( (~mat).columns() == (~vec).size(), "Invalid matrix and vector sizes" );
901 
902  return trans( ~mat ) * (~vec);
903 }
905 //*************************************************************************************************
906 
907 
908 //*************************************************************************************************
940 template< typename MT // Type of the left-hand side dense matrix
941  , typename VT > // Type of the right-hand side sparse vector
942 inline decltype(auto)
943  operator*( const DenseMatrix<MT,false>& mat, const SparseVector<VT,false>& vec )
944 {
946 
948 
949  if( (~mat).columns() != (~vec).size() ) {
950  BLAZE_THROW_INVALID_ARGUMENT( "Matrix and vector sizes do not match" );
951  }
952 
953  return dmatsvecmult( ~mat, ~vec );
954 }
955 //*************************************************************************************************
956 
957 
958 
959 
960 //=================================================================================================
961 //
962 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
963 //
964 //=================================================================================================
965 
966 //*************************************************************************************************
980 template< typename MT // Matrix base type of the left-hand side expression
981  , typename VT > // Type of the right-hand side sparse vector
982 inline decltype(auto)
983  operator*( const MatMatMultExpr<MT>& mat, const SparseVector<VT,false>& vec )
984 {
986 
987  return (~mat).leftOperand() * ( (~mat).rightOperand() * vec );
988 }
990 //*************************************************************************************************
991 
992 
993 
994 
995 //=================================================================================================
996 //
997 // SIZE SPECIALIZATIONS
998 //
999 //=================================================================================================
1000 
1001 //*************************************************************************************************
1003 template< typename MT, typename VT >
1004 struct Size< DMatSVecMultExpr<MT,VT>, 0UL >
1005  : public Size<MT,0UL>
1006 {};
1008 //*************************************************************************************************
1009 
1010 
1011 
1012 
1013 //=================================================================================================
1014 //
1015 // ISALIGNED SPECIALIZATIONS
1016 //
1017 //=================================================================================================
1018 
1019 //*************************************************************************************************
1021 template< typename MT, typename VT >
1022 struct IsAligned< DMatSVecMultExpr<MT,VT> >
1023  : public IsAligned<MT>
1024 {};
1026 //*************************************************************************************************
1027 
1028 } // namespace blaze
1029 
1030 #endif
IfTrue_< useAssign, const ResultType, const DMatSVecMultExpr &> CompositeType
Data type for composite expression templates.
Definition: DMatSVecMultExpr.h:166
decltype(auto) subvector(Vector< VT, TF > &, RSAs...)
Creating a view on a specific subvector of the given vector.
Definition: Subvector.h:329
#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.
Header file for the blaze::checked and blaze::unchecked instances.
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:71
IfTrue_< evaluateMatrix, const MRT, MCT > LT
Type for the assignment of the left-hand side dense matrix operand.
Definition: DMatSVecMultExpr.h:175
Header file for basic type definitions.
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: DMatSVecMultExpr.h:244
#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:164
Header file for the serial shim.
Header file for the IsDiagonal type trait.
#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:364
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:588
constexpr Unchecked unchecked
Global Unchecked instance.The blaze::unchecked instance is an optional token for the creation of view...
Definition: Check.h:138
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
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:224
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:87
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: DMatSVecMultExpr.h:210
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatSVecMultExpr.h:311
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:291
Header file for the Computation base class.
Header file for the MatMatMultExpr base class.
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:87
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:328
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:343
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:133
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:80
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.
Compile time check for the alignment of data types.This type trait tests whether the given data type ...
Definition: IsAligned.h:87
Constraint on the data type.
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:71
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:101
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:58
Header file for the If class template.
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:102
#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
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:329
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:76
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:89
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:506
ResultType_< MT > MRT
Result type of the left-hand side dense matrix expression.
Definition: DMatSVecMultExpr.h:107
Base class for all matrix/vector multiplication expression templates.The MatVecMultExpr class serves ...
Definition: MatVecMultExpr.h:67
#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:87
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: DMatSVecMultExpr.h:161
#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:108
Constraint on the data type.
Header file for the exception macros of the math module.
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse vector operand.
Definition: DMatSVecMultExpr.h:277
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
decltype(auto) operator*(const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:8893
Constraint on the data type.
Header file for all forward declarations for expression class templates.
Constraint on the data type.
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: DMatSVecMultExpr.h:257
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
MultTrait_< MRT, VRT > ResultType
Result type for expression template evaluations.
Definition: DMatSVecMultExpr.h:160
Base class for all matrix/matrix multiplication expression templates.The MatMatMultExpr class serves ...
Definition: MatMatMultExpr.h:67
#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
#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
If_< IsExpression< MT >, const MT, const MT &> LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatSVecMultExpr.h:169
Header file for run time assertion macros.
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense matrix operand.
Definition: DMatSVecMultExpr.h:267
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatSVecMultExpr.h:289
ElementType_< ResultType > ElementType
Resulting element type.
Definition: DMatSVecMultExpr.h:162
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:154
decltype(auto) row(Matrix< MT, SO > &, RRAs...)
Creating a view on a specific row of the given matrix.
Definition: Row.h:131
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.
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
Constraint on the data type.
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:816
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.In case the given data type T requires an intermediate evaluation within ...
Definition: RequiresEvaluation.h:81
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:224
CompositeType_< VT > VCT
Composite type of the right-hand side sparse vector expression.
Definition: DMatSVecMultExpr.h:110
If_< IsExpression< VT >, const VT, const VT &> RightOperand
Composite type of the right-hand side dense vector expression.
Definition: DMatSVecMultExpr.h:172
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
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:789
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:66
Compile time evaluation of the size of vectors and matrices.The Size type trait evaluates the size of...
Definition: Size.h:80
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:130
ResultType_< VT > VRT
Result type of the right-hand side sparse vector expression.
Definition: DMatSVecMultExpr.h:108
CompositeType_< MT > MCT
Composite type of the left-hand side dense matrix expression.
Definition: DMatSVecMultExpr.h:109
Constraint on the data type.
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:423
Header file for the IsUpper type trait.
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.
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatSVecMultExpr.h:321
#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
const ElementType ReturnType
Return type for expression template evaluations.
Definition: DMatSVecMultExpr.h:163
DMatSVecMultExpr(const MT &mat, const VT &vec) noexcept
Constructor for the DMatSVecMultExpr class.
Definition: DMatSVecMultExpr.h:196
Header file for the IsExpression type trait class.
Header file for the function trace functionality.
IfTrue_< evaluateVector, const VRT, VCT > RT
Type for the assignment of the right-hand side dense matrix operand.
Definition: DMatSVecMultExpr.h:178
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatSVecMultExpr.h:301