All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SMatSerialExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATSERIALEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATSERIALEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <cmath>
65 #include <blaze/util/Assert.h>
67 #include <blaze/util/InvalidType.h>
69 #include <blaze/util/SelectType.h>
70 #include <blaze/util/Types.h>
72 
73 
74 namespace blaze {
75 
76 //=================================================================================================
77 //
78 // CLASS SMATSERIALEXPR
79 //
80 //=================================================================================================
81 
82 //*************************************************************************************************
89 template< typename MT // Type of the sparse matrix
90  , bool SO > // Storage order
91 class SMatSerialExpr : public SparseMatrix< SMatSerialExpr<MT,SO>, SO >
92  , private MatSerialExpr
93  , private Computation
94 {
95  public:
96  //**Type definitions****************************************************************************
98  typedef typename MT::ResultType ResultType;
99  typedef typename MT::OppositeType OppositeType;
100  typedef typename MT::TransposeType TransposeType;
101  typedef typename MT::ElementType ElementType;
102  typedef typename MT::ReturnType ReturnType;
103 
105  typedef const ResultType CompositeType;
106 
108  typedef typename SelectType< IsExpression<MT>::value, const MT, const MT& >::Type Operand;
109  //**********************************************************************************************
110 
111  //**Compilation flags***************************************************************************
113  enum { smpAssignable = MT::smpAssignable };
114  //**********************************************************************************************
115 
116  //**Constructor*********************************************************************************
121  explicit inline SMatSerialExpr( const MT& sm )
122  : sm_( sm ) // Sparse matrix of the serial evaluation expression
123  {}
124  //**********************************************************************************************
125 
126  //**Access operator*****************************************************************************
133  inline ReturnType operator()( size_t i, size_t j ) const {
134  BLAZE_INTERNAL_ASSERT( i < sm_.rows() , "Invalid row access index" );
135  BLAZE_INTERNAL_ASSERT( j < sm_.columns(), "Invalid column access index" );
136  return sm_(i,j);
137  }
138  //**********************************************************************************************
139 
140  //**Rows function*******************************************************************************
145  inline size_t rows() const {
146  return sm_.rows();
147  }
148  //**********************************************************************************************
149 
150  //**Columns function****************************************************************************
155  inline size_t columns() const {
156  return sm_.columns();
157  }
158  //**********************************************************************************************
159 
160  //**NonZeros function***************************************************************************
165  inline size_t nonZeros() const {
166  return sm_.nonZeros();
167  }
168  //**********************************************************************************************
169 
170  //**NonZeros function***************************************************************************
176  inline size_t nonZeros( size_t i ) const {
177  return sm_.nonZeros(i);
178  }
179  //**********************************************************************************************
180 
181  //**Operand access******************************************************************************
186  inline Operand operand() const {
187  return sm_;
188  }
189  //**********************************************************************************************
190 
191  //**Conversion operator*************************************************************************
196  inline operator Operand() const {
197  return sm_;
198  }
199  //**********************************************************************************************
200 
201  //**********************************************************************************************
207  template< typename T >
208  inline bool canAlias( const T* alias ) const {
209  return sm_.canAlias( alias );
210  }
211  //**********************************************************************************************
212 
213  //**********************************************************************************************
219  template< typename T >
220  inline bool isAliased( const T* alias ) const {
221  return sm_.isAliased( alias );
222  }
223  //**********************************************************************************************
224 
225  //**********************************************************************************************
230  inline bool canSMPAssign() const {
231  return sm_.canSMPAssign();
232  }
233  //**********************************************************************************************
234 
235  private:
236  //**Member variables****************************************************************************
238  //**********************************************************************************************
239 
240  //**Assignment to dense matrices****************************************************************
252  template< typename MT2 // Type of the target dense matrix
253  , bool SO2 > // Storage order of the target dense matrix
254  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
255  {
257 
258  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
259  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
260 
261  assign( ~lhs, rhs.sm_ );
262  }
264  //**********************************************************************************************
265 
266  //**Assignment to sparse matrices***************************************************************
278  template< typename MT2 // Type of the target sparse matrix
279  , bool SO2 > // Storage order of the target sparse matrix
280  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
281  {
283 
284  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
285  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
286 
287  assign( ~lhs, rhs.sm_ );
288  }
290  //**********************************************************************************************
291 
292  //**Addition assignment to dense matrices*******************************************************
304  template< typename MT2 // Type of the target dense matrix
305  , bool SO2 > // Storage order of the target dense matrix
306  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
307  {
309 
310  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
311  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
312 
313  addAssign( ~lhs, rhs.sm_ );
314  }
316  //**********************************************************************************************
317 
318  //**Addition assignment to sparse matrices******************************************************
330  template< typename MT2 // Type of the target sparse matrix
331  , bool SO2 > // Storage order of the target sparse matrix
332  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
333  {
335 
336  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
337  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
338 
339  addAssign( ~lhs, rhs.sm_ );
340  }
342  //**********************************************************************************************
343 
344  //**Subtraction assignment to dense matrices****************************************************
357  template< typename MT2 // Type of the target dense matrix
358  , bool SO2 > // Storage order of the target dense matrix
359  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
360  {
362 
363  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
364  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
365 
366  subAssign( ~lhs, rhs.sm_ );
367  }
369  //**********************************************************************************************
370 
371  //**Subtraction assignment to sparse matrices***************************************************
384  template< typename MT2 // Type of the target sparse matrix
385  , bool SO2 > // Storage order of the target sparse matrix
386  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
387  {
389 
390  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
391  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
392 
393  subAssign( ~lhs, rhs.sm_ );
394  }
396  //**********************************************************************************************
397 
398  //**Multiplication assignment to dense matrices*************************************************
411  template< typename MT2 // Type of the target dense matrix
412  , bool SO2 > // Storage order of the target dense matrix
413  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
414  {
416 
417  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
418  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
419 
420  multAssign( ~lhs, rhs.sm_ );
421  }
423  //**********************************************************************************************
424 
425  //**Multiplication assignment to sparse matrices************************************************
438  template< typename MT2 // Type of the target sparse matrix
439  , bool SO2 > // Storage order of the target sparse matrix
440  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
441  {
443 
444  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
445  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
446 
447  multAssign( ~lhs, rhs.sm_ );
448  }
450  //**********************************************************************************************
451 
452  //**SMP assignment to dense matrices************************************************************
464  template< typename MT2 // Type of the target dense matrix
465  , bool SO2 > // Storage order of the target dense matrix
466  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
467  {
469 
470  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
471  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
472 
473  assign( ~lhs, rhs.sm_ );
474  }
476  //**********************************************************************************************
477 
478  //**SMP assignment to sparse matrices***********************************************************
490  template< typename MT2 // Type of the target sparse matrix
491  , bool SO2 > // Storage order of the target sparse matrix
492  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
493  {
495 
496  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
497  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
498 
499  assign( ~lhs, rhs.sm_ );
500  }
502  //**********************************************************************************************
503 
504  //**SMP addition assignment to dense matrices***************************************************
517  template< typename MT2 // Type of the target dense matrix
518  , bool SO2 > // Storage order of the target dense matrix
519  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
520  {
522 
523  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
524  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
525 
526  addAssign( ~lhs, rhs.sm_ );
527  }
529  //**********************************************************************************************
530 
531  //**SMP addition assignment to sparse matrices**************************************************
544  template< typename MT2 // Type of the target sparse matrix
545  , bool SO2 > // Storage order of the target sparse matrix
546  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
547  {
549 
550  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
551  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
552 
553  addAssign( ~lhs, rhs.sm_ );
554  }
556  //**********************************************************************************************
557 
558  //**SMP subtraction assignment to dense matrices************************************************
571  template< typename MT2 // Type of the target dense matrix
572  , bool SO2 > // Storage order of the target dense matrix
573  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
574  {
576 
577  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
578  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
579 
580  subAssign( ~lhs, rhs.sm_ );
581  }
583  //**********************************************************************************************
584 
585  //**SMP subtraction assignment to sparse matrices***********************************************
598  template< typename MT2 // Type of the target sparse matrix
599  , bool SO2 > // Storage order of the target sparse matrix
600  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
601  {
603 
604  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
605  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
606 
607  subAssign( ~lhs, rhs.sm_ );
608  }
610  //**********************************************************************************************
611 
612  //**SMP multiplication assignment to dense matrices*********************************************
625  template< typename MT2 // Type of the target dense matrix
626  , bool SO2 > // Storage order of the target dense matrix
627  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
628  {
630 
631  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
632  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
633 
634  multAssign( ~lhs, rhs.sm_ );
635  }
637  //**********************************************************************************************
638 
639  //**SMP multiplication assignment to sparse matrices********************************************
652  template< typename MT2 // Type of the target sparse matrix
653  , bool SO2 > // Storage order of the target sparse matrix
654  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
655  {
657 
658  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
659  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
660 
661  multAssign( ~lhs, rhs.sm_ );
662  }
664  //**********************************************************************************************
665 
666  //**Compile time checks*************************************************************************
671  //**********************************************************************************************
672 };
673 //*************************************************************************************************
674 
675 
676 
677 
678 //=================================================================================================
679 //
680 // GLOBAL FUNCTIONS
681 //
682 //=================================================================================================
683 
684 //*************************************************************************************************
701 template< typename MT // Type of the sparse matrix
702  , bool SO > // Storage order
704 {
706 
707  return SMatSerialExpr<MT,SO>( ~sm );
708 }
709 //*************************************************************************************************
710 
711 
712 
713 
714 //=================================================================================================
715 //
716 // GLOBAL RESTRUCTURING FUNCTIONS
717 //
718 //=================================================================================================
719 
720 //*************************************************************************************************
731 template< typename MT // Type of the sparse matrix
732  , bool SO > // Storage order
733 inline const SMatSerialExpr<MT,SO> serial( const SMatSerialExpr<MT,SO>& sm )
734 {
735  return sm;
736 }
738 //*************************************************************************************************
739 
740 
741 
742 
743 //=================================================================================================
744 //
745 // ROWS SPECIALIZATIONS
746 //
747 //=================================================================================================
748 
749 //*************************************************************************************************
751 template< typename MT, bool SO >
752 struct Rows< SMatSerialExpr<MT,SO> > : public Rows<MT>
753 {};
755 //*************************************************************************************************
756 
757 
758 
759 
760 //=================================================================================================
761 //
762 // COLUMNS SPECIALIZATIONS
763 //
764 //=================================================================================================
765 
766 //*************************************************************************************************
768 template< typename MT, bool SO >
769 struct Columns< SMatSerialExpr<MT,SO> > : public Columns<MT>
770 {};
772 //*************************************************************************************************
773 
774 
775 
776 
777 //=================================================================================================
778 //
779 // ISSYMMETRIC SPECIALIZATIONS
780 //
781 //=================================================================================================
782 
783 //*************************************************************************************************
785 template< typename MT, bool SO >
786 struct IsSymmetric< SMatSerialExpr<MT,SO> > : public IsTrue< IsSymmetric<MT>::value >
787 {};
789 //*************************************************************************************************
790 
791 
792 
793 
794 //=================================================================================================
795 //
796 // ISLOWER SPECIALIZATIONS
797 //
798 //=================================================================================================
799 
800 //*************************************************************************************************
802 template< typename MT, bool SO >
803 struct IsLower< SMatSerialExpr<MT,SO> > : public IsTrue< IsLower<MT>::value >
804 {};
806 //*************************************************************************************************
807 
808 
809 
810 
811 //=================================================================================================
812 //
813 // ISUPPER SPECIALIZATIONS
814 //
815 //=================================================================================================
816 
817 //*************************************************************************************************
819 template< typename MT, bool SO >
820 struct IsUpper< SMatSerialExpr<MT,SO> > : public IsTrue< IsUpper<MT>::value >
821 {};
823 //*************************************************************************************************
824 
825 
826 
827 
828 //=================================================================================================
829 //
830 // EXPRESSION TRAIT SPECIALIZATIONS
831 //
832 //=================================================================================================
833 
834 //*************************************************************************************************
836 template< typename MT >
837 struct SMatSerialExprTrait< SMatSerialExpr<MT,false> >
838 {
839  public:
840  //**********************************************************************************************
841  typedef typename SelectType< IsSparseMatrix<MT>::value && IsRowMajorMatrix<MT>::value
842  , SMatSerialExpr<MT,false>
843  , INVALID_TYPE >::Type Type;
844  //**********************************************************************************************
845 };
847 //*************************************************************************************************
848 
849 
850 //*************************************************************************************************
852 template< typename MT >
853 struct TSMatSerialExprTrait< SMatSerialExpr<MT,true> >
854 {
855  public:
856  //**********************************************************************************************
857  typedef typename SelectType< IsSparseMatrix<MT>::value && IsColumnMajorMatrix<MT>::value
858  , SMatSerialExpr<MT,true>
859  , INVALID_TYPE >::Type Type;
860  //**********************************************************************************************
861 };
863 //*************************************************************************************************
864 
865 
866 //*************************************************************************************************
868 template< typename MT, bool SO, bool AF >
869 struct SubmatrixExprTrait< SMatSerialExpr<MT,SO>, AF >
870 {
871  public:
872  //**********************************************************************************************
873  typedef typename SerialExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
874  //**********************************************************************************************
875 };
877 //*************************************************************************************************
878 
879 
880 //*************************************************************************************************
882 template< typename MT, bool SO >
883 struct RowExprTrait< SMatSerialExpr<MT,SO> >
884 {
885  public:
886  //**********************************************************************************************
887  typedef typename SerialExprTrait< typename RowExprTrait<const MT>::Type >::Type Type;
888  //**********************************************************************************************
889 };
891 //*************************************************************************************************
892 
893 
894 //*************************************************************************************************
896 template< typename MT, bool SO >
897 struct ColumnExprTrait< SMatSerialExpr<MT,SO> >
898 {
899  public:
900  //**********************************************************************************************
901  typedef typename SerialExprTrait< typename ColumnExprTrait<const MT>::Type >::Type Type;
902  //**********************************************************************************************
903 };
905 //*************************************************************************************************
906 
907 } // namespace blaze
908 
909 #endif
BLAZE_ALWAYS_INLINE void multAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the multiplication assignment of a matrix to a matrix.
Definition: Matrix.h:879
Header file for the Rows type trait.
Header file for the SMatSerialExprTrait class template.
Header file for the IsSparseMatrix type trait.
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in...
Definition: StorageOrder.h:242
SMatSerialExpr(const MT &sm)
Constructor for the SMatSerialExpr class.
Definition: SMatSerialExpr.h:121
Header file for the ColumnExprTrait class template.
SMatSerialExpr< MT, SO > This
Type of this SMatSerialExpr instance.
Definition: SMatSerialExpr.h:97
Header file for the IsColumnMajorMatrix type trait.
MT::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatSerialExpr.h:100
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatSerialExpr.h:155
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:695
Header file for the Computation base class.
MT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: SMatSerialExpr.h:102
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2474
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:107
Constraint on the data type.
Header file for the TSMatSerialExprTrait class template.
Header file for the SparseMatrix base class.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: SMatSerialExpr.h:230
Constraint on the data type.
Operand operand() const
Returns the sparse matrix operand.
Definition: SMatSerialExpr.h:186
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatSerialExpr.h:208
Header file for the IsSymmetric type trait.
MT::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatSerialExpr.h:99
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatSerialExpr.h:105
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatSerialExpr.h:165
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatSerialExpr.h:145
BLAZE_ALWAYS_INLINE 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:635
Header file for the Columns type trait.
MT::ResultType ResultType
Result type for expression template evaluations.
Definition: SMatSerialExpr.h:98
Header file for the IsLower type trait.
Header file for the SerialExprTrait class template.
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2475
Constraints on the storage order of matrix types.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2476
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Header file for the MatSerialExpr base class.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatSerialExpr.h:220
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type Operand
Composite data type of the sparse matrix expression.
Definition: SMatSerialExpr.h:108
EnableIf< IsDenseMatrix< MT1 > >::Type smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
Header file for the SubmatrixExprTrait class template.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2477
Header file for run time assertion macros.
EnableIf< IsDenseMatrix< MT1 > >::Type 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
Utility type for generic codes.
BLAZE_ALWAYS_INLINE 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:742
MT::ElementType ElementType
Resulting element type.
Definition: SMatSerialExpr.h:101
Header file for the IsRowMajorMatrix type trait.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
#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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatSerialExpr.h:133
Operand sm_
Sparse matrix of the serial evaluation expression.
Definition: SMatSerialExpr.h:237
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2473
Header file for the IsTrue value trait.
Header file for basic type definitions.
Header file for the IsUpper type trait.
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatSerialExpr.h:176
Expression object for the forced serial evaluation of sparse matrices.The SMatSerialExpr class repres...
Definition: Forward.h:95
EnableIf< IsDenseVector< VT1 > >::Type smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
Default implementation of the SMP multiplication assignment of a vector to a dense vector...
Definition: DenseVector.h:189
#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
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
BLAZE_ALWAYS_INLINE 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:849