StrictlyUpperMatrix.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_ADAPTORS_STRICTLYUPPERMATRIX_H_
36 #define _BLAZE_MATH_ADAPTORS_STRICTLYUPPERMATRIX_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
47 #include <blaze/math/Forward.h>
82 #include <blaze/util/Assert.h>
83 #include <blaze/util/EnableIf.h>
84 #include <blaze/util/TrueType.h>
86 #include <blaze/util/Unused.h>
87 
88 
89 namespace blaze {
90 
91 //=================================================================================================
92 //
93 // STRICTLYUPPERMATRIX OPERATORS
94 //
95 //=================================================================================================
96 
97 //*************************************************************************************************
100 template< typename MT, bool SO, bool DF >
101 inline void reset( StrictlyUpperMatrix<MT,SO,DF>& m );
102 
103 template< typename MT, bool SO, bool DF >
104 inline void reset( StrictlyUpperMatrix<MT,SO,DF>& m, size_t i );
105 
106 template< typename MT, bool SO, bool DF >
107 inline void clear( StrictlyUpperMatrix<MT,SO,DF>& m );
108 
109 template< bool RF, typename MT, bool SO, bool DF >
110 inline bool isDefault( const StrictlyUpperMatrix<MT,SO,DF>& m );
111 
112 template< typename MT, bool SO, bool DF >
113 inline bool isIntact( const StrictlyUpperMatrix<MT,SO,DF>& m );
114 
115 template< typename MT, bool SO, bool DF >
116 inline void swap( StrictlyUpperMatrix<MT,SO,DF>& a, StrictlyUpperMatrix<MT,SO,DF>& b ) noexcept;
118 //*************************************************************************************************
119 
120 
121 //*************************************************************************************************
128 template< typename MT // Type of the adapted matrix
129  , bool SO // Storage order of the adapted matrix
130  , bool DF > // Density flag
132 {
133  m.reset();
134 }
135 //*************************************************************************************************
136 
137 
138 //*************************************************************************************************
151 template< typename MT // Type of the adapted matrix
152  , bool SO // Storage order of the adapted matrix
153  , bool DF > // Density flag
154 inline void reset( StrictlyUpperMatrix<MT,SO,DF>& m, size_t i )
155 {
156  m.reset( i );
157 }
158 //*************************************************************************************************
159 
160 
161 //*************************************************************************************************
168 template< typename MT // Type of the adapted matrix
169  , bool SO // Storage order of the adapted matrix
170  , bool DF > // Density flag
172 {
173  m.clear();
174 }
175 //*************************************************************************************************
176 
177 
178 //*************************************************************************************************
189 template< bool RF // Relaxation flag
190  , typename MT // Type of the adapted matrix
191  , bool SO // Storage order of the adapted matrix
192  , bool DF > // Density flag
193 inline bool isDefault_backend( const StrictlyUpperMatrix<MT,SO,DF>& m, TrueType )
194 {
195  return ( m.rows() == 0UL );
196 }
198 //*************************************************************************************************
199 
200 
201 //*************************************************************************************************
212 template< bool RF // Relaxation flag
213  , typename MT // Type of the adapted matrix
214  , bool SO // Storage order of the adapted matrix
215  , bool DF > // Density flag
216 inline bool isDefault_backend( const StrictlyUpperMatrix<MT,SO,DF>& m, FalseType )
217 {
218  if( SO ) {
219  for( size_t j=1UL; j<m.columns(); ++j ) {
220  for( size_t i=0UL; i<j; ++i ) {
221  if( !isDefault<RF>( m(i,j) ) )
222  return false;
223  }
224  }
225  }
226  else {
227  for( size_t i=0UL; i<m.rows(); ++i ) {
228  for( size_t j=i+1UL; j<m.columns(); ++j ) {
229  if( !isDefault<RF>( m(i,j) ) )
230  return false;
231  }
232  }
233  }
234 
235  return true;
236 }
238 //*************************************************************************************************
239 
240 
241 //*************************************************************************************************
268 template< bool RF // Relaxation flag
269  , typename MT // Type of the adapted matrix
270  , bool SO // Storage order of the adapted matrix
271  , bool DF > // Density flag
273 {
274  return isDefault_backend<RF>( m, typename IsResizable<MT>::Type() );
275 }
276 //*************************************************************************************************
277 
278 
279 //*************************************************************************************************
300 template< typename MT // Type of the adapted matrix
301  , bool SO // Storage order of the adapted matrix
302  , bool DF > // Density flag
304 {
305  return m.isIntact();
306 }
307 //*************************************************************************************************
308 
309 
310 //*************************************************************************************************
318 template< typename MT // Type of the adapted matrix
319  , bool SO // Storage order of the adapted matrix
320  , bool DF > // Density flag
322 {
323  a.swap( b );
324 }
325 //*************************************************************************************************
326 
327 
328 //*************************************************************************************************
344 template< typename MT // Type of the adapted matrix
345  , bool SO // Storage order of the adapted matrix
346  , bool DF // Density flag
347  , typename ET > // Type of the element
348 inline bool trySet( const StrictlyUpperMatrix<MT,SO,DF>& mat, size_t i, size_t j, const ET& value )
349 {
350  BLAZE_INTERNAL_ASSERT( i < (~mat).rows(), "Invalid row access index" );
351  BLAZE_INTERNAL_ASSERT( j < (~mat).columns(), "Invalid column access index" );
352 
353  UNUSED_PARAMETER( mat );
354 
355  return ( i < j || isDefault( value ) );
356 }
358 //*************************************************************************************************
359 
360 
361 //*************************************************************************************************
377 template< typename MT // Type of the adapted matrix
378  , bool SO // Storage order of the adapted matrix
379  , bool DF // Density flag
380  , typename ET > // Type of the element
381 inline bool tryAdd( const StrictlyUpperMatrix<MT,SO,DF>& mat, size_t i, size_t j, const ET& value )
382 {
383  return trySet( mat, i, j, value );
384 }
386 //*************************************************************************************************
387 
388 
389 //*************************************************************************************************
405 template< typename MT // Type of the adapted matrix
406  , bool SO // Storage order of the adapted matrix
407  , bool DF // Density flag
408  , typename ET > // Type of the element
409 inline bool trySub( const StrictlyUpperMatrix<MT,SO,DF>& mat, size_t i, size_t j, const ET& value )
410 {
411  return trySet( mat, i, j, value );
412 }
414 //*************************************************************************************************
415 
416 
417 //*************************************************************************************************
434 template< typename MT // Type of the adapted matrix
435  , bool SO // Storage order of the adapted matrix
436  , bool DF // Density flag
437  , typename VT > // Type of the right-hand side dense vector
438 inline bool tryAssign( const StrictlyUpperMatrix<MT,SO,DF>& lhs,
439  const DenseVector<VT,false>& rhs, size_t row, size_t column )
440 {
442 
443  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
444  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
445  BLAZE_INTERNAL_ASSERT( row + (~rhs).size() <= lhs.rows(), "Invalid number of rows" );
446 
447  UNUSED_PARAMETER( lhs );
448 
449  const size_t ibegin( ( column <= row )?( 0UL ):( column - row ) );
450 
451  for( size_t i=ibegin; i<(~rhs).size(); ++i ) {
452  if( !isDefault( (~rhs)[i] ) )
453  return false;
454  }
455 
456  return true;
457 }
459 //*************************************************************************************************
460 
461 
462 //*************************************************************************************************
479 template< typename MT // Type of the adapted matrix
480  , bool SO // Storage order of the adapted matrix
481  , bool DF // Density flag
482  , typename VT > // Type of the right-hand side dense vector
483 inline bool tryAssign( const StrictlyUpperMatrix<MT,SO,DF>& lhs,
484  const DenseVector<VT,true>& rhs, size_t row, size_t column )
485 {
487 
488  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
489  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
490  BLAZE_INTERNAL_ASSERT( column + (~rhs).size() <= lhs.columns(), "Invalid number of columns" );
491 
492  UNUSED_PARAMETER( lhs );
493 
494  if( row < column )
495  return true;
496 
497  const size_t iend( min( row - column + 1UL, (~rhs).size() ) );
498 
499  for( size_t i=0UL; i<iend; ++i ) {
500  if( !isDefault( (~rhs)[i] ) )
501  return false;
502  }
503 
504  return true;
505 }
507 //*************************************************************************************************
508 
509 
510 //*************************************************************************************************
528 template< typename MT // Type of the adapted matrix
529  , bool SO // Storage order of the adapted matrix
530  , bool DF // Density flag
531  , typename VT // Type of the right-hand side dense vector
532  , bool TF > // Transpose flag of the right-hand side dense vector
533 inline bool tryAssign( const StrictlyUpperMatrix<MT,SO,DF>& lhs, const DenseVector<VT,TF>& rhs,
534  ptrdiff_t band, size_t row, size_t column )
535 {
537 
538  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
539  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
540  BLAZE_INTERNAL_ASSERT( row + (~rhs).size() <= lhs.rows(), "Invalid number of rows" );
541  BLAZE_INTERNAL_ASSERT( column + (~rhs).size() <= lhs.columns(), "Invalid number of columns" );
542 
543  UNUSED_PARAMETER( lhs, row, column );
544 
545  if( band <= 0L ) {
546  for( size_t i=0UL; i<(~rhs).size(); ++i ) {
547  if( !isDefault( (~rhs)[i] ) )
548  return false;
549  }
550  }
551 
552  return true;
553 }
555 //*************************************************************************************************
556 
557 
558 //*************************************************************************************************
575 template< typename MT // Type of the adapted matrix
576  , bool SO // Storage order of the adapted matrix
577  , bool DF // Density flag
578  , typename VT > // Type of the right-hand side sparse vector
579 inline bool tryAssign( const StrictlyUpperMatrix<MT,SO,DF>& lhs,
580  const SparseVector<VT,false>& rhs, size_t row, size_t column )
581 {
583 
584  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
585  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
586  BLAZE_INTERNAL_ASSERT( row + (~rhs).size() <= lhs.rows(), "Invalid number of rows" );
587 
588  UNUSED_PARAMETER( lhs );
589 
590  using RhsIterator = typename VT::ConstIterator;
591 
592  const RhsIterator last( (~rhs).end() );
593  RhsIterator element( (~rhs).lowerBound( ( column <= row )?( 0UL ):( column - row ) ) );
594 
595  for( ; element!=last; ++element ) {
596  if( !isDefault( element->value() ) )
597  return false;
598  }
599 
600  return true;
601 }
603 //*************************************************************************************************
604 
605 
606 //*************************************************************************************************
623 template< typename MT // Type of the adapted matrix
624  , bool SO // Storage order of the adapted matrix
625  , bool DF // Density flag
626  , typename VT > // Type of the right-hand side sparse vector
627 inline bool tryAssign( const StrictlyUpperMatrix<MT,SO,DF>& lhs,
628  const SparseVector<VT,true>& rhs, size_t row, size_t column )
629 {
631 
632  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
633  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
634  BLAZE_INTERNAL_ASSERT( column + (~rhs).size() <= lhs.columns(), "Invalid number of columns" );
635 
636  UNUSED_PARAMETER( lhs );
637 
638  using RhsIterator = typename VT::ConstIterator;
639 
640  if( row < column )
641  return true;
642 
643  const RhsIterator last( (~rhs).lowerBound( row - column + 1UL ) );
644 
645  for( RhsIterator element=(~rhs).begin(); element!=last; ++element ) {
646  if( !isDefault( element->value() ) )
647  return false;
648  }
649 
650  return true;
651 }
653 //*************************************************************************************************
654 
655 
656 //*************************************************************************************************
674 template< typename MT // Type of the adapted matrix
675  , bool SO // Storage order of the adapted matrix
676  , bool DF // Density flag
677  , typename VT // Type of the right-hand side sparse vector
678  , bool TF > // Transpose flag of the right-hand side sparse vector
679 inline bool tryAssign( const StrictlyUpperMatrix<MT,SO,DF>& lhs, const SparseVector<VT,TF>& rhs,
680  ptrdiff_t band, size_t row, size_t column )
681 {
683 
684  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
685  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
686  BLAZE_INTERNAL_ASSERT( row + (~rhs).size() <= lhs.rows(), "Invalid number of rows" );
687  BLAZE_INTERNAL_ASSERT( column + (~rhs).size() <= lhs.columns(), "Invalid number of columns" );
688 
689  UNUSED_PARAMETER( lhs, row, column );
690 
691  if( band <= 0L ) {
692  for( const auto& element : ~rhs ) {
693  if( !isDefault( element.value() ) )
694  return false;
695  }
696  }
697 
698  return true;
699 }
701 //*************************************************************************************************
702 
703 
704 //*************************************************************************************************
721 template< typename MT1 // Type of the adapted matrix
722  , bool SO // Storage order of the adapted matrix
723  , bool DF // Density flag
724  , typename MT2 > // Type of the right-hand side dense matrix
725 inline bool tryAssign( const StrictlyUpperMatrix<MT1,SO,DF>& lhs,
726  const DenseMatrix<MT2,false>& rhs, size_t row, size_t column )
727 {
729 
730  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
731  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
732  BLAZE_INTERNAL_ASSERT( row + (~rhs).rows() <= lhs.rows(), "Invalid number of rows" );
733  BLAZE_INTERNAL_ASSERT( column + (~rhs).columns() <= lhs.columns(), "Invalid number of columns" );
734 
735  UNUSED_PARAMETER( lhs );
736 
737  const size_t M( (~rhs).rows() );
738  const size_t N( (~rhs).columns() );
739 
740  if( column >= row + M )
741  return true;
742 
743  const size_t ibegin( ( column <= row )?( 0UL ):( column - row ) );
744 
745  for( size_t i=ibegin; i<M; ++i )
746  {
747  const size_t jend( min( row + i - column + 1UL, N ) );
748 
749  for( size_t j=0UL; j<jend; ++j ) {
750  if( !isDefault( (~rhs)(i,j) ) )
751  return false;
752  }
753  }
754 
755  return true;
756 }
758 //*************************************************************************************************
759 
760 
761 //*************************************************************************************************
778 template< typename MT1 // Type of the adapted matrix
779  , bool SO // Storage order of the adapted matrix
780  , bool DF // Density flag
781  , typename MT2 > // Type of the right-hand side dense matrix
782 inline bool tryAssign( const StrictlyUpperMatrix<MT1,SO,DF>& lhs,
783  const DenseMatrix<MT2,true>& rhs, size_t row, size_t column )
784 {
786 
787  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
788  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
789  BLAZE_INTERNAL_ASSERT( row + (~rhs).rows() <= lhs.rows(), "Invalid number of rows" );
790  BLAZE_INTERNAL_ASSERT( column + (~rhs).columns() <= lhs.columns(), "Invalid number of columns" );
791 
792  UNUSED_PARAMETER( lhs );
793 
794  const size_t M( (~rhs).rows() );
795  const size_t N( (~rhs).columns() );
796 
797  if( column >= row + M )
798  return true;
799 
800  const size_t jend( min( row + M - column, N ) );
801 
802  for( size_t j=0UL; j<jend; ++j )
803  {
804  const bool containsDiagonal( column + j >= row );
805  const size_t ibegin( ( containsDiagonal )?( column + j - row ):( 0UL ) );
806 
807  for( size_t i=ibegin; i<M; ++i ) {
808  if( !isDefault( (~rhs)(i,j) ) )
809  return false;
810  }
811  }
812 
813  return true;
814 }
816 //*************************************************************************************************
817 
818 
819 //*************************************************************************************************
836 template< typename MT1 // Type of the adapted matrix
837  , bool SO // Storage order of the adapted matrix
838  , bool DF // Density flag
839  , typename MT2 > // Type of the right-hand side sparse matrix
840 inline bool tryAssign( const StrictlyUpperMatrix<MT1,SO,DF>& lhs,
841  const SparseMatrix<MT2,false>& rhs, size_t row, size_t column )
842 {
844 
845  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
846  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
847  BLAZE_INTERNAL_ASSERT( row + (~rhs).rows() <= lhs.rows(), "Invalid number of rows" );
848  BLAZE_INTERNAL_ASSERT( column + (~rhs).columns() <= lhs.columns(), "Invalid number of columns" );
849 
850  UNUSED_PARAMETER( lhs );
851 
852  using RhsIterator = typename MT2::ConstIterator;
853 
854  const size_t M( (~rhs).rows() );
855  const size_t N( (~rhs).columns() );
856 
857  if( column >= row + M )
858  return true;
859 
860  const size_t ibegin( ( column < row )?( 0UL ):( column - row ) );
861 
862  for( size_t i=ibegin; i<M; ++i )
863  {
864  const size_t index( row + i - column + 1UL );
865  const RhsIterator last( (~rhs).lowerBound( i, min( index, N ) ) );
866 
867  for( RhsIterator element=(~rhs).begin(i); element!=last; ++element ) {
868  if( !isDefault( element->value() ) )
869  return false;
870  }
871  }
872 
873  return true;
874 }
876 //*************************************************************************************************
877 
878 
879 //*************************************************************************************************
896 template< typename MT1 // Type of the adapted matrix
897  , bool SO // Storage order of the adapted matrix
898  , bool DF // Density flag
899  , typename MT2 > // Type of the right-hand side sparse matrix
900 inline bool tryAssign( const StrictlyUpperMatrix<MT1,SO,DF>& lhs,
901  const SparseMatrix<MT2,true>& rhs, size_t row, size_t column )
902 {
904 
905  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
906  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
907  BLAZE_INTERNAL_ASSERT( row + (~rhs).rows() <= lhs.rows(), "Invalid number of rows" );
908  BLAZE_INTERNAL_ASSERT( column + (~rhs).columns() <= lhs.columns(), "Invalid number of columns" );
909 
910  UNUSED_PARAMETER( lhs );
911 
912  using RhsIterator = typename MT2::ConstIterator;
913 
914  const size_t M( (~rhs).rows() );
915  const size_t N( (~rhs).columns() );
916 
917  if( column >= row + M )
918  return true;
919 
920  const size_t jend( min( row + M - column, N ) );
921 
922  for( size_t j=0UL; j<jend; ++j )
923  {
924  const bool containsDiagonal( column + j >= row );
925  const size_t index( ( containsDiagonal )?( column + j - row ):( 0UL ) );
926 
927  const RhsIterator last( (~rhs).end(j) );
928  RhsIterator element( (~rhs).lowerBound( index, j ) );
929 
930  for( ; element!=last; ++element ) {
931  if( !isDefault( element->value() ) )
932  return false;
933  }
934  }
935 
936  return true;
937 }
939 //*************************************************************************************************
940 
941 
942 //*************************************************************************************************
959 template< typename MT // Type of the adapted matrix
960  , bool SO // Storage order of the adapted matrix
961  , bool DF // Density flag
962  , typename VT // Type of the right-hand side vector
963  , bool TF > // Transpose flag of the right-hand side vector
964 inline bool tryAddAssign( const StrictlyUpperMatrix<MT,SO,DF>& lhs,
965  const Vector<VT,TF>& rhs, size_t row, size_t column )
966 {
967  return tryAssign( lhs, ~rhs, row, column );
968 }
970 //*************************************************************************************************
971 
972 
973 //*************************************************************************************************
991 template< typename MT // Type of the adapted matrix
992  , bool SO // Storage order of the adapted matrix
993  , bool DF // Density flag
994  , typename VT // Type of the right-hand side vector
995  , bool TF > // Transpose flag of the right-hand side vector
996 inline bool tryAddAssign( const StrictlyUpperMatrix<MT,SO,DF>& lhs, const Vector<VT,TF>& rhs,
997  ptrdiff_t band, size_t row, size_t column )
998 {
999  return tryAssign( lhs, ~rhs, band, row, column );
1000 }
1002 //*************************************************************************************************
1003 
1004 
1005 //*************************************************************************************************
1022 template< typename MT1 // Type of the adapted matrix
1023  , bool SO1 // Storage order of the adapted matrix
1024  , bool DF // Density flag
1025  , typename MT2 // Type of the right-hand side matrix
1026  , bool SO2 > // Storage order of the right-hand side matrix
1027 inline bool tryAddAssign( const StrictlyUpperMatrix<MT1,SO1,DF>& lhs,
1028  const Matrix<MT2,SO2>& rhs, size_t row, size_t column )
1029 {
1030  return tryAssign( lhs, ~rhs, row, column );
1031 }
1033 //*************************************************************************************************
1034 
1035 
1036 //*************************************************************************************************
1053 template< typename MT // Type of the adapted matrix
1054  , bool SO // Storage order of the adapted matrix
1055  , bool DF // Density flag
1056  , typename VT // Type of the right-hand side vector
1057  , bool TF > // Transpose flag of the right-hand side vector
1058 inline bool trySubAssign( const StrictlyUpperMatrix<MT,SO,DF>& lhs,
1059  const Vector<VT,TF>& rhs, size_t row, size_t column )
1060 {
1061  return tryAssign( lhs, ~rhs, row, column );
1062 }
1064 //*************************************************************************************************
1065 
1066 
1067 //*************************************************************************************************
1085 template< typename MT // Type of the adapted matrix
1086  , bool SO // Storage order of the adapted matrix
1087  , bool DF // Density flag
1088  , typename VT // Type of the right-hand side vector
1089  , bool TF > // Transpose flag of the right-hand side vector
1090 inline bool trySubAssign( const StrictlyUpperMatrix<MT,SO,DF>& lhs, const Vector<VT,TF>& rhs,
1091  ptrdiff_t band, size_t row, size_t column )
1092 {
1093  return tryAssign( lhs, ~rhs, band, row, column );
1094 }
1096 //*************************************************************************************************
1097 
1098 
1099 //*************************************************************************************************
1116 template< typename MT1 // Type of the adapted matrix
1117  , bool SO1 // Storage order of the adapted matrix
1118  , bool DF // Density flag
1119  , typename MT2 // Type of the right-hand side matrix
1120  , bool SO2 > // Storage order of the right-hand side matrix
1121 inline bool trySubAssign( const StrictlyUpperMatrix<MT1,SO1,DF>& lhs,
1122  const Matrix<MT2,SO2>& rhs, size_t row, size_t column )
1123 {
1124  return tryAssign( lhs, ~rhs, row, column );
1125 }
1127 //*************************************************************************************************
1128 
1129 
1130 //*************************************************************************************************
1144 template< typename MT // Type of the adapted matrix
1145  , bool SO // Storage order of the adapted matrix
1146  , bool DF > // Density flag
1147 inline MT& derestrict( StrictlyUpperMatrix<MT,SO,DF>& m )
1148 {
1149  return m.matrix_;
1150 }
1152 //*************************************************************************************************
1153 
1154 
1155 
1156 
1157 //=================================================================================================
1158 //
1159 // SIZE SPECIALIZATIONS
1160 //
1161 //=================================================================================================
1162 
1163 //*************************************************************************************************
1165 template< typename MT, bool SO, bool DF >
1166 struct Size< StrictlyUpperMatrix<MT,SO,DF>, 0UL >
1167  : public Size<MT,0UL>
1168 {};
1169 
1170 template< typename MT, bool SO, bool DF >
1171 struct Size< StrictlyUpperMatrix<MT,SO,DF>, 1UL >
1172  : public Size<MT,1UL>
1173 {};
1175 //*************************************************************************************************
1176 
1177 
1178 
1179 
1180 //=================================================================================================
1181 //
1182 // ISSQUARE SPECIALIZATIONS
1183 //
1184 //=================================================================================================
1185 
1186 //*************************************************************************************************
1188 template< typename MT, bool SO, bool DF >
1189 struct IsSquare< StrictlyUpperMatrix<MT,SO,DF> >
1190  : public TrueType
1191 {};
1193 //*************************************************************************************************
1194 
1195 
1196 
1197 
1198 //=================================================================================================
1199 //
1200 // ISSTRICTLYUPPER SPECIALIZATIONS
1201 //
1202 //=================================================================================================
1203 
1204 //*************************************************************************************************
1206 template< typename MT, bool SO, bool DF >
1207 struct IsStrictlyUpper< StrictlyUpperMatrix<MT,SO,DF> >
1208  : public TrueType
1209 {};
1211 //*************************************************************************************************
1212 
1213 
1214 
1215 
1216 //=================================================================================================
1217 //
1218 // ISADAPTOR SPECIALIZATIONS
1219 //
1220 //=================================================================================================
1221 
1222 //*************************************************************************************************
1224 template< typename MT, bool SO, bool DF >
1225 struct IsAdaptor< StrictlyUpperMatrix<MT,SO,DF> >
1226  : public TrueType
1227 {};
1229 //*************************************************************************************************
1230 
1231 
1232 
1233 
1234 //=================================================================================================
1235 //
1236 // ISRESTRICTED SPECIALIZATIONS
1237 //
1238 //=================================================================================================
1239 
1240 //*************************************************************************************************
1242 template< typename MT, bool SO, bool DF >
1243 struct IsRestricted< StrictlyUpperMatrix<MT,SO,DF> >
1244  : public TrueType
1245 {};
1247 //*************************************************************************************************
1248 
1249 
1250 
1251 
1252 //=================================================================================================
1253 //
1254 // HASCONSTDATAACCESS SPECIALIZATIONS
1255 //
1256 //=================================================================================================
1257 
1258 //*************************************************************************************************
1260 template< typename MT, bool SO >
1261 struct HasConstDataAccess< StrictlyUpperMatrix<MT,SO,true> >
1262  : public TrueType
1263 {};
1265 //*************************************************************************************************
1266 
1267 
1268 
1269 
1270 //=================================================================================================
1271 //
1272 // ISALIGNED SPECIALIZATIONS
1273 //
1274 //=================================================================================================
1275 
1276 //*************************************************************************************************
1278 template< typename MT, bool SO, bool DF >
1279 struct IsAligned< StrictlyUpperMatrix<MT,SO,DF> >
1280  : public IsAligned<MT>
1281 {};
1283 //*************************************************************************************************
1284 
1285 
1286 
1287 
1288 //=================================================================================================
1289 //
1290 // ISCONTIGUOUS SPECIALIZATIONS
1291 //
1292 //=================================================================================================
1293 
1294 //*************************************************************************************************
1296 template< typename MT, bool SO, bool DF >
1297 struct IsContiguous< StrictlyUpperMatrix<MT,SO,DF> >
1298  : public IsContiguous<MT>
1299 {};
1301 //*************************************************************************************************
1302 
1303 
1304 
1305 
1306 //=================================================================================================
1307 //
1308 // ISPADDED SPECIALIZATIONS
1309 //
1310 //=================================================================================================
1311 
1312 //*************************************************************************************************
1314 template< typename MT, bool SO, bool DF >
1315 struct IsPadded< StrictlyUpperMatrix<MT,SO,DF> >
1316  : public IsPadded<MT>
1317 {};
1319 //*************************************************************************************************
1320 
1321 
1322 
1323 
1324 //=================================================================================================
1325 //
1326 // ISRESIZABLE SPECIALIZATIONS
1327 //
1328 //=================================================================================================
1329 
1330 //*************************************************************************************************
1332 template< typename MT, bool SO, bool DF >
1333 struct IsResizable< StrictlyUpperMatrix<MT,SO,DF> >
1334  : public IsResizable<MT>
1335 {};
1337 //*************************************************************************************************
1338 
1339 
1340 
1341 
1342 //=================================================================================================
1343 //
1344 // ISSHRINKABLE SPECIALIZATIONS
1345 //
1346 //=================================================================================================
1347 
1348 //*************************************************************************************************
1350 template< typename MT, bool SO, bool DF >
1351 struct IsShrinkable< StrictlyUpperMatrix<MT,SO,DF> >
1352  : public IsShrinkable<MT>
1353 {};
1355 //*************************************************************************************************
1356 
1357 
1358 
1359 
1360 //=================================================================================================
1361 //
1362 // REMOVEADAPTOR SPECIALIZATIONS
1363 //
1364 //=================================================================================================
1365 
1366 //*************************************************************************************************
1368 template< typename MT, bool SO, bool DF >
1369 struct RemoveAdaptor< StrictlyUpperMatrix<MT,SO,DF> >
1370 {
1371  using Type = MT;
1372 };
1374 //*************************************************************************************************
1375 
1376 
1377 
1378 
1379 //=================================================================================================
1380 //
1381 // ADDTRAIT SPECIALIZATIONS
1382 //
1383 //=================================================================================================
1384 
1385 //*************************************************************************************************
1387 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1388 struct AddTrait< StrictlyUpperMatrix<MT,SO1,DF>, StaticMatrix<T,M,N,SO2> >
1389 {
1391 };
1392 
1393 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
1394 struct AddTrait< StaticMatrix<T,M,N,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1395 {
1396  using Type = AddTrait_< StaticMatrix<T,M,N,SO1>, MT >;
1397 };
1398 
1399 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1400 struct AddTrait< StrictlyUpperMatrix<MT,SO1,DF>, HybridMatrix<T,M,N,SO2> >
1401 {
1403 };
1404 
1405 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
1406 struct AddTrait< HybridMatrix<T,M,N,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1407 {
1408  using Type = AddTrait_< HybridMatrix<T,M,N,SO1>, MT >;
1409 };
1410 
1411 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1412 struct AddTrait< StrictlyUpperMatrix<MT,SO1,DF>, DynamicMatrix<T,SO2> >
1413 {
1414  using Type = AddTrait_< MT, DynamicMatrix<T,SO2> >;
1415 };
1416 
1417 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1418 struct AddTrait< DynamicMatrix<T,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1419 {
1420  using Type = AddTrait_< DynamicMatrix<T,SO1>, MT >;
1421 };
1422 
1423 template< typename MT, bool SO1, bool DF, typename T, bool AF, bool PF, bool SO2 >
1424 struct AddTrait< StrictlyUpperMatrix<MT,SO1,DF>, CustomMatrix<T,AF,PF,SO2> >
1425 {
1427 };
1428 
1429 template< typename T, bool AF, bool PF, bool SO1, typename MT, bool SO2, bool DF >
1430 struct AddTrait< CustomMatrix<T,AF,PF,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1431 {
1432  using Type = AddTrait_< CustomMatrix<T,AF,PF,SO1>, MT >;
1433 };
1434 
1435 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1436 struct AddTrait< StrictlyUpperMatrix<MT,SO1,DF>, CompressedMatrix<T,SO2> >
1437 {
1439 };
1440 
1441 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1442 struct AddTrait< CompressedMatrix<T,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1443 {
1444  using Type = AddTrait_< CompressedMatrix<T,SO1>, MT >;
1445 };
1446 
1447 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1448 struct AddTrait< StrictlyUpperMatrix<MT,SO1,DF>, IdentityMatrix<T,SO2> >
1449 {
1451 };
1452 
1453 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1454 struct AddTrait< IdentityMatrix<T,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1455 {
1457 };
1458 
1459 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2, bool NF >
1460 struct AddTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, SymmetricMatrix<MT2,SO2,DF2,NF> >
1461 {
1462  using Type = AddTrait_<MT1,MT2>;
1463 };
1464 
1465 template< typename MT1, bool SO1, bool DF1, bool NF, typename MT2, bool SO2, bool DF2 >
1466 struct AddTrait< SymmetricMatrix<MT1,SO1,DF1,NF>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1467 {
1468  using Type = AddTrait_<MT1,MT2>;
1469 };
1470 
1471 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1472 struct AddTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, HermitianMatrix<MT2,SO2,DF2> >
1473 {
1474  using Type = AddTrait_<MT1,MT2>;
1475 };
1476 
1477 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1478 struct AddTrait< HermitianMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1479 {
1480  using Type = AddTrait_<MT1,MT2>;
1481 };
1482 
1483 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1484 struct AddTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, LowerMatrix<MT2,SO2,DF2> >
1485 {
1486  using Type = AddTrait_<MT1,MT2>;
1487 };
1488 
1489 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1490 struct AddTrait< LowerMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1491 {
1492  using Type = AddTrait_<MT1,MT2>;
1493 };
1494 
1495 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1496 struct AddTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UniLowerMatrix<MT2,SO2,DF2> >
1497 {
1498  using Type = AddTrait_<MT1,MT2>;
1499 };
1500 
1501 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1502 struct AddTrait< UniLowerMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1503 {
1504  using Type = AddTrait_<MT1,MT2>;
1505 };
1506 
1507 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1508 struct AddTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1509 {
1510  using Type = AddTrait_<MT1,MT2>;
1511 };
1512 
1513 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1514 struct AddTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1515 {
1516  using Type = AddTrait_<MT1,MT2>;
1517 };
1518 
1519 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1520 struct AddTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UpperMatrix<MT2,SO2,DF2> >
1521 {
1522  using Type = UpperMatrix< AddTrait_<MT1,MT2> >;
1523 };
1524 
1525 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1526 struct AddTrait< UpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1527 {
1528  using Type = UpperMatrix< AddTrait_<MT1,MT2> >;
1529 };
1530 
1531 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1532 struct AddTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UniUpperMatrix<MT2,SO2,DF2> >
1533 {
1534  using Type = UniUpperMatrix< AddTrait_<MT1,MT2> >;
1535 };
1536 
1537 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1538 struct AddTrait< UniUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1539 {
1540  using Type = UniUpperMatrix< AddTrait_<MT1,MT2> >;
1541 };
1542 
1543 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1544 struct AddTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1545 {
1547 };
1549 //*************************************************************************************************
1550 
1551 
1552 
1553 
1554 //=================================================================================================
1555 //
1556 // SUBTRAIT SPECIALIZATIONS
1557 //
1558 //=================================================================================================
1559 
1560 //*************************************************************************************************
1562 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1563 struct SubTrait< StrictlyUpperMatrix<MT,SO1,DF>, StaticMatrix<T,M,N,SO2> >
1564 {
1566 };
1567 
1568 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
1569 struct SubTrait< StaticMatrix<T,M,N,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1570 {
1571  using Type = SubTrait_< StaticMatrix<T,M,N,SO1>, MT >;
1572 };
1573 
1574 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1575 struct SubTrait< StrictlyUpperMatrix<MT,SO1,DF>, HybridMatrix<T,M,N,SO2> >
1576 {
1578 };
1579 
1580 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
1581 struct SubTrait< HybridMatrix<T,M,N,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1582 {
1583  using Type = SubTrait_< HybridMatrix<T,M,N,SO1>, MT >;
1584 };
1585 
1586 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1587 struct SubTrait< StrictlyUpperMatrix<MT,SO1,DF>, DynamicMatrix<T,SO2> >
1588 {
1589  using Type = SubTrait_< MT, DynamicMatrix<T,SO2> >;
1590 };
1591 
1592 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1593 struct SubTrait< DynamicMatrix<T,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1594 {
1595  using Type = SubTrait_< DynamicMatrix<T,SO1>, MT >;
1596 };
1597 
1598 template< typename MT, bool SO1, bool DF, typename T, bool AF, bool PF, bool SO2 >
1599 struct SubTrait< StrictlyUpperMatrix<MT,SO1,DF>, CustomMatrix<T,AF,PF,SO2> >
1600 {
1602 };
1603 
1604 template< typename T, bool AF, bool PF, bool SO1, typename MT, bool SO2, bool DF >
1605 struct SubTrait< CustomMatrix<T,AF,PF,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1606 {
1607  using Type = SubTrait_< CustomMatrix<T,AF,PF,SO1>, MT >;
1608 };
1609 
1610 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1611 struct SubTrait< StrictlyUpperMatrix<MT,SO1,DF>, CompressedMatrix<T,SO2> >
1612 {
1614 };
1615 
1616 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1617 struct SubTrait< CompressedMatrix<T,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1618 {
1619  using Type = SubTrait_< CompressedMatrix<T,SO1>, MT >;
1620 };
1621 
1622 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1623 struct SubTrait< StrictlyUpperMatrix<MT,SO1,DF>, IdentityMatrix<T,SO2> >
1624 {
1626 };
1627 
1628 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1629 struct SubTrait< IdentityMatrix<T,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1630 {
1632 };
1633 
1634 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2, bool NF >
1635 struct SubTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, SymmetricMatrix<MT2,SO2,DF2,NF> >
1636 {
1637  using Type = SubTrait_<MT1,MT2>;
1638 };
1639 
1640 template< typename MT1, bool SO1, bool DF1, bool NF, typename MT2, bool SO2, bool DF2 >
1641 struct SubTrait< SymmetricMatrix<MT1,SO1,DF1,NF>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1642 {
1643  using Type = SubTrait_<MT1,MT2>;
1644 };
1645 
1646 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1647 struct SubTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, HermitianMatrix<MT2,SO2,DF2> >
1648 {
1649  using Type = SubTrait_<MT1,MT2>;
1650 };
1651 
1652 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1653 struct SubTrait< HermitianMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1654 {
1655  using Type = SubTrait_<MT1,MT2>;
1656 };
1657 
1658 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1659 struct SubTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, LowerMatrix<MT2,SO2,DF2> >
1660 {
1661  using Type = SubTrait_<MT1,MT2>;
1662 };
1663 
1664 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1665 struct SubTrait< LowerMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1666 {
1667  using Type = SubTrait_<MT1,MT2>;
1668 };
1669 
1670 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1671 struct SubTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UniLowerMatrix<MT2,SO2,DF2> >
1672 {
1673  using Type = SubTrait_<MT1,MT2>;
1674 };
1675 
1676 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1677 struct SubTrait< UniLowerMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1678 {
1679  using Type = SubTrait_<MT1,MT2>;
1680 };
1681 
1682 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1683 struct SubTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1684 {
1685  using Type = SubTrait_<MT1,MT2>;
1686 };
1687 
1688 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1689 struct SubTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1690 {
1691  using Type = SubTrait_<MT1,MT2>;
1692 };
1693 
1694 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1695 struct SubTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UpperMatrix<MT2,SO2,DF2> >
1696 {
1697  using Type = UpperMatrix< SubTrait_<MT1,MT2> >;
1698 };
1699 
1700 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1701 struct SubTrait< UpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1702 {
1703  using Type = UpperMatrix< SubTrait_<MT1,MT2> >;
1704 };
1705 
1706 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1707 struct SubTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UniUpperMatrix<MT2,SO2,DF2> >
1708 {
1709  using Type = UpperMatrix< SubTrait_<MT1,MT2> >;
1710 };
1711 
1712 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1713 struct SubTrait< UniUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1714 {
1715  using Type = UniUpperMatrix< SubTrait_<MT1,MT2> >;
1716 };
1717 
1718 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1719 struct SubTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1720 {
1722 };
1724 //*************************************************************************************************
1725 
1726 
1727 
1728 
1729 //=================================================================================================
1730 //
1731 // SCHURTRAIT SPECIALIZATIONS
1732 //
1733 //=================================================================================================
1734 
1735 //*************************************************************************************************
1737 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1738 struct SchurTrait< StrictlyUpperMatrix<MT,SO1,DF>, StaticMatrix<T,M,N,SO2> >
1739 {
1741 };
1742 
1743 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
1744 struct SchurTrait< StaticMatrix<T,M,N,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1745 {
1747 };
1748 
1749 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1750 struct SchurTrait< StrictlyUpperMatrix<MT,SO1,DF>, HybridMatrix<T,M,N,SO2> >
1751 {
1753 };
1754 
1755 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
1756 struct SchurTrait< HybridMatrix<T,M,N,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1757 {
1759 };
1760 
1761 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1762 struct SchurTrait< StrictlyUpperMatrix<MT,SO1,DF>, DynamicMatrix<T,SO2> >
1763 {
1765 };
1766 
1767 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1768 struct SchurTrait< DynamicMatrix<T,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1769 {
1771 };
1772 
1773 template< typename MT, bool SO1, bool DF, typename T, bool AF, bool PF, bool SO2 >
1774 struct SchurTrait< StrictlyUpperMatrix<MT,SO1,DF>, CustomMatrix<T,AF,PF,SO2> >
1775 {
1777 };
1778 
1779 template< typename T, bool AF, bool PF, bool SO1, typename MT, bool SO2, bool DF >
1780 struct SchurTrait< CustomMatrix<T,AF,PF,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1781 {
1783 };
1784 
1785 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1786 struct SchurTrait< StrictlyUpperMatrix<MT,SO1,DF>, CompressedMatrix<T,SO2> >
1787 {
1789 };
1790 
1791 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1792 struct SchurTrait< CompressedMatrix<T,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1793 {
1795 };
1796 
1797 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1798 struct SchurTrait< StrictlyUpperMatrix<MT,SO1,DF>, IdentityMatrix<T,SO2> >
1799 {
1801 };
1802 
1803 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1804 struct SchurTrait< IdentityMatrix<T,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1805 {
1807 };
1808 
1809 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2, bool NF >
1810 struct SchurTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, SymmetricMatrix<MT2,SO2,DF2,NF> >
1811 {
1813 };
1814 
1815 template< typename MT1, bool SO1, bool DF1, bool NF, typename MT2, bool SO2, bool DF2 >
1816 struct SchurTrait< SymmetricMatrix<MT1,SO1,DF1,NF>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1817 {
1819 };
1820 
1821 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1822 struct SchurTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, HermitianMatrix<MT2,SO2,DF2> >
1823 {
1825 };
1826 
1827 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1828 struct SchurTrait< HermitianMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1829 {
1831 };
1832 
1833 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1834 struct SchurTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, LowerMatrix<MT2,SO2,DF2> >
1835 {
1836  using Type = DiagonalMatrix< SchurTrait_<MT1,MT2> >;
1837 };
1838 
1839 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1840 struct SchurTrait< LowerMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1841 {
1842  using Type = DiagonalMatrix< SchurTrait_<MT1,MT2> >;
1843 };
1844 
1845 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1846 struct SchurTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UniLowerMatrix<MT2,SO2,DF2> >
1847 {
1848  using Type = DiagonalMatrix< SchurTrait_<MT1,MT2> >;
1849 };
1850 
1851 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1852 struct SchurTrait< UniLowerMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1853 {
1854  using Type = DiagonalMatrix< SchurTrait_<MT1,MT2> >;
1855 };
1856 
1857 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1858 struct SchurTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1859 {
1860  using Type = DiagonalMatrix< SchurTrait_<MT1,MT2> >;
1861 };
1862 
1863 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1864 struct SchurTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1865 {
1866  using Type = DiagonalMatrix< SchurTrait_<MT1,MT2> >;
1867 };
1868 
1869 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1870 struct SchurTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UpperMatrix<MT2,SO2,DF2> >
1871 {
1873 };
1874 
1875 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1876 struct SchurTrait< UpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1877 {
1879 };
1880 
1881 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1882 struct SchurTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UniUpperMatrix<MT2,SO2,DF2> >
1883 {
1885 };
1886 
1887 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1888 struct SchurTrait< UniUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1889 {
1891 };
1892 
1893 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1894 struct SchurTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
1895 {
1897 };
1899 //*************************************************************************************************
1900 
1901 
1902 
1903 
1904 //=================================================================================================
1905 //
1906 // MULTTRAIT SPECIALIZATIONS
1907 //
1908 //=================================================================================================
1909 
1910 //*************************************************************************************************
1912 template< typename MT, bool SO, bool DF, typename T >
1913 struct MultTrait< StrictlyUpperMatrix<MT,SO,DF>, T, EnableIf_< IsNumeric<T> > >
1914 {
1916 };
1917 
1918 template< typename T, typename MT, bool SO, bool DF >
1919 struct MultTrait< T, StrictlyUpperMatrix<MT,SO,DF>, EnableIf_< IsNumeric<T> > >
1920 {
1922 };
1923 
1924 template< typename MT, bool SO, bool DF, typename T, size_t N >
1925 struct MultTrait< StrictlyUpperMatrix<MT,SO,DF>, StaticVector<T,N,false> >
1926 {
1928 };
1929 
1930 template< typename T, size_t N, typename MT, bool SO, bool DF >
1931 struct MultTrait< StaticVector<T,N,true>, StrictlyUpperMatrix<MT,SO,DF> >
1932 {
1933  using Type = MultTrait_< StaticVector<T,N,true>, MT >;
1934 };
1935 
1936 template< typename MT, bool SO, bool DF, typename T, size_t N >
1937 struct MultTrait< StrictlyUpperMatrix<MT,SO,DF>, HybridVector<T,N,false> >
1938 {
1940 };
1941 
1942 template< typename T, size_t N, typename MT, bool SO, bool DF >
1943 struct MultTrait< HybridVector<T,N,true>, StrictlyUpperMatrix<MT,SO,DF> >
1944 {
1945  using Type = MultTrait_< HybridVector<T,N,true>, MT >;
1946 };
1947 
1948 template< typename MT, bool SO, bool DF, typename T >
1949 struct MultTrait< StrictlyUpperMatrix<MT,SO,DF>, DynamicVector<T,false> >
1950 {
1952 };
1953 
1954 template< typename T, typename MT, bool SO, bool DF >
1955 struct MultTrait< DynamicVector<T,true>, StrictlyUpperMatrix<MT,SO,DF> >
1956 {
1957  using Type = MultTrait_< DynamicVector<T,true>, MT >;
1958 };
1959 
1960 template< typename MT, bool SO, bool DF, typename T, bool AF, bool PF >
1961 struct MultTrait< StrictlyUpperMatrix<MT,SO,DF>, CustomVector<T,AF,PF,false> >
1962 {
1964 };
1965 
1966 template< typename T, bool AF, bool PF, typename MT, bool SO, bool DF >
1967 struct MultTrait< CustomVector<T,AF,PF,true>, StrictlyUpperMatrix<MT,SO,DF> >
1968 {
1969  using Type = MultTrait_< CustomVector<T,AF,PF,true>, MT >;
1970 };
1971 
1972 template< typename MT, bool SO, bool DF, typename T >
1973 struct MultTrait< StrictlyUpperMatrix<MT,SO,DF>, CompressedVector<T,false> >
1974 {
1976 };
1977 
1978 template< typename T, typename MT, bool SO, bool DF >
1979 struct MultTrait< CompressedVector<T,true>, StrictlyUpperMatrix<MT,SO,DF> >
1980 {
1981  using Type = MultTrait_< CompressedVector<T,true>, MT >;
1982 };
1983 
1984 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1985 struct MultTrait< StrictlyUpperMatrix<MT,SO1,DF>, StaticMatrix<T,M,N,SO2> >
1986 {
1988 };
1989 
1990 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
1991 struct MultTrait< StaticMatrix<T,M,N,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
1992 {
1993  using Type = MultTrait_< StaticMatrix<T,M,N,SO1>, MT >;
1994 };
1995 
1996 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1997 struct MultTrait< StrictlyUpperMatrix<MT,SO1,DF>, HybridMatrix<T,M,N,SO2> >
1998 {
2000 };
2001 
2002 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
2003 struct MultTrait< HybridMatrix<T,M,N,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
2004 {
2005  using Type = MultTrait_< HybridMatrix<T,M,N,SO1>, MT >;
2006 };
2007 
2008 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
2009 struct MultTrait< StrictlyUpperMatrix<MT,SO1,DF>, DynamicMatrix<T,SO2> >
2010 {
2011  using Type = MultTrait_< MT, DynamicMatrix<T,SO2> >;
2012 };
2013 
2014 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
2015 struct MultTrait< DynamicMatrix<T,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
2016 {
2017  using Type = MultTrait_< DynamicMatrix<T,SO1>, MT >;
2018 };
2019 
2020 template< typename MT, bool SO1, bool DF, typename T, bool AF, bool PF, bool SO2 >
2021 struct MultTrait< StrictlyUpperMatrix<MT,SO1,DF>, CustomMatrix<T,AF,PF,SO2> >
2022 {
2024 };
2025 
2026 template< typename T, bool AF, bool PF, bool SO1, typename MT, bool SO2, bool DF >
2027 struct MultTrait< CustomMatrix<T,AF,PF,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
2028 {
2029  using Type = MultTrait_< CustomMatrix<T,AF,PF,SO1>, MT >;
2030 };
2031 
2032 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
2033 struct MultTrait< StrictlyUpperMatrix<MT,SO1,DF>, CompressedMatrix<T,SO2> >
2034 {
2036 };
2037 
2038 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
2039 struct MultTrait< CompressedMatrix<T,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
2040 {
2041  using Type = MultTrait_< CompressedMatrix<T,SO1>, MT >;
2042 };
2043 
2044 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
2045 struct MultTrait< StrictlyUpperMatrix<MT,SO1,DF>, IdentityMatrix<T,SO2> >
2046 {
2048 };
2049 
2050 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
2051 struct MultTrait< IdentityMatrix<T,SO1>, StrictlyUpperMatrix<MT,SO2,DF> >
2052 {
2054 };
2055 
2056 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2, bool NF >
2057 struct MultTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, SymmetricMatrix<MT2,SO2,DF2,NF> >
2058 {
2059  using Type = MultTrait_<MT1,MT2>;
2060 };
2061 
2062 template< typename MT1, bool SO1, bool DF1, bool NF, typename MT2, bool SO2, bool DF2 >
2063 struct MultTrait< SymmetricMatrix<MT1,SO1,DF1,NF>, StrictlyUpperMatrix<MT2,SO2,DF2> >
2064 {
2065  using Type = MultTrait_<MT1,MT2>;
2066 };
2067 
2068 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2069 struct MultTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, HermitianMatrix<MT2,SO2,DF2> >
2070 {
2071  using Type = MultTrait_<MT1,MT2>;
2072 };
2073 
2074 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2075 struct MultTrait< HermitianMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
2076 {
2077  using Type = MultTrait_<MT1,MT2>;
2078 };
2079 
2080 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2081 struct MultTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, LowerMatrix<MT2,SO2,DF2> >
2082 {
2083  using Type = MultTrait_<MT1,MT2>;
2084 };
2085 
2086 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2087 struct MultTrait< LowerMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
2088 {
2089  using Type = MultTrait_<MT1,MT2>;
2090 };
2091 
2092 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2093 struct MultTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UniLowerMatrix<MT2,SO2,DF2> >
2094 {
2095  using Type = MultTrait_<MT1,MT2>;
2096 };
2097 
2098 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2099 struct MultTrait< UniLowerMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
2100 {
2101  using Type = MultTrait_<MT1,MT2>;
2102 };
2103 
2104 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2105 struct MultTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
2106 {
2107  using Type = MultTrait_<MT1,MT2>;
2108 };
2109 
2110 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2111 struct MultTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
2112 {
2113  using Type = MultTrait_<MT1,MT2>;
2114 };
2115 
2116 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2117 struct MultTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UpperMatrix<MT2,SO2,DF2> >
2118 {
2120 };
2121 
2122 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2123 struct MultTrait< UpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
2124 {
2126 };
2127 
2128 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2129 struct MultTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UniUpperMatrix<MT2,SO2,DF2> >
2130 {
2132 };
2133 
2134 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2135 struct MultTrait< UniUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
2136 {
2138 };
2139 
2140 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2141 struct MultTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
2142 {
2144 };
2146 //*************************************************************************************************
2147 
2148 
2149 
2150 
2151 //=================================================================================================
2152 //
2153 // DIVTRAIT SPECIALIZATIONS
2154 //
2155 //=================================================================================================
2156 
2157 //*************************************************************************************************
2159 template< typename MT, bool SO, bool DF, typename T >
2160 struct DivTrait< StrictlyUpperMatrix<MT,SO,DF>, T, EnableIf_< IsNumeric<T> > >
2161 {
2162  using Type = StrictlyUpperMatrix< DivTrait_<MT,T> >;
2163 };
2165 //*************************************************************************************************
2166 
2167 
2168 
2169 
2170 //=================================================================================================
2171 //
2172 // UNARYMAPTRAIT SPECIALIZATIONS
2173 //
2174 //=================================================================================================
2175 
2176 //*************************************************************************************************
2178 template< typename MT, bool SO, bool DF >
2179 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Abs >
2180 {
2182 };
2183 
2184 template< typename MT, bool SO, bool DF >
2185 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Floor >
2186 {
2188 };
2189 
2190 template< typename MT, bool SO, bool DF >
2191 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Ceil >
2192 {
2194 };
2195 
2196 template< typename MT, bool SO, bool DF >
2197 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Trunc >
2198 {
2200 };
2201 
2202 template< typename MT, bool SO, bool DF >
2203 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Round >
2204 {
2206 };
2207 
2208 template< typename MT, bool SO, bool DF >
2209 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Conj >
2210 {
2212 };
2213 
2214 template< typename MT, bool SO, bool DF >
2215 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Real >
2216 {
2218 };
2219 
2220 template< typename MT, bool SO, bool DF >
2221 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Imag >
2222 {
2224 };
2225 
2226 template< typename MT, bool SO, bool DF >
2227 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Sqrt >
2228 {
2230 };
2231 
2232 template< typename MT, bool SO, bool DF >
2233 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Cbrt >
2234 {
2236 };
2237 
2238 template< typename MT, bool SO, bool DF >
2239 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Sin >
2240 {
2242 };
2243 
2244 template< typename MT, bool SO, bool DF >
2245 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Asin >
2246 {
2248 };
2249 
2250 template< typename MT, bool SO, bool DF >
2251 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Sinh >
2252 {
2254 };
2255 
2256 template< typename MT, bool SO, bool DF >
2257 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Asinh >
2258 {
2260 };
2261 
2262 template< typename MT, bool SO, bool DF >
2263 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Tan >
2264 {
2266 };
2267 
2268 template< typename MT, bool SO, bool DF >
2269 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Atan >
2270 {
2272 };
2273 
2274 template< typename MT, bool SO, bool DF >
2275 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Tanh >
2276 {
2278 };
2279 
2280 template< typename MT, bool SO, bool DF >
2281 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Atanh >
2282 {
2284 };
2285 
2286 template< typename MT, bool SO, bool DF >
2287 struct UnaryMapTrait< StrictlyUpperMatrix<MT,SO,DF>, Erf >
2288 {
2290 };
2292 //*************************************************************************************************
2293 
2294 
2295 
2296 
2297 //=================================================================================================
2298 //
2299 // BINARYMAPTRAIT SPECIALIZATIONS
2300 //
2301 //=================================================================================================
2302 
2303 //*************************************************************************************************
2305 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2306 struct BinaryMapTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UpperMatrix<MT2,SO2,DF2>, Min >
2307 {
2309 };
2310 
2311 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2312 struct BinaryMapTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UpperMatrix<MT2,SO2,DF2>, Max >
2313 {
2315 };
2316 
2317 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2318 struct BinaryMapTrait< UpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2>, Min >
2319 {
2321 };
2322 
2323 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2324 struct BinaryMapTrait< UpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2>, Max >
2325 {
2327 };
2328 
2329 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2330 struct BinaryMapTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UniUpperMatrix<MT2,SO2,DF2>, Min >
2331 {
2333 };
2334 
2335 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2336 struct BinaryMapTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, UniUpperMatrix<MT2,SO2,DF2>, Max >
2337 {
2339 };
2340 
2341 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2342 struct BinaryMapTrait< UniUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2>, Min >
2343 {
2345 };
2346 
2347 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2348 struct BinaryMapTrait< UniUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2>, Max >
2349 {
2351 };
2352 
2353 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2354 struct BinaryMapTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2>, Min >
2355 {
2357 };
2358 
2359 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2360 struct BinaryMapTrait< StrictlyUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2>, Max >
2361 {
2363 };
2365 //*************************************************************************************************
2366 
2367 
2368 
2369 
2370 //=================================================================================================
2371 //
2372 // DECLSYMTRAIT SPECIALIZATIONS
2373 //
2374 //=================================================================================================
2375 
2376 //*************************************************************************************************
2378 template< typename MT, bool SO, bool DF >
2379 struct DeclSymTrait< StrictlyUpperMatrix<MT,SO,DF> >
2380 {
2381  using Type = DiagonalMatrix<MT>;
2382 };
2384 //*************************************************************************************************
2385 
2386 
2387 
2388 
2389 //=================================================================================================
2390 //
2391 // DECLHERMTRAIT SPECIALIZATIONS
2392 //
2393 //=================================================================================================
2394 
2395 //*************************************************************************************************
2397 template< typename MT, bool SO, bool DF >
2398 struct DeclHermTrait< StrictlyUpperMatrix<MT,SO,DF> >
2399 {
2400  using Type = HermitianMatrix<MT>;
2401 };
2403 //*************************************************************************************************
2404 
2405 
2406 
2407 
2408 //=================================================================================================
2409 //
2410 // DECLLOWTRAIT SPECIALIZATIONS
2411 //
2412 //=================================================================================================
2413 
2414 //*************************************************************************************************
2416 template< typename MT, bool SO, bool DF >
2417 struct DeclLowTrait< StrictlyUpperMatrix<MT,SO,DF> >
2418 {
2419  using Type = DiagonalMatrix<MT>;
2420 };
2422 //*************************************************************************************************
2423 
2424 
2425 
2426 
2427 //=================================================================================================
2428 //
2429 // DECLUPPTRAIT SPECIALIZATIONS
2430 //
2431 //=================================================================================================
2432 
2433 //*************************************************************************************************
2435 template< typename MT, bool SO, bool DF >
2436 struct DeclUppTrait< StrictlyUpperMatrix<MT,SO,DF> >
2437 {
2438  using Type = DiagonalMatrix<MT>;
2439 };
2441 //*************************************************************************************************
2442 
2443 
2444 
2445 
2446 //=================================================================================================
2447 //
2448 // DECLDIAGTRAIT SPECIALIZATIONS
2449 //
2450 //=================================================================================================
2451 
2452 //*************************************************************************************************
2454 template< typename MT, bool SO, bool DF >
2455 struct DeclDiagTrait< StrictlyUpperMatrix<MT,SO,DF> >
2456 {
2457  using Type = DiagonalMatrix<MT>;
2458 };
2460 //*************************************************************************************************
2461 
2462 
2463 
2464 
2465 //=================================================================================================
2466 //
2467 // HIGHTYPE SPECIALIZATIONS
2468 //
2469 //=================================================================================================
2470 
2471 //*************************************************************************************************
2473 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2474 struct HighType< StrictlyUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
2475 {
2477 };
2479 //*************************************************************************************************
2480 
2481 
2482 
2483 
2484 //=================================================================================================
2485 //
2486 // LOWTYPE SPECIALIZATIONS
2487 //
2488 //=================================================================================================
2489 
2490 //*************************************************************************************************
2492 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2493 struct LowType< StrictlyUpperMatrix<MT1,SO1,DF1>, StrictlyUpperMatrix<MT2,SO2,DF2> >
2494 {
2496 };
2498 //*************************************************************************************************
2499 
2500 
2501 
2502 
2503 //=================================================================================================
2504 //
2505 // SUBMATRIXTRAIT SPECIALIZATIONS
2506 //
2507 //=================================================================================================
2508 
2509 //*************************************************************************************************
2511 template< typename MT, bool SO, bool DF, size_t... CSAs >
2512 struct SubmatrixTrait< StrictlyUpperMatrix<MT,SO,DF>, CSAs... >
2513 {
2514  using Type = SubmatrixTrait_<MT,CSAs...>;
2515 };
2517 //*************************************************************************************************
2518 
2519 
2520 
2521 
2522 //=================================================================================================
2523 //
2524 // ROWTRAIT SPECIALIZATIONS
2525 //
2526 //=================================================================================================
2527 
2528 //*************************************************************************************************
2530 template< typename MT, bool SO, bool DF, size_t... CRAs >
2531 struct RowTrait< StrictlyUpperMatrix<MT,SO,DF>, CRAs... >
2532 {
2533  using Type = RowTrait_<MT,CRAs...>;
2534 };
2536 //*************************************************************************************************
2537 
2538 
2539 
2540 
2541 //=================================================================================================
2542 //
2543 // ROWSTRAIT SPECIALIZATIONS
2544 //
2545 //=================================================================================================
2546 
2547 //*************************************************************************************************
2549 template< typename MT, bool SO, bool DF, size_t... CRAs >
2550 struct RowsTrait< StrictlyUpperMatrix<MT,SO,DF>, CRAs... >
2551 {
2552  using Type = RowsTrait_<MT,CRAs...>;
2553 };
2555 //*************************************************************************************************
2556 
2557 
2558 
2559 
2560 //=================================================================================================
2561 //
2562 // COLUMNTRAIT SPECIALIZATIONS
2563 //
2564 //=================================================================================================
2565 
2566 //*************************************************************************************************
2568 template< typename MT, bool SO, bool DF, size_t... CCAs >
2569 struct ColumnTrait< StrictlyUpperMatrix<MT,SO,DF>, CCAs... >
2570 {
2571  using Type = ColumnTrait_<MT,CCAs...>;
2572 };
2574 //*************************************************************************************************
2575 
2576 
2577 
2578 
2579 //=================================================================================================
2580 //
2581 // COLUMNSTRAIT SPECIALIZATIONS
2582 //
2583 //=================================================================================================
2584 
2585 //*************************************************************************************************
2587 template< typename MT, bool SO, bool DF, size_t... CCAs >
2588 struct ColumnsTrait< StrictlyUpperMatrix<MT,SO,DF>, CCAs... >
2589 {
2590  using Type = ColumnsTrait_<MT,CCAs...>;
2591 };
2593 //*************************************************************************************************
2594 
2595 
2596 
2597 
2598 //=================================================================================================
2599 //
2600 // BANDTRAIT SPECIALIZATIONS
2601 //
2602 //=================================================================================================
2603 
2604 //*************************************************************************************************
2606 template< typename MT, bool SO, bool DF, ptrdiff_t... CBAs >
2607 struct BandTrait< StrictlyUpperMatrix<MT,SO,DF>, CBAs... >
2608 {
2609  using Type = BandTrait_<MT,CBAs...>;
2610 };
2612 //*************************************************************************************************
2613 
2614 } // namespace blaze
2615 
2616 #endif
Pointer difference type of the Blaze library.
decltype(auto) column(Matrix< MT, SO > &matrix, RCAs... args)
Creating a view on a specific column of the given matrix.
Definition: Column.h:131
Headerfile for the generic min algorithm.
Header file for the decldiag trait.
Header file for the Schur product trait.
Compile time check for low-level access to constant data.This type trait tests whether the given data...
Definition: HasConstDataAccess.h:75
Header file for the UNUSED_PARAMETER function template.
Header file for the subtraction trait.
Header file for the row trait.
Header file for the declherm trait.
Base template for the SubmatrixTrait class.
Definition: SubmatrixTrait.h:109
Base template for the ColumnTrait class.
Definition: ColumnTrait.h:108
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:265
Base template for the DeclUppTrait class.
Definition: DeclUppTrait.h:113
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
Base template for the SchurTrait class.
Definition: SchurTrait.h:112
BLAZE_ALWAYS_INLINE MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:364
StrictlyUpperMatrix specialization for dense matrices.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:588
const ElementType_< MT > min(const DenseMatrix< MT, SO > &dm)
Returns the smallest element of the dense matrix.
Definition: DenseMatrix.h:1903
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:291
typename SubmatrixTrait< MT, CSAs... >::Type SubmatrixTrait_
Auxiliary alias declaration for the SubmatrixTrait type trait.The SubmatrixTrait_ alias declaration p...
Definition: SubmatrixTrait.h:145
typename RowTrait< MT, CRAs... >::Type RowTrait_
Auxiliary alias declaration for the RowTrait type trait.The RowTrait_ alias declaration provides a co...
Definition: RowTrait.h:145
Base template for the RowsTrait class.
Definition: RowsTrait.h:109
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:80
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
Header file for the band trait.
Compile time check for data types with restricted data access.This type trait tests whether the given...
Definition: IsRestricted.h:82
Header file for the IsSquare type trait.
Compile time check for the alignment of data types.This type trait tests whether the given data type ...
Definition: IsAligned.h:87
Base template for the RowTrait class.
Definition: RowTrait.h:109
Compile time check for the memory layout of data types.This type trait tests whether the given data t...
Definition: IsContiguous.h:86
typename ColumnTrait< MT, CCAs... >::Type ColumnTrait_
Auxiliary alias declaration for the ColumnTrait type trait.The ColumnTrait_ alias declaration provide...
Definition: ColumnTrait.h:144
Header file for the LowType type trait.
Base template for the HighType type trait.
Definition: HighType.h:133
Header file for the multiplication trait.
Header file for the IsStrictlyUpper type trait.
Header file for the unary map trait.
typename ColumnsTrait< MT, CCAs... >::Type ColumnsTrait_
Auxiliary alias declaration for the ColumnsTrait type trait.The ColumnsTrait_ alias declaration provi...
Definition: ColumnsTrait.h:145
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
Matrix adapter for strictly upper triangular matrices.
Definition: BaseTemplate.h:558
Header file for the IsShrinkable type trait.
Header file for all forward declarations of the math module.
Compile time check for data types with padding.This type trait tests whether the given data type empl...
Definition: IsPadded.h:76
Header file for the decllow trait.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3085
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:76
Compile time check for square matrices.This type trait tests whether or not the given template parame...
Definition: IsSquare.h:88
Header file for the IsAligned type trait.
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:506
Base template for the DeclSymTrait class.
Definition: DeclSymTrait.h:113
StrictlyUpperMatrix specialization for sparse matrices.
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:430
Header file for the RemoveAdaptor type trait.
Constraint on the data type.
Matrix adapter for upper triangular matrices.
Definition: BaseTemplate.h:553
Compile time check for adaptors.This type trait tests whether the given template parameter is an adap...
Definition: IsAdaptor.h:88
typename BandTrait< MT, CBAs... >::Type BandTrait_
Auxiliary alias declaration for the BandTrait type trait.The BandTrait_ alias declaration provides a ...
Definition: BandTrait.h:145
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:608
Header file for the IsPadded type trait.
Header file for the IsAdaptor type trait.
Header file for the implementation of the base template of the StrictlyUpperMatrix.
decltype(auto) band(Matrix< MT, SO > &matrix, RBAs... args)
Creating a view on a specific band of the given matrix.
Definition: Band.h:134
typename RowsTrait< MT, CRAs... >::Type RowsTrait_
Auxiliary alias declaration for the RowsTrait type trait.The RowsTrait_ alias declaration provides a ...
Definition: RowsTrait.h:145
Compile time check for shrinkable data types.This type trait tests whether the given data type is a s...
Definition: IsShrinkable.h:75
Header file for the IsNumeric type trait.
Base template for the LowType type trait.
Definition: LowType.h:133
Header file for the HasConstDataAccess type trait.
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
Header file for the declupp trait.
Matrix adapter for upper unitriangular matrices.
Definition: BaseTemplate.h:576
Header file for the binary map trait.
Header file for run time assertion macros.
Base template for the AddTrait class.
Definition: AddTrait.h:119
Base template for the DeclHermTrait class.
Definition: DeclHermTrait.h:113
Base template for the MultTrait class.
Definition: MultTrait.h:119
Header file for the addition trait.
Header file for the division trait.
Header file for the submatrix trait.
Header file for the IsContiguous type trait.
Header file for the columns trait.
decltype(auto) row(Matrix< MT, SO > &, RRAs...)
Creating a view on a specific row of the given matrix.
Definition: Row.h:131
Header file for the declsym trait.
Matrix adapter for Hermitian matrices.
Definition: BaseTemplate.h:611
Header file for the column trait.
Header file for the isDefault shim.
void swap(DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b) noexcept
Swapping the contents of two matrices.
Definition: DiagonalMatrix.h:272
Base class for matrices.The Matrix class is a base class for all dense and sparse matrix classes with...
Definition: Forward.h:101
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.In case the given data type T requires an intermediate evaluation within ...
Definition: RequiresEvaluation.h:81
Base template for the DivTrait class.
Definition: DivTrait.h:120
Header file for the rows trait.
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:490
Base template for the DeclLowTrait class.
Definition: DeclLowTrait.h:113
Removal of top level adaptor types.In case the given type is an adaptor type (SymmetricMatrix, LowerMatrix, UpperMatrix, ...), the RemoveAdaptor type trait removes the adaptor and extracts the contained general matrix type. Else the given type is returned as is. Note that cv-qualifiers are preserved.
Definition: RemoveAdaptor.h:76
Base template for the ColumnsTrait class.
Definition: ColumnsTrait.h:109
Base class for N-dimensional vectors.The Vector class is a base class for all arbitrarily sized (N-di...
Definition: Forward.h:177
typename SubTrait< T1, T2 >::Type SubTrait_
Auxiliary alias declaration for the SubTrait class template.The SubTrait_ alias declaration provides ...
Definition: SubTrait.h:291
Compile time evaluation of the size of vectors and matrices.The Size type trait evaluates the size of...
Definition: Size.h:80
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:130
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:254
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:628
Base template for the SubTrait class.
Definition: SubTrait.h:119
Matrix adapter for diagonal matrices.
Definition: BaseTemplate.h:560
void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
Base template for the DeclDiagTrait class.
Definition: DeclDiagTrait.h:113
Base template for the BinaryMapTrait class.
Definition: BinaryMapTrait.h:97
Header file for the IsResizable type trait.
Header file for the IsRestricted type trait.
Base template for the UnaryMapTrait class.
Definition: UnaryMapTrait.h:95
Header file for the Size type trait.
typename AddTrait< T1, T2 >::Type AddTrait_
Auxiliary alias declaration for the AddTrait class template.The AddTrait_ alias declaration provides ...
Definition: AddTrait.h:291
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
Header file for the HighType type trait.
Header file for the TrueType type/value trait base class.
Base template for the BandTrait class.
Definition: BandTrait.h:109