All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SMatTSMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATTSMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATTSMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
73 #include <blaze/util/Assert.h>
74 #include <blaze/util/InvalidType.h>
76 #include <blaze/util/SelectType.h>
77 #include <blaze/util/Types.h>
79 #include <blaze/util/Unused.h>
80 
81 
82 namespace blaze {
83 
84 //=================================================================================================
85 //
86 // CLASS SMATTSMATMULTEXPR
87 //
88 //=================================================================================================
89 
90 //*************************************************************************************************
97 template< typename MT1 // Type of the left-hand side sparse matrix
98  , typename MT2 > // Type of the right-hand side sparse matrix
99 class SMatTSMatMultExpr : public SparseMatrix< SMatTSMatMultExpr<MT1,MT2>, false >
100  , private MatMatMultExpr
101  , private Computation
102 {
103  private:
104  //**Type definitions****************************************************************************
105  typedef typename MT1::ResultType RT1;
106  typedef typename MT2::ResultType RT2;
107  typedef typename MT1::CompositeType CT1;
108  typedef typename MT2::CompositeType CT2;
109  //**********************************************************************************************
110 
111  public:
112  //**Type definitions****************************************************************************
118  typedef const ElementType ReturnType;
119  typedef const ResultType CompositeType;
120 
122  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
123 
125  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
126  //**********************************************************************************************
127 
128  //**Constructor*********************************************************************************
134  explicit inline SMatTSMatMultExpr( const MT1& lhs, const MT2& rhs )
135  : lhs_( lhs ) // Left-hand side sparse matrix of the multiplication expression
136  , rhs_( rhs ) // Right-hand side sparse matrix of the multiplication expression
137  {
138  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.rows(), "Invalid matrix sizes" );
139  }
140  //**********************************************************************************************
141 
142  //**Access operator*****************************************************************************
149  inline ReturnType operator()( size_t i, size_t j ) const {
150  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
151  BLAZE_INTERNAL_ASSERT( j < rhs_.columns(), "Invalid column access index" );
152 
153  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
154  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
155 
156  ElementType tmp = ElementType();
157 
158  // Early exit
159  if( lhs_.columns() == 0UL )
160  return tmp;
161 
162  // Fast computation in case both the left-hand side and the right-hand side
163  // sparse matrices directly provide iterators
165  {
166  // Evaluation of the left-hand side sparse matrix operand
167  CT1 A( lhs_ );
168 
169  const LeftIterator lend( A.end(i) );
170  LeftIterator lelem( A.begin(i) );
171 
172  // Evaluation of the right-hand side sparse matrix operand
173  CT2 B( rhs_ );
174 
175  const RightIterator rend( B.end(j) );
176  RightIterator relem( B.begin(j) );
177 
178  // Early exit in case row i or column j are empty
179  if( lelem == lend || relem == rend )
180  return tmp;
181 
182  // Calculating element (i,j)
183  while( true ) {
184  if( lelem->index() < relem->index() ) {
185  ++lelem;
186  if( lelem == lend ) break;
187  }
188  else if( relem->index() < lelem->index() ) {
189  ++relem;
190  if( relem == rend ) break;
191  }
192  else {
193  tmp = lelem->value() * relem->value();
194  ++lelem;
195  ++relem;
196  break;
197  }
198  }
199 
200  if( lelem != lend && relem != rend )
201  {
202  while( true ) {
203  if( lelem->index() < relem->index() ) {
204  ++lelem;
205  if( lelem == lend ) break;
206  }
207  else if( relem->index() < lelem->index() ) {
208  ++relem;
209  if( relem == rend ) break;
210  }
211  else {
212  tmp += lelem->value() * relem->value();
213  ++lelem;
214  if( lelem == lend ) break;
215  ++relem;
216  if( relem == rend ) break;
217  }
218  }
219  }
220  }
221 
222  // Optimized computation in case the left-hand side sparse matrix directly provides iterators
224  {
225  // Evaluation of the left-hand side sparse matrix operand
226  CT1 A( lhs_ );
227 
228  const LeftIterator end( A.end(i) );
229  LeftIterator element( A.begin(i) );
230 
231  // Early exit in case row i is empty
232  if( element == end )
233  return tmp;
234 
235  // Calculating element (i,j)
236  tmp = element->value() * rhs_(element->index(),j);
237  ++element;
238  for( ; element!=end; ++element )
239  tmp += element->value() * rhs_(element->index(),j);
240  }
241 
242  // Optimized computation in case the right-hand side sparse matrix directly provides iterators
244  {
245  // Evaluation of the right-hand side sparse matrix operand
246  CT2 B( rhs_ );
247 
248  const RightIterator end( B.end(j) );
249  RightIterator element( B.begin(j) );
250 
251  // Early exit in case row i is empty
252  if( element == end )
253  return tmp;
254 
255  // Calculating element (i,j)
256  tmp = lhs_(i,element->index()) * element->value();
257  ++element;
258  for( ; element!=end; ++element )
259  tmp += lhs_(i,element->index()) * element->value();
260  }
261 
262  // Default computation in case both sparse matrices don't provide iterators
263  else {
264  tmp = lhs_(i,0UL) * rhs_(0UL,j);
265  for( size_t k=1UL; k<lhs_.columns(); ++k ) {
266  tmp += lhs_(i,k) * rhs_(k,j);
267  }
268  }
269 
270  return tmp;
271  }
272  //**********************************************************************************************
273 
274  //**Rows function*******************************************************************************
279  inline size_t rows() const {
280  return lhs_.rows();
281  }
282  //**********************************************************************************************
283 
284  //**Columns function****************************************************************************
289  inline size_t columns() const {
290  return rhs_.columns();
291  }
292  //**********************************************************************************************
293 
294  //**NonZeros function***************************************************************************
299  inline size_t nonZeros() const {
300  return 0UL;
301  }
302  //**********************************************************************************************
303 
304  //**NonZeros function***************************************************************************
310  inline size_t nonZeros( size_t i ) const {
311  UNUSED_PARAMETER( i );
312  return 0UL;
313  }
314  //**********************************************************************************************
315 
316  //**Left operand access*************************************************************************
321  inline LeftOperand leftOperand() const {
322  return lhs_;
323  }
324  //**********************************************************************************************
325 
326  //**Right operand access************************************************************************
331  inline RightOperand rightOperand() const {
332  return rhs_;
333  }
334  //**********************************************************************************************
335 
336  //**********************************************************************************************
342  template< typename T >
343  inline bool canAlias( const T* alias ) const {
344  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
345  }
346  //**********************************************************************************************
347 
348  //**********************************************************************************************
354  template< typename T >
355  inline bool isAliased( const T* alias ) const {
356  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
357  }
358  //**********************************************************************************************
359 
360  private:
361  //**Member variables****************************************************************************
364  //**********************************************************************************************
365 
366  //**Assignment to row-major dense matrices******************************************************
379  template< typename MT > // Type of the target dense matrix
380  friend inline void assign( DenseMatrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
381  {
383 
384  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
385  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
386 
388 
389  const typename MT2::OppositeType tmp( rhs.rhs_ );
390  assign( ~lhs, rhs.lhs_ * tmp );
391  }
393  //**********************************************************************************************
394 
395  //**Assignment to column-major dense matrices***************************************************
408  template< typename MT > // Type of the target dense matrix
409  friend inline void assign( DenseMatrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
410  {
412 
413  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
414  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
415 
417 
418  const typename MT1::OppositeType tmp( rhs.lhs_ );
419  assign( ~lhs, tmp * rhs.rhs_ );
420  }
422  //**********************************************************************************************
423 
424  //**Assignment to row-major sparse matrices*****************************************************
437  template< typename MT > // Type of the target sparse matrix
438  friend inline void assign( SparseMatrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
439  {
441 
442  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
443  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
444 
446 
447  const typename MT2::OppositeType tmp( rhs.rhs_ );
448  assign( ~lhs, rhs.lhs_ * tmp );
449  }
451  //**********************************************************************************************
452 
453  //**Assignment to column-major sparse matrices**************************************************
466  template< typename MT > // Type of the target sparse matrix
467  friend inline void assign( SparseMatrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
468  {
470 
471  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
472  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
473 
475 
476  const typename MT1::OppositeType tmp( rhs.lhs_ );
477  assign( ~lhs, tmp * rhs.rhs_ );
478  }
480  //**********************************************************************************************
481 
482  //**Addition assignment to row-major dense matrices*********************************************
495  template< typename MT > // Type of the target dense matrix
496  friend inline void addAssign( DenseMatrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
497  {
499 
500  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
501  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
502 
504 
505  const typename MT2::OppositeType tmp( rhs.rhs_ );
506  addAssign( ~lhs, rhs.lhs_ * tmp );
507  }
509  //**********************************************************************************************
510 
511  //**Addition assignment to column-major dense matrices******************************************
524  template< typename MT > // Type of the target dense matrix
525  friend inline void addAssign( DenseMatrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
526  {
528 
529  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
530  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
531 
533 
534  const typename MT1::OppositeType tmp( rhs.lhs_ );
535  addAssign( ~lhs, tmp * rhs.rhs_ );
536  }
538  //**********************************************************************************************
539 
540  //**Addition assignment to sparse matrices******************************************************
541  // No special implementation for the addition assignment to sparse matrices.
542  //**********************************************************************************************
543 
544  //**Subtraction assignment to row-major dense matrices******************************************
557  template< typename MT > // Type of the target dense matrix
558  friend inline void subAssign( DenseMatrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
559  {
561 
562  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
563  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
564 
566 
567  const typename MT2::OppositeType tmp( rhs.rhs_ );
568  subAssign( ~lhs, rhs.lhs_ * tmp );
569  }
571  //**********************************************************************************************
572 
573  //**Subtraction assignment to column-major dense matrices***************************************
586  template< typename MT > // Type of the target dense matrix
587  friend inline void subAssign( DenseMatrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
588  {
590 
591  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
592  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
593 
595 
596  const typename MT1::OppositeType tmp( rhs.lhs_ );
597  subAssign( ~lhs, tmp * rhs.rhs_ );
598  }
600  //**********************************************************************************************
601 
602  //**Subtraction assignment to sparse matrices***************************************************
603  // No special implementation for the subtraction assignment to sparse matrices.
604  //**********************************************************************************************
605 
606  //**Multiplication assignment to dense matrices*************************************************
607  // No special implementation for the multiplication assignment to dense matrices.
608  //**********************************************************************************************
609 
610  //**Multiplication assignment to sparse matrices************************************************
611  // No special implementation for the multiplication assignment to sparse matrices.
612  //**********************************************************************************************
613 
614  //**Compile time checks*************************************************************************
621  //**********************************************************************************************
622 };
623 //*************************************************************************************************
624 
625 
626 
627 
628 //=================================================================================================
629 //
630 // GLOBAL BINARY ARITHMETIC OPERATORS
631 //
632 //=================================================================================================
633 
634 //*************************************************************************************************
664 template< typename T1 // Type of the left-hand side sparse matrix
665  , typename T2 > // Type of the right-hand side sparse matrix
666 inline const SMatTSMatMultExpr<T1,T2>
668 {
670 
671  if( (~lhs).columns() != (~rhs).rows() )
672  throw std::invalid_argument( "Matrix sizes do not match" );
673 
674  return SMatTSMatMultExpr<T1,T2>( ~lhs, ~rhs );
675 }
676 //*************************************************************************************************
677 
678 
679 
680 
681 //=================================================================================================
682 //
683 // EXPRESSION TRAIT SPECIALIZATIONS
684 //
685 //=================================================================================================
686 
687 //*************************************************************************************************
689 template< typename MT1, typename MT2, typename VT >
690 struct SMatDVecMultExprTrait< SMatTSMatMultExpr<MT1,MT2>, VT >
691 {
692  public:
693  //**********************************************************************************************
694  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
695  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
696  IsDenseVector<VT>::value && IsColumnVector<VT>::value
697  , typename SMatDVecMultExprTrait< MT1, typename TSMatDVecMultExprTrait<MT2,VT>::Type >::Type
698  , INVALID_TYPE >::Type Type;
699  //**********************************************************************************************
700 };
702 //*************************************************************************************************
703 
704 
705 //*************************************************************************************************
707 template< typename MT1, typename MT2, typename VT >
708 struct SMatSVecMultExprTrait< SMatTSMatMultExpr<MT1,MT2>, VT >
709 {
710  public:
711  //**********************************************************************************************
712  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
713  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
714  IsSparseVector<VT>::value && IsColumnVector<VT>::value
715  , typename SMatSVecMultExprTrait< MT1, typename TSMatSVecMultExprTrait<MT2,VT>::Type >::Type
716  , INVALID_TYPE >::Type Type;
717  //**********************************************************************************************
718 };
720 //*************************************************************************************************
721 
722 
723 //*************************************************************************************************
725 template< typename VT, typename MT1, typename MT2 >
726 struct TDVecSMatMultExprTrait< VT, SMatTSMatMultExpr<MT1,MT2> >
727 {
728  public:
729  //**********************************************************************************************
730  typedef typename SelectType< IsDenseVector<VT>::value && IsRowVector<VT>::value &&
731  IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
732  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
733  , typename TDVecTSMatMultExprTrait< typename TDVecSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
734  , INVALID_TYPE >::Type Type;
735  //**********************************************************************************************
736 };
738 //*************************************************************************************************
739 
740 
741 //*************************************************************************************************
743 template< typename VT, typename MT1, typename MT2 >
744 struct TSVecSMatMultExprTrait< VT, SMatTSMatMultExpr<MT1,MT2> >
745 {
746  public:
747  //**********************************************************************************************
748  typedef typename SelectType< IsSparseVector<VT>::value && IsRowVector<VT>::value &&
749  IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
750  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
751  , typename TDVecTSMatMultExprTrait< typename TDVecSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
752  , INVALID_TYPE >::Type Type;
753  //**********************************************************************************************
754 };
756 //*************************************************************************************************
757 
758 
759 //*************************************************************************************************
761 template< typename MT1, typename MT2 >
762 struct SubmatrixExprTrait< SMatTSMatMultExpr<MT1,MT2> >
763 {
764  public:
765  //**********************************************************************************************
766  typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT1>::Type
767  , typename SubmatrixExprTrait<const MT2>::Type >::Type Type;
768  //**********************************************************************************************
769 };
771 //*************************************************************************************************
772 
773 
774 //*************************************************************************************************
776 template< typename MT1, typename MT2 >
777 struct RowExprTrait< SMatTSMatMultExpr<MT1,MT2> >
778 {
779  public:
780  //**********************************************************************************************
781  typedef typename MultExprTrait< typename RowExprTrait<const MT1>::Type, MT2 >::Type Type;
782  //**********************************************************************************************
783 };
785 //*************************************************************************************************
786 
787 
788 //*************************************************************************************************
790 template< typename MT1, typename MT2 >
791 struct ColumnExprTrait< SMatTSMatMultExpr<MT1,MT2> >
792 {
793  public:
794  //**********************************************************************************************
795  typedef typename MultExprTrait< MT1, typename ColumnExprTrait<const MT2>::Type >::Type Type;
796  //**********************************************************************************************
797 };
799 //*************************************************************************************************
800 
801 } // namespace blaze
802 
803 #endif
Header file for the SMatDVecMultExprTrait class template.
Header file for the UNUSED_PARAMETER function template.
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:3703
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatTSMatMultExpr.h:310
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:107
Header file for the IsSparseMatrix type trait.
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:196
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatTSMatMultExpr.h:343
Header file for the TSVecTSMatMultExprTrait class template.
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2375
Header file for the IsRowVector type trait.
SMatTSMatMultExpr< MT1, MT2 > This
Type of this SMatTSMatMultExpr instance.
Definition: SMatTSMatMultExpr.h:113
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:248
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:105
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:125
void UNUSED_PARAMETER(const T1 &)
Suppression of unused parameter warnings.
Definition: Unused.h:84
MT2::CompositeType CT2
Composite type of the right-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:108
Header file for the TDVecSMatMultExprTrait class template.
Header file for the Computation base class.
Header file for the MatMatMultExpr base class.
Header file for the RequiresEvaluation type trait.
Header file for the TSVecSMatMultExprTrait class template.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2371
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:104
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatTSMatMultExpr.h:119
Header file for the SparseMatrix base class.
Constraint on the data type.
Expression object for sparse matrix-transpose sparse matrix multiplications.The SMatTSMatMultExpr cla...
Definition: Forward.h:102
Header file for the MultExprTrait class template.
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:90
ResultType::ElementType ElementType
Resulting element type.
Definition: SMatTSMatMultExpr.h:117
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
Header file for the multiplication trait.
#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: StorageOrder.h:161
Header file for the TDVecTSMatMultExprTrait class template.
Header file for the TSMatDVecMultExprTrait class template.
void assign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the assignment of a matrix to a matrix.
Definition: Matrix.h:179
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatTSMatMultExpr.h:355
Header file for the SMatSVecMultExprTrait class template.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatTSMatMultExpr.h:289
Constraints on the storage order of matrix types.
RightOperand rightOperand() const
Returns the right-hand side transpose sparse matrix operand.
Definition: SMatTSMatMultExpr.h:331
RightOperand rhs_
Right-hand side sparse matrix of the multiplication expression.
Definition: SMatTSMatMultExpr.h:363
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatTSMatMultExpr.h:299
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatTSMatMultExpr.h:149
Header file for the IsSparseVector type trait.
Header file for the SubmatrixExprTrait class template.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: StorageOrder.h:81
Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given...
Definition: RemoveReference.h:69
Header file for run time assertion macros.
Utility type for generic codes.
Base template for the MultTrait class.
Definition: MultTrait.h:141
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:122
void addAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the addition assignment of a matrix to a matrix.
Definition: Matrix.h:209
void subAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the subtraction assignment of a matrix to matrix.
Definition: Matrix.h:239
MultTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SMatTSMatMultExpr.h:114
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatTSMatMultExpr.h:279
Header file for the RemoveReference type trait.
Header file for the IsDenseVector type trait.
SMatTSMatMultExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the SMatTSMatMultExpr class.
Definition: SMatTSMatMultExpr.h:134
LeftOperand leftOperand() const
Returns the left-hand side sparse matrix operand.
Definition: SMatTSMatMultExpr.h:321
LeftOperand lhs_
Left-hand side sparse matrix of the multiplication expression.
Definition: SMatTSMatMultExpr.h:362
Header file for the IsRowMajorMatrix type trait.
Header file for the IsComputation type trait class.
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2370
size_t columns(const Matrix< MT, SO > &m)
Returns the current number of columns of the matrix.
Definition: Matrix.h:154
Header file for basic type definitions.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatTSMatMultExpr.h:115
Header file for the IsColumnVector type trait.
size_t rows(const Matrix< MT, SO > &m)
Returns the current number of rows of the matrix.
Definition: Matrix.h:138
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type...
Definition: SparseMatrix.h:79
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:106
Header file for the IsExpression type trait class.
Header file for the TSMatSVecMultExprTrait class template.
Header file for the FunctionTrace class.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatTSMatMultExpr.h:116
const ElementType ReturnType
Return type for expression template evaluations.
Definition: SMatTSMatMultExpr.h:118