StrictlyLowerMatrix.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_ADAPTORS_STRICTLYLOWERMATRIX_H_
36 #define _BLAZE_MATH_ADAPTORS_STRICTLYLOWERMATRIX_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
49 #include <blaze/math/Forward.h>
50 #include <blaze/math/Functions.h>
73 #include <blaze/util/Assert.h>
74 #include <blaze/util/EnableIf.h>
76 #include <blaze/util/TrueType.h>
78 #include <blaze/util/Unused.h>
79 
80 
81 namespace blaze {
82 
83 //=================================================================================================
84 //
85 // STRICTLYLOWERMATRIX OPERATORS
86 //
87 //=================================================================================================
88 
89 //*************************************************************************************************
92 template< typename MT, bool SO, bool DF >
93 inline void reset( StrictlyLowerMatrix<MT,SO,DF>& m );
94 
95 template< typename MT, bool SO, bool DF >
96 inline void reset( StrictlyLowerMatrix<MT,SO,DF>& m, size_t i );
97 
98 template< typename MT, bool SO, bool DF >
99 inline void clear( StrictlyLowerMatrix<MT,SO,DF>& m );
100 
101 template< typename MT, bool SO, bool DF >
102 inline bool isDefault( const StrictlyLowerMatrix<MT,SO,DF>& m );
103 
104 template< typename MT, bool SO, bool DF >
105 inline bool isIntact( const StrictlyLowerMatrix<MT,SO,DF>& m );
106 
107 template< typename MT, bool SO, bool DF >
108 inline void swap( StrictlyLowerMatrix<MT,SO,DF>& a, StrictlyLowerMatrix<MT,SO,DF>& b ) noexcept;
110 //*************************************************************************************************
111 
112 
113 //*************************************************************************************************
120 template< typename MT // Type of the adapted matrix
121  , bool SO // Storage order of the adapted matrix
122  , bool DF > // Density flag
124 {
125  m.reset();
126 }
127 //*************************************************************************************************
128 
129 
130 //*************************************************************************************************
143 template< typename MT // Type of the adapted matrix
144  , bool SO // Storage order of the adapted matrix
145  , bool DF > // Density flag
146 inline void reset( StrictlyLowerMatrix<MT,SO,DF>& m, size_t i )
147 {
148  m.reset( i );
149 }
150 //*************************************************************************************************
151 
152 
153 //*************************************************************************************************
160 template< typename MT // Type of the adapted matrix
161  , bool SO // Storage order of the adapted matrix
162  , bool DF > // Density flag
164 {
165  m.clear();
166 }
167 //*************************************************************************************************
168 
169 
170 //*************************************************************************************************
181 template< typename MT // Type of the adapted matrix
182  , bool SO // Storage order of the adapted matrix
183  , bool DF > // Density flag
184 inline bool isDefault_backend( const StrictlyLowerMatrix<MT,SO,DF>& m, TrueType )
185 {
186  return ( m.rows() == 0UL );
187 }
189 //*************************************************************************************************
190 
191 
192 //*************************************************************************************************
203 template< typename MT // Type of the adapted matrix
204  , bool SO // Storage order of the adapted matrix
205  , bool DF > // Density flag
206 inline bool isDefault_backend( const StrictlyLowerMatrix<MT,SO,DF>& m, FalseType )
207 {
208  return isIdentity( m );
209 }
211 //*************************************************************************************************
212 
213 
214 //*************************************************************************************************
233 template< typename MT // Type of the adapted matrix
234  , bool SO // Storage order of the adapted matrix
235  , bool DF > // Density flag
237 {
238  return isDefault_backend( m, typename IsResizable<MT>::Type() );
239 }
240 //*************************************************************************************************
241 
242 
243 //*************************************************************************************************
264 template< typename MT // Type of the adapted matrix
265  , bool SO // Storage order of the adapted matrix
266  , bool DF > // Density flag
268 {
269  return m.isIntact();
270 }
271 //*************************************************************************************************
272 
273 
274 //*************************************************************************************************
282 template< typename MT // Type of the adapted matrix
283  , bool SO // Storage order of the adapted matrix
284  , bool DF > // Density flag
286 {
287  a.swap( b );
288 }
289 //*************************************************************************************************
290 
291 
292 //*************************************************************************************************
309 template< typename MT // Type of the adapted matrix
310  , bool SO // Storage order of the adapted matrix
311  , bool DF // Density flag
312  , typename VT > // Type of the right-hand side dense vector
313 inline bool tryAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
314  const DenseVector<VT,false>& rhs, size_t row, size_t column )
315 {
317 
318  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
319  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
320  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.rows() - row, "Invalid number of rows" );
321 
322  UNUSED_PARAMETER( lhs );
323 
324  if( column < row )
325  return true;
326 
327  const size_t iend( min( column - row + 1UL, (~rhs).size() ) );
328 
329  for( size_t i=0UL; i<iend; ++i ) {
330  if( !isDefault( (~rhs)[i] ) )
331  return false;
332  }
333 
334  return true;
335 }
337 //*************************************************************************************************
338 
339 
340 //*************************************************************************************************
357 template< typename MT // Type of the adapted matrix
358  , bool SO // Storage order of the adapted matrix
359  , bool DF // Density flag
360  , typename VT > // Type of the right-hand side dense vector
361 inline bool tryAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
362  const DenseVector<VT,true>& rhs, size_t row, size_t column )
363 {
365 
366  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
367  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
368  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.columns() - column, "Invalid number of columns" );
369 
370  UNUSED_PARAMETER( lhs );
371 
372  const size_t ibegin( ( row <= column )?( 0UL ):( row - column ) );
373 
374  for( size_t i=ibegin; i<(~rhs).size(); ++i ) {
375  if( !isDefault( (~rhs)[i] ) )
376  return false;
377  }
378 
379  return true;
380 }
382 //*************************************************************************************************
383 
384 
385 //*************************************************************************************************
402 template< typename MT // Type of the adapted matrix
403  , bool SO // Storage order of the adapted matrix
404  , bool DF // Density flag
405  , typename VT > // Type of the right-hand side sparse vector
406 inline bool tryAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
407  const SparseVector<VT,false>& rhs, size_t row, size_t column )
408 {
410 
411  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
412  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
413  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.rows() - row, "Invalid number of rows" );
414 
415  UNUSED_PARAMETER( lhs );
416 
417  typedef typename VT::ConstIterator RhsIterator;
418 
419  if( column < row )
420  return true;
421 
422  const RhsIterator last( (~rhs).lowerBound( column - row + 1UL ) );
423 
424  for( RhsIterator element=(~rhs).begin(); element!=last; ++element ) {
425  if( !isDefault( element->value() ) )
426  return false;
427  }
428 
429  return true;
430 }
432 //*************************************************************************************************
433 
434 
435 //*************************************************************************************************
452 template< typename MT // Type of the adapted matrix
453  , bool SO // Storage order of the adapted matrix
454  , bool DF // Density flag
455  , typename VT > // Type of the right-hand side sparse vector
456 inline bool tryAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
457  const SparseVector<VT,true>& rhs, size_t row, size_t column )
458 {
460 
461  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
462  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
463  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.columns() - column, "Invalid number of columns" );
464 
465  UNUSED_PARAMETER( lhs );
466 
467  typedef typename VT::ConstIterator RhsIterator;
468 
469  const RhsIterator last( (~rhs).end() );
470  RhsIterator element( (~rhs).lowerBound( ( row <= column )?( 0UL ):( row - column ) ) );
471 
472  for( ; element!=last; ++element ) {
473  if( !isDefault( element->value() ) )
474  return false;
475  }
476 
477  return true;
478 }
480 //*************************************************************************************************
481 
482 
483 //*************************************************************************************************
500 template< typename MT1 // Type of the adapted matrix
501  , bool SO // Storage order of the adapted matrix
502  , bool DF // Density flag
503  , typename MT2 > // Type of the right-hand side dense matrix
504 inline bool tryAssign( const StrictlyLowerMatrix<MT1,SO,DF>& lhs,
505  const DenseMatrix<MT2,false>& rhs, size_t row, size_t column )
506 {
508 
509  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
510  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
511  BLAZE_INTERNAL_ASSERT( (~rhs).rows() <= lhs.rows() - row, "Invalid number of rows" );
512  BLAZE_INTERNAL_ASSERT( (~rhs).columns() <= lhs.columns() - column, "Invalid number of columns" );
513 
514  UNUSED_PARAMETER( lhs );
515 
516  const size_t M( (~rhs).rows() );
517  const size_t N( (~rhs).columns() );
518 
519  if( row + 1UL >= column + N )
520  return true;
521 
522  const size_t iend( min( column + N - row, M ) );
523 
524  for( size_t i=0UL; i<iend; ++i )
525  {
526  const bool containsDiagonal( row + i >= column );
527  const size_t jbegin( ( containsDiagonal )?( row + i - column ):( 0UL ) );
528 
529  for( size_t j=jbegin; j<N; ++j ) {
530  if( !isDefault( (~rhs)(i,j) ) )
531  return false;
532  }
533  }
534 
535  return true;
536 }
538 //*************************************************************************************************
539 
540 
541 //*************************************************************************************************
558 template< typename MT1 // Type of the adapted matrix
559  , bool SO // Storage order of the adapted matrix
560  , bool DF // Density flag
561  , typename MT2 > // Type of the right-hand side dense matrix
562 inline bool tryAssign( const StrictlyLowerMatrix<MT1,SO,DF>& lhs,
563  const DenseMatrix<MT2,true>& rhs, size_t row, size_t column )
564 {
566 
567  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
568  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
569  BLAZE_INTERNAL_ASSERT( (~rhs).rows() <= lhs.rows() - row, "Invalid number of rows" );
570  BLAZE_INTERNAL_ASSERT( (~rhs).columns() <= lhs.columns() - column, "Invalid number of columns" );
571 
572  UNUSED_PARAMETER( lhs );
573 
574  const size_t M( (~rhs).rows() );
575  const size_t N( (~rhs).columns() );
576 
577  if( row + 1UL >= column + N )
578  return true;
579 
580  const size_t jbegin( ( row <= column )?( 0UL ):( row - column ) );
581 
582  for( size_t j=jbegin; j<N; ++j )
583  {
584  const size_t iend( min( column + j - row + 1UL, M ) );
585 
586  for( size_t i=0UL; i<iend; ++i ) {
587  if( !isDefault( (~rhs)(i,j) ) )
588  return false;
589  }
590  }
591 
592  return true;
593 }
595 //*************************************************************************************************
596 
597 
598 //*************************************************************************************************
615 template< typename MT1 // Type of the adapted matrix
616  , bool SO // Storage order of the adapted matrix
617  , bool DF // Density flag
618  , typename MT2 > // Type of the right-hand side sparse matrix
619 inline bool tryAssign( const StrictlyLowerMatrix<MT1,SO,DF>& lhs,
620  const SparseMatrix<MT2,false>& rhs, size_t row, size_t column )
621 {
623 
624  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
625  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
626  BLAZE_INTERNAL_ASSERT( (~rhs).rows() <= lhs.rows() - row, "Invalid number of rows" );
627  BLAZE_INTERNAL_ASSERT( (~rhs).columns() <= lhs.columns() - column, "Invalid number of columns" );
628 
629  UNUSED_PARAMETER( lhs );
630 
631  typedef typename MT2::ConstIterator RhsIterator;
632 
633  const size_t M( (~rhs).rows() );
634  const size_t N( (~rhs).columns() );
635 
636  if( row + 1UL >= column + N )
637  return true;
638 
639  const size_t iend( min( column + N - row, M ) );
640 
641  for( size_t i=0UL; i<iend; ++i )
642  {
643  const bool containsDiagonal( row + i >= column );
644  const size_t index( ( containsDiagonal )?( row + i - column ):( 0UL ) );
645 
646  const RhsIterator last( (~rhs).end(i) );
647  RhsIterator element( (~rhs).lowerBound( i, index ) );
648 
649  for( ; element!=last; ++element ) {
650  if( !isDefault( element->value() ) )
651  return false;
652  }
653  }
654 
655  return true;
656 }
658 //*************************************************************************************************
659 
660 
661 //*************************************************************************************************
678 template< typename MT1 // Type of the adapted matrix
679  , bool SO // Storage order of the adapted matrix
680  , bool DF // Density flag
681  , typename MT2 > // Type of the right-hand side sparse matrix
682 inline bool tryAssign( const StrictlyLowerMatrix<MT1,SO,DF>& lhs,
683  const SparseMatrix<MT2,true>& rhs, size_t row, size_t column )
684 {
686 
687  BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
688  BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
689  BLAZE_INTERNAL_ASSERT( (~rhs).rows() <= lhs.rows() - row, "Invalid number of rows" );
690  BLAZE_INTERNAL_ASSERT( (~rhs).columns() <= lhs.columns() - column, "Invalid number of columns" );
691 
692  UNUSED_PARAMETER( lhs );
693 
694  typedef typename MT2::ConstIterator RhsIterator;
695 
696  const size_t M( (~rhs).rows() );
697  const size_t N( (~rhs).columns() );
698 
699  if( row + 1UL >= column + N )
700  return true;
701 
702  const size_t jbegin( ( row < column )?( 0UL ):( row - column ) );
703 
704  for( size_t j=jbegin; j<N; ++j )
705  {
706  const size_t index( column + j - row + 1UL );
707  const RhsIterator last( (~rhs).lowerBound( min( index, M ), j ) );
708 
709  for( RhsIterator element=(~rhs).begin(j); element!=last; ++element ) {
710  if( !isDefault( element->value() ) )
711  return false;
712  }
713  }
714 
715  return true;
716 }
718 //*************************************************************************************************
719 
720 
721 //*************************************************************************************************
738 template< typename MT // Type of the adapted matrix
739  , bool SO // Storage order of the adapted matrix
740  , bool DF // Density flag
741  , typename VT // Type of the right-hand side vector
742  , bool TF > // Transpose flag of the right-hand side vector
743 inline bool tryAddAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
744  const Vector<VT,TF>& rhs, size_t row, size_t column )
745 {
746  return tryAssign( lhs, ~rhs, row, column );
747 }
749 //*************************************************************************************************
750 
751 
752 //*************************************************************************************************
769 template< typename MT1 // Type of the adapted matrix
770  , bool SO1 // Storage order of the adapted matrix
771  , bool DF // Density flag
772  , typename MT2 // Type of the right-hand side matrix
773  , bool SO2 > // Storage order of the right-hand side matrix
774 inline bool tryAddAssign( const StrictlyLowerMatrix<MT1,SO1,DF>& lhs,
775  const Matrix<MT2,SO2>& rhs, size_t row, size_t column )
776 {
777  return tryAssign( lhs, ~rhs, row, column );
778 }
780 //*************************************************************************************************
781 
782 
783 //*************************************************************************************************
800 template< typename MT // Type of the adapted matrix
801  , bool SO // Storage order of the adapted matrix
802  , bool DF // Density flag
803  , typename VT // Type of the right-hand side vector
804  , bool TF > // Transpose flag of the right-hand side vector
805 inline bool trySubAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
806  const Vector<VT,TF>& rhs, size_t row, size_t column )
807 {
808  return tryAssign( lhs, ~rhs, row, column );
809 }
811 //*************************************************************************************************
812 
813 
814 //*************************************************************************************************
831 template< typename MT1 // Type of the adapted matrix
832  , bool SO1 // Storage order of the adapted matrix
833  , bool DF // Density flag
834  , typename MT2 // Type of the right-hand side matrix
835  , bool SO2 > // Storage order of the right-hand side matrix
836 inline bool trySubAssign( const StrictlyLowerMatrix<MT1,SO1,DF>& lhs,
837  const Matrix<MT2,SO2>& rhs, size_t row, size_t column )
838 {
839  return tryAssign( lhs, ~rhs, row, column );
840 }
842 //*************************************************************************************************
843 
844 
845 //*************************************************************************************************
859 template< typename MT // Type of the adapted matrix
860  , bool SO // Storage order of the adapted matrix
861  , bool DF > // Density flag
862 inline MT& derestrict( StrictlyLowerMatrix<MT,SO,DF>& m )
863 {
864  return m.matrix_;
865 }
867 //*************************************************************************************************
868 
869 
870 
871 
872 //=================================================================================================
873 //
874 // ROWS SPECIALIZATIONS
875 //
876 //=================================================================================================
877 
878 //*************************************************************************************************
880 template< typename MT, bool SO, bool DF >
881 struct Rows< StrictlyLowerMatrix<MT,SO,DF> > : public Rows<MT>
882 {};
884 //*************************************************************************************************
885 
886 
887 
888 
889 //=================================================================================================
890 //
891 // COLUMNS SPECIALIZATIONS
892 //
893 //=================================================================================================
894 
895 //*************************************************************************************************
897 template< typename MT, bool SO, bool DF >
898 struct Columns< StrictlyLowerMatrix<MT,SO,DF> > : public Columns<MT>
899 {};
901 //*************************************************************************************************
902 
903 
904 
905 
906 //=================================================================================================
907 //
908 // ISSQUARE SPECIALIZATIONS
909 //
910 //=================================================================================================
911 
912 //*************************************************************************************************
914 template< typename MT, bool SO, bool DF >
915 struct IsSquare< StrictlyLowerMatrix<MT,SO,DF> > : public TrueType
916 {};
918 //*************************************************************************************************
919 
920 
921 
922 
923 //=================================================================================================
924 //
925 // ISSTRICTLYLOWER SPECIALIZATIONS
926 //
927 //=================================================================================================
928 
929 //*************************************************************************************************
931 template< typename MT, bool SO, bool DF >
932 struct IsStrictlyLower< StrictlyLowerMatrix<MT,SO,DF> > : public TrueType
933 {};
935 //*************************************************************************************************
936 
937 
938 
939 
940 //=================================================================================================
941 //
942 // ISADAPTOR SPECIALIZATIONS
943 //
944 //=================================================================================================
945 
946 //*************************************************************************************************
948 template< typename MT, bool SO, bool DF >
949 struct IsAdaptor< StrictlyLowerMatrix<MT,SO,DF> > : public TrueType
950 {};
952 //*************************************************************************************************
953 
954 
955 
956 
957 //=================================================================================================
958 //
959 // ISRESTRICTED SPECIALIZATIONS
960 //
961 //=================================================================================================
962 
963 //*************************************************************************************************
965 template< typename MT, bool SO, bool DF >
966 struct IsRestricted< StrictlyLowerMatrix<MT,SO,DF> > : public TrueType
967 {};
969 //*************************************************************************************************
970 
971 
972 
973 
974 //=================================================================================================
975 //
976 // HASCONSTDATAACCESS SPECIALIZATIONS
977 //
978 //=================================================================================================
979 
980 //*************************************************************************************************
982 template< typename MT, bool SO >
983 struct HasConstDataAccess< StrictlyLowerMatrix<MT,SO,true> > : public TrueType
984 {};
986 //*************************************************************************************************
987 
988 
989 
990 
991 //=================================================================================================
992 //
993 // ISALIGNED SPECIALIZATIONS
994 //
995 //=================================================================================================
996 
997 //*************************************************************************************************
999 template< typename MT, bool SO, bool DF >
1000 struct IsAligned< StrictlyLowerMatrix<MT,SO,DF> > : public BoolConstant< IsAligned<MT>::value >
1001 {};
1003 //*************************************************************************************************
1004 
1005 
1006 
1007 
1008 //=================================================================================================
1009 //
1010 // ISPADDED SPECIALIZATIONS
1011 //
1012 //=================================================================================================
1013 
1014 //*************************************************************************************************
1016 template< typename MT, bool SO, bool DF >
1017 struct IsPadded< StrictlyLowerMatrix<MT,SO,DF> > : public BoolConstant< IsPadded<MT>::value >
1018 {};
1020 //*************************************************************************************************
1021 
1022 
1023 
1024 
1025 //=================================================================================================
1026 //
1027 // ISRESIZABLE SPECIALIZATIONS
1028 //
1029 //=================================================================================================
1030 
1031 //*************************************************************************************************
1033 template< typename MT, bool SO, bool DF >
1034 struct IsResizable< StrictlyLowerMatrix<MT,SO,DF> > : public BoolConstant< IsResizable<MT>::value >
1035 {};
1037 //*************************************************************************************************
1038 
1039 
1040 
1041 
1042 //=================================================================================================
1043 //
1044 // REMOVEADAPTOR SPECIALIZATIONS
1045 //
1046 //=================================================================================================
1047 
1048 //*************************************************************************************************
1050 template< typename MT, bool SO, bool DF >
1051 struct RemoveAdaptor< StrictlyLowerMatrix<MT,SO,DF> >
1052 {
1053  using Type = MT;
1054 };
1056 //*************************************************************************************************
1057 
1058 
1059 
1060 
1061 //=================================================================================================
1062 //
1063 // DERESTRICTTRAIT SPECIALIZATIONS
1064 //
1065 //=================================================================================================
1066 
1067 //*************************************************************************************************
1069 template< typename MT, bool SO, bool DF >
1070 struct DerestrictTrait< StrictlyLowerMatrix<MT,SO,DF> >
1071 {
1072  using Type = MT&;
1073 };
1075 //*************************************************************************************************
1076 
1077 
1078 
1079 
1080 //=================================================================================================
1081 //
1082 // ADDTRAIT SPECIALIZATIONS
1083 //
1084 //=================================================================================================
1085 
1086 //*************************************************************************************************
1088 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1089 struct AddTrait< StrictlyLowerMatrix<MT,SO1,DF>, StaticMatrix<T,M,N,SO2> >
1090 {
1091  using Type = AddTrait_< MT, StaticMatrix<T,M,N,SO2> >;
1092 };
1093 
1094 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
1095 struct AddTrait< StaticMatrix<T,M,N,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1096 {
1097  using Type = AddTrait_< StaticMatrix<T,M,N,SO1>, MT >;
1098 };
1099 
1100 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1101 struct AddTrait< StrictlyLowerMatrix<MT,SO1,DF>, HybridMatrix<T,M,N,SO2> >
1102 {
1103  using Type = AddTrait_< MT, HybridMatrix<T,M,N,SO2> >;
1104 };
1105 
1106 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
1107 struct AddTrait< HybridMatrix<T,M,N,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1108 {
1109  using Type = AddTrait_< HybridMatrix<T,M,N,SO1>, MT >;
1110 };
1111 
1112 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1113 struct AddTrait< StrictlyLowerMatrix<MT,SO1,DF>, DynamicMatrix<T,SO2> >
1114 {
1115  using Type = AddTrait_< MT, DynamicMatrix<T,SO2> >;
1116 };
1117 
1118 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1119 struct AddTrait< DynamicMatrix<T,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1120 {
1121  using Type = AddTrait_< DynamicMatrix<T,SO1>, MT >;
1122 };
1123 
1124 template< typename MT, bool SO1, bool DF, typename T, bool AF, bool PF, bool SO2 >
1125 struct AddTrait< StrictlyLowerMatrix<MT,SO1,DF>, CustomMatrix<T,AF,PF,SO2> >
1126 {
1127  using Type = AddTrait_< MT, CustomMatrix<T,AF,PF,SO2> >;
1128 };
1129 
1130 template< typename T, bool AF, bool PF, bool SO1, typename MT, bool SO2, bool DF >
1131 struct AddTrait< CustomMatrix<T,AF,PF,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1132 {
1133  using Type = AddTrait_< CustomMatrix<T,AF,PF,SO1>, MT >;
1134 };
1135 
1136 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1137 struct AddTrait< StrictlyLowerMatrix<MT,SO1,DF>, CompressedMatrix<T,SO2> >
1138 {
1139  using Type = AddTrait_< MT, CompressedMatrix<T,SO2> >;
1140 };
1141 
1142 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1143 struct AddTrait< CompressedMatrix<T,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1144 {
1145  using Type = AddTrait_< CompressedMatrix<T,SO1>, MT >;
1146 };
1147 
1148 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2, bool NF >
1149 struct AddTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, SymmetricMatrix<MT2,SO2,DF2,NF> >
1150 {
1151  using Type = AddTrait_<MT1,MT2>;
1152 };
1153 
1154 template< typename MT1, bool SO1, bool DF1, bool NF, typename MT2, bool SO2, bool DF2 >
1155 struct AddTrait< SymmetricMatrix<MT1,SO1,DF1,NF>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1156 {
1157  using Type = AddTrait_<MT1,MT2>;
1158 };
1159 
1160 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1161 struct AddTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, HermitianMatrix<MT2,SO2,DF2> >
1162 {
1163  using Type = AddTrait_<MT1,MT2>;
1164 };
1165 
1166 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1167 struct AddTrait< HermitianMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1168 {
1169  using Type = AddTrait_<MT1,MT2>;
1170 };
1171 
1172 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1173 struct AddTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, LowerMatrix<MT2,SO2,DF2> >
1174 {
1175  using Type = LowerMatrix< AddTrait_<MT1,MT2> >;
1176 };
1177 
1178 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1179 struct AddTrait< LowerMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1180 {
1181  using Type = LowerMatrix< AddTrait_<MT1,MT2> >;
1182 };
1183 
1184 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1185 struct AddTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, UniLowerMatrix<MT2,SO2,DF2> >
1186 {
1187  using Type = UniLowerMatrix< AddTrait_<MT1,MT2> >;
1188 };
1189 
1190 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1191 struct AddTrait< UniLowerMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1192 {
1193  using Type = UniLowerMatrix< AddTrait_<MT1,MT2> >;
1194 };
1195 
1196 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1197 struct AddTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1198 {
1199  using Type = StrictlyLowerMatrix< AddTrait_<MT1,MT2> >;
1200 };
1202 //*************************************************************************************************
1203 
1204 
1205 
1206 
1207 //=================================================================================================
1208 //
1209 // SUBTRAIT SPECIALIZATIONS
1210 //
1211 //=================================================================================================
1212 
1213 //*************************************************************************************************
1215 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1216 struct SubTrait< StrictlyLowerMatrix<MT,SO1,DF>, StaticMatrix<T,M,N,SO2> >
1217 {
1218  using Type = SubTrait_< MT, StaticMatrix<T,M,N,SO2> >;
1219 };
1220 
1221 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
1222 struct SubTrait< StaticMatrix<T,M,N,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1223 {
1224  using Type = SubTrait_< StaticMatrix<T,M,N,SO1>, MT >;
1225 };
1226 
1227 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1228 struct SubTrait< StrictlyLowerMatrix<MT,SO1,DF>, HybridMatrix<T,M,N,SO2> >
1229 {
1230  using Type = SubTrait_< MT, HybridMatrix<T,M,N,SO2> >;
1231 };
1232 
1233 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
1234 struct SubTrait< HybridMatrix<T,M,N,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1235 {
1236  using Type = SubTrait_< HybridMatrix<T,M,N,SO1>, MT >;
1237 };
1238 
1239 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1240 struct SubTrait< StrictlyLowerMatrix<MT,SO1,DF>, DynamicMatrix<T,SO2> >
1241 {
1242  using Type = SubTrait_< MT, DynamicMatrix<T,SO2> >;
1243 };
1244 
1245 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1246 struct SubTrait< DynamicMatrix<T,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1247 {
1248  using Type = SubTrait_< DynamicMatrix<T,SO1>, MT >;
1249 };
1250 
1251 template< typename MT, bool SO1, bool DF, typename T, bool AF, bool PF, bool SO2 >
1252 struct SubTrait< StrictlyLowerMatrix<MT,SO1,DF>, CustomMatrix<T,AF,PF,SO2> >
1253 {
1254  using Type = SubTrait_< MT, CustomMatrix<T,AF,PF,SO2> >;
1255 };
1256 
1257 template< typename T, bool AF, bool PF, bool SO1, typename MT, bool SO2, bool DF >
1258 struct SubTrait< CustomMatrix<T,AF,PF,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1259 {
1260  using Type = SubTrait_< CustomMatrix<T,AF,PF,SO1>, MT >;
1261 };
1262 
1263 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1264 struct SubTrait< StrictlyLowerMatrix<MT,SO1,DF>, CompressedMatrix<T,SO2> >
1265 {
1266  using Type = SubTrait_< MT, CompressedMatrix<T,SO2> >;
1267 };
1268 
1269 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1270 struct SubTrait< CompressedMatrix<T,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1271 {
1272  using Type = SubTrait_< CompressedMatrix<T,SO1>, MT >;
1273 };
1274 
1275 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2, bool NF >
1276 struct SubTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, SymmetricMatrix<MT2,SO2,DF2,NF> >
1277 {
1278  using Type = SubTrait_<MT1,MT2>;
1279 };
1280 
1281 template< typename MT1, bool SO1, bool DF1, bool NF, typename MT2, bool SO2, bool DF2 >
1282 struct SubTrait< SymmetricMatrix<MT1,SO1,DF1,NF>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1283 {
1284  using Type = SubTrait_<MT1,MT2>;
1285 };
1286 
1287 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1288 struct SubTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, HermitianMatrix<MT2,SO2,DF2> >
1289 {
1290  using Type = SubTrait_<MT1,MT2>;
1291 };
1292 
1293 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1294 struct SubTrait< HermitianMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1295 {
1296  using Type = SubTrait_<MT1,MT2>;
1297 };
1298 
1299 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1300 struct SubTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, LowerMatrix<MT2,SO2,DF2> >
1301 {
1302  using Type = LowerMatrix< SubTrait_<MT1,MT2> >;
1303 };
1304 
1305 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1306 struct SubTrait< LowerMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1307 {
1308  using Type = LowerMatrix< SubTrait_<MT1,MT2> >;
1309 };
1310 
1311 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1312 struct SubTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, UniLowerMatrix<MT2,SO2,DF2> >
1313 {
1314  using Type = LowerMatrix< SubTrait_<MT1,MT2> >;
1315 };
1316 
1317 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1318 struct SubTrait< UniLowerMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1319 {
1320  using Type = UniLowerMatrix< SubTrait_<MT1,MT2> >;
1321 };
1322 
1323 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1324 struct SubTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1325 {
1326  using Type = StrictlyLowerMatrix< SubTrait_<MT1,MT2> >;
1327 };
1329 //*************************************************************************************************
1330 
1331 
1332 
1333 
1334 //=================================================================================================
1335 //
1336 // MULTTRAIT SPECIALIZATIONS
1337 //
1338 //=================================================================================================
1339 
1340 //*************************************************************************************************
1342 template< typename MT, bool SO, bool DF, typename T >
1343 struct MultTrait< StrictlyLowerMatrix<MT,SO,DF>, T, EnableIf_< IsNumeric<T> > >
1344 {
1345  using Type = StrictlyLowerMatrix< MultTrait_<MT,T> >;
1346 };
1347 
1348 template< typename T, typename MT, bool SO, bool DF >
1349 struct MultTrait< T, StrictlyLowerMatrix<MT,SO,DF>, EnableIf_< IsNumeric<T> > >
1350 {
1351  using Type = StrictlyLowerMatrix< MultTrait_<T,MT> >;
1352 };
1353 
1354 template< typename MT, bool SO, bool DF, typename T, size_t N >
1355 struct MultTrait< StrictlyLowerMatrix<MT,SO,DF>, StaticVector<T,N,false> >
1356 {
1357  using Type = MultTrait_< MT, StaticVector<T,N,false> >;
1358 };
1359 
1360 template< typename T, size_t N, typename MT, bool SO, bool DF >
1361 struct MultTrait< StaticVector<T,N,true>, StrictlyLowerMatrix<MT,SO,DF> >
1362 {
1363  using Type = MultTrait_< StaticVector<T,N,true>, MT >;
1364 };
1365 
1366 template< typename MT, bool SO, bool DF, typename T, size_t N >
1367 struct MultTrait< StrictlyLowerMatrix<MT,SO,DF>, HybridVector<T,N,false> >
1368 {
1369  using Type = MultTrait_< MT, HybridVector<T,N,false> >;
1370 };
1371 
1372 template< typename T, size_t N, typename MT, bool SO, bool DF >
1373 struct MultTrait< HybridVector<T,N,true>, StrictlyLowerMatrix<MT,SO,DF> >
1374 {
1375  using Type = MultTrait_< HybridVector<T,N,true>, MT >;
1376 };
1377 
1378 template< typename MT, bool SO, bool DF, typename T >
1379 struct MultTrait< StrictlyLowerMatrix<MT,SO,DF>, DynamicVector<T,false> >
1380 {
1381  using Type = MultTrait_< MT, DynamicVector<T,false> >;
1382 };
1383 
1384 template< typename T, typename MT, bool SO, bool DF >
1385 struct MultTrait< DynamicVector<T,true>, StrictlyLowerMatrix<MT,SO,DF> >
1386 {
1387  using Type = MultTrait_< DynamicVector<T,true>, MT >;
1388 };
1389 
1390 template< typename MT, bool SO, bool DF, typename T, bool AF, bool PF >
1391 struct MultTrait< StrictlyLowerMatrix<MT,SO,DF>, CustomVector<T,AF,PF,false> >
1392 {
1393  using Type = MultTrait_< MT, CustomVector<T,AF,PF,false> >;
1394 };
1395 
1396 template< typename T, bool AF, bool PF, typename MT, bool SO, bool DF >
1397 struct MultTrait< CustomVector<T,AF,PF,true>, StrictlyLowerMatrix<MT,SO,DF> >
1398 {
1399  using Type = MultTrait_< CustomVector<T,AF,PF,true>, MT >;
1400 };
1401 
1402 template< typename MT, bool SO, bool DF, typename T >
1403 struct MultTrait< StrictlyLowerMatrix<MT,SO,DF>, CompressedVector<T,false> >
1404 {
1405  using Type = MultTrait_< MT, CompressedVector<T,false> >;
1406 };
1407 
1408 template< typename T, typename MT, bool SO, bool DF >
1409 struct MultTrait< CompressedVector<T,true>, StrictlyLowerMatrix<MT,SO,DF> >
1410 {
1411  using Type = MultTrait_< CompressedVector<T,true>, MT >;
1412 };
1413 
1414 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1415 struct MultTrait< StrictlyLowerMatrix<MT,SO1,DF>, StaticMatrix<T,M,N,SO2> >
1416 {
1417  using Type = MultTrait_< MT, StaticMatrix<T,M,N,SO2> >;
1418 };
1419 
1420 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
1421 struct MultTrait< StaticMatrix<T,M,N,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1422 {
1423  using Type = MultTrait_< StaticMatrix<T,M,N,SO1>, MT >;
1424 };
1425 
1426 template< typename MT, bool SO1, bool DF, typename T, size_t M, size_t N, bool SO2 >
1427 struct MultTrait< StrictlyLowerMatrix<MT,SO1,DF>, HybridMatrix<T,M,N,SO2> >
1428 {
1429  using Type = MultTrait_< MT, HybridMatrix<T,M,N,SO2> >;
1430 };
1431 
1432 template< typename T, size_t M, size_t N, bool SO1, typename MT, bool SO2, bool DF >
1433 struct MultTrait< HybridMatrix<T,M,N,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1434 {
1435  using Type = MultTrait_< HybridMatrix<T,M,N,SO1>, MT >;
1436 };
1437 
1438 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1439 struct MultTrait< StrictlyLowerMatrix<MT,SO1,DF>, DynamicMatrix<T,SO2> >
1440 {
1441  using Type = MultTrait_< MT, DynamicMatrix<T,SO2> >;
1442 };
1443 
1444 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1445 struct MultTrait< DynamicMatrix<T,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1446 {
1447  using Type = MultTrait_< DynamicMatrix<T,SO1>, MT >;
1448 };
1449 
1450 template< typename MT, bool SO1, bool DF, typename T, bool AF, bool PF, bool SO2 >
1451 struct MultTrait< StrictlyLowerMatrix<MT,SO1,DF>, CustomMatrix<T,AF,PF,SO2> >
1452 {
1453  using Type = MultTrait_< MT, CustomMatrix<T,AF,PF,SO2> >;
1454 };
1455 
1456 template< typename T, bool AF, bool PF, bool SO1, typename MT, bool SO2, bool DF >
1457 struct MultTrait< CustomMatrix<T,AF,PF,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1458 {
1459  using Type = MultTrait_< CustomMatrix<T,AF,PF,SO1>, MT >;
1460 };
1461 
1462 template< typename MT, bool SO1, bool DF, typename T, bool SO2 >
1463 struct MultTrait< StrictlyLowerMatrix<MT,SO1,DF>, CompressedMatrix<T,SO2> >
1464 {
1465  using Type = MultTrait_< MT, CompressedMatrix<T,SO2> >;
1466 };
1467 
1468 template< typename T, bool SO1, typename MT, bool SO2, bool DF >
1469 struct MultTrait< CompressedMatrix<T,SO1>, StrictlyLowerMatrix<MT,SO2,DF> >
1470 {
1471  using Type = MultTrait_< CompressedMatrix<T,SO1>, MT >;
1472 };
1473 
1474 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2, bool NF >
1475 struct MultTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, SymmetricMatrix<MT2,SO2,DF2,NF> >
1476 {
1477  using Type = MultTrait_<MT1,MT2>;
1478 };
1479 
1480 template< typename MT1, bool SO1, bool DF1, bool NF, typename MT2, bool SO2, bool DF2 >
1481 struct MultTrait< SymmetricMatrix<MT1,SO1,DF1,NF>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1482 {
1483  using Type = MultTrait_<MT1,MT2>;
1484 };
1485 
1486 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1487 struct MultTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, HermitianMatrix<MT2,SO2,DF2> >
1488 {
1489  using Type = MultTrait_<MT1,MT2>;
1490 };
1491 
1492 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1493 struct MultTrait< HermitianMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1494 {
1495  using Type = MultTrait_<MT1,MT2>;
1496 };
1497 
1498 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1499 struct MultTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, LowerMatrix<MT2,SO2,DF2> >
1500 {
1501  using Type = StrictlyLowerMatrix< MultTrait_<MT1,MT2> >;
1502 };
1503 
1504 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1505 struct MultTrait< LowerMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1506 {
1507  using Type = StrictlyLowerMatrix< MultTrait_<MT1,MT2> >;
1508 };
1509 
1510 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1511 struct MultTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, UniLowerMatrix<MT2,SO2,DF2> >
1512 {
1513  using Type = StrictlyLowerMatrix< MultTrait_<MT1,MT2> >;
1514 };
1515 
1516 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1517 struct MultTrait< UniLowerMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1518 {
1519  using Type = StrictlyLowerMatrix< MultTrait_<MT1,MT2> >;
1520 };
1521 
1522 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1523 struct MultTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1524 {
1525  using Type = StrictlyLowerMatrix< MultTrait_<MT1,MT2> >;
1526 };
1528 //*************************************************************************************************
1529 
1530 
1531 
1532 
1533 //=================================================================================================
1534 //
1535 // DIVTRAIT SPECIALIZATIONS
1536 //
1537 //=================================================================================================
1538 
1539 //*************************************************************************************************
1541 template< typename MT, bool SO, bool DF, typename T >
1542 struct DivTrait< StrictlyLowerMatrix<MT,SO,DF>, T, EnableIf_< IsNumeric<T> > >
1543 {
1544  using Type = StrictlyLowerMatrix< DivTrait_<MT,T> >;
1545 };
1547 //*************************************************************************************************
1548 
1549 
1550 
1551 
1552 //=================================================================================================
1553 //
1554 // FOREACHTRAIT SPECIALIZATIONS
1555 //
1556 //=================================================================================================
1557 
1558 //*************************************************************************************************
1560 template< typename MT, bool SO, bool DF >
1561 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Abs >
1562 {
1563  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Abs> >;
1564 };
1565 
1566 template< typename MT, bool SO, bool DF >
1567 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Floor >
1568 {
1569  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Floor> >;
1570 };
1571 
1572 template< typename MT, bool SO, bool DF >
1573 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Ceil >
1574 {
1575  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Ceil> >;
1576 };
1577 
1578 template< typename MT, bool SO, bool DF >
1579 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Conj >
1580 {
1581  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Conj> >;
1582 };
1583 
1584 template< typename MT, bool SO, bool DF >
1585 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Real >
1586 {
1587  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Real> >;
1588 };
1589 
1590 template< typename MT, bool SO, bool DF >
1591 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Imag >
1592 {
1593  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Imag> >;
1594 };
1595 
1596 template< typename MT, bool SO, bool DF >
1597 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Sin >
1598 {
1599  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Sin> >;
1600 };
1601 
1602 template< typename MT, bool SO, bool DF >
1603 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Asin >
1604 {
1605  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Asin> >;
1606 };
1607 
1608 template< typename MT, bool SO, bool DF >
1609 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Sinh >
1610 {
1611  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Sinh> >;
1612 };
1613 
1614 template< typename MT, bool SO, bool DF >
1615 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Asinh >
1616 {
1617  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Asinh> >;
1618 };
1619 
1620 template< typename MT, bool SO, bool DF >
1621 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Tan >
1622 {
1623  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Tan> >;
1624 };
1625 
1626 template< typename MT, bool SO, bool DF >
1627 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Atan >
1628 {
1629  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Atan> >;
1630 };
1631 
1632 template< typename MT, bool SO, bool DF >
1633 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Tanh >
1634 {
1635  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Tanh> >;
1636 };
1637 
1638 template< typename MT, bool SO, bool DF >
1639 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Atanh >
1640 {
1641  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Atanh> >;
1642 };
1643 
1644 template< typename MT, bool SO, bool DF >
1645 struct ForEachTrait< StrictlyLowerMatrix<MT,SO,DF>, Erf >
1646 {
1647  using Type = StrictlyLowerMatrix< ForEachTrait_<MT,Erf> >;
1648 };
1650 //*************************************************************************************************
1651 
1652 
1653 
1654 
1655 //=================================================================================================
1656 //
1657 // MATHTRAIT SPECIALIZATIONS
1658 //
1659 //=================================================================================================
1660 
1661 //*************************************************************************************************
1663 template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
1664 struct MathTrait< StrictlyLowerMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
1665 {
1666  using HighType = StrictlyLowerMatrix< typename MathTrait<MT1,MT2>::HighType >;
1667  using LowType = StrictlyLowerMatrix< typename MathTrait<MT1,MT2>::LowType >;
1668 };
1670 //*************************************************************************************************
1671 
1672 
1673 
1674 
1675 //=================================================================================================
1676 //
1677 // SUBMATRIXTRAIT SPECIALIZATIONS
1678 //
1679 //=================================================================================================
1680 
1681 //*************************************************************************************************
1683 template< typename MT, bool SO, bool DF >
1684 struct SubmatrixTrait< StrictlyLowerMatrix<MT,SO,DF> >
1685 {
1686  using Type = SubmatrixTrait_<MT>;
1687 };
1689 //*************************************************************************************************
1690 
1691 
1692 
1693 
1694 //=================================================================================================
1695 //
1696 // ROWTRAIT SPECIALIZATIONS
1697 //
1698 //=================================================================================================
1699 
1700 //*************************************************************************************************
1702 template< typename MT, bool SO, bool DF >
1703 struct RowTrait< StrictlyLowerMatrix<MT,SO,DF> >
1704 {
1705  using Type = RowTrait_<MT>;
1706 };
1708 //*************************************************************************************************
1709 
1710 
1711 
1712 
1713 //=================================================================================================
1714 //
1715 // COLUMNTRAIT SPECIALIZATIONS
1716 //
1717 //=================================================================================================
1718 
1719 //*************************************************************************************************
1721 template< typename MT, bool SO, bool DF >
1722 struct ColumnTrait< StrictlyLowerMatrix<MT,SO,DF> >
1723 {
1724  using Type = ColumnTrait_<MT>;
1725 };
1727 //*************************************************************************************************
1728 
1729 } // namespace blaze
1730 
1731 #endif
BoolConstant< false > FalseType
Type/value traits base class.The FalseType class is used as base class for type traits and value trai...
Definition: FalseType.h:61
Header file for the implementation of the base template of the UniLowerMatrix.
Header file for mathematical functions.
Header file for the Rows type trait.
Header file for the UNUSED_PARAMETER function template.
StrictlyLowerMatrix specialization for sparse matrices.
Header file for the subtraction trait.
Header file for the implementation of the base template of the StrictlyLowerMatrix.
Header file for the row trait.
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:258
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:188
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
const ElementType_< MT > min(const DenseMatrix< MT, SO > &dm)
Returns the smallest element of the dense matrix.
Definition: DenseMatrix.h:1669
BoolConstant< true > TrueType
Type traits base class.The TrueType class is used as base class for type traits and value traits that...
Definition: TrueType.h:61
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, ColumnExprTrait_< MT > > column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:126
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:573
Header file for the IsSquare type trait.
Header file for the multiplication trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
StrictlyLowerMatrix specialization for dense matrices.
Header file for all forward declarations of the math module.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2647
Header file for the Columns type trait.
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:330
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:254
Header file for the RemoveAdaptor type trait.
Constraint on the data type.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:553
Header file for the IsPadded type trait.
Header file for the IsAdaptor type trait.
Header file for the DerestrictTrait class template.
Header file for the IsNumeric type trait.
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
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, RowExprTrait_< MT > > row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:126
Header file for run time assertion macros.
Header file for the addition trait.
Header file for the division trait.
Header file for the submatrix trait.
Matrix adapter for strictly lower triangular matrices.
Definition: Forward.h:50
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:258
#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
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents ...
Definition: IntegralConstant.h:100
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
Header file for the mathematical 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:314
Header file for the implementation of the base template of the LowerMatrix.
Header file for the for-each trait.
Header file for the IntegralConstant class template.
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:240
void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
Header file for the IsResizable type trait.
Header file for the IsRestricted type trait.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
Header file for the TrueType type/value trait base class.
bool isIdentity(const DenseMatrix< MT, SO > &dm)
Checks if the give dense matrix is an identity matrix.
Definition: DenseMatrix.h:1593