SMatTransExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATTRANSEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATTRANSEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <iterator>
44 #include <blaze/math/Aliases.h>
48 #include <blaze/math/Exception.h>
69 #include <blaze/util/Assert.h>
70 #include <blaze/util/EnableIf.h>
73 #include <blaze/util/InvalidType.h>
74 #include <blaze/util/mpl/If.h>
75 #include <blaze/util/Types.h>
78 
79 
80 namespace blaze {
81 
82 //=================================================================================================
83 //
84 // CLASS SMATTRANSEXPR
85 //
86 //=================================================================================================
87 
88 //*************************************************************************************************
95 template< typename MT // Type of the sparse matrix
96  , bool SO > // Storage order
97 class SMatTransExpr
98  : public MatTransExpr< SparseMatrix< SMatTransExpr<MT,SO>, SO > >
99  , private If< IsComputation<MT>, Computation, Transformation >::Type
100 {
101  private:
102  //**Type definitions****************************************************************************
103  using RT = ResultType_<MT>;
105  //**********************************************************************************************
106 
107  //**Serial evaluation strategy******************************************************************
109 
115  enum : bool { useAssign = RequiresEvaluation<MT>::value };
116 
118  template< typename MT2 >
120  struct UseAssign {
121  enum : bool { value = useAssign };
122  };
124  //**********************************************************************************************
125 
126  //**Parallel evaluation strategy****************************************************************
128 
133  template< typename MT2 >
134  struct UseSMPAssign {
135  enum : bool { value = MT2::smpAssignable && useAssign };
136  };
138  //**********************************************************************************************
139 
140  //**********************************************************************************************
142 
146  template< typename MT2 >
147  struct GetConstIterator {
149  struct Success { using Type = typename MT2::ConstIterator; };
150  struct Failure { using Type = INVALID_TYPE; };
151  using Type = typename If_< HasConstIterator<MT2>, Success, Failure >::Type;
152  };
154  //**********************************************************************************************
155 
156  public:
157  //**Type definitions****************************************************************************
164 
167 
169  using ConstIterator = typename GetConstIterator<MT>::Type;
170 
172  using Operand = If_< IsExpression<MT>, const MT, const MT& >;
173  //**********************************************************************************************
174 
175  //**Compilation flags***************************************************************************
177  enum : bool { smpAssignable = MT::smpAssignable };
178  //**********************************************************************************************
179 
180  //**Constructor*********************************************************************************
185  explicit inline SMatTransExpr( const MT& sm ) noexcept
186  : sm_( sm )
187  {}
188  //**********************************************************************************************
189 
190  //**Access operator*****************************************************************************
197  inline ReturnType operator()( size_t i, size_t j ) const {
198  BLAZE_INTERNAL_ASSERT( i < sm_.columns(), "Invalid row access index" );
199  BLAZE_INTERNAL_ASSERT( j < sm_.rows() , "Invalid column access index" );
200  return sm_(j,i);
201  }
202  //**********************************************************************************************
203 
204  //**At function*********************************************************************************
212  inline ReturnType at( size_t i, size_t j ) const {
213  if( i >= sm_.columns() ) {
214  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
215  }
216  if( j >= sm_.rows() ) {
217  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
218  }
219  return (*this)(i,j);
220  }
221  //**********************************************************************************************
222 
223  //**Begin function******************************************************************************
229  inline ConstIterator begin( size_t i ) const {
230  return sm_.begin(i);
231  }
232  //**********************************************************************************************
233 
234  //**End function********************************************************************************
240  inline ConstIterator end( size_t i ) const {
241  return sm_.end(i);
242  }
243  //**********************************************************************************************
244 
245  //**Rows function*******************************************************************************
250  inline size_t rows() const noexcept {
251  return sm_.columns();
252  }
253  //**********************************************************************************************
254 
255  //**Columns function****************************************************************************
260  inline size_t columns() const noexcept {
261  return sm_.rows();
262  }
263  //**********************************************************************************************
264 
265  //**NonZeros function***************************************************************************
270  inline size_t nonZeros() const {
271  return sm_.nonZeros();
272  }
273  //**********************************************************************************************
274 
275  //**NonZeros function***************************************************************************
281  inline size_t nonZeros( size_t i ) const {
282  return sm_.nonZeros( i );
283  }
284  //**********************************************************************************************
285 
286  //**Find function*******************************************************************************
293  inline ConstIterator find( size_t i, size_t j ) const {
295  return sm_.find( j, i );
296  }
297  //**********************************************************************************************
298 
299  //**LowerBound function*************************************************************************
306  inline ConstIterator lowerBound( size_t i, size_t j ) const {
308  return sm_.lowerBound( j, i );
309  }
310  //**********************************************************************************************
311 
312  //**UpperBound function*************************************************************************
319  inline ConstIterator upperBound( size_t i, size_t j ) const {
321  return sm_.upperBound( j, i );
322  }
323  //**********************************************************************************************
324 
325  //**Operand access******************************************************************************
330  inline Operand operand() const noexcept {
331  return sm_;
332  }
333  //**********************************************************************************************
334 
335  //**********************************************************************************************
341  template< typename T >
342  inline bool canAlias( const T* alias ) const noexcept {
343  return sm_.isAliased( alias );
344  }
345  //**********************************************************************************************
346 
347  //**********************************************************************************************
353  template< typename T >
354  inline bool isAliased( const T* alias ) const noexcept {
355  return sm_.isAliased( alias );
356  }
357  //**********************************************************************************************
358 
359  //**********************************************************************************************
364  inline bool canSMPAssign() const noexcept {
365  return sm_.canSMPAssign();
366  }
367  //**********************************************************************************************
368 
369  private:
370  //**Member variables****************************************************************************
372  //**********************************************************************************************
373 
374  //**Assignment to dense matrices****************************************************************
388  template< typename MT2 // Type of the target dense matrix
389  , bool SO2 > // Storage order of the target dense matrix
390  friend inline EnableIf_< UseAssign<MT2> >
391  assign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
392  {
394 
395  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
396  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
397 
398  DMatTransposer<MT2,!SO2> tmp( ~lhs );
399  assign( tmp, rhs.sm_ );
400  }
402  //**********************************************************************************************
403 
404  //**Assignment to sparse matrices***************************************************************
418  template< typename MT2 // Type of the target sparse matrix
419  , bool SO2 > // Storage order of the target sparse matrix
420  friend inline EnableIf_< UseAssign<MT2> >
421  assign( SparseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
422  {
424 
425  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
426  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
427 
428  SMatTransposer<MT2,!SO2> tmp( ~lhs );
429  assign( tmp, rhs.sm_ );
430  }
432  //**********************************************************************************************
433 
434  //**Addition assignment to dense matrices*******************************************************
448  template< typename MT2 // Type of the target dense matrix
449  , bool SO2 > // Storage order of the target dense matrix
450  friend inline EnableIf_< UseAssign<MT2> >
451  addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
452  {
454 
455  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
456  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
457 
458  DMatTransposer<MT2,!SO2> tmp( ~lhs );
459  addAssign( tmp, rhs.sm_ );
460  }
462  //**********************************************************************************************
463 
464  //**Addition assignment to sparse matrices******************************************************
465  // No special implementation for the addition assignment to sparse matrices.
466  //**********************************************************************************************
467 
468  //**Subtraction assignment to dense matrices****************************************************
482  template< typename MT2 // Type of the target dense matrix
483  , bool SO2 > // Storage order of the target dense matrix
484  friend inline EnableIf_< UseAssign<MT2> >
485  subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
486  {
488 
489  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
490  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
491 
492  DMatTransposer<MT2,!SO2> tmp( ~lhs );
493  subAssign( tmp, rhs.sm_ );
494  }
496  //**********************************************************************************************
497 
498  //**Subtraction assignment to sparse matrices***************************************************
499  // No special implementation for the subtraction assignment to sparse matrices.
500  //**********************************************************************************************
501 
502  //**Schur product assignment to dense matrices**************************************************
516  template< typename MT2 // Type of the target dense matrix
517  , bool SO2 > // Storage order of the target dense matrix
518  friend inline EnableIf_< UseAssign<MT2> >
519  schurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
520  {
522 
523  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
524  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
525 
526  DMatTransposer<MT2,!SO2> tmp( ~lhs );
527  schurAssign( tmp, rhs.sm_ );
528  }
530  //**********************************************************************************************
531 
532  //**Schur product assignment to sparse matrices*************************************************
533  // No special implementation for the Schur product assignment to sparse matrices.
534  //**********************************************************************************************
535 
536  //**Multiplication assignment to dense matrices*************************************************
537  // No special implementation for the multiplication assignment to dense matrices.
538  //**********************************************************************************************
539 
540  //**Multiplication assignment to sparse matrices************************************************
541  // No special implementation for the multiplication assignment to sparse matrices.
542  //**********************************************************************************************
543 
544  //**SMP assignment to dense matrices************************************************************
558  template< typename MT2 // Type of the target dense matrix
559  , bool SO2 > // Storage order of the target dense matrix
560  friend inline EnableIf_< UseSMPAssign<MT2> >
561  smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
562  {
564 
565  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
566  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
567 
568  DMatTransposer<MT2,!SO2> tmp( ~lhs );
569  smpAssign( tmp, rhs.sm_ );
570  }
572  //**********************************************************************************************
573 
574  //**SMP assignment to sparse matrices***********************************************************
588  template< typename MT2 // Type of the target sparse matrix
589  , bool SO2 > // Storage order of the target sparse matrix
590  friend inline EnableIf_< UseSMPAssign<MT2> >
591  smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
592  {
594 
595  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
596  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
597 
598  SMatTransposer<MT2,!SO2> tmp( ~lhs );
599  smpAssign( tmp, rhs.sm_ );
600  }
602  //**********************************************************************************************
603 
604  //**SMP addition 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 EnableIf_< UseSMPAssign<MT2> >
622  {
624 
625  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
626  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
627 
628  DMatTransposer<MT2,!SO2> tmp( ~lhs );
629  smpAddAssign( tmp, rhs.sm_ );
630  }
632  //**********************************************************************************************
633 
634  //**SMP addition assignment to sparse matrices**************************************************
635  // No special implementation for the SMP addition assignment to sparse matrices.
636  //**********************************************************************************************
637 
638  //**SMP subtraction assignment to dense matrices************************************************
653  template< typename MT2 // Type of the target dense matrix
654  , bool SO2 > // Storage order of the target dense matrix
655  friend inline EnableIf_< UseSMPAssign<MT2> >
657  {
659 
660  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
661  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
662 
663  DMatTransposer<MT2,!SO2> tmp( ~lhs );
664  smpSubAssign( tmp, rhs.sm_ );
665  }
667  //**********************************************************************************************
668 
669  //**SMP subtraction assignment to sparse matrices***********************************************
670  // No special implementation for the SMP subtraction assignment to sparse matrices.
671  //**********************************************************************************************
672 
673  //**SMP Schur product assignment to dense matrices**********************************************
688  template< typename MT2 // Type of the target dense matrix
689  , bool SO2 > // Storage order of the target dense matrix
690  friend inline EnableIf_< UseSMPAssign<MT2> >
692  {
694 
695  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
696  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
697 
698  DMatTransposer<MT2,!SO2> tmp( ~lhs );
699  smpSchurAssign( tmp, rhs.sm_ );
700  }
702  //**********************************************************************************************
703 
704  //**SMP Schur product assignment to sparse matrices*********************************************
705  // No special implementation for the SMP Schur product assignment to sparse matrices.
706  //**********************************************************************************************
707 
708  //**SMP multiplication assignment to dense matrices*********************************************
709  // No special implementation for the SMP multiplication assignment to dense matrices.
710  //**********************************************************************************************
711 
712  //**SMP multiplication assignment to sparse matrices********************************************
713  // No special implementation for the SMP multiplication assignment to sparse matrices.
714  //**********************************************************************************************
715 
716  //**Compile time checks*************************************************************************
721  //**********************************************************************************************
722 };
723 //*************************************************************************************************
724 
725 
726 
727 
728 //=================================================================================================
729 //
730 // GLOBAL OPERATORS
731 //
732 //=================================================================================================
733 
734 //*************************************************************************************************
753 template< typename MT // Type of the sparse matrix
754  , bool SO > // Storage order
755 inline decltype(auto) trans( const SparseMatrix<MT,SO>& sm )
756 {
758 
759  using ReturnType = const SMatTransExpr<MT,!SO>;
760  return ReturnType( ~sm );
761 }
762 //*************************************************************************************************
763 
764 
765 
766 
767 //=================================================================================================
768 //
769 // GLOBAL RESTRUCTURING FUNCTIONS
770 //
771 //=================================================================================================
772 
773 //*************************************************************************************************
793 template< typename MT // Type of the dense matrix
794  , bool SO > // Storage order
795 inline decltype(auto) trans( const SMatTransExpr<MT,SO>& sm )
796 {
798 
799  return sm.operand();
800 }
802 //*************************************************************************************************
803 
804 
805 //*************************************************************************************************
817 template< typename MT // Type of the left-hand side sparse matrix
818  , typename ST // Type of the right-hand side scalar value
819  , bool SO > // Storage order
820 inline decltype(auto) trans( const SMatScalarMultExpr<MT,ST,SO>& sm )
821 {
823 
824  return trans( sm.leftOperand() ) * sm.rightOperand();
825 }
827 //*************************************************************************************************
828 
829 
830 
831 
832 //=================================================================================================
833 //
834 // ROWS SPECIALIZATIONS
835 //
836 //=================================================================================================
837 
838 //*************************************************************************************************
840 template< typename MT, bool SO >
841 struct Rows< SMatTransExpr<MT,SO> >
842  : public Columns<MT>
843 {};
845 //*************************************************************************************************
846 
847 
848 
849 
850 //=================================================================================================
851 //
852 // COLUMNS SPECIALIZATIONS
853 //
854 //=================================================================================================
855 
856 //*************************************************************************************************
858 template< typename MT, bool SO >
859 struct Columns< SMatTransExpr<MT,SO> >
860  : public Rows<MT>
861 {};
863 //*************************************************************************************************
864 
865 
866 
867 
868 //=================================================================================================
869 //
870 // ISSYMMETRIC SPECIALIZATIONS
871 //
872 //=================================================================================================
873 
874 //*************************************************************************************************
876 template< typename MT, bool SO >
877 struct IsSymmetric< SMatTransExpr<MT,SO> >
878  : public BoolConstant< IsSymmetric<MT>::value >
879 {};
881 //*************************************************************************************************
882 
883 
884 
885 
886 //=================================================================================================
887 //
888 // ISHERMITIAN SPECIALIZATIONS
889 //
890 //=================================================================================================
891 
892 //*************************************************************************************************
894 template< typename MT, bool SO >
895 struct IsHermitian< SMatTransExpr<MT,SO> >
896  : public BoolConstant< IsHermitian<MT>::value >
897 {};
899 //*************************************************************************************************
900 
901 
902 
903 
904 //=================================================================================================
905 //
906 // ISLOWER SPECIALIZATIONS
907 //
908 //=================================================================================================
909 
910 //*************************************************************************************************
912 template< typename MT, bool SO >
913 struct IsLower< SMatTransExpr<MT,SO> >
914  : public BoolConstant< IsUpper<MT>::value >
915 {};
917 //*************************************************************************************************
918 
919 
920 
921 
922 //=================================================================================================
923 //
924 // ISUNILOWER SPECIALIZATIONS
925 //
926 //=================================================================================================
927 
928 //*************************************************************************************************
930 template< typename MT, bool SO >
931 struct IsUniLower< SMatTransExpr<MT,SO> >
932  : public BoolConstant< IsUniUpper<MT>::value >
933 {};
935 //*************************************************************************************************
936 
937 
938 
939 
940 //=================================================================================================
941 //
942 // ISSTRICTLYLOWER SPECIALIZATIONS
943 //
944 //=================================================================================================
945 
946 //*************************************************************************************************
948 template< typename MT, bool SO >
949 struct IsStrictlyLower< SMatTransExpr<MT,SO> >
950  : public BoolConstant< IsStrictlyUpper<MT>::value >
951 {};
953 //*************************************************************************************************
954 
955 
956 
957 
958 //=================================================================================================
959 //
960 // ISUPPER SPECIALIZATIONS
961 //
962 //=================================================================================================
963 
964 //*************************************************************************************************
966 template< typename MT, bool SO >
967 struct IsUpper< SMatTransExpr<MT,SO> >
968  : public BoolConstant< IsLower<MT>::value >
969 {};
971 //*************************************************************************************************
972 
973 
974 
975 
976 //=================================================================================================
977 //
978 // ISUNIUPPER SPECIALIZATIONS
979 //
980 //=================================================================================================
981 
982 //*************************************************************************************************
984 template< typename MT, bool SO >
985 struct IsUniUpper< SMatTransExpr<MT,SO> >
986  : public BoolConstant< IsUniLower<MT>::value >
987 {};
989 //*************************************************************************************************
990 
991 
992 
993 
994 //=================================================================================================
995 //
996 // ISSTRICTLYUPPER SPECIALIZATIONS
997 //
998 //=================================================================================================
999 
1000 //*************************************************************************************************
1002 template< typename MT, bool SO >
1003 struct IsStrictlyUpper< SMatTransExpr<MT,SO> >
1004  : public BoolConstant< IsStrictlyLower<MT>::value >
1005 {};
1007 //*************************************************************************************************
1008 
1009 } // namespace blaze
1010 
1011 #endif
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row/column.
Definition: SMatTransExpr.h:281
TransposeType_< MT > ResultType
Result type for expression template evaluations.
Definition: SMatTransExpr.h:159
Header file for the sparse matrix transposer.
Header file for auxiliary alias declarations.
Header file for the Rows type trait.
IfTrue_< useAssign, const ResultType, const SMatTransExpr &> CompositeType
Data type for composite expression templates.
Definition: SMatTransExpr.h:166
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
RightOperand rightOperand() const noexcept
Returns the right-hand side scalar operand.
Definition: SMatScalarMultExpr.h:478
Header file for basic type definitions.
ResultType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: SMatTransExpr.h:161
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatTransExpr.h:270
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
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: SMatTransExpr.h:212
#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
SMatTransExpr(const MT &sm) noexcept
Constructor for the SMatTransExpr class.
Definition: SMatTransExpr.h:185
Header file for the MatTransExpr base class.
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the sparse matrix expression.
Definition: SMatTransExpr.h:172
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatTransExpr.h:197
ElementType_< MT > ElementType
Resulting element type.
Definition: SMatTransExpr.h:162
LeftOperand leftOperand() const noexcept
Returns the left-hand side sparse matrix operand.
Definition: SMatScalarMultExpr.h:468
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
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:88
Header file for the RequiresEvaluation type trait.
Header file for the IsUniLower type trait.
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
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:78
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: SMatTransExpr.h:354
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SMatTransExpr.h:364
typename IfTrue< Condition, T1, T2 >::Type IfTrue_
Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a co...
Definition: If.h:109
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.
Constraint on the data type.
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:72
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
ResultType_< MT > RT
Result type of the sparse matrix expression.
Definition: SMatTransExpr.h:103
Operand sm_
Sparse matrix of the transposition expression.
Definition: SMatTransExpr.h:371
Header file for the IsStrictlyUpper type trait.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: SMatTransExpr.h:260
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: SMatTransExpr.h:229
Header file for the IsSymmetric type trait.
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatTransExpr.h:160
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
Header file for the Transformation base class.
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
CompositeType_< MT > CT
Composite type of the sparse matrix expression.
Definition: SMatTransExpr.h:104
#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.
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: SMatTransExpr.h:163
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3087
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Expression object for the transposition of a dense matrix.The DMatTransposer class is a wrapper objec...
Definition: DMatTransposer.h:81
ConstIterator upperBound(size_t i, size_t j) const
Returns an iterator to the first index greater then the given index.
Definition: SMatTransExpr.h:319
Header file for the IsLower type trait.
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
Constraint on the data type.
Expression object for sparse matrix-scalar multiplications.The SMatScalarMult class represents the co...
Definition: Forward.h:114
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
Header file for the dense matrix transposer.
Expression object for the transposition of a sparse matrix.The SMatTransposer class is a wrapper obje...
Definition: Forward.h:124
typename GetConstIterator< MT >::Type ConstIterator
Iterator over the elements of the dense matrix.
Definition: SMatTransExpr.h:169
ConstIterator find(size_t i, size_t j) const
Searches for a specific matrix element.
Definition: SMatTransExpr.h:293
Header file for run time assertion macros.
Utility type for generic codes.
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
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: SMatTransExpr.h:240
#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
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: SMatTransExpr.h:342
Header file for the HasMember type traits.
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.In case the given data type T requires an intermediate evaluation within ...
Definition: RequiresEvaluation.h:81
Header file for the RemoveReference type trait.
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:224
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:263
Operand operand() const noexcept
Returns the sparse matrix operand.
Definition: SMatTransExpr.h:330
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
ConstIterator lowerBound(size_t i, size_t j) const
Returns an iterator to the first index not less then the given index.
Definition: SMatTransExpr.h:306
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3082
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:790
Header file for the IsComputation type trait class.
Expression object for sparse matrix transpositions.The SMatTransExpr class represents the compile tim...
Definition: Forward.h:123
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:75
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:75
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: SMatTransExpr.h:250
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.
Header file for the IsHermitian 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.