DMatTransExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATTRANSEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATTRANSEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <iterator>
44 #include <blaze/math/Aliases.h>
48 #include <blaze/math/Exception.h>
72 #include <blaze/system/Inline.h>
73 #include <blaze/util/Assert.h>
74 #include <blaze/util/EnableIf.h>
76 #include <blaze/util/InvalidType.h>
77 #include <blaze/util/mpl/If.h>
78 #include <blaze/util/Types.h>
80 
81 
82 namespace blaze {
83 
84 //=================================================================================================
85 //
86 // CLASS DMATTRANSEXPR
87 //
88 //=================================================================================================
89 
90 //*************************************************************************************************
97 template< typename MT // Type of the dense matrix
98  , bool SO > // Storage order
100  : public MatTransExpr< DenseMatrix< DMatTransExpr<MT,SO>, SO > >
101  , private If< IsComputation<MT>, Computation, Transformation >::Type
102 {
103  private:
104  //**Type definitions****************************************************************************
105  using RT = ResultType_<MT>;
107  //**********************************************************************************************
108 
109  //**Serial evaluation strategy******************************************************************
111 
117  enum : bool { useAssign = RequiresEvaluation<MT>::value };
118 
120  template< typename MT2 >
122  struct UseAssign {
123  enum : bool { value = useAssign };
124  };
126  //**********************************************************************************************
127 
128  //**Parallel evaluation strategy****************************************************************
130 
135  template< typename MT2 >
136  struct UseSMPAssign {
137  enum : bool { value = MT2::smpAssignable && useAssign };
138  };
140  //**********************************************************************************************
141 
142  //**********************************************************************************************
144 
148  template< typename MT2 >
149  struct GetConstIterator {
151  struct Success { using Type = typename MT2::ConstIterator; };
152  struct Failure { using Type = INVALID_TYPE; };
153  using Type = typename If_< HasConstIterator<MT2>, Success, Failure >::Type;
154  };
156  //**********************************************************************************************
157 
158  public:
159  //**Type definitions****************************************************************************
166 
169 
171  using ConstIterator = typename GetConstIterator<MT>::Type;
172 
174  using Operand = If_< IsExpression<MT>, const MT, const MT& >;
175  //**********************************************************************************************
176 
177  //**Compilation flags***************************************************************************
179  enum : bool { simdEnabled = MT::simdEnabled };
180 
182  enum : bool { smpAssignable = MT::smpAssignable };
183  //**********************************************************************************************
184 
185  //**SIMD properties*****************************************************************************
187  enum : size_t { SIMDSIZE = SIMDTrait<ElementType>::size };
188  //**********************************************************************************************
189 
190  //**Constructor*********************************************************************************
195  explicit inline DMatTransExpr( const MT& dm ) noexcept
196  : dm_( dm ) // Dense matrix of the transposition expression
197  {}
198  //**********************************************************************************************
199 
200  //**Access operator*****************************************************************************
207  inline ReturnType operator()( size_t i, size_t j ) const {
208  BLAZE_INTERNAL_ASSERT( i < dm_.columns(), "Invalid row access index" );
209  BLAZE_INTERNAL_ASSERT( j < dm_.rows() , "Invalid column access index" );
210  return dm_(j,i);
211  }
212  //**********************************************************************************************
213 
214  //**At function*********************************************************************************
222  inline ReturnType at( size_t i, size_t j ) const {
223  if( i >= dm_.columns() ) {
224  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
225  }
226  if( j >= dm_.rows() ) {
227  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
228  }
229  return (*this)(i,j);
230  }
231  //**********************************************************************************************
232 
233  //**Load function*******************************************************************************
240  BLAZE_ALWAYS_INLINE auto load( size_t i, size_t j ) const noexcept {
241  BLAZE_INTERNAL_ASSERT( i < dm_.columns(), "Invalid row access index" );
242  BLAZE_INTERNAL_ASSERT( j < dm_.rows() , "Invalid column access index" );
243  BLAZE_INTERNAL_ASSERT( !SO || ( i % SIMDSIZE == 0UL ), "Invalid row access index" );
244  BLAZE_INTERNAL_ASSERT( SO || ( j % SIMDSIZE == 0UL ), "Invalid column access index" );
245  return dm_.load(j,i);
246  }
247  //**********************************************************************************************
248 
249  //**Low-level data access***********************************************************************
254  inline const ElementType* data() const noexcept {
255  return dm_.data();
256  }
257  //**********************************************************************************************
258 
259  //**Begin function******************************************************************************
265  inline ConstIterator begin( size_t i ) const {
266  return ConstIterator( dm_.begin(i) );
267  }
268  //**********************************************************************************************
269 
270  //**End function********************************************************************************
276  inline ConstIterator end( size_t i ) const {
277  return ConstIterator( dm_.end(i) );
278  }
279  //**********************************************************************************************
280 
281  //**Rows function*******************************************************************************
286  inline size_t rows() const noexcept {
287  return dm_.columns();
288  }
289  //**********************************************************************************************
290 
291  //**Columns function****************************************************************************
296  inline size_t columns() const noexcept {
297  return dm_.rows();
298  }
299  //**********************************************************************************************
300 
301  //**Spacing function****************************************************************************
306  inline size_t spacing() const noexcept {
307  return dm_.spacing();
308  }
309  //**********************************************************************************************
310 
311  //**NonZeros function***************************************************************************
316  inline size_t nonZeros() const {
317  return dm_.nonZeros();
318  }
319  //**********************************************************************************************
320 
321  //**NonZeros function***************************************************************************
327  inline size_t nonZeros( size_t i ) const {
328  return dm_.nonZeros( i );
329  }
330  //**********************************************************************************************
331 
332  //**Operand access******************************************************************************
337  inline Operand operand() const noexcept {
338  return dm_;
339  }
340  //**********************************************************************************************
341 
342  //**********************************************************************************************
348  template< typename T >
349  inline bool canAlias( const T* alias ) const noexcept {
350  return dm_.isAliased( alias );
351  }
352  //**********************************************************************************************
353 
354  //**********************************************************************************************
360  template< typename T >
361  inline bool isAliased( const T* alias ) const noexcept {
362  return dm_.isAliased( alias );
363  }
364  //**********************************************************************************************
365 
366  //**********************************************************************************************
371  inline bool isAligned() const noexcept {
372  return dm_.isAligned();
373  }
374  //**********************************************************************************************
375 
376  //**********************************************************************************************
381  inline bool canSMPAssign() const noexcept {
382  return dm_.canSMPAssign();
383  }
384  //**********************************************************************************************
385 
386  private:
387  //**Member variables****************************************************************************
389  //**********************************************************************************************
390 
391  //**Assignment to dense matrices****************************************************************
405  template< typename MT2 // Type of the target dense matrix
406  , bool SO2 > // Storage order of the target dense matrix
407  friend inline EnableIf_< UseAssign<MT2> >
408  assign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
409  {
411 
412  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
413  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
414 
415  DMatTransposer<MT2,!SO2> tmp( ~lhs );
416  assign( tmp, rhs.dm_ );
417  }
419  //**********************************************************************************************
420 
421  //**Assignment to sparse matrices***************************************************************
435  template< typename MT2 // Type of the target sparse matrix
436  , bool SO2 > // Storage order of the target sparse matrix
437  friend inline EnableIf_< UseAssign<MT2> >
438  assign( SparseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
439  {
441 
443 
450 
451  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
452  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
453 
454  const TmpType tmp( serial( rhs ) );
455  assign( ~lhs, tmp );
456  }
458  //**********************************************************************************************
459 
460  //**Addition assignment to dense matrices*******************************************************
474  template< typename MT2 // Type of the target dense matrix
475  , bool SO2 > // Storage order of the target dense matrix
476  friend inline EnableIf_< UseAssign<MT2> >
477  addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
478  {
480 
481  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
482  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
483 
484  DMatTransposer<MT2,!SO2> tmp( ~lhs );
485  addAssign( tmp, rhs.dm_ );
486  }
488  //**********************************************************************************************
489 
490  //**Addition assignment to sparse matrices******************************************************
491  // No special implementation for the addition assignment to sparse matrices.
492  //**********************************************************************************************
493 
494  //**Subtraction assignment to dense matrices****************************************************
508  template< typename MT2 // Type of the target dense matrix
509  , bool SO2 > // Storage order of the target dense matrix
510  friend inline EnableIf_< UseAssign<MT2> >
511  subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
512  {
514 
515  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
516  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
517 
518  DMatTransposer<MT2,!SO2> tmp( ~lhs );
519  subAssign( tmp, rhs.dm_ );
520  }
522  //**********************************************************************************************
523 
524  //**Subtraction assignment to sparse matrices***************************************************
525  // No special implementation for the subtraction assignment to sparse matrices.
526  //**********************************************************************************************
527 
528  //**Schur product assignment to dense matrices**************************************************
542  template< typename MT2 // Type of the target dense matrix
543  , bool SO2 > // Storage order of the target dense matrix
544  friend inline EnableIf_< UseAssign<MT2> >
545  schurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
546  {
548 
549  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
550  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
551 
552  DMatTransposer<MT2,!SO2> tmp( ~lhs );
553  schurAssign( tmp, rhs.dm_ );
554  }
556  //**********************************************************************************************
557 
558  //**Schur product assignment to sparse matrices*************************************************
559  // No special implementation for the Schur product assignment to sparse matrices.
560  //**********************************************************************************************
561 
562  //**Multiplication assignment to dense matrices*************************************************
563  // No special implementation for the multiplication assignment to dense matrices.
564  //**********************************************************************************************
565 
566  //**Multiplication assignment to sparse matrices************************************************
567  // No special implementation for the multiplication assignment to sparse matrices.
568  //**********************************************************************************************
569 
570  //**SMP assignment to dense matrices************************************************************
584  template< typename MT2 // Type of the target dense matrix
585  , bool SO2 > // Storage order of the target dense matrix
586  friend inline EnableIf_< UseSMPAssign<MT2> >
587  smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
588  {
590 
591  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
592  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
593 
594  DMatTransposer<MT2,!SO2> tmp( ~lhs );
595  smpAssign( tmp, rhs.dm_ );
596  }
598  //**********************************************************************************************
599 
600  //**SMP assignment to sparse matrices***********************************************************
614  template< typename MT2 // Type of the target sparse matrix
615  , bool SO2 > // Storage order of the target sparse matrix
616  friend inline EnableIf_< UseSMPAssign<MT2> >
617  smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
618  {
620 
622 
629 
630  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
631  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
632 
633  const TmpType tmp( rhs );
634  smpAssign( ~lhs, tmp );
635  }
637  //**********************************************************************************************
638 
639  //**SMP addition 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  smpAddAssign( tmp, rhs.dm_ );
665  }
667  //**********************************************************************************************
668 
669  //**SMP addition assignment to sparse matrices**************************************************
670  // No special implementation for the SMP addition assignment to sparse matrices.
671  //**********************************************************************************************
672 
673  //**SMP subtraction assignment to dense matrices************************************************
687  template< typename MT2 // Type of the target dense matrix
688  , bool SO2 > // Storage order of the target dense matrix
689  friend inline EnableIf_< UseSMPAssign<MT2> >
691  {
693 
694  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
695  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
696 
697  DMatTransposer<MT2,!SO2> tmp( ~lhs );
698  smpSubAssign( tmp, rhs.dm_ );
699  }
701  //**********************************************************************************************
702 
703  //**SMP subtraction assignment to sparse matrices***********************************************
704  // No special implementation for the SMP subtraction assignment to sparse matrices.
705  //**********************************************************************************************
706 
707  //**SMP Schur product assignment to dense matrices**********************************************
722  template< typename MT2 // Type of the target dense matrix
723  , bool SO2 > // Storage order of the target dense matrix
724  friend inline EnableIf_< UseSMPAssign<MT2> >
726  {
728 
729  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
730  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
731 
732  DMatTransposer<MT2,!SO2> tmp( ~lhs );
733  smpSchurAssign( tmp, rhs.dm_ );
734  }
736  //**********************************************************************************************
737 
738  //**SMP Schur product assignment to sparse matrices*********************************************
739  // No special implementation for the SMP Schur product assignment to sparse matrices.
740  //**********************************************************************************************
741 
742  //**SMP multiplication assignment to dense matrices*********************************************
743  // No special implementation for the SMP multiplication assignment to dense matrices.
744  //**********************************************************************************************
745 
746  //**SMP multiplication assignment to sparse matrices********************************************
747  // No special implementation for the SMP multiplication assignment to sparse matrices.
748  //**********************************************************************************************
749 
750  //**Compile time checks*************************************************************************
755  //**********************************************************************************************
756 };
757 //*************************************************************************************************
758 
759 
760 
761 
762 //=================================================================================================
763 //
764 // GLOBAL OPERATORS
765 //
766 //=================================================================================================
767 
768 //*************************************************************************************************
787 template< typename MT // Type of the dense matrix
788  , bool SO > // Storage order
789 inline decltype(auto) trans( const DenseMatrix<MT,SO>& dm )
790 {
792 
793  using ReturnType = const DMatTransExpr<MT,!SO>;
794  return ReturnType( ~dm );
795 }
796 //*************************************************************************************************
797 
798 
799 
800 
801 //=================================================================================================
802 //
803 // GLOBAL RESTRUCTURING FUNCTIONS
804 //
805 //=================================================================================================
806 
807 //*************************************************************************************************
827 template< typename MT // Type of the dense matrix
828  , bool SO > // Storage order
829 inline decltype(auto) trans( const DMatTransExpr<MT,SO>& dm )
830 {
832 
833  return dm.operand();
834 }
836 //*************************************************************************************************
837 
838 
839 //*************************************************************************************************
851 template< typename MT // Type of the left-hand side dense matrix
852  , typename ST // Type of the right-hand side scalar value
853  , bool SO > // Storage order
854 inline decltype(auto) trans( const DMatScalarMultExpr<MT,ST,SO>& dm )
855 {
857 
858  return trans( dm.leftOperand() ) * dm.rightOperand();
859 }
861 //*************************************************************************************************
862 
863 
864 
865 
866 //=================================================================================================
867 //
868 // SIZE SPECIALIZATIONS
869 //
870 //=================================================================================================
871 
872 //*************************************************************************************************
874 template< typename MT, bool SO >
875 struct Size< DMatTransExpr<MT,SO>, 0UL >
876  : public Size<MT,1UL>
877 {};
878 
879 template< typename MT, bool SO >
880 struct Size< DMatTransExpr<MT,SO>, 1UL >
881  : public Size<MT,0UL>
882 {};
884 //*************************************************************************************************
885 
886 
887 
888 
889 //=================================================================================================
890 //
891 // HASCONSTDATAACCESS SPECIALIZATIONS
892 //
893 //=================================================================================================
894 
895 //*************************************************************************************************
897 template< typename MT, bool SO >
898 struct HasConstDataAccess< DMatTransExpr<MT,SO> >
899  : public HasConstDataAccess<MT>
900 {};
902 //*************************************************************************************************
903 
904 
905 
906 
907 //=================================================================================================
908 //
909 // ISALIGNED SPECIALIZATIONS
910 //
911 //=================================================================================================
912 
913 //*************************************************************************************************
915 template< typename MT, bool SO >
916 struct IsAligned< DMatTransExpr<MT,SO> >
917  : public IsAligned<MT>
918 {};
920 //*************************************************************************************************
921 
922 
923 
924 
925 //=================================================================================================
926 //
927 // ISPADDED SPECIALIZATIONS
928 //
929 //=================================================================================================
930 
931 //*************************************************************************************************
933 template< typename MT, bool SO >
934 struct IsPadded< DMatTransExpr<MT,SO> >
935  : public IsPadded<MT>
936 {};
938 //*************************************************************************************************
939 
940 
941 
942 
943 //=================================================================================================
944 //
945 // ISSYMMETRIC SPECIALIZATIONS
946 //
947 //=================================================================================================
948 
949 //*************************************************************************************************
951 template< typename MT, bool SO >
952 struct IsSymmetric< DMatTransExpr<MT,SO> >
953  : public IsSymmetric<MT>
954 {};
956 //*************************************************************************************************
957 
958 
959 
960 
961 //=================================================================================================
962 //
963 // ISHERMITIAN SPECIALIZATIONS
964 //
965 //=================================================================================================
966 
967 //*************************************************************************************************
969 template< typename MT, bool SO >
970 struct IsHermitian< DMatTransExpr<MT,SO> >
971  : public IsHermitian<MT>
972 {};
974 //*************************************************************************************************
975 
976 
977 
978 
979 //=================================================================================================
980 //
981 // ISLOWER SPECIALIZATIONS
982 //
983 //=================================================================================================
984 
985 //*************************************************************************************************
987 template< typename MT, bool SO >
988 struct IsLower< DMatTransExpr<MT,SO> >
989  : public IsUpper<MT>
990 {};
992 //*************************************************************************************************
993 
994 
995 
996 
997 //=================================================================================================
998 //
999 // ISUNILOWER SPECIALIZATIONS
1000 //
1001 //=================================================================================================
1002 
1003 //*************************************************************************************************
1005 template< typename MT, bool SO >
1006 struct IsUniLower< DMatTransExpr<MT,SO> >
1007  : public IsUniUpper<MT>
1008 {};
1010 //*************************************************************************************************
1011 
1012 
1013 
1014 
1015 //=================================================================================================
1016 //
1017 // ISSTRICTLYLOWER SPECIALIZATIONS
1018 //
1019 //=================================================================================================
1020 
1021 //*************************************************************************************************
1023 template< typename MT, bool SO >
1024 struct IsStrictlyLower< DMatTransExpr<MT,SO> >
1025  : public IsStrictlyUpper<MT>
1026 {};
1028 //*************************************************************************************************
1029 
1030 
1031 
1032 
1033 //=================================================================================================
1034 //
1035 // ISUPPER SPECIALIZATIONS
1036 //
1037 //=================================================================================================
1038 
1039 //*************************************************************************************************
1041 template< typename MT, bool SO >
1042 struct IsUpper< DMatTransExpr<MT,SO> >
1043  : public IsLower<MT>
1044 {};
1046 //*************************************************************************************************
1047 
1048 
1049 
1050 
1051 //=================================================================================================
1052 //
1053 // ISUNIUPPER SPECIALIZATIONS
1054 //
1055 //=================================================================================================
1056 
1057 //*************************************************************************************************
1059 template< typename MT, bool SO >
1060 struct IsUniUpper< DMatTransExpr<MT,SO> >
1061  : public IsUniLower<MT>
1062 {};
1064 //*************************************************************************************************
1065 
1066 
1067 
1068 
1069 //=================================================================================================
1070 //
1071 // ISSTRICTLYUPPER SPECIALIZATIONS
1072 //
1073 //=================================================================================================
1074 
1075 //*************************************************************************************************
1077 template< typename MT, bool SO >
1078 struct IsStrictlyUpper< DMatTransExpr<MT,SO> >
1079  : public IsStrictlyLower<MT>
1080 {};
1082 //*************************************************************************************************
1083 
1084 } // namespace blaze
1085 
1086 #endif
Header file for auxiliary alias declarations.
Compile time check for low-level access to constant data.This type trait tests whether the given data...
Definition: HasConstDataAccess.h:75
typename GetConstIterator< MT >::Type ConstIterator
Iterator over the elements of the dense matrix.
Definition: DMatTransExpr.h:171
size_t spacing() const noexcept
Returns the spacing between the beginning of two rows/columns.
Definition: DMatTransExpr.h:306
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
Compile time type selection.The If alias declaration selects one of the two given types T2 and T3 dep...
Definition: If.h:132
Header file for basic type definitions.
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatTransExpr.h:371
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
Header file for the serial shim.
Expression object for dense matrix transpositions.The DMatTransExpr class represents the compile time...
Definition: DMatTransExpr.h:99
#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
Header file for the MatTransExpr base class.
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatTransExpr.h:381
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:61
const ElementType * data() const noexcept
Low-level data access to the matrix elements.
Definition: DMatTransExpr.h:254
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:87
#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:87
Operand operand() const noexcept
Returns the dense matrix operand.
Definition: DMatTransExpr.h:337
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatTransExpr.h:296
Header file for the RequiresEvaluation type trait.
Operand dm_
Dense matrix of the transposition expression.
Definition: DMatTransExpr.h:388
Header file for the SIMD 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
BLAZE_ALWAYS_INLINE auto load(size_t i, size_t j) const noexcept
Access to the SIMD elements of the matrix.
Definition: DMatTransExpr.h:240
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 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
TransposeType_< MT > ResultType
Result type for expression template evaluations.
Definition: DMatTransExpr.h:161
Compile time check for the alignment of data types.This type trait tests whether the given data type ...
Definition: IsAligned.h:87
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:71
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
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: DMatTransExpr.h:165
IfTrue_< useAssign, const ResultType, const DMatTransExpr &> CompositeType
Data type for composite expression templates.
Definition: DMatTransExpr.h:168
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
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
Header file for the If class template.
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: DMatTransExpr.h:276
Header file for the Transformation base class.
Compile time check for data types with padding.This type trait tests whether the given data type empl...
Definition: IsPadded.h:76
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
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatTransExpr.h:286
Expression object for dense matrix-scalar multiplications.The DMatScalarMultExpr class represents the...
Definition: DMatScalarMultExpr.h:107
#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 DenseMatrix base class.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3085
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:77
Header file for the IsLower type trait.
Header file for the IsAligned type trait.
RightOperand rightOperand() const noexcept
Returns the right-hand side scalar operand.
Definition: DMatScalarMultExpr.h:564
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.
Header file for all forward declarations for expression class templates.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatTransExpr.h:349
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Header file for the IsPadded type trait.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatTransExpr.h:361
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTransExpr.h:162
ResultType_< MT > RT
Result type of the dense matrix expression.
Definition: DMatTransExpr.h:105
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatTransExpr.h:207
Header file for the dense matrix transposer.
Header file for the HasConstDataAccess type trait.
DMatTransExpr(const MT &dm) noexcept
Constructor for the DMatTransExpr class.
Definition: DMatTransExpr.h:195
Header file for run time assertion macros.
Utility type for generic codes.
size_t nonZeros() const
Returns the number of non-zero elements in the dense matrix.
Definition: DMatTransExpr.h:316
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the dense matrix expression.
Definition: DMatTransExpr.h:174
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 begin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: DMatTransExpr.h:265
SIMD characteristics of data types.The SIMDTrait class template provides the SIMD characteristics of ...
Definition: SIMDTrait.h:296
#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
CompositeType_< MT > CT
Composite type of the dense matrix expression.
Definition: DMatTransExpr.h:106
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:816
Base class for all matrix transposition expression templates.The MatTransExpr class serves as a tag f...
Definition: MatTransExpr.h:66
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
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
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2)
Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type ...
Definition: StorageOrder.h:84
ElementType_< MT > ElementType
Resulting element type.
Definition: DMatTransExpr.h:164
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
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:789
Header file for the IsComputation type trait class.
Compile time evaluation of the size of vectors and matrices.The Size type trait evaluates the size of...
Definition: Size.h:80
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.
ResultType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DMatTransExpr.h:163
Header file for the IsHermitian type trait.
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row/column.
Definition: DMatTransExpr.h:327
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense matrix operand.
Definition: DMatScalarMultExpr.h:554
System settings for the inline keywords.
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
Header file for the IsExpression type trait class.
Header file for the function trace functionality.
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatTransExpr.h:222