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>
47 #include <blaze/math/Exception.h>
80 #include <blaze/system/Inline.h>
81 #include <blaze/util/Assert.h>
83 #include <blaze/util/EmptyType.h>
84 #include <blaze/util/EnableIf.h>
87 #include <blaze/util/InvalidType.h>
88 #include <blaze/util/mpl/And.h>
89 #include <blaze/util/mpl/If.h>
90 #include <blaze/util/Types.h>
93 
94 
95 namespace blaze {
96 
97 //=================================================================================================
98 //
99 // CLASS DMATTRANSEXPR
100 //
101 //=================================================================================================
102 
103 //*************************************************************************************************
110 template< typename MT // Type of the dense matrix
111  , bool SO > // Storage order
112 class DMatTransExpr : public DenseMatrix< DMatTransExpr<MT,SO>, SO >
113  , private MatTransExpr
114  , private If< IsComputation<MT>, Computation, EmptyType >::Type
115 {
116  private:
117  //**Type definitions****************************************************************************
118  typedef ResultType_<MT> RT;
120  //**********************************************************************************************
121 
122  //**Serial evaluation strategy******************************************************************
124 
130  enum : bool { useAssign = RequiresEvaluation<MT>::value };
131 
133  template< typename MT2 >
135  struct UseAssign {
136  enum : bool { value = useAssign };
137  };
139  //**********************************************************************************************
140 
141  //**Parallel evaluation strategy****************************************************************
143 
148  template< typename MT2 >
149  struct UseSMPAssign {
150  enum : bool { value = MT2::smpAssignable && useAssign };
151  };
153  //**********************************************************************************************
154 
155  //**********************************************************************************************
157 
161  template< typename MT2 >
162  struct GetConstIterator {
164  struct Success { using Type = typename MT2::ConstIterator; };
165  struct Failure { using Type = INVALID_TYPE; };
166  using Type = typename If_< HasConstIterator<MT2>, Success, Failure >::Type;
167  };
169  //**********************************************************************************************
170 
171  public:
172  //**Type definitions****************************************************************************
179 
182 
184  typedef typename GetConstIterator<MT>::Type ConstIterator;
185 
187  typedef If_< IsExpression<MT>, const MT, const MT& > Operand;
188  //**********************************************************************************************
189 
190  //**Compilation flags***************************************************************************
192  enum : bool { simdEnabled = MT::simdEnabled };
193 
195  enum : bool { smpAssignable = MT::smpAssignable };
196  //**********************************************************************************************
197 
198  //**SIMD properties*****************************************************************************
200  enum : size_t { SIMDSIZE = SIMDTrait<ElementType>::size };
201  //**********************************************************************************************
202 
203  //**Constructor*********************************************************************************
208  explicit inline DMatTransExpr( const MT& dm ) noexcept
209  : dm_( dm ) // Dense matrix of the transposition expression
210  {}
211  //**********************************************************************************************
212 
213  //**Access operator*****************************************************************************
220  inline ReturnType operator()( size_t i, size_t j ) const {
221  BLAZE_INTERNAL_ASSERT( i < dm_.columns(), "Invalid row access index" );
222  BLAZE_INTERNAL_ASSERT( j < dm_.rows() , "Invalid column access index" );
223  return dm_(j,i);
224  }
225  //**********************************************************************************************
226 
227  //**At function*********************************************************************************
235  inline ReturnType at( size_t i, size_t j ) const {
236  if( i >= dm_.columns() ) {
237  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
238  }
239  if( j >= dm_.rows() ) {
240  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
241  }
242  return (*this)(i,j);
243  }
244  //**********************************************************************************************
245 
246  //**Load function*******************************************************************************
253  BLAZE_ALWAYS_INLINE auto load( size_t i, size_t j ) const noexcept {
254  BLAZE_INTERNAL_ASSERT( i < dm_.columns(), "Invalid row access index" );
255  BLAZE_INTERNAL_ASSERT( j < dm_.rows() , "Invalid column access index" );
256  BLAZE_INTERNAL_ASSERT( !SO || ( i % SIMDSIZE == 0UL ), "Invalid row access index" );
257  BLAZE_INTERNAL_ASSERT( SO || ( j % SIMDSIZE == 0UL ), "Invalid column access index" );
258  return dm_.load(j,i);
259  }
260  //**********************************************************************************************
261 
262  //**Low-level data access***********************************************************************
267  inline const ElementType* data() const noexcept {
268  return dm_.data();
269  }
270  //**********************************************************************************************
271 
272  //**Begin function******************************************************************************
278  inline ConstIterator begin( size_t i ) const {
279  return ConstIterator( dm_.begin(i) );
280  }
281  //**********************************************************************************************
282 
283  //**End function********************************************************************************
289  inline ConstIterator end( size_t i ) const {
290  return ConstIterator( dm_.end(i) );
291  }
292  //**********************************************************************************************
293 
294  //**Rows function*******************************************************************************
299  inline size_t rows() const noexcept {
300  return dm_.columns();
301  }
302  //**********************************************************************************************
303 
304  //**Columns function****************************************************************************
309  inline size_t columns() const noexcept {
310  return dm_.rows();
311  }
312  //**********************************************************************************************
313 
314  //**Spacing function****************************************************************************
319  inline size_t spacing() const noexcept {
320  return dm_.spacing();
321  }
322  //**********************************************************************************************
323 
324  //**NonZeros function***************************************************************************
329  inline size_t nonZeros() const {
330  return dm_.nonZeros();
331  }
332  //**********************************************************************************************
333 
334  //**NonZeros function***************************************************************************
340  inline size_t nonZeros( size_t i ) const {
341  return dm_.nonZeros( i );
342  }
343  //**********************************************************************************************
344 
345  //**Operand access******************************************************************************
350  inline Operand operand() const noexcept {
351  return dm_;
352  }
353  //**********************************************************************************************
354 
355  //**********************************************************************************************
361  template< typename T >
362  inline bool canAlias( const T* alias ) const noexcept {
363  return dm_.isAliased( alias );
364  }
365  //**********************************************************************************************
366 
367  //**********************************************************************************************
373  template< typename T >
374  inline bool isAliased( const T* alias ) const noexcept {
375  return dm_.isAliased( alias );
376  }
377  //**********************************************************************************************
378 
379  //**********************************************************************************************
384  inline bool isAligned() const noexcept {
385  return dm_.isAligned();
386  }
387  //**********************************************************************************************
388 
389  //**********************************************************************************************
394  inline bool canSMPAssign() const noexcept {
395  return dm_.canSMPAssign();
396  }
397  //**********************************************************************************************
398 
399  private:
400  //**Member variables****************************************************************************
401  Operand dm_;
402  //**********************************************************************************************
403 
404  //**Assignment to dense matrices****************************************************************
418  template< typename MT2 // Type of the target dense matrix
419  , bool SO2 > // Storage order of the target dense matrix
420  friend inline EnableIf_< UseAssign<MT2> >
421  assign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& 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  DMatTransposer<MT2,!SO2> tmp( ~lhs );
429  assign( tmp, rhs.dm_ );
430  }
432  //**********************************************************************************************
433 
434  //**Assignment to sparse matrices***************************************************************
448  template< typename MT2 // Type of the target sparse matrix
449  , bool SO2 > // Storage order of the target sparse matrix
450  friend inline EnableIf_< UseAssign<MT2> >
451  assign( SparseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
452  {
454 
456 
463 
464  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
465  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
466 
467  const TmpType tmp( serial( rhs ) );
468  assign( ~lhs, tmp );
469  }
471  //**********************************************************************************************
472 
473  //**Addition assignment to dense matrices*******************************************************
487  template< typename MT2 // Type of the target dense matrix
488  , bool SO2 > // Storage order of the target dense matrix
489  friend inline EnableIf_< UseAssign<MT2> >
490  addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& 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  DMatTransposer<MT2,!SO2> tmp( ~lhs );
498  addAssign( tmp, rhs.dm_ );
499  }
501  //**********************************************************************************************
502 
503  //**Addition assignment to sparse matrices******************************************************
504  // No special implementation for the addition assignment to sparse matrices.
505  //**********************************************************************************************
506 
507  //**Subtraction assignment to dense matrices****************************************************
521  template< typename MT2 // Type of the target dense matrix
522  , bool SO2 > // Storage order of the target dense matrix
523  friend inline EnableIf_< UseAssign<MT2> >
524  subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
525  {
527 
528  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
529  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
530 
531  DMatTransposer<MT2,!SO2> tmp( ~lhs );
532  subAssign( tmp, rhs.dm_ );
533  }
535  //**********************************************************************************************
536 
537  //**Subtraction assignment to sparse matrices***************************************************
538  // No special implementation for the subtraction assignment to sparse matrices.
539  //**********************************************************************************************
540 
541  //**Multiplication assignment to dense matrices*************************************************
542  // No special implementation for the multiplication assignment to dense matrices.
543  //**********************************************************************************************
544 
545  //**Multiplication assignment to sparse matrices************************************************
546  // No special implementation for the multiplication assignment to sparse matrices.
547  //**********************************************************************************************
548 
549  //**SMP assignment to dense matrices************************************************************
563  template< typename MT2 // Type of the target dense matrix
564  , bool SO2 > // Storage order of the target dense matrix
565  friend inline EnableIf_< UseSMPAssign<MT2> >
566  smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
567  {
569 
570  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
571  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
572 
573  DMatTransposer<MT2,!SO2> tmp( ~lhs );
574  smpAssign( tmp, rhs.dm_ );
575  }
577  //**********************************************************************************************
578 
579  //**SMP assignment to sparse matrices***********************************************************
593  template< typename MT2 // Type of the target sparse matrix
594  , bool SO2 > // Storage order of the target sparse matrix
595  friend inline EnableIf_< UseSMPAssign<MT2> >
596  smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
597  {
599 
601 
608 
609  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
610  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
611 
612  const TmpType tmp( rhs );
613  smpAssign( ~lhs, tmp );
614  }
616  //**********************************************************************************************
617 
618  //**SMP addition assignment to dense matrices***************************************************
632  template< typename MT2 // Type of the target dense matrix
633  , bool SO2 > // Storage order of the target dense matrix
634  friend inline EnableIf_< UseSMPAssign<MT2> >
636  {
638 
639  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
640  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
641 
642  DMatTransposer<MT2,!SO2> tmp( ~lhs );
643  smpAddAssign( tmp, rhs.dm_ );
644  }
646  //**********************************************************************************************
647 
648  //**SMP addition assignment to sparse matrices**************************************************
649  // No special implementation for the SMP addition assignment to sparse matrices.
650  //**********************************************************************************************
651 
652  //**SMP subtraction assignment to dense matrices************************************************
666  template< typename MT2 // Type of the target dense matrix
667  , bool SO2 > // Storage order of the target dense matrix
668  friend inline EnableIf_< UseSMPAssign<MT2> >
670  {
672 
673  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
674  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
675 
676  DMatTransposer<MT2,!SO2> tmp( ~lhs );
677  smpSubAssign( tmp, rhs.dm_ );
678  }
680  //**********************************************************************************************
681 
682  //**SMP subtraction assignment to sparse matrices***********************************************
683  // No special implementation for the SMP subtraction assignment to sparse matrices.
684  //**********************************************************************************************
685 
686  //**SMP multiplication assignment to dense matrices*********************************************
687  // No special implementation for the SMP multiplication assignment to dense matrices.
688  //**********************************************************************************************
689 
690  //**SMP multiplication assignment to sparse matrices********************************************
691  // No special implementation for the SMP multiplication assignment to sparse matrices.
692  //**********************************************************************************************
693 
694  //**Compile time checks*************************************************************************
699  //**********************************************************************************************
700 };
701 //*************************************************************************************************
702 
703 
704 
705 
706 //=================================================================================================
707 //
708 // GLOBAL OPERATORS
709 //
710 //=================================================================================================
711 
712 //*************************************************************************************************
731 template< typename MT // Type of the dense matrix
732  , bool SO > // Storage order
734 {
736 
737  return DMatTransExpr<MT,!SO>( ~dm );
738 }
739 //*************************************************************************************************
740 
741 
742 
743 
744 //=================================================================================================
745 //
746 // GLOBAL RESTRUCTURING FUNCTIONS
747 //
748 //=================================================================================================
749 
750 //*************************************************************************************************
770 template< typename MT // Type of the dense matrix
771  , bool SO > // Storage order
772 inline typename DMatTransExpr<MT,SO>::Operand trans( const DMatTransExpr<MT,SO>& dm )
773 {
775 
776  return dm.operand();
777 }
779 //*************************************************************************************************
780 
781 
782 //*************************************************************************************************
794 template< typename MT // Type of the left-hand side dense matrix
795  , typename ST // Type of the right-hand side scalar value
796  , bool SO > // Storage order
797 inline const MultExprTrait_< TransExprTrait_<MT>, ST >
799 {
801 
802  return trans( dm.leftOperand() ) * dm.rightOperand();
803 }
805 //*************************************************************************************************
806 
807 
808 
809 
810 //=================================================================================================
811 //
812 // ROWS SPECIALIZATIONS
813 //
814 //=================================================================================================
815 
816 //*************************************************************************************************
818 template< typename MT, bool SO >
819 struct Rows< DMatTransExpr<MT,SO> > : public Columns<MT>
820 {};
822 //*************************************************************************************************
823 
824 
825 
826 
827 //=================================================================================================
828 //
829 // COLUMNS SPECIALIZATIONS
830 //
831 //=================================================================================================
832 
833 //*************************************************************************************************
835 template< typename MT, bool SO >
836 struct Columns< DMatTransExpr<MT,SO> > : public Rows<MT>
837 {};
839 //*************************************************************************************************
840 
841 
842 
843 
844 //=================================================================================================
845 //
846 // ISALIGNED SPECIALIZATIONS
847 //
848 //=================================================================================================
849 
850 //*************************************************************************************************
852 template< typename MT, bool SO >
853 struct IsAligned< DMatTransExpr<MT,SO> >
854  : public BoolConstant< IsAligned<MT>::value >
855 {};
857 //*************************************************************************************************
858 
859 
860 
861 
862 //=================================================================================================
863 //
864 // ISPADDED SPECIALIZATIONS
865 //
866 //=================================================================================================
867 
868 //*************************************************************************************************
870 template< typename MT, bool SO >
871 struct IsPadded< DMatTransExpr<MT,SO> >
872  : public BoolConstant< IsPadded<MT>::value >
873 {};
875 //*************************************************************************************************
876 
877 
878 
879 
880 //=================================================================================================
881 //
882 // ISSYMMETRIC SPECIALIZATIONS
883 //
884 //=================================================================================================
885 
886 //*************************************************************************************************
888 template< typename MT, bool SO >
889 struct IsSymmetric< DMatTransExpr<MT,SO> >
890  : public BoolConstant< IsSymmetric<MT>::value >
891 {};
893 //*************************************************************************************************
894 
895 
896 
897 
898 //=================================================================================================
899 //
900 // ISHERMITIAN SPECIALIZATIONS
901 //
902 //=================================================================================================
903 
904 //*************************************************************************************************
906 template< typename MT, bool SO >
907 struct IsHermitian< DMatTransExpr<MT,SO> >
908  : public BoolConstant< IsHermitian<MT>::value >
909 {};
911 //*************************************************************************************************
912 
913 
914 
915 
916 //=================================================================================================
917 //
918 // ISLOWER SPECIALIZATIONS
919 //
920 //=================================================================================================
921 
922 //*************************************************************************************************
924 template< typename MT, bool SO >
925 struct IsLower< DMatTransExpr<MT,SO> >
926  : public BoolConstant< IsUpper<MT>::value >
927 {};
929 //*************************************************************************************************
930 
931 
932 
933 
934 //=================================================================================================
935 //
936 // ISUNILOWER SPECIALIZATIONS
937 //
938 //=================================================================================================
939 
940 //*************************************************************************************************
942 template< typename MT, bool SO >
943 struct IsUniLower< DMatTransExpr<MT,SO> >
944  : public BoolConstant< IsUniUpper<MT>::value >
945 {};
947 //*************************************************************************************************
948 
949 
950 
951 
952 //=================================================================================================
953 //
954 // ISSTRICTLYLOWER SPECIALIZATIONS
955 //
956 //=================================================================================================
957 
958 //*************************************************************************************************
960 template< typename MT, bool SO >
961 struct IsStrictlyLower< DMatTransExpr<MT,SO> >
962  : public BoolConstant< IsStrictlyUpper<MT>::value >
963 {};
965 //*************************************************************************************************
966 
967 
968 
969 
970 //=================================================================================================
971 //
972 // ISUPPER SPECIALIZATIONS
973 //
974 //=================================================================================================
975 
976 //*************************************************************************************************
978 template< typename MT, bool SO >
979 struct IsUpper< DMatTransExpr<MT,SO> >
980  : public BoolConstant< IsLower<MT>::value >
981 {};
983 //*************************************************************************************************
984 
985 
986 
987 
988 //=================================================================================================
989 //
990 // ISUNIUPPER SPECIALIZATIONS
991 //
992 //=================================================================================================
993 
994 //*************************************************************************************************
996 template< typename MT, bool SO >
997 struct IsUniUpper< DMatTransExpr<MT,SO> >
998  : public BoolConstant< IsUniLower<MT>::value >
999 {};
1001 //*************************************************************************************************
1002 
1003 
1004 
1005 
1006 //=================================================================================================
1007 //
1008 // ISSTRICTLYUPPER SPECIALIZATIONS
1009 //
1010 //=================================================================================================
1011 
1012 //*************************************************************************************************
1014 template< typename MT, bool SO >
1015 struct IsStrictlyUpper< DMatTransExpr<MT,SO> >
1016  : public BoolConstant< IsStrictlyLower<MT>::value >
1017 {};
1019 //*************************************************************************************************
1020 
1021 
1022 
1023 
1024 //=================================================================================================
1025 //
1026 // EXPRESSION TRAIT SPECIALIZATIONS
1027 //
1028 //=================================================================================================
1029 
1030 //*************************************************************************************************
1032 template< typename MT >
1033 struct DMatTransExprTrait< DMatTransExpr<MT,false> >
1034 {
1035  public:
1036  //**********************************************************************************************
1039  , INVALID_TYPE >;
1040  //**********************************************************************************************
1041 };
1043 //*************************************************************************************************
1044 
1045 
1046 //*************************************************************************************************
1048 template< typename MT >
1049 struct TDMatTransExprTrait< DMatTransExpr<MT,true> >
1050 {
1051  public:
1052  //**********************************************************************************************
1055  , INVALID_TYPE >;
1056  //**********************************************************************************************
1057 };
1059 //*************************************************************************************************
1060 
1061 
1062 //*************************************************************************************************
1064 template< typename MT, typename ST >
1065 struct DMatTransExprTrait< DMatScalarMultExpr<MT,ST,false> >
1066 {
1067  public:
1068  //**********************************************************************************************
1070  , MultExprTrait_< TransExprTrait_<MT>, ST >
1071  , INVALID_TYPE >;
1072  //**********************************************************************************************
1073 };
1075 //*************************************************************************************************
1076 
1077 
1078 //*************************************************************************************************
1080 template< typename MT, typename ST >
1081 struct TDMatTransExprTrait< DMatScalarMultExpr<MT,ST,true> >
1082 {
1083  public:
1084  //**********************************************************************************************
1086  , MultExprTrait_< TransExprTrait_<MT>, ST >
1087  , INVALID_TYPE >;
1088  //**********************************************************************************************
1089 };
1091 //*************************************************************************************************
1092 
1093 
1094 //*************************************************************************************************
1096 template< typename MT, bool SO, bool AF >
1097 struct SubmatrixExprTrait< DMatTransExpr<MT,SO>, AF >
1098 {
1099  public:
1100  //**********************************************************************************************
1102  //**********************************************************************************************
1103 };
1105 //*************************************************************************************************
1106 
1107 
1108 //*************************************************************************************************
1110 template< typename MT, bool SO >
1111 struct RowExprTrait< DMatTransExpr<MT,SO> >
1112 {
1113  public:
1114  //**********************************************************************************************
1116  //**********************************************************************************************
1117 };
1119 //*************************************************************************************************
1120 
1121 
1122 //*************************************************************************************************
1124 template< typename MT, bool SO >
1125 struct ColumnExprTrait< DMatTransExpr<MT,SO> >
1126 {
1127  public:
1128  //**********************************************************************************************
1130  //**********************************************************************************************
1131 };
1133 //*************************************************************************************************
1134 
1135 } // namespace blaze
1136 
1137 #endif
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
size_t spacing() const noexcept
Returns the spacing between the beginning of two rows/columns.
Definition: DMatTransExpr.h:319
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
Compile time type selection.The If class template selects one of the two given types T2 and T3 depend...
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:384
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 serial shim.
Expression object for dense matrix transpositions.The DMatTransExpr class represents the compile time...
Definition: DMatTransExpr.h:112
#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 MatTransExpr base class.
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatTransExpr.h:394
#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
Header file for the ColumnExprTrait class template.
const ElementType * data() const noexcept
Low-level data access to the matrix elements.
Definition: DMatTransExpr.h:267
Header file for the IsColumnMajorMatrix type trait.
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
ResultType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DMatTransExpr.h:176
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the dense matrix expression.
Definition: DMatTransExpr.h:187
TransposeType_< MT > ResultType
Result type for expression template evaluations.
Definition: DMatTransExpr.h:174
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
Header file for the Computation base class.
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: DMatTransExpr.h:178
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
Operand operand() const noexcept
Returns the dense matrix operand.
Definition: DMatTransExpr.h:350
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatTransExpr.h:309
Header file for the RequiresEvaluation type trait.
Operand dm_
Dense matrix of the transposition expression.
Definition: DMatTransExpr.h:401
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: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
BLAZE_ALWAYS_INLINE auto load(size_t i, size_t j) const noexcept
Access to the SIMD elements of the matrix.
Definition: DMatTransExpr.h:253
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
Constraint on the data type.
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:343
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.
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 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
Header file for the DMatTransExprTrait class template.
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
typename TransExprTrait< T >::Type TransExprTrait_
Auxiliary alias declaration for the TransExprTrait class template.The TransExprTrait_ alias declarati...
Definition: TransExprTrait.h:143
ResultType_< MT > RT
Result type of the dense matrix expression.
Definition: DMatTransExpr.h:118
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
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
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
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: DMatTransExpr.h:289
Evaluation of the expression type of a dense matrix transpose operation.Via this type trait it is pos...
Definition: DMatTransExprTrait.h:74
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2939
IfTrue_< useAssign, const ResultType, const DMatTransExpr &> CompositeType
Data type for composite expression templates.
Definition: DMatTransExpr.h:181
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:98
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatTransExpr.h:299
Expression object for dense matrix-scalar multiplications.The DMatScalarMultExpr class represents the...
Definition: DMatScalarMultExpr.h:123
#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.
Header file for the Columns type trait.
ElementType_< MT > ElementType
Resulting element type.
Definition: DMatTransExpr.h:177
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:80
Header file for the TDMatTransExprTrait class template.
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.
Header file for the IsAligned type trait.
RightOperand rightOperand() const noexcept
Returns the right-hand side scalar operand.
Definition: DMatScalarMultExpr.h:580
#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:60
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
Evaluation of the expression type type of a row operation.Via this type trait it is possible to evalu...
Definition: RowExprTrait.h:79
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Header file for the IsDenseMatrix type trait.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatTransExpr.h:362
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Header file for the IsPadded type trait.
CompositeType_< MT > CT
Composite type of the dense matrix expression.
Definition: DMatTransExpr.h:119
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatTransExpr.h:374
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatTransExpr.h:220
Header file for the dense matrix transposer.
Header file for the IsNumeric type trait.
GetConstIterator< MT >::Type ConstIterator
Iterator over the elements of the dense matrix.
Definition: DMatTransExpr.h:184
DMatTransExpr(const MT &dm) noexcept
Constructor for the DMatTransExpr class.
Definition: DMatTransExpr.h:208
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.
size_t nonZeros() const
Returns the number of non-zero elements in the dense matrix.
Definition: DMatTransExpr.h:329
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
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: DMatTransExpr.h:278
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:93
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 TransExprTrait class template.
Base class for all matrix transposition expression templates.The MatTransExpr class serves as a tag f...
Definition: MatTransExpr.h:65
Header file for the HasMember type traits.
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
#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
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
Header file for the IsRowMajorMatrix type trait.
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:733
Header file for the IsComputation type trait class.
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTransExpr.h:175
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 empty type.
DMatTransExpr< MT, SO > This
Type of this DMatTransExpr instance.
Definition: DMatTransExpr.h:173
Evaluation of the expression type of a dense matrix transpose operation.Via this type trait it is pos...
Definition: TDMatTransExprTrait.h:74
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:340
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense matrix operand.
Definition: DMatScalarMultExpr.h:570
System settings for the inline keywords.
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
typename T::Operand Operand_
Alias declaration for nested Operand type definitions.The Operand_ alias declaration provides a conve...
Definition: Aliases.h:223
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:235