SMatEvalExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATEVALEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATEVALEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
46 #include <blaze/math/Exception.h>
61 #include <blaze/util/Assert.h>
63 #include <blaze/util/mpl/If.h>
64 #include <blaze/util/Types.h>
65 
66 
67 namespace blaze {
68 
69 //=================================================================================================
70 //
71 // CLASS SMATEVALEXPR
72 //
73 //=================================================================================================
74 
75 //*************************************************************************************************
82 template< typename MT // Type of the sparse matrix
83  , bool SO > // Storage order
84 class SMatEvalExpr
85  : public MatEvalExpr< SparseMatrix< SMatEvalExpr<MT,SO>, SO > >
86  , private Computation
87 {
88  public:
89  //**Type definitions****************************************************************************
96 
98  using CompositeType = const ResultType;
99 
101  using Operand = If_< IsExpression<MT>, const MT, const MT& >;
102  //**********************************************************************************************
103 
104  //**Compilation flags***************************************************************************
106  enum : bool { smpAssignable = MT::smpAssignable };
107  //**********************************************************************************************
108 
109  //**Constructor*********************************************************************************
114  explicit inline SMatEvalExpr( const MT& sm ) noexcept
115  : sm_( sm ) // Sparse matrix of the evaluation expression
116  {}
117  //**********************************************************************************************
118 
119  //**Access operator*****************************************************************************
126  inline ReturnType operator()( size_t i, size_t j ) const {
127  BLAZE_INTERNAL_ASSERT( i < sm_.rows() , "Invalid row access index" );
128  BLAZE_INTERNAL_ASSERT( j < sm_.columns(), "Invalid column access index" );
129  return sm_(i,j);
130  }
131  //**********************************************************************************************
132 
133  //**At function*********************************************************************************
141  inline ReturnType at( size_t i, size_t j ) const {
142  if( i >= sm_.rows() ) {
143  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
144  }
145  if( j >= sm_.columns() ) {
146  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
147  }
148  return (*this)(i,j);
149  }
150  //**********************************************************************************************
151 
152  //**Rows function*******************************************************************************
157  inline size_t rows() const noexcept {
158  return sm_.rows();
159  }
160  //**********************************************************************************************
161 
162  //**Columns function****************************************************************************
167  inline size_t columns() const noexcept {
168  return sm_.columns();
169  }
170  //**********************************************************************************************
171 
172  //**NonZeros function***************************************************************************
177  inline size_t nonZeros() const {
178  return sm_.nonZeros();
179  }
180  //**********************************************************************************************
181 
182  //**NonZeros function***************************************************************************
188  inline size_t nonZeros( size_t i ) const {
189  return sm_.nonZeros(i);
190  }
191  //**********************************************************************************************
192 
193  //**Operand access******************************************************************************
198  inline Operand operand() const noexcept {
199  return sm_;
200  }
201  //**********************************************************************************************
202 
203  //**********************************************************************************************
209  template< typename T >
210  inline bool canAlias( const T* alias ) const noexcept {
211  return sm_.canAlias( alias );
212  }
213  //**********************************************************************************************
214 
215  //**********************************************************************************************
221  template< typename T >
222  inline bool isAliased( const T* alias ) const noexcept {
223  return sm_.isAliased( alias );
224  }
225  //**********************************************************************************************
226 
227  //**********************************************************************************************
232  inline bool canSMPAssign() const noexcept {
233  return sm_.canSMPAssign();
234  }
235  //**********************************************************************************************
236 
237  private:
238  //**Member variables****************************************************************************
240  //**********************************************************************************************
241 
242  //**Assignment to dense matrices****************************************************************
254  template< typename MT2 // Type of the target dense matrix
255  , bool SO2 > // Storage order of the target dense matrix
256  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
257  {
259 
260  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
261  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
262 
263  assign( ~lhs, rhs.sm_ );
264  }
266  //**********************************************************************************************
267 
268  //**Assignment to sparse matrices***************************************************************
280  template< typename MT2 // Type of the target sparse matrix
281  , bool SO2 > // Storage order of the target sparse matrix
282  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
283  {
285 
286  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
287  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
288 
289  assign( ~lhs, rhs.sm_ );
290  }
292  //**********************************************************************************************
293 
294  //**Addition assignment to dense matrices*******************************************************
306  template< typename MT2 // Type of the target dense matrix
307  , bool SO2 > // Storage order of the target dense matrix
308  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
309  {
311 
312  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
313  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
314 
315  addAssign( ~lhs, rhs.sm_ );
316  }
318  //**********************************************************************************************
319 
320  //**Addition assignment to sparse matrices******************************************************
332  template< typename MT2 // Type of the target sparse matrix
333  , bool SO2 > // Storage order of the target sparse matrix
334  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
335  {
337 
338  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
339  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
340 
341  addAssign( ~lhs, rhs.sm_ );
342  }
344  //**********************************************************************************************
345 
346  //**Subtraction assignment to dense matrices****************************************************
358  template< typename MT2 // Type of the target dense matrix
359  , bool SO2 > // Storage order of the target dense matrix
360  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
361  {
363 
364  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
365  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
366 
367  subAssign( ~lhs, rhs.sm_ );
368  }
370  //**********************************************************************************************
371 
372  //**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 SMatEvalExpr& 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  //**Schur product assignment to dense matrices**************************************************
410  template< typename MT2 // Type of the target dense matrix
411  , bool SO2 > // Storage order of the target dense matrix
412  friend inline void schurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
413  {
415 
416  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
417  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
418 
419  schurAssign( ~lhs, rhs.sm_ );
420  }
422  //**********************************************************************************************
423 
424  //**Schur product assignment to sparse matrices*************************************************
436  template< typename MT2 // Type of the target sparse matrix
437  , bool SO2 > // Storage order of the target sparse matrix
438  friend inline void schurAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& 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 
445  schurAssign( ~lhs, rhs.sm_ );
446  }
448  //**********************************************************************************************
449 
450  //**Multiplication assignment to dense matrices*************************************************
462  template< typename MT2 // Type of the target dense matrix
463  , bool SO2 > // Storage order of the target dense matrix
464  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
465  {
467 
468  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
469  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
470 
471  multAssign( ~lhs, rhs.sm_ );
472  }
474  //**********************************************************************************************
475 
476  //**Multiplication assignment to sparse matrices************************************************
488  template< typename MT2 // Type of the target sparse matrix
489  , bool SO2 > // Storage order of the target sparse matrix
490  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
491  {
493 
494  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
495  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
496 
497  multAssign( ~lhs, rhs.sm_ );
498  }
500  //**********************************************************************************************
501 
502  //**SMP assignment to dense matrices************************************************************
514  template< typename MT2 // Type of the target dense matrix
515  , bool SO2 > // Storage order of the target dense matrix
516  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
517  {
519 
520  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
521  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
522 
523  smpAssign( ~lhs, rhs.sm_ );
524  }
526  //**********************************************************************************************
527 
528  //**SMP assignment to sparse matrices***********************************************************
540  template< typename MT2 // Type of the target sparse matrix
541  , bool SO2 > // Storage order of the target sparse matrix
542  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
543  {
545 
546  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
547  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
548 
549  smpAssign( ~lhs, rhs.sm_ );
550  }
552  //**********************************************************************************************
553 
554  //**SMP addition assignment to dense matrices***************************************************
566  template< typename MT2 // Type of the target dense matrix
567  , bool SO2 > // Storage order of the target dense matrix
568  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
569  {
571 
572  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
573  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
574 
575  smpAddAssign( ~lhs, rhs.sm_ );
576  }
578  //**********************************************************************************************
579 
580  //**SMP addition assignment to sparse matrices**************************************************
592  template< typename MT2 // Type of the target sparse matrix
593  , bool SO2 > // Storage order of the target sparse matrix
594  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
595  {
597 
598  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
599  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
600 
601  smpAddAssign( ~lhs, rhs.sm_ );
602  }
604  //**********************************************************************************************
605 
606  //**SMP subtraction assignment to dense matrices************************************************
618  template< typename MT2 // Type of the target dense matrix
619  , bool SO2 > // Storage order of the target dense matrix
620  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
621  {
623 
624  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
625  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
626 
627  smpSubAssign( ~lhs, rhs.sm_ );
628  }
630  //**********************************************************************************************
631 
632  //**SMP subtraction assignment to sparse matrices***********************************************
644  template< typename MT2 // Type of the target sparse matrix
645  , bool SO2 > // Storage order of the target sparse matrix
646  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
647  {
649 
650  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
651  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
652 
653  smpSubAssign( ~lhs, rhs.sm_ );
654  }
656  //**********************************************************************************************
657 
658  //**SMP Schur product assignment to dense matrices**********************************************
671  template< typename MT2 // Type of the target dense matrix
672  , bool SO2 > // Storage order of the target dense matrix
673  friend inline void smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
674  {
676 
677  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
678  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
679 
680  smpSchurAssign( ~lhs, rhs.sm_ );
681  }
683  //**********************************************************************************************
684 
685  //**SMP Schur product assignment to sparse matrices*********************************************
698  template< typename MT2 // Type of the target sparse matrix
699  , bool SO2 > // Storage order of the target sparse matrix
700  friend inline void smpSchurAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
701  {
703 
704  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
705  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
706 
707  smpSchurAssign( ~lhs, rhs.sm_ );
708  }
710  //**********************************************************************************************
711 
712  //**SMP multiplication assignment to dense matrices*********************************************
725  template< typename MT2 // Type of the target dense matrix
726  , bool SO2 > // Storage order of the target dense matrix
727  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
728  {
730 
731  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
732  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
733 
734  smpMultAssign( ~lhs, rhs.sm_ );
735  }
737  //**********************************************************************************************
738 
739  //**SMP multiplication assignment to sparse matrices********************************************
752  template< typename MT2 // Type of the target sparse matrix
753  , bool SO2 > // Storage order of the target sparse matrix
754  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
755  {
757 
758  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
759  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
760 
761  smpMultAssign( ~lhs, rhs.sm_ );
762  }
764  //**********************************************************************************************
765 
766  //**Compile time checks*************************************************************************
771  //**********************************************************************************************
772 };
773 //*************************************************************************************************
774 
775 
776 
777 
778 //=================================================================================================
779 //
780 // GLOBAL FUNCTIONS
781 //
782 //=================================================================================================
783 
784 //*************************************************************************************************
801 template< typename MT // Type of the sparse matrix
802  , bool SO > // Storage order
803 inline decltype(auto) eval( const SparseMatrix<MT,SO>& sm )
804 {
806 
807  using ReturnType = const SMatEvalExpr<MT,SO>;
808  return ReturnType( ~sm );
809 }
810 //*************************************************************************************************
811 
812 
813 
814 
815 //=================================================================================================
816 //
817 // GLOBAL RESTRUCTURING FUNCTIONS
818 //
819 //=================================================================================================
820 
821 //*************************************************************************************************
832 template< typename MT // Type of the sparse matrix
833  , bool SO > // Storage order
834 inline decltype(auto) eval( const SMatEvalExpr<MT,SO>& sm )
835 {
836  return sm;
837 }
839 //*************************************************************************************************
840 
841 
842 
843 
844 //=================================================================================================
845 //
846 // SIZE SPECIALIZATIONS
847 //
848 //=================================================================================================
849 
850 //*************************************************************************************************
852 template< typename MT, bool SO >
853 struct Size< SMatEvalExpr<MT,SO>, 0UL >
854  : public Size<MT,0UL>
855 {};
856 
857 template< typename MT, bool SO >
858 struct Size< SMatEvalExpr<MT,SO>, 1UL >
859  : public Size<MT,1UL>
860 {};
862 //*************************************************************************************************
863 
864 
865 
866 
867 //=================================================================================================
868 //
869 // ISSYMMETRIC SPECIALIZATIONS
870 //
871 //=================================================================================================
872 
873 //*************************************************************************************************
875 template< typename MT, bool SO >
876 struct IsSymmetric< SMatEvalExpr<MT,SO> >
877  : public IsSymmetric<MT>
878 {};
880 //*************************************************************************************************
881 
882 
883 
884 
885 //=================================================================================================
886 //
887 // ISHERMITIAN SPECIALIZATIONS
888 //
889 //=================================================================================================
890 
891 //*************************************************************************************************
893 template< typename MT, bool SO >
894 struct IsHermitian< SMatEvalExpr<MT,SO> >
895  : public IsHermitian<MT>
896 {};
898 //*************************************************************************************************
899 
900 
901 
902 
903 //=================================================================================================
904 //
905 // ISLOWER SPECIALIZATIONS
906 //
907 //=================================================================================================
908 
909 //*************************************************************************************************
911 template< typename MT, bool SO >
912 struct IsLower< SMatEvalExpr<MT,SO> >
913  : public IsLower<MT>
914 {};
916 //*************************************************************************************************
917 
918 
919 
920 
921 //=================================================================================================
922 //
923 // ISUNILOWER SPECIALIZATIONS
924 //
925 //=================================================================================================
926 
927 //*************************************************************************************************
929 template< typename MT, bool SO >
930 struct IsUniLower< SMatEvalExpr<MT,SO> >
931  : public IsUniLower<MT>
932 {};
934 //*************************************************************************************************
935 
936 
937 
938 
939 //=================================================================================================
940 //
941 // ISSTRICTLYLOWER SPECIALIZATIONS
942 //
943 //=================================================================================================
944 
945 //*************************************************************************************************
947 template< typename MT, bool SO >
948 struct IsStrictlyLower< SMatEvalExpr<MT,SO> >
949  : public IsStrictlyLower<MT>
950 {};
952 //*************************************************************************************************
953 
954 
955 
956 
957 //=================================================================================================
958 //
959 // ISUPPER SPECIALIZATIONS
960 //
961 //=================================================================================================
962 
963 //*************************************************************************************************
965 template< typename MT, bool SO >
966 struct IsUpper< SMatEvalExpr<MT,SO> >
967  : public IsUpper<MT>
968 {};
970 //*************************************************************************************************
971 
972 
973 
974 
975 //=================================================================================================
976 //
977 // ISUNIUPPER SPECIALIZATIONS
978 //
979 //=================================================================================================
980 
981 //*************************************************************************************************
983 template< typename MT, bool SO >
984 struct IsUniUpper< SMatEvalExpr<MT,SO> >
985  : public IsUniUpper<MT>
986 {};
988 //*************************************************************************************************
989 
990 
991 
992 
993 //=================================================================================================
994 //
995 // ISSTRICTLYUPPER SPECIALIZATIONS
996 //
997 //=================================================================================================
998 
999 //*************************************************************************************************
1001 template< typename MT, bool SO >
1002 struct IsStrictlyUpper< SMatEvalExpr<MT,SO> >
1003  : public IsStrictlyUpper<MT>
1004 {};
1006 //*************************************************************************************************
1007 
1008 } // namespace blaze
1009 
1010 #endif
Header file for auxiliary alias declarations.
Header file for the IsUniUpper type trait.
EnableIf_< IsDenseMatrix< MT1 > > smpSchurAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP Schur product assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:196
Header file for basic type definitions.
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatEvalExpr.h:98
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: SMatEvalExpr.h:167
EnableIf_< IsDenseMatrix< MT1 > > 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:164
#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:63
EnableIf_< IsDenseVector< VT1 > > 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:193
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:87
Header file for the MatEvalExpr base class.
Header file for the Computation base class.
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:87
Header file for the IsUniLower type trait.
ElementType_< MT > ElementType
Resulting element type.
Definition: SMatEvalExpr.h:94
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:343
EnableIf_< IsDenseMatrix< MT1 > > 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:133
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: SMatEvalExpr.h:95
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:80
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:363
Header file for the SparseMatrix base class.
SMatEvalExpr(const MT &sm) noexcept
Constructor for the SMatEvalExpr class.
Definition: SMatEvalExpr.h:114
Constraint on the data type.
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
Header file for the If class template.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: SMatEvalExpr.h:210
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: SMatEvalExpr.h:222
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the sparse matrix expression.
Definition: SMatEvalExpr.h:101
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: SMatEvalExpr.h:141
EnableIf_< IsDenseMatrix< MT1 > > smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:102
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SMatEvalExpr.h:232
Header file for the IsLower type trait.
Operand operand() const noexcept
Returns the sparse matrix operand.
Definition: SMatEvalExpr.h:198
decltype(auto) eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:794
Constraints on the storage order of matrix types.
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
Header file for the exception macros of the math module.
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatEvalExpr.h:188
Header file for all forward declarations for expression class templates.
Header file for the IsStrictlyLower type trait.
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
Operand sm_
Sparse matrix of the evaluation expression.
Definition: SMatEvalExpr.h:239
OppositeType_< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatEvalExpr.h:92
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatEvalExpr.h:177
Header file for run time assertion macros.
ResultType_< MT > ResultType
Result type for expression template evaluations.
Definition: SMatEvalExpr.h:91
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:154
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatEvalExpr.h:126
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:263
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3080
Compile time evaluation of the size of vectors and matrices.The Size type trait evaluates the size of...
Definition: Size.h:80
TransposeType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: SMatEvalExpr.h:93
Expression object for the forced evaluation of sparse matrices.The SMatEvalExpr class represents the ...
Definition: Forward.h:111
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:423
Header file for the IsUpper type trait.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: SMatEvalExpr.h:157
Header file for the IsHermitian type trait.
Header file for the Size type trait.
#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:61
Header file for the IsExpression type trait class.
Header file for the function trace functionality.