All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DMatTransposer.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATTRANSPOSER_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATTRANSPOSER_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
49 #include <blaze/util/Assert.h>
50 #include <blaze/util/EnableIf.h>
51 #include <blaze/util/Types.h>
53 
54 
55 namespace blaze {
56 
57 //=================================================================================================
58 //
59 // CLASS DMATTRANSPOSER
60 //
61 //=================================================================================================
62 
63 //*************************************************************************************************
69 template< typename MT // Type of the dense matrix
70  , bool SO > // Storage order
71 class DMatTransposer : public DenseMatrix< DMatTransposer<MT,SO>, SO >
72 {
73  private:
74  //**Type definitions****************************************************************************
76  //**********************************************************************************************
77 
78  public:
79  //**Type definitions****************************************************************************
81  typedef typename MT::TransposeType ResultType;
82  typedef typename MT::OppositeType OppositeType;
83  typedef typename MT::ResultType TransposeType;
84  typedef typename MT::ElementType ElementType;
85  typedef typename IT::Type IntrinsicType;
86  typedef typename MT::ReturnType ReturnType;
87  typedef const This& CompositeType;
88  typedef typename MT::Reference Reference;
90  typedef typename MT::Iterator Iterator;
91  typedef typename MT::ConstIterator ConstIterator;
92  //**********************************************************************************************
93 
94  //**Compilation flags***************************************************************************
96 
99  enum { vectorizable = MT::vectorizable };
100 
102 
105  enum { smpAssignable = MT::smpAssignable };
106  //**********************************************************************************************
107 
108  //**Constructor*********************************************************************************
113  explicit inline DMatTransposer( MT& dm )
114  : dm_( dm ) // The dense matrix operand
115  {}
116  //**********************************************************************************************
117 
118  //**Access operator*****************************************************************************
125  inline Reference operator()( size_t i, size_t j ) {
126  BLAZE_INTERNAL_ASSERT( i < dm_.columns(), "Invalid row access index" );
127  BLAZE_INTERNAL_ASSERT( j < dm_.rows() , "Invalid column access index" );
128  return dm_(j,i);
129  }
130  //**********************************************************************************************
131 
132  //**Access operator*****************************************************************************
139  inline ConstReference operator()( size_t i, size_t j ) const {
140  BLAZE_INTERNAL_ASSERT( i < dm_.columns(), "Invalid row access index" );
141  BLAZE_INTERNAL_ASSERT( j < dm_.rows() , "Invalid column access index" );
142  return dm_(j,i);
143  }
144  //**********************************************************************************************
145 
146  //**Low-level data access***********************************************************************
151  inline ElementType* data() {
152  return dm_.data();
153  }
154  //**********************************************************************************************
155 
156  //**Begin function******************************************************************************
167  inline ConstIterator begin( size_t i ) const {
168  return dm_.cbegin( i );
169  }
170  //**********************************************************************************************
171 
172  //**Cbegin function*****************************************************************************
183  inline ConstIterator cbegin( size_t i ) const {
184  return dm_.cbegin( i );
185  }
186  //**********************************************************************************************
187 
188  //**End function********************************************************************************
199  inline ConstIterator end( size_t i ) const {
200  return dm_.cend( i );
201  }
202  //**********************************************************************************************
203 
204  //**Cend function*******************************************************************************
215  inline ConstIterator cend( size_t i ) const {
216  return dm_.cend( i );
217  }
218  //**********************************************************************************************
219 
220  //**Multiplication assignment operator**********************************************************
227  template< typename Other > // Data type of the right-hand side scalar
228  inline typename EnableIf< IsNumeric<Other>, DMatTransposer >::Type& operator*=( Other rhs )
229  {
230  (~dm_) *= rhs;
231  return *this;
232  }
233  //**********************************************************************************************
234 
235  //**Division assignment operator****************************************************************
244  template< typename Other > // Data type of the right-hand side scalar
245  inline typename EnableIf< IsNumeric<Other>, DMatTransposer >::Type& operator/=( Other rhs )
246  {
247  BLAZE_USER_ASSERT( rhs != Other(0), "Division by zero detected" );
248 
249  (~dm_) /= rhs;
250  return *this;
251  }
252  //**********************************************************************************************
253 
254  //**Rows function*******************************************************************************
259  inline size_t rows() const {
260  return dm_.columns();
261  }
262  //**********************************************************************************************
263 
264  //**Columns function****************************************************************************
269  inline size_t columns() const {
270  return dm_.rows();
271  }
272  //**********************************************************************************************
273 
274  //**Spacing function****************************************************************************
279  inline size_t spacing() const {
280  return dm_.spacing();
281  }
282  //**********************************************************************************************
283 
284  //**Reset function******************************************************************************
289  inline void reset() {
290  return dm_.reset();
291  }
292  //**********************************************************************************************
293 
294  //**CanAliased function*************************************************************************
300  template< typename Other > // Data type of the foreign expression
301  inline bool canAlias( const Other* alias ) const
302  {
303  return dm_.canAlias( alias );
304  }
305  //**********************************************************************************************
306 
307  //**IsAliased function**************************************************************************
313  template< typename Other > // Data type of the foreign expression
314  inline bool isAliased( const Other* alias ) const
315  {
316  return dm_.isAliased( alias );
317  }
318  //**********************************************************************************************
319 
320  //**IsAligned function**************************************************************************
325  inline bool isAligned() const
326  {
327  return dm_.isAligned();
328  }
329  //**********************************************************************************************
330 
331  //**Load function*******************************************************************************
342  inline IntrinsicType load( size_t i, size_t j ) const
343  {
344  return dm_.load( j, i );
345  }
346  //**********************************************************************************************
347 
348  //**Loadu function******************************************************************************
359  inline IntrinsicType loadu( size_t i, size_t j ) const
360  {
361  return dm_.loadu( j, i );
362  }
363  //**********************************************************************************************
364 
365  //**Store function******************************************************************************
377  inline void store( size_t i, size_t j, const IntrinsicType& value )
378  {
379  dm_.store( j, i, value );
380  }
381  //**********************************************************************************************
382 
383  //**Storeu function*****************************************************************************
395  inline void storeu( size_t i, size_t j, const IntrinsicType& value )
396  {
397  dm_.storeu( j, i, value );
398  }
399  //**********************************************************************************************
400 
401  //**Stream function*****************************************************************************
413  inline void stream( size_t i, size_t j, const IntrinsicType& value )
414  {
415  dm_.stream( j, i, value );
416  }
417  //**********************************************************************************************
418 
419  //**Transpose assignment of row-major dense matrices********************************************
430  template< typename MT2 > // Type of the right-hand side dense matrix
431  inline void assign( const DenseMatrix<MT2,SO>& rhs )
432  {
434 
435  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
436  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
437 
438  const size_t m( rows() );
439  const size_t n( columns() );
440 
441  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ( n & size_t(-2) ), "Invalid end calculation" );
442  const size_t jend( n & size_t(-2) );
443 
444  for( size_t i=0UL; i<m; ++i ) {
445  for( size_t j=0UL; j<jend; j+=2UL ) {
446  dm_(j ,i) = (~rhs)(i,j );
447  dm_(j+1UL,i) = (~rhs)(i,j+1UL);
448  }
449  if( jend < n ) {
450  dm_(jend,i) = (~rhs)(i,jend);
451  }
452  }
453  }
454  //**********************************************************************************************
455 
456  //**Transpose assignment of column-major dense matrices*****************************************
467  template< typename MT2 > // Type of the right-hand side dense matrix
468  inline void assign( const DenseMatrix<MT2,!SO>& rhs )
469  {
471 
472  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
473  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
474 
475  const size_t m( rows() );
476  const size_t n( columns() );
477  const size_t block( 16UL );
478 
479  for( size_t ii=0UL; ii<m; ii+=block ) {
480  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
481  for( size_t jj=0UL; jj<n; jj+=block ) {
482  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
483  for( size_t i=ii; i<iend; ++i ) {
484  for( size_t j=jj; j<jend; ++j ) {
485  dm_(j,i) = (~rhs)(i,j);
486  }
487  }
488  }
489  }
490  }
491  //**********************************************************************************************
492 
493  //**Transpose assignment of row-major sparse matrices*******************************************
504  template< typename MT2 > // Type of the right-hand side sparse matrix
505  inline void assign( const SparseMatrix<MT2,SO>& rhs )
506  {
508 
509  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
510  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
511 
512  typedef typename MT2::ConstIterator RhsConstIterator;
513 
514  for( size_t i=0UL; i<(~rhs).rows(); ++i )
515  for( RhsConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
516  dm_(element->index(),i) = element->value();
517  }
518  //**********************************************************************************************
519 
520  //**Transpose assignment of column-major sparse matrices****************************************
531  template< typename MT2 > // Type of the right-hand side sparse matrix
532  inline void assign( const SparseMatrix<MT2,!SO>& rhs )
533  {
535 
536  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
537  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
538 
539  typedef typename MT2::ConstIterator RhsConstIterator;
540 
541  for( size_t j=0UL; j<(~rhs).columns(); ++j )
542  for( RhsConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
543  dm_(j,element->index()) = element->value();
544  }
545  //**********************************************************************************************
546 
547  //**Transpose addition assignment of row-major dense matrices***********************************
558  template< typename MT2 > // Type of the right-hand side dense matrix
559  inline void addAssign( const DenseMatrix<MT2,SO>& rhs )
560  {
562 
563  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
564  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
565 
566  const size_t m( rows() );
567  const size_t n( columns() );
568 
569  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ( n & size_t(-2) ), "Invalid end calculation" );
570  const size_t jend( n & size_t(-2) );
571 
572  for( size_t i=0UL; i<m; ++i ) {
573  for( size_t j=0UL; j<jend; j+=2UL ) {
574  dm_(j ,i) += (~rhs)(i,j );
575  dm_(j+1UL,i) += (~rhs)(i,j+1UL);
576 
577  }
578  if( jend < n ) {
579  dm_(jend,i) += (~rhs)(i,jend);
580  }
581  }
582  }
583  //**********************************************************************************************
584 
585  //**Transpose addition assignment of column-major dense matrices********************************
596  template< typename MT2 > // Type of the right-hand side dense matrix
597  inline void addAssign( const DenseMatrix<MT2,!SO>& rhs )
598  {
600 
601  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
602  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
603 
604  const size_t m( rows() );
605  const size_t n( columns() );
606  const size_t block( 16UL );
607 
608  for( size_t ii=0UL; ii<m; ii+=block ) {
609  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
610  for( size_t jj=0UL; jj<n; jj+=block ) {
611  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
612  for( size_t i=ii; i<iend; ++i ) {
613  for( size_t j=jj; j<jend; ++j ) {
614  dm_(j,i) += (~rhs)(i,j);
615  }
616  }
617  }
618  }
619  }
620  //**********************************************************************************************
621 
622  //**Transpose addition assignment of row-major sparse matrices**********************************
633  template< typename MT2 > // Type of the right-hand side sparse matrix
634  inline void addAssign( const SparseMatrix<MT2,SO>& rhs )
635  {
637 
638  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
639  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
640 
641  typedef typename MT2::ConstIterator RhsConstIterator;
642 
643  for( size_t i=0UL; i<(~rhs).rows(); ++i )
644  for( RhsConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
645  dm_(element->index(),i) += element->value();
646  }
647  //**********************************************************************************************
648 
649  //**Transpose addition assignment of column-major sparse matrices*******************************
660  template< typename MT2 > // Type of the right-hand side sparse matrix
661  inline void addAssign( const SparseMatrix<MT2,!SO>& rhs )
662  {
664 
665  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
666  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
667 
668  typedef typename MT2::ConstIterator RhsConstIterator;
669 
670  for( size_t j=0UL; j<(~rhs).columns(); ++j )
671  for( RhsConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
672  dm_(j,element->index()) += element->value();
673  }
674  //**********************************************************************************************
675 
676  //**Transpose subtraction assignment of row-major dense matrices********************************
687  template< typename MT2 > // Type of the right-hand side dense matrix
688  inline void subAssign( const DenseMatrix<MT2,SO>& rhs )
689  {
691 
692  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
693  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
694 
695  const size_t m( rows() );
696  const size_t n( columns() );
697 
698  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ( n & size_t(-2) ), "Invalid end calculation" );
699  const size_t jend( n & size_t(-2) );
700 
701  for( size_t i=0UL; i<m; ++i ) {
702  for( size_t j=0UL; j<jend; j+=2UL ) {
703  dm_(j ,i) -= (~rhs)(i,j );
704  dm_(j+1UL,i) -= (~rhs)(i,j+1UL);
705 
706  }
707  if( jend < n ) {
708  dm_(jend,i) -= (~rhs)(i,jend);
709  }
710  }
711  }
712  //**********************************************************************************************
713 
714  //**Transpose subtraction assignment of column-major dense matrices*****************************
725  template< typename MT2 > // Type of the right-hand side dense matrix
726  inline void subAssign( const DenseMatrix<MT2,!SO>& rhs )
727  {
729 
730  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
731  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
732 
733  const size_t m( rows() );
734  const size_t n( columns() );
735  const size_t block( 16UL );
736 
737  for( size_t ii=0UL; ii<m; ii+=block ) {
738  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
739  for( size_t jj=0UL; jj<n; jj+=block ) {
740  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
741  for( size_t i=ii; i<iend; ++i ) {
742  for( size_t j=jj; j<jend; ++j ) {
743  dm_(j,i) -= (~rhs)(i,j);
744  }
745  }
746  }
747  }
748  }
749  //**********************************************************************************************
750 
751  //**Transpose subtraction assignment of row-major sparse matrices*******************************
762  template< typename MT2 > // Type of the right-hand side sparse matrix
763  inline void subAssign( const SparseMatrix<MT2,SO>& rhs )
764  {
766 
767  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
768  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
769 
770  typedef typename MT2::ConstIterator RhsConstIterator;
771 
772  for( size_t i=0UL; i<(~rhs).rows(); ++i )
773  for( RhsConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
774  dm_(element->index(),i) -= element->value();
775  }
776  //**********************************************************************************************
777 
778  //**Transpose subtraction assignment of column-major dense matrices*****************************
789  template< typename MT2 > // Type of the right-hand side sparse matrix
790  inline void subAssign( const SparseMatrix<MT2,!SO>& rhs )
791  {
793 
794  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
795  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
796 
797  typedef typename MT2::ConstIterator RhsConstIterator;
798 
799  for( size_t j=0UL; j<(~rhs).columns(); ++j )
800  for( RhsConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
801  dm_(j,element->index()) -= element->value();
802  }
803  //**********************************************************************************************
804 
805  //**Transpose multiplication assignment of dense matrices***************************************
806  // No special implementation for the transpose multiplication assignment of dense matrices.
807  //**********************************************************************************************
808 
809  //**Transpose multiplication assignment of sparse matrices**************************************
810  // No special implementation for the transpose multiplication assignment of sparse matrices.
811  //**********************************************************************************************
812 
813  private:
814  //**Member variables****************************************************************************
815  MT& dm_;
816  //**********************************************************************************************
817 
818  //**Compile time checks*************************************************************************
824  //**********************************************************************************************
825 };
826 //*************************************************************************************************
827 
828 
829 
830 
831 //=================================================================================================
832 //
833 // CLASS TEMPLATE SPECIALIZATION FOR ROW-MAJOR MATRICES
834 //
835 //=================================================================================================
836 
837 //*************************************************************************************************
845 template< typename MT > // Type of the dense matrix
846 class DMatTransposer<MT,true> : public DenseMatrix< DMatTransposer<MT,true>, true >
847 {
848  private:
849  //**Type definitions****************************************************************************
851  //**********************************************************************************************
852 
853  public:
854  //**Type definitions****************************************************************************
855  typedef DMatTransposer<MT,true> This;
856  typedef typename MT::TransposeType ResultType;
857  typedef typename MT::OppositeType OppositeType;
858  typedef typename MT::ResultType TransposeType;
859  typedef typename MT::ElementType ElementType;
860  typedef typename IT::Type IntrinsicType;
861  typedef typename MT::ReturnType ReturnType;
862  typedef const This& CompositeType;
863  typedef typename MT::Reference Reference;
864  typedef typename MT::ConstReference ConstReference;
865  typedef typename MT::Iterator Iterator;
866  typedef typename MT::ConstIterator ConstIterator;
867  //**********************************************************************************************
868 
869  //**Compilation flags***************************************************************************
871 
874  enum { vectorizable = MT::vectorizable };
875 
877 
880  enum { smpAssignable = MT::smpAssignable };
881  //**********************************************************************************************
882 
883  //**Constructor*********************************************************************************
888  explicit inline DMatTransposer( MT& dm )
889  : dm_( dm ) // The dense matrix operand
890  {}
891  //**********************************************************************************************
892 
893  //**Access operator*****************************************************************************
900  inline Reference operator()( size_t i, size_t j ) {
901  BLAZE_INTERNAL_ASSERT( i < dm_.columns(), "Invalid row access index" );
902  BLAZE_INTERNAL_ASSERT( j < dm_.rows() , "Invalid column access index" );
903  return dm_(j,i);
904  }
905  //**********************************************************************************************
906 
907  //**Access operator*****************************************************************************
914  inline ConstReference operator()( size_t i, size_t j ) const {
915  BLAZE_INTERNAL_ASSERT( i < dm_.columns(), "Invalid row access index" );
916  BLAZE_INTERNAL_ASSERT( j < dm_.rows() , "Invalid column access index" );
917  return dm_(j,i);
918  }
919  //**********************************************************************************************
920 
921  //**Low-level data access***********************************************************************
926  inline ElementType* data() {
927  return dm_.data();
928  }
929  //**********************************************************************************************
930 
931  //**Begin function******************************************************************************
937  inline ConstIterator begin( size_t j ) const {
938  return dm_.cbegin(j);
939  }
940  //**********************************************************************************************
941 
942  //**Cbegin function*****************************************************************************
948  inline ConstIterator cbegin( size_t j ) const {
949  return dm_.cbegin(j);
950  }
951  //**********************************************************************************************
952 
953  //**End function********************************************************************************
959  inline ConstIterator end( size_t j ) const {
960  return dm_.cend(j);
961  }
962  //**********************************************************************************************
963 
964  //**Cend function*******************************************************************************
970  inline ConstIterator cend( size_t j ) const {
971  return dm_.cend(j);
972  }
973  //**********************************************************************************************
974 
975  //**Multiplication assignment operator**********************************************************
982  template< typename Other > // Data type of the right-hand side scalar
983  inline typename EnableIf< IsNumeric<Other>, DMatTransposer >::Type& operator*=( Other rhs )
984  {
985  (~dm_) *= rhs;
986  return *this;
987  }
988  //**********************************************************************************************
989 
990  //**Division assignment operator****************************************************************
999  template< typename Other > // Data type of the right-hand side scalar
1000  inline typename EnableIf< IsNumeric<Other>, DMatTransposer >::Type& operator/=( Other rhs )
1001  {
1002  BLAZE_USER_ASSERT( rhs != Other(0), "Division by zero detected" );
1003 
1004  (~dm_) /= rhs;
1005  return *this;
1006  }
1007  //**********************************************************************************************
1008 
1009  //**Rows function*******************************************************************************
1014  inline size_t rows() const {
1015  return dm_.columns();
1016  }
1017  //**********************************************************************************************
1018 
1019  //**Columns function****************************************************************************
1024  inline size_t columns() const {
1025  return dm_.rows();
1026  }
1027  //**********************************************************************************************
1028 
1029  //**Spacing function****************************************************************************
1034  inline size_t spacing() const {
1035  return dm_.spacing();
1036  }
1037  //**********************************************************************************************
1038 
1039  //**Reset function******************************************************************************
1044  inline void reset() {
1045  return dm_.reset();
1046  }
1047  //**********************************************************************************************
1048 
1049  //**CanAliased function*************************************************************************
1055  template< typename Other > // Data type of the foreign expression
1056  inline bool canAlias( const Other* alias ) const
1057  {
1058  return dm_.canAlias( alias );
1059  }
1060  //**********************************************************************************************
1061 
1062  //**IsAliased function**************************************************************************
1068  template< typename Other > // Data type of the foreign expression
1069  inline bool isAliased( const Other* alias ) const
1070  {
1071  return dm_.isAliased( alias );
1072  }
1073  //**********************************************************************************************
1074 
1075  //**IsAligned function**************************************************************************
1080  inline bool isAligned() const
1081  {
1082  return dm_.isAligned();
1083  }
1084  //**********************************************************************************************
1085 
1086  //**Load function*******************************************************************************
1097  inline IntrinsicType load( size_t i, size_t j ) const
1098  {
1099  return dm_.load( j, i );
1100  }
1101  //**********************************************************************************************
1102 
1103  //**Loadu function******************************************************************************
1114  inline IntrinsicType loadu( size_t i, size_t j ) const
1115  {
1116  return dm_.loadu( j, i );
1117  }
1118  //**********************************************************************************************
1119 
1120  //**Store function******************************************************************************
1132  inline void store( size_t i, size_t j, const IntrinsicType& value )
1133  {
1134  dm_.store( j, i, value );
1135  }
1136  //**********************************************************************************************
1137 
1138  //**Storeu function*****************************************************************************
1150  inline void storeu( size_t i, size_t j, const IntrinsicType& value )
1151  {
1152  dm_.storeu( j, i, value );
1153  }
1154  //**********************************************************************************************
1155 
1156  //**Stream function*****************************************************************************
1168  inline void stream( size_t i, size_t j, const IntrinsicType& value )
1169  {
1170  dm_.stream( j, i, value );
1171  }
1172  //**********************************************************************************************
1173 
1174  //**Transpose assignment of column-major dense matrices*****************************************
1185  template< typename MT2 > // Type of the right-hand side dense matrix
1186  inline void assign( const DenseMatrix<MT2,true>& rhs )
1187  {
1189 
1190  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
1191  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
1192 
1193  const size_t m( rows() );
1194  const size_t n( columns() );
1195 
1196  BLAZE_INTERNAL_ASSERT( ( m - ( m % 2UL ) ) == ( m & size_t(-2) ), "Invalid end calculation" );
1197  const size_t iend( m & size_t(-2) );
1198 
1199  for( size_t j=0UL; j<n; ++j ) {
1200  for( size_t i=0UL; i<iend; i+=2UL ) {
1201  dm_(j,i ) = (~rhs)(i ,j);
1202  dm_(j,i+1UL) = (~rhs)(i+1UL,j);
1203  }
1204  if( iend < m ) {
1205  dm_(j,iend) = (~rhs)(iend,j);
1206  }
1207  }
1208  }
1209  //**********************************************************************************************
1210 
1211  //**Transpose assignment of row-major dense matrices********************************************
1222  template< typename MT2 > // Type of the right-hand side dense matrix
1223  inline void assign( const DenseMatrix<MT2,false>& rhs )
1224  {
1226 
1227  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
1228  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
1229 
1230  const size_t m( rows() );
1231  const size_t n( columns() );
1232  const size_t block( 16UL );
1233 
1234  for( size_t jj=0UL; jj<n; jj+=block ) {
1235  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
1236  for( size_t ii=0UL; ii<m; ii+=block ) {
1237  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
1238  for( size_t j=jj; j<jend; ++j ) {
1239  for( size_t i=ii; i<iend; ++i ) {
1240  dm_(j,i) = (~rhs)(i,j);
1241  }
1242  }
1243  }
1244  }
1245  }
1246  //**********************************************************************************************
1247 
1248  //**Transpose assignment of column-major sparse matrices****************************************
1259  template< typename MT2 > // Type of the right-hand side sparse matrix
1260  inline void assign( const SparseMatrix<MT2,true>& rhs )
1261  {
1263 
1264  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
1265  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
1266 
1267  typedef typename MT2::ConstIterator RhsConstIterator;
1268 
1269  for( size_t j=0UL; j<(~rhs).columns(); ++j )
1270  for( RhsConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
1271  dm_(j,element->index()) = element->value();
1272  }
1273  //**********************************************************************************************
1274 
1275  //**Transpose assignment of row-major sparse matrices*******************************************
1286  template< typename MT2 > // Type of the right-hand side sparse matrix
1287  inline void assign( const SparseMatrix<MT2,false>& rhs )
1288  {
1290 
1291  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
1292  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
1293 
1294  typedef typename MT2::ConstIterator RhsConstIterator;
1295 
1296  for( size_t i=0UL; i<(~rhs).rows(); ++i )
1297  for( RhsConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
1298  dm_(element->index(),i) = element->value();
1299  }
1300  //**********************************************************************************************
1301 
1302  //**Transpose addition assignment of column-major dense matrices********************************
1313  template< typename MT2 > // Type of the right-hand side dense matrix
1314  inline void addAssign( const DenseMatrix<MT2,true>& rhs )
1315  {
1317 
1318  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
1319  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
1320 
1321  const size_t m( rows() );
1322  const size_t n( columns() );
1323 
1324  BLAZE_INTERNAL_ASSERT( ( m - ( m % 2UL ) ) == ( m & size_t(-2) ), "Invalid end calculation" );
1325  const size_t iend( m & size_t(-2) );
1326 
1327  for( size_t j=0UL; j<n; ++j ) {
1328  for( size_t i=0UL; i<iend; i+=2UL ) {
1329  dm_(j,i ) += (~rhs)(i ,j);
1330  dm_(j,i+1UL) += (~rhs)(i+1UL,j);
1331  }
1332  if( iend < m ) {
1333  dm_(j,iend) += (~rhs)(iend,j);
1334  }
1335  }
1336  }
1337  //**********************************************************************************************
1338 
1339  //**Transpose addition assignment of row-major dense matrices***********************************
1350  template< typename MT2 > // Type of the right-hand side dense matrix
1351  inline void addAssign( const DenseMatrix<MT2,false>& rhs )
1352  {
1354 
1355  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
1356  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
1357 
1358  const size_t m( rows() );
1359  const size_t n( columns() );
1360  const size_t block( 16UL );
1361 
1362  for( size_t jj=0UL; jj<n; jj+=block ) {
1363  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
1364  for( size_t ii=0UL; ii<m; ii+=block ) {
1365  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
1366  for( size_t j=jj; j<jend; ++j ) {
1367  for( size_t i=ii; i<iend; ++i ) {
1368  dm_(j,i) += (~rhs)(i,j);
1369  }
1370  }
1371  }
1372  }
1373  }
1374  //**********************************************************************************************
1375 
1376  //**Transpose addition assignment of column-major sparse matrices*******************************
1387  template< typename MT2 > // Type of the right-hand side sparse matrix
1388  inline void addAssign( const SparseMatrix<MT2,true>& rhs )
1389  {
1391 
1392  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
1393  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
1394 
1395  typedef typename MT2::ConstIterator RhsConstIterator;
1396 
1397  for( size_t j=0UL; j<(~rhs).columns(); ++j )
1398  for( RhsConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
1399  dm_(j,element->index()) += element->value();
1400  }
1401  //**********************************************************************************************
1402 
1403  //**Transpose addition assignment of row-major sparse matrices**********************************
1414  template< typename MT2 > // Type of the right-hand side sparse matrix
1415  inline void addAssign( const SparseMatrix<MT2,false>& rhs )
1416  {
1418 
1419  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
1420  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
1421 
1422  typedef typename MT2::ConstIterator RhsConstIterator;
1423 
1424  for( size_t i=0UL; i<(~rhs).rows(); ++i )
1425  for( RhsConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
1426  dm_(element->index(),i) += element->value();
1427  }
1428  //**********************************************************************************************
1429 
1430  //**Transpose subtraction assignment of column-major dense matrices*****************************
1441  template< typename MT2 > // Type of the right-hand side dense matrix
1442  inline void subAssign( const DenseMatrix<MT2,true>& rhs )
1443  {
1445 
1446  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
1447  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
1448 
1449  const size_t m( rows() );
1450  const size_t n( columns() );
1451 
1452  BLAZE_INTERNAL_ASSERT( ( m - ( m % 2UL ) ) == ( m & size_t(-2) ), "Invalid end calculation" );
1453  const size_t iend( m & size_t(-2) );
1454 
1455  for( size_t j=0UL; j<n; ++j ) {
1456  for( size_t i=0UL; i<iend; i+=2UL ) {
1457  dm_(j,i ) -= (~rhs)(i ,j);
1458  dm_(j,i+1UL) -= (~rhs)(i+1UL,j);
1459  }
1460  if( iend < m ) {
1461  dm_(j,iend) -= (~rhs)(iend,j);
1462  }
1463  }
1464  }
1465  //**********************************************************************************************
1466 
1467  //**Transpose subtraction assignment of row-major dense matrices********************************
1478  template< typename MT2 > // Type of the right-hand side dense matrix
1479  inline void subAssign( const DenseMatrix<MT2,false>& rhs )
1480  {
1482 
1483  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
1484  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
1485 
1486  const size_t m( rows() );
1487  const size_t n( columns() );
1488  const size_t block( 16UL );
1489 
1490  for( size_t jj=0UL; jj<n; jj+=block ) {
1491  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
1492  for( size_t ii=0UL; ii<m; ii+=block ) {
1493  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
1494  for( size_t j=jj; j<jend; ++j ) {
1495  for( size_t i=ii; i<iend; ++i ) {
1496  dm_(j,i) -= (~rhs)(i,j);
1497  }
1498  }
1499  }
1500  }
1501  }
1502  //**********************************************************************************************
1503 
1504  //**Transpose subtraction assignment of column-major sparse matrices****************************
1515  template< typename MT2 > // Type of the right-hand side sparse matrix
1516  inline void subAssign( const SparseMatrix<MT2,true>& rhs )
1517  {
1519 
1520  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
1521  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
1522 
1523  typedef typename MT2::ConstIterator RhsConstIterator;
1524 
1525  for( size_t j=0UL; j<(~rhs).columns(); ++j )
1526  for( RhsConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
1527  dm_(j,element->index()) -= element->value();
1528  }
1529  //**********************************************************************************************
1530 
1531  //**Transpose subtraction assignment of row-major dense matrices********************************
1542  template< typename MT2 > // Type of the right-hand side sparse matrix
1543  inline void subAssign( const SparseMatrix<MT2,false>& rhs )
1544  {
1546 
1547  BLAZE_INTERNAL_ASSERT( dm_.columns() == (~rhs).rows(), "Invalid number of rows" );
1548  BLAZE_INTERNAL_ASSERT( dm_.rows() == (~rhs).columns(), "Invalid number of columns" );
1549 
1550  typedef typename MT2::ConstIterator RhsConstIterator;
1551 
1552  for( size_t i=0UL; i<(~rhs).rows(); ++i )
1553  for( RhsConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
1554  dm_(element->index(),i) -= element->value();
1555  }
1556  //**********************************************************************************************
1557 
1558  //**Transpose multiplication assignment of dense matrices***************************************
1559  // No special implementation for the transpose multiplication assignment of dense matrices.
1560  //**********************************************************************************************
1561 
1562  //**Transpose multiplication assignment of sparse matrices**************************************
1563  // No special implementation for the transpose multiplication assignment of sparse matrices.
1564  //**********************************************************************************************
1565 
1566  private:
1567  //**Member variables****************************************************************************
1568  MT& dm_;
1569  //**********************************************************************************************
1570 
1571  //**Compile time checks*************************************************************************
1577  //**********************************************************************************************
1578 };
1580 //*************************************************************************************************
1581 
1582 
1583 
1584 
1585 //=================================================================================================
1586 //
1587 // GLOBAL OPERATORS
1588 //
1589 //=================================================================================================
1590 
1591 //*************************************************************************************************
1599 template< typename MT // Type of the dense matrix
1600  , bool SO > // Storage order
1601 inline void reset( DMatTransposer<MT,SO>& m )
1602 {
1603  m.reset();
1604 }
1606 //*************************************************************************************************
1607 
1608 
1609 
1610 
1611 //=================================================================================================
1612 //
1613 // SUBMATRIXTRAIT SPECIALIZATIONS
1614 //
1615 //=================================================================================================
1616 
1617 //*************************************************************************************************
1619 template< typename MT, bool SO >
1620 struct SubmatrixTrait< DMatTransposer<MT,SO> >
1621 {
1622  typedef typename SubmatrixTrait< typename DMatTransposer<MT,SO>::ResultType >::Type Type;
1623 };
1625 //*************************************************************************************************
1626 
1627 } // namespace blaze
1628 
1629 #endif
ConstReference operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatTransposer.h:139
Constraint on the data type.
void addAssign(const SparseMatrix< MT2, SO > &rhs)
Implementation of the transpose addition assignment of a row-major sparse matrix. ...
Definition: DMatTransposer.h:634
void reset(DynamicMatrix< Type, SO > &m)
Resetting the given dense matrix.
Definition: DynamicMatrix.h:4579
#define BLAZE_USER_ASSERT(expr, msg)
Run time assertion macro for user checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_USER_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERT flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:117
DMatTransposer< MT, SO > This
Type of this DMatTransposer instance.
Definition: DMatTransposer.h:80
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: DMatTransposer.h:199
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:197
void stream(size_t i, size_t j, const IntrinsicType &value)
Aligned, non-temporal store of an intrinsic element of the matrix.
Definition: DMatTransposer.h:413
EnableIf< IsNumeric< Other >, DMatTransposer >::Type & operator/=(Other rhs)
Division assignment operator for the division of a matrix by a scalar value ( ).
Definition: DMatTransposer.h:245
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T)
Constraint on the data type.In case the given data type T is a computational expression (i...
Definition: Computation.h:118
#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:79
void subAssign(const SparseMatrix< MT2,!SO > &rhs)
Implementation of the transpose subtraction assignment of a column-major sparse matrix.
Definition: DMatTransposer.h:790
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatTransposer.h:259
void addAssign(const DenseMatrix< MT2, SO > &rhs)
Implementation of the transpose addition assignment of a row-major dense matrix.
Definition: DMatTransposer.h:559
ElementType * data()
Low-level data access to the matrix elements.
Definition: DMatTransposer.h:151
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatTransposer.h:269
MT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: DMatTransposer.h:86
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2380
Header file for the intrinsic trait.
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:104
MT::Iterator Iterator
Iterator over non-constant elements.
Definition: DMatTransposer.h:90
const This & CompositeType
Data type for composite expression templates.
Definition: DMatTransposer.h:87
Constraint on the data type.
void subAssign(const DenseMatrix< MT2, SO > &rhs)
Implementation of the transpose subtraction assignment of a row-major dense matrix.
Definition: DMatTransposer.h:688
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a column-major dense or sparse matri...
Definition: StorageOrder.h:161
Reference operator()(size_t i, size_t j)
2D-access to the matrix elements.
Definition: DMatTransposer.h:125
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2388
bool isAliased(const Other *alias) const
Returns whether the matrix is aliased with the given address alias.
Definition: DMatTransposer.h:314
Header file for the DenseMatrix base class.
EnableIf< IsNumeric< Other >, DMatTransposer >::Type & operator*=(Other rhs)
Multiplication assignment operator for the multiplication between a matrix and a scalar value ( )...
Definition: DMatTransposer.h:228
Expression object for the transposition of a dense matrix.The DMatTransposer class is a wrapper objec...
Definition: DMatTransposer.h:71
MT & dm_
The dense matrix operand.
Definition: DMatTransposer.h:815
IntrinsicType loadu(size_t i, size_t j) const
Unaligned load of an intrinsic element of the matrix.
Definition: DMatTransposer.h:359
bool isAligned() const
Returns whether the matrix is properly aligned in memory.
Definition: DMatTransposer.h:325
IntrinsicType load(size_t i, size_t j) const
Aligned load of an intrinsic element of the matrix.
Definition: DMatTransposer.h:342
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2381
Constraints on the storage order of matrix types.
MT::TransposeType ResultType
Result type for expression template evaluations.
Definition: DMatTransposer.h:81
void assign(const SparseMatrix< MT2,!SO > &rhs)
Implementation of the transpose assignment of a column-major sparse matrix.
Definition: DMatTransposer.h:532
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2382
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2386
void reset()
Resets the matrix elements.
Definition: DMatTransposer.h:289
Header file for the EnableIf class template.
void assign(const DenseMatrix< MT2,!SO > &rhs)
Implementation of the transpose assignment of a column-major dense matrix.
Definition: DMatTransposer.h:468
size_t spacing() const
Returns the spacing between the beginning of two rows.
Definition: DMatTransposer.h:279
void assign(const DenseMatrix< MT2, SO > &rhs)
Implementation of the transpose assignment of a row-major dense matrix.
Definition: DMatTransposer.h:431
Header file for the IsNumeric type trait.
IntrinsicTrait< typename MT::ElementType > IT
Intrinsic trait for the vector element type.
Definition: DMatTransposer.h:75
void subAssign(const SparseMatrix< MT2, SO > &rhs)
Implementation of the transpose subtraction assignment of a row-major sparse matrix.
Definition: DMatTransposer.h:763
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: StorageOrder.h:81
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2383
MT::ElementType ElementType
Type of the matrix elements.
Definition: DMatTransposer.h:84
Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic char...
Definition: IntrinsicTrait.h:748
IT::Type IntrinsicType
Intrinsic type of the matrix elements.
Definition: DMatTransposer.h:85
Header file for run time assertion macros.
void subAssign(const DenseMatrix< MT2,!SO > &rhs)
Implementation of the transpose subtraction assignment of a column-major dense matrix.
Definition: DMatTransposer.h:726
Header file for the submatrix trait.
ConstIterator cend(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: DMatTransposer.h:215
MT::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTransposer.h:82
void addAssign(const DenseMatrix< MT2,!SO > &rhs)
Implementation of the transpose addition assignment of a column-major dense matrix.
Definition: DMatTransposer.h:597
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
ConstIterator cbegin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: DMatTransposer.h:183
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2387
bool canAlias(const Other *alias) const
Returns whether the matrix can alias with the given address alias.
Definition: DMatTransposer.h:301
MT::Reference Reference
Reference to a non-constant matrix value.
Definition: DMatTransposer.h:88
MT::ResultType TransposeType
Transpose type for expression template evaluations.
Definition: DMatTransposer.h:83
MT::ConstReference ConstReference
Reference to a constant matrix value.
Definition: DMatTransposer.h:89
void addAssign(const SparseMatrix< MT2,!SO > &rhs)
Implementation of the transpose addition assignment of a column-major sparse matrix.
Definition: DMatTransposer.h:661
MT::ConstIterator ConstIterator
Iterator over constant elements.
Definition: DMatTransposer.h:91
void assign(const SparseMatrix< MT2, SO > &rhs)
Implementation of the transpose assignment of a row-major sparse matrix.
Definition: DMatTransposer.h:505
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2379
void store(size_t i, size_t j, const IntrinsicType &value)
Aligned store of an intrinsic element of the matrix.
Definition: DMatTransposer.h:377
Header file for basic type definitions.
DMatTransposer(MT &dm)
Constructor for the DMatTransposer class.
Definition: DMatTransposer.h:113
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2385
#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
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: DMatTransposer.h:167
void storeu(size_t i, size_t j, const IntrinsicType &value)
Unaligned store of an intrinsic element of the matrix.
Definition: DMatTransposer.h:395