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>
69 #include <blaze/util/Assert.h>
71 #include <blaze/util/InvalidType.h>
73 #include <blaze/util/SelectType.h>
74 #include <blaze/util/Types.h>
76 
77 
78 namespace blaze {
79 
80 //=================================================================================================
81 //
82 // CLASS SMATSERIALEXPR
83 //
84 //=================================================================================================
85 
86 //*************************************************************************************************
93 template< typename MT // Type of the sparse matrix
94  , bool SO > // Storage order
95 class SMatSerialExpr : public SparseMatrix< SMatSerialExpr<MT,SO>, SO >
96  , private MatSerialExpr
97  , private Computation
98 {
99  public:
100  //**Type definitions****************************************************************************
102  typedef typename MT::ResultType ResultType;
103  typedef typename MT::OppositeType OppositeType;
104  typedef typename MT::TransposeType TransposeType;
105  typedef typename MT::ElementType ElementType;
106  typedef typename MT::ReturnType ReturnType;
107 
109  typedef const ResultType CompositeType;
110 
112  typedef typename SelectType< IsExpression<MT>::value, const MT, const MT& >::Type Operand;
113  //**********************************************************************************************
114 
115  //**Compilation flags***************************************************************************
117  enum { smpAssignable = MT::smpAssignable };
118  //**********************************************************************************************
119 
120  //**Constructor*********************************************************************************
125  explicit inline SMatSerialExpr( const MT& sm )
126  : sm_( sm ) // Sparse matrix of the serial evaluation expression
127  {}
128  //**********************************************************************************************
129 
130  //**Access operator*****************************************************************************
137  inline ReturnType operator()( size_t i, size_t j ) const {
138  BLAZE_INTERNAL_ASSERT( i < sm_.rows() , "Invalid row access index" );
139  BLAZE_INTERNAL_ASSERT( j < sm_.columns(), "Invalid column access index" );
140  return sm_(i,j);
141  }
142  //**********************************************************************************************
143 
144  //**Rows function*******************************************************************************
149  inline size_t rows() const {
150  return sm_.rows();
151  }
152  //**********************************************************************************************
153 
154  //**Columns function****************************************************************************
159  inline size_t columns() const {
160  return sm_.columns();
161  }
162  //**********************************************************************************************
163 
164  //**NonZeros function***************************************************************************
169  inline size_t nonZeros() const {
170  return sm_.nonZeros();
171  }
172  //**********************************************************************************************
173 
174  //**NonZeros function***************************************************************************
180  inline size_t nonZeros( size_t i ) const {
181  return sm_.nonZeros(i);
182  }
183  //**********************************************************************************************
184 
185  //**Operand access******************************************************************************
190  inline Operand operand() const {
191  return sm_;
192  }
193  //**********************************************************************************************
194 
195  //**Conversion operator*************************************************************************
200  inline operator Operand() const {
201  return sm_;
202  }
203  //**********************************************************************************************
204 
205  //**********************************************************************************************
211  template< typename T >
212  inline bool canAlias( const T* alias ) const {
213  return sm_.canAlias( alias );
214  }
215  //**********************************************************************************************
216 
217  //**********************************************************************************************
223  template< typename T >
224  inline bool isAliased( const T* alias ) const {
225  return sm_.isAliased( alias );
226  }
227  //**********************************************************************************************
228 
229  //**********************************************************************************************
234  inline bool canSMPAssign() const {
235  return sm_.canSMPAssign();
236  }
237  //**********************************************************************************************
238 
239  private:
240  //**Member variables****************************************************************************
241  Operand sm_;
242  //**********************************************************************************************
243 
244  //**Assignment to dense matrices****************************************************************
256  template< typename MT2 // Type of the target dense matrix
257  , bool SO2 > // Storage order of the target dense matrix
258  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
259  {
261 
262  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
263  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
264 
265  assign( ~lhs, rhs.sm_ );
266  }
268  //**********************************************************************************************
269 
270  //**Assignment to sparse matrices***************************************************************
282  template< typename MT2 // Type of the target sparse matrix
283  , bool SO2 > // Storage order of the target sparse matrix
284  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
285  {
287 
288  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
289  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
290 
291  assign( ~lhs, rhs.sm_ );
292  }
294  //**********************************************************************************************
295 
296  //**Addition assignment to dense matrices*******************************************************
308  template< typename MT2 // Type of the target dense matrix
309  , bool SO2 > // Storage order of the target dense matrix
310  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
311  {
313 
314  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
315  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
316 
317  addAssign( ~lhs, rhs.sm_ );
318  }
320  //**********************************************************************************************
321 
322  //**Addition assignment to sparse matrices******************************************************
334  template< typename MT2 // Type of the target sparse matrix
335  , bool SO2 > // Storage order of the target sparse matrix
336  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
337  {
339 
340  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
341  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
342 
343  addAssign( ~lhs, rhs.sm_ );
344  }
346  //**********************************************************************************************
347 
348  //**Subtraction assignment to dense matrices****************************************************
361  template< typename MT2 // Type of the target dense matrix
362  , bool SO2 > // Storage order of the target dense matrix
363  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
364  {
366 
367  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
368  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
369 
370  subAssign( ~lhs, rhs.sm_ );
371  }
373  //**********************************************************************************************
374 
375  //**Subtraction assignment to sparse matrices***************************************************
388  template< typename MT2 // Type of the target sparse matrix
389  , bool SO2 > // Storage order of the target sparse matrix
390  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
391  {
393 
394  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
395  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
396 
397  subAssign( ~lhs, rhs.sm_ );
398  }
400  //**********************************************************************************************
401 
402  //**Multiplication assignment to dense matrices*************************************************
415  template< typename MT2 // Type of the target dense matrix
416  , bool SO2 > // Storage order of the target dense matrix
417  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
418  {
420 
421  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
422  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
423 
424  multAssign( ~lhs, rhs.sm_ );
425  }
427  //**********************************************************************************************
428 
429  //**Multiplication assignment to sparse matrices************************************************
442  template< typename MT2 // Type of the target sparse matrix
443  , bool SO2 > // Storage order of the target sparse matrix
444  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
445  {
447 
448  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
449  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
450 
451  multAssign( ~lhs, rhs.sm_ );
452  }
454  //**********************************************************************************************
455 
456  //**SMP assignment to dense matrices************************************************************
468  template< typename MT2 // Type of the target dense matrix
469  , bool SO2 > // Storage order of the target dense matrix
470  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
471  {
473 
474  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
475  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
476 
477  assign( ~lhs, rhs.sm_ );
478  }
480  //**********************************************************************************************
481 
482  //**SMP assignment to sparse matrices***********************************************************
494  template< typename MT2 // Type of the target sparse matrix
495  , bool SO2 > // Storage order of the target sparse matrix
496  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& 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 
503  assign( ~lhs, rhs.sm_ );
504  }
506  //**********************************************************************************************
507 
508  //**SMP addition assignment to dense matrices***************************************************
521  template< typename MT2 // Type of the target dense matrix
522  , bool SO2 > // Storage order of the target dense matrix
523  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
524  {
526 
527  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
528  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
529 
530  addAssign( ~lhs, rhs.sm_ );
531  }
533  //**********************************************************************************************
534 
535  //**SMP addition assignment to sparse matrices**************************************************
548  template< typename MT2 // Type of the target sparse matrix
549  , bool SO2 > // Storage order of the target sparse matrix
550  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
551  {
553 
554  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
555  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
556 
557  addAssign( ~lhs, rhs.sm_ );
558  }
560  //**********************************************************************************************
561 
562  //**SMP subtraction assignment to dense matrices************************************************
575  template< typename MT2 // Type of the target dense matrix
576  , bool SO2 > // Storage order of the target dense matrix
577  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
578  {
580 
581  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
582  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
583 
584  subAssign( ~lhs, rhs.sm_ );
585  }
587  //**********************************************************************************************
588 
589  //**SMP subtraction assignment to sparse matrices***********************************************
602  template< typename MT2 // Type of the target sparse matrix
603  , bool SO2 > // Storage order of the target sparse matrix
604  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
605  {
607 
608  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
609  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
610 
611  subAssign( ~lhs, rhs.sm_ );
612  }
614  //**********************************************************************************************
615 
616  //**SMP multiplication assignment to dense matrices*********************************************
629  template< typename MT2 // Type of the target dense matrix
630  , bool SO2 > // Storage order of the target dense matrix
631  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
632  {
634 
635  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
636  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
637 
638  multAssign( ~lhs, rhs.sm_ );
639  }
641  //**********************************************************************************************
642 
643  //**SMP multiplication assignment to sparse matrices********************************************
656  template< typename MT2 // Type of the target sparse matrix
657  , bool SO2 > // Storage order of the target sparse matrix
658  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
659  {
661 
662  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
663  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
664 
665  multAssign( ~lhs, rhs.sm_ );
666  }
668  //**********************************************************************************************
669 
670  //**Compile time checks*************************************************************************
675  //**********************************************************************************************
676 };
677 //*************************************************************************************************
678 
679 
680 
681 
682 //=================================================================================================
683 //
684 // GLOBAL FUNCTIONS
685 //
686 //=================================================================================================
687 
688 //*************************************************************************************************
705 template< typename MT // Type of the sparse matrix
706  , bool SO > // Storage order
708 {
710 
711  return SMatSerialExpr<MT,SO>( ~sm );
712 }
713 //*************************************************************************************************
714 
715 
716 
717 
718 //=================================================================================================
719 //
720 // GLOBAL RESTRUCTURING FUNCTIONS
721 //
722 //=================================================================================================
723 
724 //*************************************************************************************************
735 template< typename MT // Type of the sparse matrix
736  , bool SO > // Storage order
737 inline const SMatSerialExpr<MT,SO> serial( const SMatSerialExpr<MT,SO>& sm )
738 {
739  return sm;
740 }
742 //*************************************************************************************************
743 
744 
745 
746 
747 //=================================================================================================
748 //
749 // ROWS SPECIALIZATIONS
750 //
751 //=================================================================================================
752 
753 //*************************************************************************************************
755 template< typename MT, bool SO >
756 struct Rows< SMatSerialExpr<MT,SO> > : public Rows<MT>
757 {};
759 //*************************************************************************************************
760 
761 
762 
763 
764 //=================================================================================================
765 //
766 // COLUMNS SPECIALIZATIONS
767 //
768 //=================================================================================================
769 
770 //*************************************************************************************************
772 template< typename MT, bool SO >
773 struct Columns< SMatSerialExpr<MT,SO> > : public Columns<MT>
774 {};
776 //*************************************************************************************************
777 
778 
779 
780 
781 //=================================================================================================
782 //
783 // ISSYMMETRIC SPECIALIZATIONS
784 //
785 //=================================================================================================
786 
787 //*************************************************************************************************
789 template< typename MT, bool SO >
790 struct IsSymmetric< SMatSerialExpr<MT,SO> > : public IsTrue< IsSymmetric<MT>::value >
791 {};
793 //*************************************************************************************************
794 
795 
796 
797 
798 //=================================================================================================
799 //
800 // ISLOWER SPECIALIZATIONS
801 //
802 //=================================================================================================
803 
804 //*************************************************************************************************
806 template< typename MT, bool SO >
807 struct IsLower< SMatSerialExpr<MT,SO> > : public IsTrue< IsLower<MT>::value >
808 {};
810 //*************************************************************************************************
811 
812 
813 
814 
815 //=================================================================================================
816 //
817 // ISUNILOWER SPECIALIZATIONS
818 //
819 //=================================================================================================
820 
821 //*************************************************************************************************
823 template< typename MT, bool SO >
824 struct IsUniLower< SMatSerialExpr<MT,SO> > : public IsTrue< IsUniLower<MT>::value >
825 {};
827 //*************************************************************************************************
828 
829 
830 
831 
832 //=================================================================================================
833 //
834 // ISSTRICTLYLOWER SPECIALIZATIONS
835 //
836 //=================================================================================================
837 
838 //*************************************************************************************************
840 template< typename MT, bool SO >
841 struct IsStrictlyLower< SMatSerialExpr<MT,SO> > : public IsTrue< IsStrictlyLower<MT>::value >
842 {};
844 //*************************************************************************************************
845 
846 
847 
848 
849 //=================================================================================================
850 //
851 // ISUPPER SPECIALIZATIONS
852 //
853 //=================================================================================================
854 
855 //*************************************************************************************************
857 template< typename MT, bool SO >
858 struct IsUpper< SMatSerialExpr<MT,SO> > : public IsTrue< IsUpper<MT>::value >
859 {};
861 //*************************************************************************************************
862 
863 
864 
865 
866 //=================================================================================================
867 //
868 // ISUNIUPPER SPECIALIZATIONS
869 //
870 //=================================================================================================
871 
872 //*************************************************************************************************
874 template< typename MT, bool SO >
875 struct IsUniUpper< SMatSerialExpr<MT,SO> > : public IsTrue< IsUniUpper<MT>::value >
876 {};
878 //*************************************************************************************************
879 
880 
881 
882 
883 //=================================================================================================
884 //
885 // ISSTRICTLYUPPER SPECIALIZATIONS
886 //
887 //=================================================================================================
888 
889 //*************************************************************************************************
891 template< typename MT, bool SO >
892 struct IsStrictlyUpper< SMatSerialExpr<MT,SO> > : public IsTrue< IsStrictlyUpper<MT>::value >
893 {};
895 //*************************************************************************************************
896 
897 
898 
899 
900 //=================================================================================================
901 //
902 // EXPRESSION TRAIT SPECIALIZATIONS
903 //
904 //=================================================================================================
905 
906 //*************************************************************************************************
908 template< typename MT >
909 struct SMatSerialExprTrait< SMatSerialExpr<MT,false> >
910 {
911  public:
912  //**********************************************************************************************
913  typedef typename SelectType< IsSparseMatrix<MT>::value && IsRowMajorMatrix<MT>::value
914  , SMatSerialExpr<MT,false>
915  , INVALID_TYPE >::Type Type;
916  //**********************************************************************************************
917 };
919 //*************************************************************************************************
920 
921 
922 //*************************************************************************************************
924 template< typename MT >
925 struct TSMatSerialExprTrait< SMatSerialExpr<MT,true> >
926 {
927  public:
928  //**********************************************************************************************
929  typedef typename SelectType< IsSparseMatrix<MT>::value && IsColumnMajorMatrix<MT>::value
930  , SMatSerialExpr<MT,true>
931  , INVALID_TYPE >::Type Type;
932  //**********************************************************************************************
933 };
935 //*************************************************************************************************
936 
937 
938 //*************************************************************************************************
940 template< typename MT, bool SO, bool AF >
941 struct SubmatrixExprTrait< SMatSerialExpr<MT,SO>, AF >
942 {
943  public:
944  //**********************************************************************************************
945  typedef typename SerialExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
946  //**********************************************************************************************
947 };
949 //*************************************************************************************************
950 
951 
952 //*************************************************************************************************
954 template< typename MT, bool SO >
955 struct RowExprTrait< SMatSerialExpr<MT,SO> >
956 {
957  public:
958  //**********************************************************************************************
959  typedef typename SerialExprTrait< typename RowExprTrait<const MT>::Type >::Type Type;
960  //**********************************************************************************************
961 };
963 //*************************************************************************************************
964 
965 
966 //*************************************************************************************************
968 template< typename MT, bool SO >
969 struct ColumnExprTrait< SMatSerialExpr<MT,SO> >
970 {
971  public:
972  //**********************************************************************************************
973  typedef typename SerialExprTrait< typename ColumnExprTrait<const MT>::Type >::Type Type;
974  //**********************************************************************************************
975 };
977 //*************************************************************************************************
978 
979 } // namespace blaze
980 
981 #endif
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatSerialExpr.h:137
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 IsUniUpper type trait.
Header file for basic type definitions.
SMatSerialExpr(const MT &sm)
Constructor for the SMatSerialExpr class.
Definition: SMatSerialExpr.h:125
Header file for the SMatSerialExprTrait class template.
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatSerialExpr.h:169
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
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type Operand
Composite data type of the sparse matrix expression.
Definition: SMatSerialExpr.h:112
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:699
Header file for the Computation base class.
MT::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatSerialExpr.h:104
Header file for the IsUniLower type trait.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2503
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.
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatSerialExpr.h:180
Header file for the TSMatSerialExprTrait class template.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: SMatSerialExpr.h:234
Header file for the SparseMatrix base class.
MT::ResultType ResultType
Result type for expression template evaluations.
Definition: SMatSerialExpr.h:102
Constraint on the data type.
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 IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatSerialExpr.h:149
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.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatSerialExpr.h:212
Header file for the IsLower type trait.
Header file for the SerialExprTrait class template.
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatSerialExpr.h:109
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2504
Constraints on the storage order of matrix types.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2505
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.
Header file for the IsStrictlyLower type trait.
Operand sm_
Sparse matrix of the serial evaluation expression.
Definition: SMatSerialExpr.h:241
MT::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatSerialExpr.h:103
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:2506
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:105
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatSerialExpr.h:224
Operand operand() const
Returns the sparse matrix operand.
Definition: SMatSerialExpr.h:190
MT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: SMatSerialExpr.h:106
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatSerialExpr.h:159
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
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2502
Header file for the IsTrue value trait.
Header file for the IsUpper type trait.
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
SMatSerialExpr< MT, SO > This
Type of this SMatSerialExpr instance.
Definition: SMatSerialExpr.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