TSVecTDMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSVECTDMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSVECTDMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
51 #include <blaze/math/Exception.h>
56 #include <blaze/math/shims/Reset.h>
75 #include <blaze/util/Assert.h>
77 #include <blaze/util/DisableIf.h>
78 #include <blaze/util/EnableIf.h>
81 #include <blaze/util/mpl/If.h>
82 #include <blaze/util/mpl/Or.h>
83 #include <blaze/util/Types.h>
85 
86 
87 namespace blaze {
88 
89 //=================================================================================================
90 //
91 // CLASS TSVECDMATMULTEXPR
92 //
93 //=================================================================================================
94 
95 //*************************************************************************************************
102 template< typename VT // Type of the left-hand side sparse vector
103  , typename MT > // Type of the right-hand side dense matrix
104 class TSVecTDMatMultExpr : public DenseVector< TSVecTDMatMultExpr<VT,MT>, true >
105  , private TVecMatMultExpr
106  , private Computation
107 {
108  private:
109  //**Type definitions****************************************************************************
114  //**********************************************************************************************
115 
116  //**********************************************************************************************
118  enum : bool { evaluateVector = IsComputation<VT>::value || RequiresEvaluation<VT>::value };
119  //**********************************************************************************************
120 
121  //**********************************************************************************************
123  enum : bool { evaluateMatrix = RequiresEvaluation<MT>::value };
124  //**********************************************************************************************
125 
126  //**********************************************************************************************
128 
134  enum : bool { useAssign = ( evaluateVector || evaluateMatrix ) };
135  //**********************************************************************************************
136 
137  //**********************************************************************************************
139  template< typename VT2 >
141  struct UseAssign {
142  enum : bool { value = useAssign };
143  };
145  //**********************************************************************************************
146 
147  //**********************************************************************************************
149 
153  template< typename T1 >
154  struct UseSMPAssign {
155  enum : bool { value = useAssign };
156  };
158  //**********************************************************************************************
159 
160  public:
161  //**Type definitions****************************************************************************
166  typedef const ElementType ReturnType;
167 
170 
172  typedef If_< IsExpression<VT>, const VT, const VT& > LeftOperand;
173 
175  typedef If_< IsExpression<MT>, const MT, const MT& > RightOperand;
176 
179 
182  //**********************************************************************************************
183 
184  //**Compilation flags***************************************************************************
186  enum : bool { simdEnabled = false };
187 
189  enum : bool { smpAssignable = !evaluateVector && VT::smpAssignable &&
190  !evaluateMatrix && MT::smpAssignable };
191  //**********************************************************************************************
192 
193  //**Constructor*********************************************************************************
199  explicit inline TSVecTDMatMultExpr( const VT& vec, const MT& mat ) noexcept
200  : vec_( vec ) // Left-hand side sparse vector of the multiplication expression
201  , mat_( mat ) // Right-hand side dense matrix of the multiplication expression
202  {
203  BLAZE_INTERNAL_ASSERT( vec_.size() == mat_.rows(), "Invalid vector and matrix sizes" );
204  }
205  //**********************************************************************************************
206 
207  //**Subscript operator**************************************************************************
213  inline ReturnType operator[]( size_t index ) const {
214  BLAZE_INTERNAL_ASSERT( index < mat_.columns(), "Invalid vector access index" );
215 
217  {
218  return vec_[index] * mat_(index,index);
219  }
220  else if( IsLower<MT>::value )
221  {
222  const size_t begin( IsStrictlyLower<MT>::value ? index+1UL : index );
223  const size_t n ( mat_.rows() - begin );
224  return subvector( vec_, begin, n ) * subvector( column( mat_, index ), begin, n );
225  }
226  else if( IsUpper<MT>::value )
227  {
228  const size_t n( IsStrictlyUpper<MT>::value ? index : index+1UL );
229  return subvector( vec_, 0UL, n ) * subvector( column( mat_, index ), 0UL, n );
230  }
231  else
232  {
233  return vec_ * column( mat_, index );
234  }
235  }
236  //**********************************************************************************************
237 
238  //**At function*********************************************************************************
245  inline ReturnType at( size_t index ) const {
246  if( index >= mat_.columns() ) {
247  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
248  }
249  return (*this)[index];
250  }
251  //**********************************************************************************************
252 
253  //**Size function*******************************************************************************
258  inline size_t size() const noexcept {
259  return mat_.columns();
260  }
261  //**********************************************************************************************
262 
263  //**Left operand access*************************************************************************
268  inline LeftOperand leftOperand() const noexcept {
269  return vec_;
270  }
271  //**********************************************************************************************
272 
273  //**Right operand access************************************************************************
278  inline RightOperand rightOperand() const noexcept {
279  return mat_;
280  }
281  //**********************************************************************************************
282 
283  //**********************************************************************************************
289  template< typename T >
290  inline bool canAlias( const T* alias ) const noexcept {
291  return vec_.isAliased( alias ) || mat_.isAliased( alias );
292  }
293  //**********************************************************************************************
294 
295  //**********************************************************************************************
301  template< typename T >
302  inline bool isAliased( const T* alias ) const noexcept {
303  return vec_.isAliased( alias ) || mat_.isAliased( alias );
304  }
305  //**********************************************************************************************
306 
307  //**********************************************************************************************
312  inline bool isAligned() const noexcept {
313  return mat_.isAligned();
314  }
315  //**********************************************************************************************
316 
317  //**********************************************************************************************
322  inline bool canSMPAssign() const noexcept {
323  return ( size() > SMP_TSVECTDMATMULT_THRESHOLD );
324  }
325  //**********************************************************************************************
326 
327  private:
328  //**Member variables****************************************************************************
329  LeftOperand vec_;
330  RightOperand mat_;
331  //**********************************************************************************************
332 
333  //**Assignment to dense vectors*****************************************************************
349  template< typename VT2 > // Type of the target dense vector
350  friend inline EnableIf_< UseAssign<VT2> >
351  assign( DenseVector<VT2,true>& lhs, const TSVecTDMatMultExpr& rhs )
352  {
354 
355  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
356 
357  // Evaluation of the left-hand side sparse vector operand
358  LT x( serial( rhs.vec_ ) );
359  if( x.nonZeros() == 0UL ) {
360  reset( ~lhs );
361  return;
362  }
363 
364  // Evaluation of the right-hand side dense matrix operand
365  RT A( serial( rhs.mat_ ) );
366 
367  // Checking the evaluated operands
368  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
369  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
370  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
371  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
372 
373  // Performing the sparse vector-dense matrix multiplication
374  assign( ~lhs, x * A );
375  }
377  //**********************************************************************************************
378 
379  //**Assignment to sparse vectors****************************************************************
395  template< typename VT2 > // Type of the target sparse vector
396  friend inline EnableIf_< UseAssign<VT2> >
397  assign( SparseVector<VT2,true>& lhs, const TSVecTDMatMultExpr& rhs )
398  {
400 
404 
405  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
406 
407  const ResultType tmp( serial( rhs ) );
408  assign( ~lhs, tmp );
409  }
411  //**********************************************************************************************
412 
413  //**Addition assignment to dense vectors********************************************************
428  template< typename VT2 > // Type of the target dense vector
429  friend inline EnableIf_< UseAssign<VT2> >
431  {
433 
434  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
435 
436  // Evaluation of the left-hand side sparse vector operand
437  LT x( serial( rhs.vec_ ) );
438  if( x.nonZeros() == 0UL ) return;
439 
440  // Evaluation of the right-hand side dense matrix operand
441  RT A( serial( rhs.mat_ ) );
442 
443  // Checking the evaluated operands
444  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
445  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
446  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
447  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
448 
449  // Performing the sparse vector-dense matrix multiplication
450  addAssign( ~lhs, x * A );
451  }
452  //**********************************************************************************************
453 
454  //**Addition assignment to sparse vectors*******************************************************
455  // No special implementation for the addition assignment to sparse vectors.
456  //**********************************************************************************************
457 
458  //**Subtraction assignment to dense vectors*****************************************************
473  template< typename VT2 > // Type of the target dense vector
474  friend inline EnableIf_< UseAssign<VT2> >
476  {
478 
479  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
480 
481  // Evaluation of the left-hand side sparse vector operand
482  LT x( serial( rhs.vec_ ) );
483  if( x.nonZeros() == 0UL ) return;
484 
485  // Evaluation of the right-hand side dense matrix operand
486  RT A( serial( rhs.mat_ ) );
487 
488  // Checking the evaluated operands
489  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
490  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
491  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
492  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
493 
494  // Performing the sparse vector-dense matrix multiplication
495  subAssign( ~lhs, x * A );
496  }
497  //**********************************************************************************************
498 
499  //**Subtraction assignment to sparse vectors****************************************************
500  // No special implementation for the subtraction assignment to sparse vectors.
501  //**********************************************************************************************
502 
503  //**Multiplication assignment to dense vectors**************************************************
518  template< typename VT2 > // Type of the target dense vector
519  friend inline EnableIf_< UseAssign<VT2> >
521  {
523 
527 
528  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
529 
530  const ResultType tmp( serial( rhs ) );
531  multAssign( ~lhs, tmp );
532  }
533  //**********************************************************************************************
534 
535  //**Multiplication assignment to sparse vectors*************************************************
536  // No special implementation for the multiplication assignment to sparse vectors.
537  //**********************************************************************************************
538 
539  //**Division assignment to dense vectors********************************************************
554  template< typename VT2 > // Type of the target dense vector
555  friend inline EnableIf_< UseAssign<VT2> >
557  {
559 
563 
564  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
565 
566  const ResultType tmp( serial( rhs ) );
567  divAssign( ~lhs, tmp );
568  }
569  //**********************************************************************************************
570 
571  //**Division assignment to sparse vectors*******************************************************
572  // No special implementation for the division assignment to sparse vectors.
573  //**********************************************************************************************
574 
575  //**SMP assignment to dense vectors*************************************************************
590  template< typename VT2 > // Type of the target dense vector
591  friend inline EnableIf_< UseSMPAssign<VT2> >
593  {
595 
596  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
597 
598  // Evaluation of the left-hand side sparse vector operand
599  LT x( rhs.vec_ );
600  if( x.nonZeros() == 0UL ) {
601  reset( ~lhs );
602  return;
603  }
604 
605  // Evaluation of the right-hand side dense matrix operand
606  RT A( rhs.mat_ );
607 
608  // Checking the evaluated operands
609  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
610  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
611  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
612  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
613 
614  // Performing the sparse vector-dense matrix multiplication
615  smpAssign( ~lhs, x * A );
616  }
618  //**********************************************************************************************
619 
620  //**SMP assignment to sparse vectors************************************************************
635  template< typename VT2 > // Type of the target sparse vector
636  friend inline EnableIf_< UseSMPAssign<VT2> >
637  smpAssign( SparseVector<VT2,true>& lhs, const TSVecTDMatMultExpr& rhs )
638  {
640 
643  BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE( CompositeType_<ResultType> );
644 
645  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
646 
647  const ResultType tmp( rhs );
648  smpAssign( ~lhs, tmp );
649  }
651  //**********************************************************************************************
652 
653  //**SMP addition assignment to dense vectors****************************************************
667  template< typename VT2 > // Type of the target dense vector
668  friend inline EnableIf_< UseSMPAssign<VT2> >
670  {
672 
673  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
674 
675  // Evaluation of the left-hand side sparse vector operand
676  LT x( rhs.vec_ );
677  if( x.nonZeros() == 0UL ) return;
678 
679  // Evaluation of the right-hand side dense matrix operand
680  RT A( rhs.mat_ );
681 
682  // Checking the evaluated operands
683  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
684  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
685  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
686  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
687 
688  // Performing the sparse vector-dense matrix multiplication
689  smpAddAssign( ~lhs, x * A );
690  }
691  //**********************************************************************************************
692 
693  //**SMP addition assignment to sparse vectors***************************************************
694  // No special implementation for the SMP addition assignment to sparse vectors.
695  //**********************************************************************************************
696 
697  //**SMP subtraction assignment to dense vectors*************************************************
711  template< typename VT2 > // Type of the target dense vector
712  friend inline EnableIf_< UseSMPAssign<VT2> >
714  {
716 
717  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
718 
719  // Evaluation of the left-hand side sparse vector operand
720  LT x( rhs.vec_ );
721  if( x.nonZeros() == 0UL ) return;
722 
723  // Evaluation of the right-hand side dense matrix operand
724  RT A( rhs.mat_ );
725 
726  // Checking the evaluated operands
727  BLAZE_INTERNAL_ASSERT( x.size() == rhs.vec_.size() , "Invalid vector size" );
728  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.mat_.rows() , "Invalid number of rows" );
729  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.mat_.columns(), "Invalid number of columns" );
730  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).size() , "Invalid vector size" );
731 
732  // Performing the sparse vector-dense matrix multiplication
733  smpSubAssign( ~lhs, x * A );
734  }
735  //**********************************************************************************************
736 
737  //**SMP subtraction assignment to sparse vectors************************************************
738  // No special implementation for the SMP subtraction assignment to sparse vectors.
739  //**********************************************************************************************
740 
741  //**SMP multiplication assignment to dense vectors**********************************************
756  template< typename VT2 > // Type of the target dense vector
757  friend inline EnableIf_< UseSMPAssign<VT2> >
759  {
761 
765 
766  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
767 
768  const ResultType tmp( rhs );
769  smpMultAssign( ~lhs, tmp );
770  }
771  //**********************************************************************************************
772 
773  //**SMP multiplication assignment to sparse vectors*********************************************
774  // No special implementation for the SMP multiplication assignment to sparse vectors.
775  //**********************************************************************************************
776 
777  //**SMP division assignment to dense vectors****************************************************
791  template< typename VT2 > // Type of the target dense vector
792  friend inline EnableIf_< UseSMPAssign<VT2> >
794  {
796 
800 
801  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
802 
803  const ResultType tmp( rhs );
804  smpDivAssign( ~lhs, tmp );
805  }
806  //**********************************************************************************************
807 
808  //**SMP division assignment to sparse vectors***************************************************
809  // No special implementation for the SMP division assignment to sparse vectors.
810  //**********************************************************************************************
811 
812  //**Compile time checks*************************************************************************
821  //**********************************************************************************************
822 };
823 //*************************************************************************************************
824 
825 
826 
827 
828 //=================================================================================================
829 //
830 // GLOBAL BINARY ARITHMETIC OPERATORS
831 //
832 //=================================================================================================
833 
834 //*************************************************************************************************
865 template< typename T1, typename T2 >
866 inline const DisableIf_< Or< IsSymmetric<T2>, IsMatMatMultExpr<T2> >, TSVecTDMatMultExpr<T1,T2> >
868 {
870 
871  if( (~vec).size() != (~mat).rows() ) {
872  BLAZE_THROW_INVALID_ARGUMENT( "Vector and matrix sizes do not match" );
873  }
874 
875  return TSVecTDMatMultExpr<T1,T2>( ~vec, ~mat );
876 }
877 //*************************************************************************************************
878 
879 
880 
881 
882 //=================================================================================================
883 //
884 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
885 //
886 //=================================================================================================
887 
888 //*************************************************************************************************
903 template< typename T1 // Type of the left-hand side sparse vector
904  , typename T2 > // Type of the right-hand side dense matrix
905 inline const EnableIf_< IsSymmetric<T2>, MultExprTrait_<T1,T2> >
906  operator*( const SparseVector<T1,true>& vec, const DenseMatrix<T2,true>& mat )
907 {
909 
911 
912  if( (~vec).size() != (~mat).rows() ) {
913  BLAZE_THROW_INVALID_ARGUMENT( "Vector and matrix sizes do not match" );
914  }
915 
916  return (~vec) * trans( ~mat );
917 }
919 //*************************************************************************************************
920 
921 
922 
923 
924 //=================================================================================================
925 //
926 // SIZE SPECIALIZATIONS
927 //
928 //=================================================================================================
929 
930 //*************************************************************************************************
932 template< typename VT, typename MT >
933 struct Size< TSVecTDMatMultExpr<VT,MT> > : public Columns<MT>
934 {};
936 //*************************************************************************************************
937 
938 
939 
940 
941 //=================================================================================================
942 //
943 // ISALIGNED SPECIALIZATIONS
944 //
945 //=================================================================================================
946 
947 //*************************************************************************************************
949 template< typename VT, typename MT >
950 struct IsAligned< TSVecTDMatMultExpr<VT,MT> >
951  : public BoolConstant< IsAligned<MT>::value >
952 {};
954 //*************************************************************************************************
955 
956 
957 
958 
959 //=================================================================================================
960 //
961 // EXPRESSION TRAIT SPECIALIZATIONS
962 //
963 //=================================================================================================
964 
965 //*************************************************************************************************
967 template< typename VT, typename MT, bool AF >
968 struct SubvectorExprTrait< TSVecTDMatMultExpr<VT,MT>, AF >
969 {
970  public:
971  //**********************************************************************************************
972  using Type = MultExprTrait_< SubvectorExprTrait_<const VT,AF>
973  , SubmatrixExprTrait_<const MT,AF> >;
974  //**********************************************************************************************
975 };
977 //*************************************************************************************************
978 
979 } // namespace blaze
980 
981 #endif
LeftOperand vec_
Left-hand side sparse vector of the multiplication expression.
Definition: TSVecTDMatMultExpr.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
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSVecTDMatMultExpr.h:166
Header file for auxiliary alias declarations.
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:72
CompositeType_< VT > VCT
Composite type of the left-hand side sparse vector expression.
Definition: TSVecTDMatMultExpr.h:112
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
Header file for basic type definitions.
friend EnableIf_< UseSMPAssign< VT2 > > smpMultAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
SMP multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication to a...
Definition: TSVecTDMatMultExpr.h:758
IfTrue_< evaluateVector, const VRT, VCT > LT
Type for the assignment of the left-hand side sparse vector operand.
Definition: TSVecTDMatMultExpr.h:178
Header file for the serial shim.
friend EnableIf_< UseAssign< VT2 > > divAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
Division assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vec...
Definition: TSVecTDMatMultExpr.h:556
MultTrait_< VRT, MRT > ResultType
Result type for expression template evaluations.
Definition: TSVecTDMatMultExpr.h:163
#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
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
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
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: TSVecTDMatMultExpr.h:245
Header file for the RequiresEvaluation type trait.
IfTrue_< useAssign, const ResultType, const TSVecTDMatMultExpr & > CompositeType
Data type for composite expression templates.
Definition: TSVecTDMatMultExpr.h:169
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: TSVecTDMatMultExpr.h:312
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, ColumnExprTrait_< MT > > column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:126
friend EnableIf_< UseSMPAssign< VT2 > > smpAddAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
SMP addition assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense...
Definition: TSVecTDMatMultExpr.h:669
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
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
friend EnableIf_< UseSMPAssign< VT2 > > smpDivAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
SMP division assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense...
Definition: TSVecTDMatMultExpr.h:793
TSVecTDMatMultExpr(const VT &vec, const MT &mat) noexcept
Constructor for the TSVecTDMatMultExpr class.
Definition: TSVecTDMatMultExpr.h:199
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
CompositeType_< MT > MCT
Composite type of the right-hand side dense matrix expression.
Definition: TSVecTDMatMultExpr.h:113
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.
#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
RightOperand rightOperand() const noexcept
Returns the right-hand side transpose dense matrix operand.
Definition: TSVecTDMatMultExpr.h:278
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
If_< IsExpression< MT >, const MT, const MT & > RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TSVecTDMatMultExpr.h:175
Header file for the Or class template.
friend EnableIf_< UseSMPAssign< VT2 > > smpSubAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
SMP subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication to a de...
Definition: TSVecTDMatMultExpr.h:713
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TSVecTDMatMultExpr.h:290
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
Header file for the Columns type trait.
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
If_< IsExpression< VT >, const VT, const VT & > LeftOperand
Composite type of the left-hand side sparse vector expression.
Definition: TSVecTDMatMultExpr.h:172
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TSVecTDMatMultExpr.h:302
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
#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
Constraint on the data type.
ElementType_< ResultType > ElementType
Resulting element type.
Definition: TSVecTDMatMultExpr.h:165
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.
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TSVecTDMatMultExpr.h:164
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: TSVecTDMatMultExpr.h:322
friend EnableIf_< UseAssign< VT2 > > addAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
Addition assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vec...
Definition: TSVecTDMatMultExpr.h:430
TSVecTDMatMultExpr< VT, MT > This
Type of this TSVecTDMatMultExpr instance.
Definition: TSVecTDMatMultExpr.h:162
#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.
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: TSVecTDMatMultExpr.h:258
Header file for run time assertion macros.
IfTrue_< evaluateMatrix, const MRT, MCT > RT
Type for the assignment of the left-hand side dense matrix operand.
Definition: TSVecTDMatMultExpr.h:181
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
Header file for the reset shim.
ResultType_< VT > VRT
Result type of the left-hand side sparse vector expression.
Definition: TSVecTDMatMultExpr.h:110
Constraint on the data type.
Header file for the TVecMatMultExpr base class.
Constraints on the storage order of matrix types.
RightOperand mat_
Right-hand side dense matrix of the multiplication expression.
Definition: TSVecTDMatMultExpr.h:330
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents ...
Definition: IntegralConstant.h:100
friend EnableIf_< UseAssign< VT2 > > multAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
Multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication to a den...
Definition: TSVecTDMatMultExpr.h:520
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
Expression object for transpose sparse vector-transpose dense matrix multiplications.The TSVecTDMatMultExpr class represents the compile time expression for multiplications between transpose sparse vectors and column-major dense matrices.
Definition: Forward.h:152
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:314
#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
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_TVECMATMULTEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/matrix ...
Definition: TVecMatMultExpr.h:110
ResultType_< MT > MRT
Result type of the right-hand side dense matrix expression.
Definition: TSVecTDMatMultExpr.h:111
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TSVecTDMatMultExpr.h:213
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 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
LeftOperand leftOperand() const noexcept
Returns the left-hand side sparse vector operand.
Definition: TSVecTDMatMultExpr.h:268
Header file for the IntegralConstant class template.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a row dense or sparse vector type (i...
Definition: RowVector.h:61
Header file for the SubvectorExprTrait class template.
friend EnableIf_< UseAssign< VT2 > > subAssign(DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
Subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense ...
Definition: TSVecTDMatMultExpr.h:475
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.
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
Constraint on the transpose flag of vector types.
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.