TSMatDVecMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATDVECMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATDVECMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
54 #include <blaze/math/Exception.h>
60 #include <blaze/math/shims/Reset.h>
76 #include <blaze/math/views/Check.h>
78 #include <blaze/util/Assert.h>
79 #include <blaze/util/DisableIf.h>
80 #include <blaze/util/EnableIf.h>
82 #include <blaze/util/mpl/If.h>
83 #include <blaze/util/Types.h>
84 #include <blaze/util/Unused.h>
85 
86 
87 namespace blaze {
88 
89 //=================================================================================================
90 //
91 // CLASS TSMATDVECMULTEXPR
92 //
93 //=================================================================================================
94 
95 //*************************************************************************************************
102 template< typename MT // Type of the left-hand side sparse matrix
103  , typename VT > // Type of the right-hand side dense vector
104 class TSMatDVecMultExpr
105  : public MatVecMultExpr< DenseVector< TSMatDVecMultExpr<MT,VT>, false > >
106  , private Computation
107 {
108  private:
109  //**Type definitions****************************************************************************
114  //**********************************************************************************************
115 
116  //**********************************************************************************************
118  static constexpr bool evaluateMatrix = RequiresEvaluation_v<MT>;
119  //**********************************************************************************************
120 
121  //**********************************************************************************************
123  static constexpr bool evaluateVector = ( IsComputation_v<VT> || RequiresEvaluation_v<VT> );
124  //**********************************************************************************************
125 
126  //**********************************************************************************************
128 
132  template< typename T1 >
133  static constexpr bool UseSMPAssign_v = ( evaluateMatrix || evaluateVector );
135  //**********************************************************************************************
136 
137  public:
138  //**Type definitions****************************************************************************
144  using ReturnType = const ElementType;
145  using CompositeType = const ResultType;
146 
148  using LeftOperand = If_t< IsExpression_v<MT>, const MT, const MT& >;
149 
151  using RightOperand = If_t< IsExpression_v<VT>, const VT, const VT& >;
152 
155 
158  //**********************************************************************************************
159 
160  //**Compilation flags***************************************************************************
162  static constexpr bool simdEnabled = false;
163 
165  static constexpr bool smpAssignable =
167  //**********************************************************************************************
168 
169  //**Constructor*********************************************************************************
175  explicit inline TSMatDVecMultExpr( const MT& mat, const VT& vec ) noexcept
176  : mat_( mat ) // Left-hand side sparse matrix of the multiplication expression
177  , vec_( vec ) // Right-hand side dense vector of the multiplication expression
178  {
179  BLAZE_INTERNAL_ASSERT( mat_.columns() == vec_.size(), "Invalid matrix and vector sizes" );
180  }
181  //**********************************************************************************************
182 
183  //**Subscript operator**************************************************************************
189  inline ReturnType operator[]( size_t index ) const {
190  BLAZE_INTERNAL_ASSERT( index < mat_.rows(), "Invalid vector access index" );
191 
192  if( IsDiagonal_v<MT> )
193  {
194  return mat_(index,index) * vec_[index];
195  }
196  else if( IsLower_v<MT> )
197  {
198  const size_t n( IsStrictlyLower_v<MT> ? index : index+1UL );
199  return subvector( row( mat_, index, unchecked ), 0UL, n, unchecked ) *
200  subvector( vec_, 0UL, n, unchecked );
201  }
202  else if( IsUpper_v<MT> )
203  {
204  const size_t begin( IsStrictlyUpper_v<MT> ? index+1UL : index );
205  const size_t n ( mat_.columns() - begin );
206  return subvector( row( mat_, index, unchecked ), begin, n, unchecked ) *
207  subvector( vec_, begin, n, unchecked );
208  }
209  else
210  {
211  return row( mat_, index, unchecked ) * vec_;
212  }
213  }
214  //**********************************************************************************************
215 
216  //**At function*********************************************************************************
223  inline ReturnType at( size_t index ) const {
224  if( index >= mat_.rows() ) {
225  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
226  }
227  return (*this)[index];
228  }
229  //**********************************************************************************************
230 
231  //**Size function*******************************************************************************
236  inline size_t size() const noexcept {
237  return mat_.rows();
238  }
239  //**********************************************************************************************
240 
241  //**Left operand access*************************************************************************
246  inline LeftOperand leftOperand() const noexcept {
247  return mat_;
248  }
249  //**********************************************************************************************
250 
251  //**Right operand access************************************************************************
256  inline RightOperand rightOperand() const noexcept {
257  return vec_;
258  }
259  //**********************************************************************************************
260 
261  //**********************************************************************************************
267  template< typename T >
268  inline bool canAlias( const T* alias ) const noexcept {
269  return ( mat_.isAliased( alias ) || vec_.isAliased( alias ) );
270  }
271  //**********************************************************************************************
272 
273  //**********************************************************************************************
279  template< typename T >
280  inline bool isAliased( const T* alias ) const noexcept {
281  return ( mat_.isAliased( alias ) || vec_.isAliased( alias ) );
282  }
283  //**********************************************************************************************
284 
285  //**********************************************************************************************
290  inline bool isAligned() const noexcept {
291  return vec_.isAligned();
292  }
293  //**********************************************************************************************
294 
295  //**********************************************************************************************
300  inline bool canSMPAssign() const noexcept {
301  return ( size() > SMP_TSMATDVECMULT_THRESHOLD );
302  }
303  //**********************************************************************************************
304 
305  private:
306  //**Member variables****************************************************************************
309  //**********************************************************************************************
310 
311  //**Assignment to dense vectors*****************************************************************
324  template< typename VT2 > // Type of the target dense vector
325  friend inline void assign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
326  {
328 
329  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
330 
331  reset( ~lhs );
332 
333  if( rhs.mat_.columns() == 0UL ) return;
334 
335  LT A( serial( rhs.mat_ ) ); // Evaluation of the left-hand side sparse matrix operand
336  RT x( serial( rhs.vec_ ) ); // Evaluation of the right-hand side dense vector operand
337 
338  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
339  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
340  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
341  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
342 
343  TSMatDVecMultExpr::selectAssignKernel( ~lhs, A, x );
344  }
346  //**********************************************************************************************
347 
348  //**Optimized assignment to dense vectors*******************************************************
362  template< typename VT1 // Type of the left-hand side target vector
363  , typename MT1 // Type of the left-hand side matrix operand
364  , typename VT2 > // Type of the right-hand side vector operand
365  static inline void selectAssignKernel( VT1& y, const MT1& A, const VT2& x )
366  {
367  for( size_t j=0UL; j<A.columns(); ++j )
368  {
369  auto element( A.begin(j) );
370  const auto end( A.end(j) );
371 
372  for( ; element!=end; ++element ) {
374  isDefault( y[element->index()] ) )
375  y[element->index()] = element->value() * x[j];
376  else
377  y[element->index()] += element->value() * x[j];
378  }
379  }
380  }
382  //**********************************************************************************************
383 
384  //**Assignment to sparse vectors****************************************************************
397  template< typename VT2 > // Type of the target sparse vector
398  friend inline void assign( SparseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
399  {
401 
405 
406  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
407 
408  const ResultType tmp( serial( rhs ) );
409  assign( ~lhs, tmp );
410  }
412  //**********************************************************************************************
413 
414  //**Addition assignment to dense vectors********************************************************
427  template< typename VT2 > // Type of the target dense vector
428  friend inline void addAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
429  {
431 
432  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
433 
434  if( rhs.mat_.columns() == 0UL ) return;
435 
436  LT A( serial( rhs.mat_ ) ); // Evaluation of the left-hand side sparse matrix operand
437  RT x( serial( rhs.vec_ ) ); // Evaluation of the right-hand side dense vector operand
438 
439  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
440  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
441  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
442  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
443 
444  TSMatDVecMultExpr::selectAddAssignKernel( ~lhs, A, x );
445  }
447  //**********************************************************************************************
448 
449  //**Optimized addition assignment to dense vectors**********************************************
463  template< typename VT1 // Type of the left-hand side target vector
464  , typename MT1 // Type of the left-hand side matrix operand
465  , typename VT2 > // Type of the right-hand side vector operand
466  static inline void selectAddAssignKernel( VT1& y, const MT1& A, const VT2& x )
467  {
468  for( size_t j=0UL; j<A.columns(); ++j )
469  {
470  auto element( A.begin(j) );
471  const auto end( A.end(j) );
472 
473  for( ; element!=end; ++element ) {
474  y[element->index()] += element->value() * x[j];
475  }
476  }
477  }
479  //**********************************************************************************************
480 
481  //**Addition assignment to sparse vectors*******************************************************
482  // No special implementation for the addition assignment to sparse vectors.
483  //**********************************************************************************************
484 
485  //**Subtraction assignment to dense vectors*****************************************************
498  template< typename VT2 > // Type of the target dense vector
499  friend inline void subAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
500  {
502 
503  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
504 
505  if( rhs.mat_.columns() == 0UL ) return;
506 
507  LT A( serial( rhs.mat_ ) ); // Evaluation of the left-hand side sparse matrix operand
508  RT x( serial( rhs.vec_ ) ); // Evaluation of the right-hand side dense vector operand
509 
510  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
511  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
512  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
513  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
514 
515  TSMatDVecMultExpr::selectSubAssignKernel( ~lhs, A, x );
516  }
518  //**********************************************************************************************
519 
520  //**Optimized subtraction assignment to dense vectors*******************************************
534  template< typename VT1 // Type of the left-hand side target vector
535  , typename MT1 // Type of the left-hand side matrix operand
536  , typename VT2 > // Type of the right-hand side vector operand
537  static inline void selectSubAssignKernel( VT1& y, const MT1& A, const VT2& x )
538  {
539  for( size_t j=0UL; j<A.columns(); ++j )
540  {
541  auto element( A.begin(j) );
542  const auto end( A.end(j) );
543 
544  for( ; element!=end; ++element ) {
545  y[element->index()] -= element->value() * x[j];
546  }
547  }
548  }
550  //**********************************************************************************************
551 
552  //**Subtraction assignment to sparse vectors****************************************************
553  // No special implementation for the subtraction assignment to sparse vectors.
554  //**********************************************************************************************
555 
556  //**Multiplication assignment to dense vectors**************************************************
569  template< typename VT2 > // Type of the target dense vector
570  friend inline void multAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
571  {
573 
577 
578  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
579 
580  const ResultType tmp( serial( rhs ) );
581  multAssign( ~lhs, tmp );
582  }
584  //**********************************************************************************************
585 
586  //**Multiplication assignment to sparse vectors*************************************************
587  // No special implementation for the multiplication assignment to sparse vectors.
588  //**********************************************************************************************
589 
590  //**Division assignment to dense vectors********************************************************
603  template< typename VT2 > // Type of the target dense vector
604  friend inline void divAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
605  {
607 
611 
612  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
613 
614  const ResultType tmp( serial( rhs ) );
615  divAssign( ~lhs, tmp );
616  }
618  //**********************************************************************************************
619 
620  //**Division assignment to sparse vectors*******************************************************
621  // No special implementation for the division assignment to sparse vectors.
622  //**********************************************************************************************
623 
624  //**SMP assignment to dense vectors*************************************************************
639  template< typename VT2 > // Type of the target dense vector
640  friend inline auto smpAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
641  -> EnableIf_t< UseSMPAssign_v<VT2> >
642  {
644 
645  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
646 
647  reset( ~lhs );
648 
649  if( rhs.mat_.columns() == 0UL ) return;
650 
651  LT A( rhs.mat_ ); // Evaluation of the left-hand side sparse matrix operand
652  RT x( rhs.vec_ ); // Evaluation of the right-hand side dense vector operand
653 
654  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
655  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
656  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
657  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
658 
659  smpAssign( ~lhs, A * x );
660  }
662  //**********************************************************************************************
663 
664  //**SMP assignment to sparse vectors************************************************************
679  template< typename VT2 > // Type of the target sparse vector
680  friend inline auto smpAssign( SparseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
681  -> EnableIf_t< UseSMPAssign_v<VT2> >
682  {
684 
688 
689  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
690 
691  const ResultType tmp( rhs );
692  smpAssign( ~lhs, tmp );
693  }
695  //**********************************************************************************************
696 
697  //**SMP addition assignment to dense vectors****************************************************
712  template< typename VT2 > // Type of the target dense vector
713  friend inline auto smpAddAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
714  -> EnableIf_t< UseSMPAssign_v<VT2> >
715  {
717 
718  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
719 
720  if( rhs.mat_.columns() == 0UL ) return;
721 
722  LT A( rhs.mat_ ); // Evaluation of the left-hand side sparse matrix operand
723  RT x( rhs.vec_ ); // Evaluation of the right-hand side dense vector operand
724 
725  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
726  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
727  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
728  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
729 
730  smpAddAssign( ~lhs, A * x );
731  }
733  //**********************************************************************************************
734 
735  //**SMP addition assignment to sparse vectors***************************************************
736  // No special implementation for the SMP addition assignment to sparse vectors.
737  //**********************************************************************************************
738 
739  //**SMP subtraction assignment to dense vectors*************************************************
754  template< typename VT2 > // Type of the target dense vector
755  friend inline auto smpSubAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
756  -> EnableIf_t< UseSMPAssign_v<VT2> >
757  {
759 
760  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
761 
762  if( rhs.mat_.columns() == 0UL ) return;
763 
764  LT A( rhs.mat_ ); // Evaluation of the left-hand side sparse matrix operand
765  RT x( rhs.vec_ ); // Evaluation of the right-hand side dense vector operand
766 
767  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
768  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
769  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
770  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).size() , "Invalid vector size" );
771 
772  smpSubAssign( ~lhs, A * x );
773  }
775  //**********************************************************************************************
776 
777  //**SMP subtraction assignment to sparse vectors************************************************
778  // No special implementation for the SMP subtraction assignment to sparse vectors.
779  //**********************************************************************************************
780 
781  //**SMP multiplication assignment to dense vectors**********************************************
796  template< typename VT2 > // Type of the target dense vector
797  friend inline auto smpMultAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
798  -> EnableIf_t< UseSMPAssign_v<VT2> >
799  {
801 
805 
806  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
807 
808  const ResultType tmp( rhs );
809  smpMultAssign( ~lhs, tmp );
810  }
812  //**********************************************************************************************
813 
814  //**SMP multiplication assignment to sparse vectors*********************************************
815  // No special implementation for the SMP multiplication assignment to sparse vectors.
816  //**********************************************************************************************
817 
818  //**SMP division assignment to dense vectors****************************************************
833  template< typename VT2 > // Type of the target dense vector
834  friend inline auto smpDivAssign( DenseVector<VT2,false>& lhs, const TSMatDVecMultExpr& rhs )
835  -> EnableIf_t< UseSMPAssign_v<VT2> >
836  {
838 
842 
843  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
844 
845  const ResultType tmp( rhs );
846  smpDivAssign( ~lhs, tmp );
847  }
849  //**********************************************************************************************
850 
851  //**SMP division assignment to sparse vectors***************************************************
852  // No special implementation for the SMP division assignment to sparse vectors.
853  //**********************************************************************************************
854 
855  //**Compile time checks*************************************************************************
865  //**********************************************************************************************
866 };
867 //*************************************************************************************************
868 
869 
870 
871 
872 //=================================================================================================
873 //
874 // GLOBAL BINARY ARITHMETIC OPERATORS
875 //
876 //=================================================================================================
877 
878 //*************************************************************************************************
891 template< typename MT // Type of the left-hand side sparse matrix
892  , typename VT // Type of the right-hand side dense vector
893  , DisableIf_t< IsSymmetric_v<MT> ||
894  ( IsIdentity_v<MT> &&
895  IsSame_v< ElementType_t<MT>, ElementType_t<VT> > ) ||
896  IsZero_v<MT> >* = nullptr >
897 inline const TSMatDVecMultExpr<MT,VT>
898  tsmatdvecmult( const SparseMatrix<MT,true>& mat, const DenseVector<VT,false>& vec )
899 {
901 
902  BLAZE_INTERNAL_ASSERT( (~mat).columns() == (~vec).size(), "Invalid matrix and vector sizes" );
903 
904  return TSMatDVecMultExpr<MT,VT>( ~mat, ~vec );
905 }
907 //*************************************************************************************************
908 
909 
910 //*************************************************************************************************
924 template< typename MT // Type of the left-hand side sparse matrix
925  , typename VT // Type of the right-hand side dense vector
926  , EnableIf_t< IsSymmetric_v<MT> &&
927  !( IsIdentity_v<MT> &&
928  IsSame_v< ElementType_t<MT>, ElementType_t<VT> > ) &&
929  !IsZero_v<MT> >* = nullptr >
930 inline decltype(auto)
931  tsmatdvecmult( const SparseMatrix<MT,true>& mat, const DenseVector<VT,false>& vec )
932 {
934 
935  BLAZE_INTERNAL_ASSERT( (~mat).columns() == (~vec).size(), "Invalid matrix and vector sizes" );
936 
937  return trans( ~mat ) * (~vec);
938 }
940 //*************************************************************************************************
941 
942 
943 //*************************************************************************************************
957 template< typename MT // Type of the left-hand side sparse matrix
958  , typename VT // Type of the right-hand side dense vector
959  , EnableIf_t< IsIdentity_v<MT> &&
960  IsSame_v< ElementType_t<MT>, ElementType_t<VT> > >* = nullptr >
961 inline const VT&
962  tsmatdvecmult( const SparseMatrix<MT,true>& mat, const DenseVector<VT,false>& vec )
963 {
965 
966  UNUSED_PARAMETER( mat );
967 
968  BLAZE_INTERNAL_ASSERT( (~mat).columns() == (~vec).size(), "Invalid matrix and vector sizes" );
969 
970  return (~vec);
971 }
973 //*************************************************************************************************
974 
975 
976 //*************************************************************************************************
989 template< typename MT // Type of the left-hand side sparse matrix
990  , typename VT // Type of the right-hand side dense vector
991  , EnableIf_t< IsZero_v<MT> >* = nullptr >
992 inline decltype(auto)
993  tsmatdvecmult( const SparseMatrix<MT,true>& mat, const DenseVector<VT,false>& vec )
994 {
996 
997  UNUSED_PARAMETER( vec );
998 
999  BLAZE_INTERNAL_ASSERT( (~mat).columns() == (~vec).size(), "Invalid matrix and vector sizes" );
1000 
1001  using ReturnType = const MultTrait_t< ResultType_t<MT>, ResultType_t<VT> >;
1002 
1005 
1006  return ReturnType( (~mat).rows() );
1007 }
1009 //*************************************************************************************************
1010 
1011 
1012 //*************************************************************************************************
1043 template< typename MT // Type of the left-hand side sparse matrix
1044  , typename VT > // Type of the right-hand side dense vector
1045 inline decltype(auto)
1046  operator*( const SparseMatrix<MT,true>& mat, const DenseVector<VT,false>& vec )
1047 {
1049 
1051 
1052  if( (~mat).columns() != (~vec).size() ) {
1053  BLAZE_THROW_INVALID_ARGUMENT( "Matrix and vector sizes do not match" );
1054  }
1055 
1056  return tsmatdvecmult( ~mat, ~vec );
1057 }
1058 //*************************************************************************************************
1059 
1060 
1061 
1062 
1063 //=================================================================================================
1064 //
1065 // ISALIGNED SPECIALIZATIONS
1066 //
1067 //=================================================================================================
1068 
1069 //*************************************************************************************************
1071 template< typename MT, typename VT >
1072 struct IsAligned< TSMatDVecMultExpr<MT,VT> >
1073  : public IsAligned<VT>
1074 {};
1076 //*************************************************************************************************
1077 
1078 } // namespace blaze
1079 
1080 #endif
static constexpr bool evaluateMatrix
Compilation switch for the composite type of the left-hand side sparse matrix expression.
Definition: TSMatDVecMultExpr.h:118
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
LeftOperand mat_
Left-hand side sparse matrix of the multiplication expression.
Definition: TSMatDVecMultExpr.h:307
Header file for auxiliary alias declarations.
Header file for the blaze::checked and blaze::unchecked instances.
Expression object for transpose sparse matrix-dense vector multiplications.The TSMatDVecMultExpr clas...
Definition: Forward.h:172
Header file for the UNUSED_PARAMETER function template.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TSMatDVecMultExpr.h:280
LeftOperand leftOperand() const noexcept
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatDVecMultExpr.h:246
Header file for basic type definitions.
typename If< Condition, T1, T2 >::Type If_t
Auxiliary alias declaration for the If class template.The If_t alias declaration provides a convenien...
Definition: If.h:109
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TSMatDVecMultExpr.h:189
typename T::ResultType ResultType_t
Alias declaration for nested ResultType type definitions.The ResultType_t alias declaration provides ...
Definition: Aliases.h:390
#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
Header file for the serial shim.
Header file for the IsDiagonal type trait.
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: TSMatDVecMultExpr.h:223
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: TSMatDVecMultExpr.h:300
MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:372
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:591
static constexpr bool smpAssignable
Compilation flag for SMP assignments.
Definition: CompressedMatrix.h:3113
CompositeType_t< MT > MCT
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDVecMultExpr.h:112
constexpr Unchecked unchecked
Global Unchecked instance.The blaze::unchecked instance is an optional token for the creation of view...
Definition: Check.h:138
Constraint on the data type.
Header file for the DenseVector base class.
Header file for the IsIdentity type trait.
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: TSMatDVecMultExpr.h:236
Header file for the Computation base class.
Header file for the reset shim.
Header file for the RequiresEvaluation type trait.
constexpr void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
ResultType_t< MT > MRT
Result type of the left-hand side sparse matrix expression.
Definition: TSMatDVecMultExpr.h:110
static constexpr bool evaluateVector
Compilation switch for the composite type of the right-hand side dense vector expression.
Definition: TSMatDVecMultExpr.h:123
constexpr size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:514
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:137
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.The ElementType_t alias declaration provide...
Definition: Aliases.h:170
auto smpDivAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > >
Default implementation of the SMP division assignment of a vector to a dense vector.
Definition: DenseVector.h:220
If_t< evaluateVector, const VRT, VCT > RT
Type for the assignment of the right-hand side dense vector operand.
Definition: TSMatDVecMultExpr.h:157
static constexpr bool simdEnabled
Compilation switch for the expression template evaluation strategy.
Definition: TSMatDVecMultExpr.h:162
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:308
Constraint on the data type.
Header file for the DisableIf class template.
Header file for the multiplication trait.
Header file for the IsStrictlyUpper type trait.
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: TSMatDVecMultExpr.h:290
Header file for the IsSymmetric type trait.
constexpr bool IsResizable_v
Auxiliary variable template for the IsResizable type trait.The IsResizable_v variable template provid...
Definition: IsResizable.h:134
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
Header file for the If class template.
#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:61
#define BLAZE_CONSTRAINT_MUST_BE_ZERO_TYPE(T)
Constraint on the data type.In case the given data type T is not a zero vector or matrix type...
Definition: Zero.h:61
#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
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.
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:83
#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:104
ElementType_t< ResultType > ElementType
Resulting element type.
Definition: TSMatDVecMultExpr.h:143
Constraint on the data type.
Header file for the exception macros of the math module.
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:438
Constraint on the data type.
Header file for all forward declarations for expression class templates.
If_t< IsExpression_v< VT >, const VT, const VT &> RightOperand
Composite type of the right-hand side dense vector expression.
Definition: TSMatDVecMultExpr.h:151
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
typename MultTrait< T1, T2 >::Type MultTrait_t
Auxiliary alias declaration for the MultTrait class template.The MultTrait_t alias declaration provid...
Definition: MultTrait.h:240
ResultType_t< VT > VRT
Result type of the right-hand side dense vector expression.
Definition: TSMatDVecMultExpr.h:111
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatDVecMultExpr.h:145
#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
typename T::TransposeType TransposeType_t
Alias declaration for nested TransposeType type definitions.The TransposeType_t alias declaration pro...
Definition: Aliases.h:470
Header file for run time assertion macros.
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: TSMatDVecMultExpr.h:165
typename T::CompositeType CompositeType_t
Alias declaration for nested CompositeType type definitions.The CompositeType_t alias declaration pro...
Definition: Aliases.h:90
auto smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:131
decltype(auto) row(Matrix< MT, SO > &, RRAs...)
Creating a view on a specific row of the given matrix.
Definition: Row.h:133
RightOperand rightOperand() const noexcept
Returns the right-hand side dense vector operand.
Definition: TSMatDVecMultExpr.h:256
Header file for the IsZero type trait.
#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
Header file for the isDefault shim.
constexpr size_t size(const Matrix< MT, SO > &matrix) noexcept
Returns the total number of elements of the matrix.
Definition: Matrix.h:530
auto smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:100
Constraint on the data type.
TransposeType_t< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TSMatDVecMultExpr.h:142
Constraints on the storage order of matrix types.
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:808
#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
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:498
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TSMatDVecMultExpr.h:268
If_t< IsExpression_v< MT >, const MT, const MT &> LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDVecMultExpr.h:148
TSMatDVecMultExpr(const MT &mat, const VT &vec) noexcept
Constructor for the TSMatDVecMultExpr class.
Definition: TSMatDVecMultExpr.h:175
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3081
#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:765
MultTrait_t< MRT, VRT > ResultType
Result type for expression template evaluations.
Definition: TSMatDVecMultExpr.h:141
Header file for the IsComputation type trait class.
auto smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:162
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSMatDVecMultExpr.h:144
Constraint on the data type.
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:631
Header file for the IsUpper type trait.
Header file for the MatVecMultExpr base class.
CompositeType_t< VT > VCT
Composite type of the right-hand side dense vector expression.
Definition: TSMatDVecMultExpr.h:113
Constraint on the data type.
Header file for the IsResizable type trait.
If_t< evaluateMatrix, const MRT, MCT > LT
Type for the assignment of the left-hand side sparse matrix operand.
Definition: TSMatDVecMultExpr.h:154
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ZERO_TYPE(T)
Constraint on the data type.In case the given data type T is a zero vector or matrix type...
Definition: Zero.h:81
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
auto smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > >
Default implementation of the SMP multiplication assignment of a vector to a dense vector...
Definition: DenseVector.h:191
#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:61
Header file for the IsExpression type trait class.
Header file for the function trace functionality.