SMatDeclLowExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATDECLLOWEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATDECLLOWEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <iterator>
44 #include <blaze/math/Aliases.h>
48 #include <blaze/math/Exception.h>
75 #include <blaze/util/Assert.h>
76 #include <blaze/util/DisableIf.h>
77 #include <blaze/util/EmptyType.h>
78 #include <blaze/util/EnableIf.h>
81 #include <blaze/util/InvalidType.h>
82 #include <blaze/util/mpl/And.h>
83 #include <blaze/util/mpl/If.h>
84 #include <blaze/util/mpl/Or.h>
85 #include <blaze/util/TrueType.h>
86 #include <blaze/util/Types.h>
88 
89 
90 namespace blaze {
91 
92 //=================================================================================================
93 //
94 // CLASS SMATDECLLOWEXPR
95 //
96 //=================================================================================================
97 
98 //*************************************************************************************************
105 template< typename MT // Type of the sparse matrix
106  , bool SO > // Storage order
107 class SMatDeclLowExpr : public SparseMatrix< SMatDeclLowExpr<MT,SO>, SO >
108  , private DeclLowExpr
109  , private If< IsComputation<MT>, Computation, EmptyType >::Type
110 {
111  private:
112  //**Serial evaluation strategy******************************************************************
114 
120  enum : bool { useAssign = RequiresEvaluation<MT>::value };
121 
123  template< typename MT2 >
125  struct UseAssign {
126  enum : bool { value = useAssign };
127  };
129  //**********************************************************************************************
130 
131  //**Parallel evaluation strategy****************************************************************
133 
138  template< typename MT2 >
139  struct UseSMPAssign {
140  enum : bool { value = MT2::smpAssignable && useAssign };
141  };
143  //**********************************************************************************************
144 
145  //**********************************************************************************************
147 
151  template< typename MT2 >
152  struct GetConstIterator {
154  struct Success { using Type = typename MT2::ConstIterator; };
155  struct Failure { using Type = INVALID_TYPE; };
156  using Type = typename If_< HasConstIterator<MT2>, Success, Failure >::Type;
157  };
159  //**********************************************************************************************
160 
161  public:
162  //**Type definitions****************************************************************************
169 
172 
174  typedef typename GetConstIterator<MT>::Type ConstIterator;
175 
177  typedef If_< IsExpression<MT>, const MT, const MT& > Operand;
178  //**********************************************************************************************
179 
180  //**Compilation flags***************************************************************************
182  enum : bool { smpAssignable = MT::smpAssignable };
183  //**********************************************************************************************
184 
185  //**Constructor*********************************************************************************
190  explicit inline SMatDeclLowExpr( const MT& sm ) noexcept
191  : sm_( sm ) // Sparse matrix of the decllow expression
192  {}
193  //**********************************************************************************************
194 
195  //**Access operator*****************************************************************************
202  inline ReturnType operator()( size_t i, size_t j ) const {
203  BLAZE_INTERNAL_ASSERT( i < sm_.rows() , "Invalid row access index" );
204  BLAZE_INTERNAL_ASSERT( j < sm_.columns(), "Invalid column access index" );
205  return sm_(i,j);
206  }
207  //**********************************************************************************************
208 
209  //**At function*********************************************************************************
217  inline ReturnType at( size_t i, size_t j ) const {
218  if( i >= sm_.rows() ) {
219  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
220  }
221  if( j >= sm_.columns() ) {
222  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
223  }
224  return (*this)(i,j);
225  }
226  //**********************************************************************************************
227 
228  //**Begin function******************************************************************************
234  inline ConstIterator begin( size_t i ) const {
235  return ConstIterator( sm_.begin(i) );
236  }
237  //**********************************************************************************************
238 
239  //**End function********************************************************************************
245  inline ConstIterator end( size_t i ) const {
246  return ConstIterator( sm_.end(i) );
247  }
248  //**********************************************************************************************
249 
250  //**Rows function*******************************************************************************
255  inline size_t rows() const noexcept {
256  return sm_.rows();
257  }
258  //**********************************************************************************************
259 
260  //**Columns function****************************************************************************
265  inline size_t columns() const noexcept {
266  return sm_.columns();
267  }
268  //**********************************************************************************************
269 
270  //**NonZeros function***************************************************************************
275  inline size_t nonZeros() const {
276  return sm_.nonZeros();
277  }
278  //**********************************************************************************************
279 
280  //**NonZeros function***************************************************************************
286  inline size_t nonZeros( size_t i ) const {
287  return sm_.nonZeros(i);
288  }
289  //**********************************************************************************************
290 
291  //**Operand access******************************************************************************
296  inline Operand operand() const noexcept {
297  return sm_;
298  }
299  //**********************************************************************************************
300 
301  //**********************************************************************************************
307  template< typename T >
308  inline bool canAlias( const T* alias ) const noexcept {
309  return sm_.canAlias( alias );
310  }
311  //**********************************************************************************************
312 
313  //**********************************************************************************************
319  template< typename T >
320  inline bool isAliased( const T* alias ) const noexcept {
321  return sm_.isAliased( alias );
322  }
323  //**********************************************************************************************
324 
325  //**********************************************************************************************
330  inline bool canSMPAssign() const noexcept {
331  return sm_.canSMPAssign();
332  }
333  //**********************************************************************************************
334 
335  private:
336  //**Member variables****************************************************************************
337  Operand sm_;
338  //**********************************************************************************************
339 
340  //**Assignment to dense matrices****************************************************************
352  template< typename MT2 // Type of the target dense matrix
353  , bool SO2 > // Storage order of the target dense matrix
354  friend inline EnableIf_< UseAssign<MT2> >
355  assign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
356  {
358 
359  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
360  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
361 
362  assign( ~lhs, rhs.sm_ );
363  }
365  //**********************************************************************************************
366 
367  //**Assignment to sparse matrices***************************************************************
379  template< typename MT2 // Type of the target sparse matrix
380  , bool SO2 > // Storage order of the target sparse matrix
381  friend inline EnableIf_< UseAssign<MT2> >
382  assign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
383  {
385 
386  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
387  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
388 
389  assign( ~lhs, rhs.sm_ );
390  }
392  //**********************************************************************************************
393 
394  //**Addition assignment to dense matrices*******************************************************
406  template< typename MT2 // Type of the target dense matrix
407  , bool SO2 > // Storage order of the target dense matrix
408  friend inline EnableIf_< UseAssign<MT2> >
409  addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
410  {
412 
413  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
414  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
415 
416  addAssign( ~lhs, rhs.sm_ );
417  }
419  //**********************************************************************************************
420 
421  //**Addition assignment to sparse matrices******************************************************
433  template< typename MT2 // Type of the target sparse matrix
434  , bool SO2 > // Storage order of the target sparse matrix
435  friend inline EnableIf_< UseAssign<MT2> >
436  addAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
437  {
439 
440  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
441  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
442 
443  addAssign( ~lhs, rhs.sm_ );
444  }
446  //**********************************************************************************************
447 
448  //**Subtraction assignment to dense matrices****************************************************
460  template< typename MT2 // Type of the target dense matrix
461  , bool SO2 > // Storage order of the target dense matrix
462  friend inline EnableIf_< UseAssign<MT2> >
463  subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
464  {
466 
467  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
468  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
469 
470  subAssign( ~lhs, rhs.sm_ );
471  }
473  //**********************************************************************************************
474 
475  //**Subtraction assignment to sparse matrices***************************************************
487  template< typename MT2 // Type of the target sparse matrix
488  , bool SO2 > // Storage order of the target sparse matrix
489  friend inline EnableIf_< UseAssign<MT2> >
490  subAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& 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  subAssign( ~lhs, rhs.sm_ );
498  }
500  //**********************************************************************************************
501 
502  //**Multiplication 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 EnableIf_< UseAssign<MT2> >
517  multAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
518  {
520 
521  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
522  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
523 
524  multAssign( ~lhs, rhs.sm_ );
525  }
527  //**********************************************************************************************
528 
529  //**Multiplication assignment to sparse matrices************************************************
541  template< typename MT2 // Type of the target sparse matrix
542  , bool SO2 > // Storage order of the target sparse matrix
543  friend inline EnableIf_< UseAssign<MT2> >
544  multAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
545  {
547 
548  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
549  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
550 
551  multAssign( ~lhs, rhs.sm_ );
552  }
554  //**********************************************************************************************
555 
556  //**SMP assignment to dense matrices************************************************************
568  template< typename MT2 // Type of the target dense matrix
569  , bool SO2 > // Storage order of the target dense matrix
570  friend inline EnableIf_< UseSMPAssign<MT2> >
572  {
574 
575  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
576  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
577 
578  smpAssign( ~lhs, rhs.sm_ );
579  }
581  //**********************************************************************************************
582 
583  //**SMP assignment to sparse matrices***********************************************************
595  template< typename MT2 // Type of the target sparse matrix
596  , bool SO2 > // Storage order of the target sparse matrix
597  friend inline EnableIf_< UseSMPAssign<MT2> >
599  {
601 
602  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
603  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
604 
605  smpAssign( ~lhs, rhs.sm_ );
606  }
608  //**********************************************************************************************
609 
610  //**SMP addition assignment to dense matrices***************************************************
622  template< typename MT2 // Type of the target dense matrix
623  , bool SO2 > // Storage order of the target dense matrix
624  friend inline EnableIf_< UseSMPAssign<MT2> >
626  {
628 
629  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
630  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
631 
632  smpAddAssign( ~lhs, rhs.sm_ );
633  }
635  //**********************************************************************************************
636 
637  //**SMP addition assignment to sparse matrices**************************************************
649  template< typename MT2 // Type of the target sparse matrix
650  , bool SO2 > // Storage order of the target sparse matrix
651  friend inline EnableIf_< UseSMPAssign<MT2> >
653  {
655 
656  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
657  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
658 
659  smpAddAssign( ~lhs, rhs.sm_ );
660  }
662  //**********************************************************************************************
663 
664  //**SMP subtraction assignment to dense matrices************************************************
676  template< typename MT2 // Type of the target dense matrix
677  , bool SO2 > // Storage order of the target dense matrix
678  friend inline EnableIf_< UseSMPAssign<MT2> >
680  {
682 
683  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
684  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
685 
686  smpSubAssign( ~lhs, rhs.sm_ );
687  }
689  //**********************************************************************************************
690 
691  //**SMP subtraction assignment to sparse matrices***********************************************
703  template< typename MT2 // Type of the target sparse matrix
704  , bool SO2 > // Storage order of the target sparse matrix
705  friend inline EnableIf_< UseSMPAssign<MT2> >
707  {
709 
710  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
711  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
712 
713  smpSubAssign( ~lhs, rhs.sm_ );
714  }
716  //**********************************************************************************************
717 
718  //**SMP multiplication assignment to dense matrices*********************************************
731  template< typename MT2 // Type of the target dense matrix
732  , bool SO2 > // Storage order of the target dense matrix
733  friend inline EnableIf_< UseSMPAssign<MT2> >
735  {
737 
738  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
739  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
740 
741  smpMultAssign( ~lhs, rhs.sm_ );
742  }
744  //**********************************************************************************************
745 
746  //**SMP multiplication assignment to sparse matrices********************************************
759  template< typename MT2 // Type of the target sparse matrix
760  , bool SO2 > // Storage order of the target sparse matrix
761  friend inline EnableIf_< UseSMPAssign<MT2> >
763  {
765 
766  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
767  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
768 
769  smpMultAssign( ~lhs, rhs.sm_ );
770  }
772  //**********************************************************************************************
773 
774  //**Compile time checks*************************************************************************
780  //**********************************************************************************************
781 };
782 //*************************************************************************************************
783 
784 
785 
786 
787 //=================================================================================================
788 //
789 // GLOBAL FUNCTIONS
790 //
791 //=================================================================================================
792 
793 //*************************************************************************************************
812 template< typename MT // Type of the sparse matrix
813  , bool SO > // Storage order
816 {
818 
819  if( !isSquare( ~sm ) ) {
820  BLAZE_THROW_INVALID_ARGUMENT( "Invalid lower matrix specification" );
821  }
822 
823  return SMatDeclLowExpr<MT,SO>( ~sm );
824 }
825 //*************************************************************************************************
826 
827 
828 //*************************************************************************************************
838 template< typename MT // Type of the sparse matrix
839  , bool SO > // Storage order
840 inline EnableIf_< IsLower<MT>, const MT& >
842 {
844 
845  return ~sm;
846 }
847 //*************************************************************************************************
848 
849 
850 
851 
852 //=================================================================================================
853 //
854 // GLOBAL RESTRUCTURING FUNCTIONS
855 //
856 //=================================================================================================
857 
858 //*************************************************************************************************
872 template< typename MT // Type of the left-hand side sparse matrix
873  , typename ST // Type of the right-hand side scalar value
874  , bool SO > // Storage order
875 inline const DisableIf_< IsLower<MT>, MultExprTrait_< DeclLowExprTrait_<MT>, ST > >
877 {
879 
880  if( !isSquare( ~sm ) ) {
881  BLAZE_THROW_INVALID_ARGUMENT( "Invalid lower matrix specification" );
882  }
883 
884  return decllow( sm.leftOperand() ) * sm.rightOperand();
885 }
887 //*************************************************************************************************
888 
889 
890 
891 
892 //=================================================================================================
893 //
894 // ROWS SPECIALIZATIONS
895 //
896 //=================================================================================================
897 
898 //*************************************************************************************************
900 template< typename MT, bool SO >
901 struct Rows< SMatDeclLowExpr<MT,SO> > : public Rows<MT>
902 {};
904 //*************************************************************************************************
905 
906 
907 
908 
909 //=================================================================================================
910 //
911 // COLUMNS SPECIALIZATIONS
912 //
913 //=================================================================================================
914 
915 //*************************************************************************************************
917 template< typename MT, bool SO >
918 struct Columns< SMatDeclLowExpr<MT,SO> > : public Columns<MT>
919 {};
921 //*************************************************************************************************
922 
923 
924 
925 
926 //=================================================================================================
927 //
928 // ISSYMMETRIC SPECIALIZATIONS
929 //
930 //=================================================================================================
931 
932 //*************************************************************************************************
934 template< typename MT, bool SO >
935 struct IsSymmetric< SMatDeclLowExpr<MT,SO> >
936  : public BoolConstant< IsSymmetric<MT>::value >
937 {};
939 //*************************************************************************************************
940 
941 
942 
943 
944 //=================================================================================================
945 //
946 // ISHERMITIAN SPECIALIZATIONS
947 //
948 //=================================================================================================
949 
950 //*************************************************************************************************
952 template< typename MT, bool SO >
953 struct IsHermitian< SMatDeclLowExpr<MT,SO> >
954  : public BoolConstant< IsHermitian<MT>::value >
955 {};
957 //*************************************************************************************************
958 
959 
960 
961 
962 //=================================================================================================
963 //
964 // ISLOWER SPECIALIZATIONS
965 //
966 //=================================================================================================
967 
968 //*************************************************************************************************
970 template< typename MT, bool SO >
971 struct IsLower< SMatDeclLowExpr<MT,SO> >
972  : public TrueType
973 {};
975 //*************************************************************************************************
976 
977 
978 
979 
980 //=================================================================================================
981 //
982 // ISUNILOWER SPECIALIZATIONS
983 //
984 //=================================================================================================
985 
986 //*************************************************************************************************
988 template< typename MT, bool SO >
989 struct IsUniLower< SMatDeclLowExpr<MT,SO> >
990  : public BoolConstant< IsUniLower<MT>::value >
991 {};
993 //*************************************************************************************************
994 
995 
996 
997 
998 //=================================================================================================
999 //
1000 // ISSTRICTLYLOWER SPECIALIZATIONS
1001 //
1002 //=================================================================================================
1003 
1004 //*************************************************************************************************
1006 template< typename MT, bool SO >
1007 struct IsStrictlyLower< SMatDeclLowExpr<MT,SO> >
1008  : public BoolConstant< IsStrictlyLower<MT>::value >
1009 {};
1011 //*************************************************************************************************
1012 
1013 
1014 
1015 
1016 //=================================================================================================
1017 //
1018 // ISUPPER SPECIALIZATIONS
1019 //
1020 //=================================================================================================
1021 
1022 //*************************************************************************************************
1024 template< typename MT, bool SO >
1025 struct IsUpper< SMatDeclLowExpr<MT,SO> >
1026  : public BoolConstant< Or< IsSymmetric<MT>, IsHermitian<MT>, IsUpper<MT> >::value >
1027 {};
1029 //*************************************************************************************************
1030 
1031 
1032 
1033 
1034 //=================================================================================================
1035 //
1036 // ISUNIUPPER SPECIALIZATIONS
1037 //
1038 //=================================================================================================
1039 
1040 //*************************************************************************************************
1042 template< typename MT, bool SO >
1043 struct IsUniUpper< SMatDeclLowExpr<MT,SO> >
1044  : public BoolConstant< IsUniUpper<MT>::value >
1045 {};
1047 //*************************************************************************************************
1048 
1049 
1050 
1051 
1052 //=================================================================================================
1053 //
1054 // ISSTRICTLYUPPER SPECIALIZATIONS
1055 //
1056 //=================================================================================================
1057 
1058 //*************************************************************************************************
1060 template< typename MT, bool SO >
1061 struct IsStrictlyUpper< SMatDeclLowExpr<MT,SO> >
1062  : public BoolConstant< IsStrictlyUpper<MT>::value >
1063 {};
1065 //*************************************************************************************************
1066 
1067 
1068 
1069 
1070 //=================================================================================================
1071 //
1072 // EXPRESSION TRAIT SPECIALIZATIONS
1073 //
1074 //=================================================================================================
1075 
1076 //*************************************************************************************************
1078 template< typename MT, typename ST >
1079 struct SMatDeclLowExprTrait< SMatScalarMultExpr<MT,ST,false> >
1080 {
1081  public:
1082  //**********************************************************************************************
1084  , MultExprTrait_< DeclLowExprTrait_<MT>, ST >
1085  , INVALID_TYPE >;
1086  //**********************************************************************************************
1087 };
1089 //*************************************************************************************************
1090 
1091 
1092 //*************************************************************************************************
1094 template< typename MT, typename ST >
1095 struct TSMatDeclLowExprTrait< SMatScalarMultExpr<MT,ST,true> >
1096 {
1097  public:
1098  //**********************************************************************************************
1100  , MultExprTrait_< DeclLowExprTrait_<MT>, ST >
1101  , INVALID_TYPE >;
1102  //**********************************************************************************************
1103 };
1105 //*************************************************************************************************
1106 
1107 
1108 //*************************************************************************************************
1110 template< typename MT, bool SO, bool AF >
1111 struct SubmatrixExprTrait< SMatDeclLowExpr<MT,SO>, AF >
1112 {
1113  public:
1114  //**********************************************************************************************
1115  using Type = SubmatrixExprTrait_<const MT,AF>;
1116  //**********************************************************************************************
1117 };
1119 //*************************************************************************************************
1120 
1121 
1122 //*************************************************************************************************
1124 template< typename MT, bool SO >
1125 struct RowExprTrait< SMatDeclLowExpr<MT,SO> >
1126 {
1127  public:
1128  //**********************************************************************************************
1129  using Type = RowExprTrait_<const MT>;
1130  //**********************************************************************************************
1131 };
1133 //*************************************************************************************************
1134 
1135 
1136 //*************************************************************************************************
1138 template< typename MT, bool SO >
1139 struct ColumnExprTrait< SMatDeclLowExpr<MT,SO> >
1140 {
1141  public:
1142  //**********************************************************************************************
1143  using Type = ColumnExprTrait_<const MT>;
1144  //**********************************************************************************************
1145 };
1147 //*************************************************************************************************
1148 
1149 } // namespace blaze
1150 
1151 #endif
typename SubmatrixExprTrait< MT, AF >::Type SubmatrixExprTrait_
Auxiliary alias declaration for the SubmatrixExprTrait type trait.The SubmatrixExprTrait_ alias decla...
Definition: SubmatrixExprTrait.h:134
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for auxiliary alias declarations.
Compile time check for numeric types.This type trait tests whether or not the given template paramete...
Definition: IsNumeric.h:79
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
RightOperand rightOperand() const noexcept
Returns the right-hand side scalar operand.
Definition: SMatScalarMultExpr.h:492
Header file for basic type definitions.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: SMatDeclLowExpr.h:308
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:160
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:63
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
LeftOperand leftOperand() const noexcept
Returns the left-hand side sparse matrix operand.
Definition: SMatScalarMultExpr.h:482
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
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:223
Header file for the And class template.
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
#define BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT(TYPE_TRAIT_NAME, MEMBER_NAME)
Macro for the creation of a type trait for compile time checks for member types.This macro creates th...
Definition: HasMember.h:182
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SMatDeclLowExpr.h:330
Expression object for the explicit lower declaration of sparse matrices.The SMatDeclLowExpr class rep...
Definition: Forward.h:97
Header file for the Computation base class.
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: SMatDeclLowExpr.h:217
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
Header file for the RequiresEvaluation type trait.
Constraint on the data type.
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the sparse matrix expression.
Definition: SMatDeclLowExpr.h:177
Header file for the IsUniLower type trait.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatDeclLowExpr.h:202
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
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:129
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:71
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:119
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row i.
Definition: SMatDeclLowExpr.h:245
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
Header file for the SparseMatrix base class.
Constraint on the data type.
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row i.
Definition: SMatDeclLowExpr.h:234
typename MultExprTrait< T1, T2 >::Type MultExprTrait_
Auxiliary alias declaration for the MultExprTrait class template.The MultExprTrait_ alias declaration...
Definition: MultExprTrait.h:344
Header file for the MultExprTrait class template.
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 DisableIf class template.
typename RowExprTrait< MT >::Type RowExprTrait_
Auxiliary alias declaration for the RowExprTrait type trait.The RowExprTrait_ alias declaration provi...
Definition: RowExprTrait.h:134
TransposeType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: SMatDeclLowExpr.h:166
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
Operand operand() const noexcept
Returns the sparse matrix operand.
Definition: SMatDeclLowExpr.h:296
Header file for the If class template.
Compile time check for row-major matrix types.This type trait tests whether or not the given template...
Definition: IsRowMajorMatrix.h:83
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2939
EnableIf_< IsDenseMatrix< MT1 > > smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:98
Header file for the Or class template.
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the Columns type trait.
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: SMatDeclLowExpr.h:255
Evaluation of the expression type type of a submatrix operation.Via this type trait it is possible to...
Definition: SubmatrixExprTrait.h:80
Header file for the IsLower type trait.
typename ColumnExprTrait< MT >::Type ColumnExprTrait_
Auxiliary alias declaration for the ColumnExprTrait type trait.The ColumnExprTrait_ alias declaration...
Definition: ColumnExprTrait.h:133
Header file for the SMatDeclLowExprTrait class template.
Constraints on the storage order of matrix types.
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatDeclLowExpr.h:275
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.
DisableIf_< IsLower< MT >, const DMatDeclLowExpr< MT, SO > > decllow(const DenseMatrix< MT, SO > &dm)
Declares the given non-lower dense matrix expression dm as lower.
Definition: DMatDeclLowExpr.h:842
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
Header file for the DeclLowExpr base class.
Evaluation of the expression type type of a row operation.Via this type trait it is possible to evalu...
Definition: RowExprTrait.h:79
If_< RequiresEvaluation< MT >, const ResultType, const SMatDeclLowExpr &> CompositeType
Data type for composite expression templates.
Definition: SMatDeclLowExpr.h:171
Header file for the RowExprTrait class template.
Expression object for sparse matrix-scalar multiplications.The SMatScalarMult class represents the co...
Definition: Forward.h:106
Header file for all forward declarations for expression class templates.
Header file for the EnableIf class template.
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
SMatDeclLowExpr< MT, SO > This
Type of this SMatDeclLowExpr instance.
Definition: SMatDeclLowExpr.h:163
Header file for the SubmatrixExprTrait class template.
Header file for run time assertion macros.
Compile time check for column-major matrix types.This type trait tests whether or not the given templ...
Definition: IsColumnMajorMatrix.h:83
Utility type for generic codes.
ElementType_< MT > ElementType
Resulting element type.
Definition: SMatDeclLowExpr.h:167
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:160
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower triangular matrix type...
Definition: Lower.h:81
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:93
Header file for the TSMatDeclLowExprTrait class template.
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
Header file for the HasMember type traits.
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: SMatDeclLowExpr.h:168
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
Evaluation of the expression type of a sparse matrix decllow operation.Via this type trait it is poss...
Definition: SMatDeclLowExprTrait.h:75
Header file for the IsRowMajorMatrix type trait.
SMatDeclLowExpr(const MT &sm) noexcept
Constructor for the SMatDeclLowExpr class.
Definition: SMatDeclLowExpr.h:190
GetConstIterator< MT >::Type ConstIterator
Iterator over the elements of the dense matrix.
Definition: SMatDeclLowExpr.h:174
OppositeType_< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatDeclLowExpr.h:165
Operand sm_
Sparse matrix of the decllow expression.
Definition: SMatDeclLowExpr.h:337
Header file for the IntegralConstant class template.
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:76
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
Header file for the IsUpper type trait.
Header file for the DeclLowExprTrait class template.
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatDeclLowExpr.h:286
Header file for the empty type.
Header file for the IsHermitian type trait.
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:677
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: SMatDeclLowExpr.h:265
Evaluation of the expression type type of a column operation.Via this type trait it is possible to ev...
Definition: ColumnExprTrait.h:78
#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
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: SMatDeclLowExpr.h:320
Header file for the TrueType type/value trait base class.
Header file for the IsExpression type trait class.
Evaluation of the expression type of a sparse matrix decllow operation.Via this type trait it is poss...
Definition: TSMatDeclLowExprTrait.h:75
Header file for the function trace functionality.
ResultType_< MT > ResultType
Result type for expression template evaluations.
Definition: SMatDeclLowExpr.h:164