Blaze 3.9
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
47#include <blaze/math/Forward.h>
96#include <blaze/util/Assert.h>
97#include <blaze/util/EnableIf.h>
101
102
103namespace blaze {
104
105//=================================================================================================
106//
107// STRICTLYLOWERMATRIX OPERATORS
108//
109//=================================================================================================
110
111//*************************************************************************************************
114template< RelaxationFlag RF, typename MT, bool SO, bool DF >
115bool isDefault( const StrictlyLowerMatrix<MT,SO,DF>& m );
116
117template< typename MT, bool SO, bool DF >
118bool isIntact( const StrictlyLowerMatrix<MT,SO,DF>& m );
119
120template< typename MT, bool SO, bool DF >
121void swap( StrictlyLowerMatrix<MT,SO,DF>& a, StrictlyLowerMatrix<MT,SO,DF>& b ) noexcept;
123//*************************************************************************************************
124
125
126//*************************************************************************************************
152template< RelaxationFlag RF // Relaxation flag
153 , typename MT // Type of the adapted matrix
154 , bool SO // Storage order of the adapted matrix
155 , bool DF > // Density flag
156inline bool isDefault( const StrictlyLowerMatrix<MT,SO,DF>& m )
157{
158 if( Size_v<MT,0UL> == DefaultSize_v )
159 return m.rows() == 0UL;
160 else return isUpper<RF>( m );
161}
162//*************************************************************************************************
163
164
165//*************************************************************************************************
186template< typename MT // Type of the adapted matrix
187 , bool SO // Storage order of the adapted matrix
188 , bool DF > // Density flag
189inline bool isIntact( const StrictlyLowerMatrix<MT,SO,DF>& m )
190{
191 return m.isIntact();
192}
193//*************************************************************************************************
194
195
196//*************************************************************************************************
204template< typename MT // Type of the adapted matrix
205 , bool SO // Storage order of the adapted matrix
206 , bool DF > // Density flag
207inline void swap( StrictlyLowerMatrix<MT,SO,DF>& a, StrictlyLowerMatrix<MT,SO,DF>& b ) noexcept
208{
209 a.swap( b );
210}
211//*************************************************************************************************
212
213
214//*************************************************************************************************
230template< typename MT // Type of the adapted matrix
231 , bool SO // Storage order of the adapted matrix
232 , bool DF // Density flag
233 , typename ET > // Type of the element
234inline bool trySet( const StrictlyLowerMatrix<MT,SO,DF>& mat, size_t i, size_t j, const ET& value )
235{
236 BLAZE_INTERNAL_ASSERT( i < (*mat).rows(), "Invalid row access index" );
237 BLAZE_INTERNAL_ASSERT( j < (*mat).columns(), "Invalid column access index" );
238
239 MAYBE_UNUSED( mat );
240
241 return ( i > j || isDefault( value ) );
242}
244//*************************************************************************************************
245
246
247//*************************************************************************************************
265template< typename MT // Type of the adapted matrix
266 , bool SO // Storage order of the adapted matrix
267 , bool DF // Density flag
268 , typename ET > // Type of the element
270 trySet( const StrictlyLowerMatrix<MT,SO,DF>& mat, size_t row, size_t column, size_t m, size_t n, const ET& value )
271{
272 BLAZE_INTERNAL_ASSERT( row <= (*mat).rows(), "Invalid row access index" );
273 BLAZE_INTERNAL_ASSERT( column <= (*mat).columns(), "Invalid column access index" );
274 BLAZE_INTERNAL_ASSERT( row + m <= (*mat).rows(), "Invalid number of rows" );
275 BLAZE_INTERNAL_ASSERT( column + n <= (*mat).columns(), "Invalid number of columns" );
276
277 MAYBE_UNUSED( mat );
278
279 return ( m == 0UL ) ||
280 ( n == 0UL ) ||
281 ( row >= column + n ) ||
282 isDefault( value );
283}
285//*************************************************************************************************
286
287
288//*************************************************************************************************
304template< typename MT // Type of the adapted matrix
305 , bool SO // Storage order of the adapted matrix
306 , bool DF // Density flag
307 , typename ET > // Type of the element
308inline bool tryAdd( const StrictlyLowerMatrix<MT,SO,DF>& mat, size_t i, size_t j, const ET& value )
309{
310 return trySet( mat, i, j, value );
311}
313//*************************************************************************************************
314
315
316//*************************************************************************************************
334template< typename MT // Type of the adapted matrix
335 , bool SO // Storage order of the adapted matrix
336 , bool DF // Density flag
337 , typename ET > // Type of the element
339 tryAdd( const StrictlyLowerMatrix<MT,SO,DF>& mat, size_t row, size_t column, size_t m, size_t n, const ET& value )
340{
341 return trySet( mat, row, column, m, n, value );
342}
344//*************************************************************************************************
345
346
347//*************************************************************************************************
364template< typename MT // Type of the adapted matrix
365 , bool SO // Storage order of the adapted matrix
366 , bool DF // Density flag
367 , typename ET > // Type of the element
368inline bool trySub( const StrictlyLowerMatrix<MT,SO,DF>& mat, size_t i, size_t j, const ET& value )
369{
370 return trySet( mat, i, j, value );
371}
373//*************************************************************************************************
374
375
376//*************************************************************************************************
395template< typename MT // Type of the adapted matrix
396 , bool SO // Storage order of the adapted matrix
397 , bool DF // Density flag
398 , typename ET > // Type of the element
400 trySub( const StrictlyLowerMatrix<MT,SO,DF>& mat, size_t row, size_t column, size_t m, size_t n, const ET& value )
401{
402 return trySet( mat, row, column, m, n, value );
403}
405//*************************************************************************************************
406
407
408//*************************************************************************************************
424template< typename MT // Type of the adapted matrix
425 , bool SO // Storage order of the adapted matrix
426 , bool DF // Density flag
427 , typename ET > // Type of the element
428inline bool tryBitor( const StrictlyLowerMatrix<MT,SO,DF>& mat, size_t i, size_t j, const ET& value )
429{
430 return trySet( mat, i, j, value );
431}
433//*************************************************************************************************
434
435
436//*************************************************************************************************
454template< typename MT // Type of the adapted matrix
455 , bool SO // Storage order of the adapted matrix
456 , bool DF // Density flag
457 , typename ET > // Type of the element
459 tryBitor( const StrictlyLowerMatrix<MT,SO,DF>& mat, size_t row, size_t column, size_t m, size_t n, const ET& value )
460{
461 return trySet( mat, row, column, m, n, value );
462}
464//*************************************************************************************************
465
466
467//*************************************************************************************************
483template< typename MT // Type of the adapted matrix
484 , bool SO // Storage order of the adapted matrix
485 , bool DF // Density flag
486 , typename ET > // Type of the element
487inline bool tryBitxor( const StrictlyLowerMatrix<MT,SO,DF>& mat, size_t i, size_t j, const ET& value )
488{
489 return tryAdd( mat, i, j, value );
490}
492//*************************************************************************************************
493
494
495//*************************************************************************************************
513template< typename MT // Type of the adapted matrix
514 , bool SO // Storage order of the adapted matrix
515 , bool DF // Density flag
516 , typename ET > // Type of the element
518 tryBitxor( const StrictlyLowerMatrix<MT,SO,DF>& mat, size_t row, size_t column, size_t m, size_t n, const ET& value )
519{
520 return tryAdd( mat, row, column, m, n, value );
521}
523//*************************************************************************************************
524
525
526//*************************************************************************************************
543template< typename MT // Type of the adapted matrix
544 , bool SO // Storage order of the adapted matrix
545 , bool DF // Density flag
546 , typename VT > // Type of the right-hand side dense vector
547inline bool tryAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
548 const DenseVector<VT,false>& rhs, size_t row, size_t column )
549{
551
552 BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
553 BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
554 BLAZE_INTERNAL_ASSERT( row + (*rhs).size() <= lhs.rows(), "Invalid number of rows" );
555
556 MAYBE_UNUSED( lhs );
557
558 if( column < row )
559 return true;
560
561 const size_t iend( min( column - row + 1UL, (*rhs).size() ) );
562
563 for( size_t i=0UL; i<iend; ++i ) {
564 if( !isDefault( (*rhs)[i] ) )
565 return false;
566 }
567
568 return true;
569}
571//*************************************************************************************************
572
573
574//*************************************************************************************************
591template< typename MT // Type of the adapted matrix
592 , bool SO // Storage order of the adapted matrix
593 , bool DF // Density flag
594 , typename VT > // Type of the right-hand side dense vector
595inline bool tryAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
596 const DenseVector<VT,true>& rhs, size_t row, size_t column )
597{
599
600 BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
601 BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
602 BLAZE_INTERNAL_ASSERT( column + (*rhs).size() <= lhs.columns(), "Invalid number of columns" );
603
604 MAYBE_UNUSED( lhs );
605
606 const size_t ibegin( ( row <= column )?( 0UL ):( row - column ) );
607
608 for( size_t i=ibegin; i<(*rhs).size(); ++i ) {
609 if( !isDefault( (*rhs)[i] ) )
610 return false;
611 }
612
613 return true;
614}
616//*************************************************************************************************
617
618
619//*************************************************************************************************
637template< typename MT // Type of the adapted matrix
638 , bool SO // Storage order of the adapted matrix
639 , bool DF // Density flag
640 , typename VT // Type of the right-hand side dense vector
641 , bool TF > // Transpose flag of the right-hand side dense vector
642inline bool tryAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs, const DenseVector<VT,TF>& rhs,
643 ptrdiff_t band, size_t row, size_t column )
644{
646
647 BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
648 BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
649 BLAZE_INTERNAL_ASSERT( row + (*rhs).size() <= lhs.rows(), "Invalid number of rows" );
650 BLAZE_INTERNAL_ASSERT( column + (*rhs).size() <= lhs.columns(), "Invalid number of columns" );
651
652 MAYBE_UNUSED( lhs, row, column );
653
654 if( band >= 0L ) {
655 for( size_t i=0UL; i<(*rhs).size(); ++i ) {
656 if( !isDefault( (*rhs)[i] ) )
657 return false;
658 }
659 }
660
661 return true;
662}
664//*************************************************************************************************
665
666
667//*************************************************************************************************
684template< typename MT // Type of the adapted matrix
685 , bool SO // Storage order of the adapted matrix
686 , bool DF // Density flag
687 , typename VT > // Type of the right-hand side sparse vector
688inline bool tryAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
689 const SparseVector<VT,false>& rhs, size_t row, size_t column )
690{
692
693 BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
694 BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
695 BLAZE_INTERNAL_ASSERT( row + (*rhs).size() <= lhs.rows(), "Invalid number of rows" );
696
697 MAYBE_UNUSED( lhs );
698
699 if( column < row )
700 return true;
701
702 const auto last( (*rhs).lowerBound( column - row + 1UL ) );
703
704 for( auto element=(*rhs).begin(); element!=last; ++element ) {
705 if( !isDefault( element->value() ) )
706 return false;
707 }
708
709 return true;
710}
712//*************************************************************************************************
713
714
715//*************************************************************************************************
732template< typename MT // Type of the adapted matrix
733 , bool SO // Storage order of the adapted matrix
734 , bool DF // Density flag
735 , typename VT > // Type of the right-hand side sparse vector
736inline bool tryAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
737 const SparseVector<VT,true>& rhs, size_t row, size_t column )
738{
740
741 BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
742 BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
743 BLAZE_INTERNAL_ASSERT( column + (*rhs).size() <= lhs.columns(), "Invalid number of columns" );
744
745 MAYBE_UNUSED( lhs );
746
747 const auto last( (*rhs).end() );
748 auto element( (*rhs).lowerBound( ( row <= column )?( 0UL ):( row - column ) ) );
749
750 for( ; element!=last; ++element ) {
751 if( !isDefault( element->value() ) )
752 return false;
753 }
754
755 return true;
756}
758//*************************************************************************************************
759
760
761//*************************************************************************************************
779template< typename MT // Type of the adapted matrix
780 , bool SO // Storage order of the adapted matrix
781 , bool DF // Density flag
782 , typename VT // Type of the right-hand side sparse vector
783 , bool TF > // Transpose flag of the right-hand side sparse vector
784inline bool tryAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs, const SparseVector<VT,TF>& rhs,
785 ptrdiff_t band, size_t row, size_t column )
786{
788
789 BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
790 BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
791 BLAZE_INTERNAL_ASSERT( row + (*rhs).size() <= lhs.rows(), "Invalid number of rows" );
792 BLAZE_INTERNAL_ASSERT( column + (*rhs).size() <= lhs.columns(), "Invalid number of columns" );
793
794 MAYBE_UNUSED( lhs, row, column );
795
796 if( band >= 0L ) {
797 for( const auto& element : *rhs ) {
798 if( !isDefault( element.value() ) )
799 return false;
800 }
801 }
802
803 return true;
804}
806//*************************************************************************************************
807
808
809//*************************************************************************************************
826template< typename MT1 // Type of the adapted matrix
827 , bool SO // Storage order of the adapted matrix
828 , bool DF // Density flag
829 , typename MT2 > // Type of the right-hand side dense matrix
830inline bool tryAssign( const StrictlyLowerMatrix<MT1,SO,DF>& lhs,
831 const DenseMatrix<MT2,false>& rhs, size_t row, size_t column )
832{
834
835 BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
836 BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
837 BLAZE_INTERNAL_ASSERT( row + (*rhs).rows() <= lhs.rows(), "Invalid number of rows" );
838 BLAZE_INTERNAL_ASSERT( column + (*rhs).columns() <= lhs.columns(), "Invalid number of columns" );
839
840 MAYBE_UNUSED( lhs );
841
842 const size_t M( (*rhs).rows() );
843 const size_t N( (*rhs).columns() );
844
845 if( row >= column + N )
846 return true;
847
848 const size_t iend( min( column + N - row, M ) );
849
850 for( size_t i=0UL; i<iend; ++i )
851 {
852 const bool containsDiagonal( row + i >= column );
853 const size_t jbegin( ( containsDiagonal )?( row + i - column ):( 0UL ) );
854
855 for( size_t j=jbegin; j<N; ++j ) {
856 if( !isDefault( (*rhs)(i,j) ) )
857 return false;
858 }
859 }
860
861 return true;
862}
864//*************************************************************************************************
865
866
867//*************************************************************************************************
884template< typename MT1 // Type of the adapted matrix
885 , bool SO // Storage order of the adapted matrix
886 , bool DF // Density flag
887 , typename MT2 > // Type of the right-hand side dense matrix
888inline bool tryAssign( const StrictlyLowerMatrix<MT1,SO,DF>& lhs,
889 const DenseMatrix<MT2,true>& rhs, size_t row, size_t column )
890{
892
893 BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
894 BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
895 BLAZE_INTERNAL_ASSERT( row + (*rhs).rows() <= lhs.rows(), "Invalid number of rows" );
896 BLAZE_INTERNAL_ASSERT( column + (*rhs).columns() <= lhs.columns(), "Invalid number of columns" );
897
898 MAYBE_UNUSED( lhs );
899
900 const size_t M( (*rhs).rows() );
901 const size_t N( (*rhs).columns() );
902
903 if( row >= column + N )
904 return true;
905
906 const size_t jbegin( ( row <= column )?( 0UL ):( row - column ) );
907
908 for( size_t j=jbegin; j<N; ++j )
909 {
910 const size_t iend( min( column + j - row + 1UL, M ) );
911
912 for( size_t i=0UL; i<iend; ++i ) {
913 if( !isDefault( (*rhs)(i,j) ) )
914 return false;
915 }
916 }
917
918 return true;
919}
921//*************************************************************************************************
922
923
924//*************************************************************************************************
941template< typename MT1 // Type of the adapted matrix
942 , bool SO // Storage order of the adapted matrix
943 , bool DF // Density flag
944 , typename MT2 > // Type of the right-hand side sparse matrix
945inline bool tryAssign( const StrictlyLowerMatrix<MT1,SO,DF>& lhs,
946 const SparseMatrix<MT2,false>& rhs, size_t row, size_t column )
947{
949
950 BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
951 BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
952 BLAZE_INTERNAL_ASSERT( row + (*rhs).rows() <= lhs.rows(), "Invalid number of rows" );
953 BLAZE_INTERNAL_ASSERT( column + (*rhs).columns() <= lhs.columns(), "Invalid number of columns" );
954
955 MAYBE_UNUSED( lhs );
956
957 const size_t M( (*rhs).rows() );
958 const size_t N( (*rhs).columns() );
959
960 if( row >= column + N )
961 return true;
962
963 const size_t iend( min( column + N - row, M ) );
964
965 for( size_t i=0UL; i<iend; ++i )
966 {
967 const bool containsDiagonal( row + i >= column );
968 const size_t index( ( containsDiagonal )?( row + i - column ):( 0UL ) );
969
970 const auto last( (*rhs).end(i) );
971 auto element( (*rhs).lowerBound( i, index ) );
972
973 for( ; element!=last; ++element ) {
974 if( !isDefault( element->value() ) )
975 return false;
976 }
977 }
978
979 return true;
980}
982//*************************************************************************************************
983
984
985//*************************************************************************************************
1002template< typename MT1 // Type of the adapted matrix
1003 , bool SO // Storage order of the adapted matrix
1004 , bool DF // Density flag
1005 , typename MT2 > // Type of the right-hand side sparse matrix
1006inline bool tryAssign( const StrictlyLowerMatrix<MT1,SO,DF>& lhs,
1007 const SparseMatrix<MT2,true>& rhs, size_t row, size_t column )
1008{
1010
1011 BLAZE_INTERNAL_ASSERT( row <= lhs.rows(), "Invalid row access index" );
1012 BLAZE_INTERNAL_ASSERT( column <= lhs.columns(), "Invalid column access index" );
1013 BLAZE_INTERNAL_ASSERT( row + (*rhs).rows() <= lhs.rows(), "Invalid number of rows" );
1014 BLAZE_INTERNAL_ASSERT( column + (*rhs).columns() <= lhs.columns(), "Invalid number of columns" );
1015
1016 MAYBE_UNUSED( lhs );
1017
1018 const size_t M( (*rhs).rows() );
1019 const size_t N( (*rhs).columns() );
1020
1021 if( row >= column + N )
1022 return true;
1023
1024 const size_t jbegin( ( row < column )?( 0UL ):( row - column ) );
1025
1026 for( size_t j=jbegin; j<N; ++j )
1027 {
1028 const size_t index( column + j - row + 1UL );
1029 const auto last( (*rhs).lowerBound( min( index, M ), j ) );
1030
1031 for( auto element=(*rhs).begin(j); element!=last; ++element ) {
1032 if( !isDefault( element->value() ) )
1033 return false;
1034 }
1035 }
1036
1037 return true;
1038}
1040//*************************************************************************************************
1041
1042
1043//*************************************************************************************************
1060template< typename MT // Type of the adapted matrix
1061 , bool SO // Storage order of the adapted matrix
1062 , bool DF // Density flag
1063 , typename VT // Type of the right-hand side vector
1064 , bool TF > // Transpose flag of the right-hand side vector
1065inline bool tryAddAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
1066 const Vector<VT,TF>& rhs, size_t row, size_t column )
1067{
1068 return tryAssign( lhs, *rhs, row, column );
1069}
1071//*************************************************************************************************
1072
1073
1074//*************************************************************************************************
1092template< typename MT // Type of the adapted matrix
1093 , bool SO // Storage order of the adapted matrix
1094 , bool DF // Density flag
1095 , typename VT // Type of the right-hand side vector
1096 , bool TF > // Transpose flag of the right-hand side vector
1097inline bool tryAddAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs, const Vector<VT,TF>& rhs,
1098 ptrdiff_t band, size_t row, size_t column )
1099{
1100 return tryAssign( lhs, *rhs, band, row, column );
1101}
1103//*************************************************************************************************
1104
1105
1106//*************************************************************************************************
1123template< typename MT1 // Type of the adapted matrix
1124 , bool SO1 // Storage order of the adapted matrix
1125 , bool DF // Density flag
1126 , typename MT2 // Type of the right-hand side matrix
1127 , bool SO2 > // Storage order of the right-hand side matrix
1128inline bool tryAddAssign( const StrictlyLowerMatrix<MT1,SO1,DF>& lhs,
1129 const Matrix<MT2,SO2>& rhs, size_t row, size_t column )
1130{
1131 return tryAssign( lhs, *rhs, row, column );
1132}
1134//*************************************************************************************************
1135
1136
1137//*************************************************************************************************
1154template< typename MT // Type of the adapted matrix
1155 , bool SO // Storage order of the adapted matrix
1156 , bool DF // Density flag
1157 , typename VT // Type of the right-hand side vector
1158 , bool TF > // Transpose flag of the right-hand side vector
1159inline bool trySubAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
1160 const Vector<VT,TF>& rhs, size_t row, size_t column )
1161{
1162 return tryAssign( lhs, *rhs, row, column );
1163}
1165//*************************************************************************************************
1166
1167
1168//*************************************************************************************************
1186template< typename MT // Type of the adapted matrix
1187 , bool SO // Storage order of the adapted matrix
1188 , bool DF // Density flag
1189 , typename VT // Type of the right-hand side vector
1190 , bool TF > // Transpose flag of the right-hand side vector
1191inline bool trySubAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs, const Vector<VT,TF>& rhs,
1192 ptrdiff_t band, size_t row, size_t column )
1193{
1194 return tryAssign( lhs, *rhs, band, row, column );
1195}
1197//*************************************************************************************************
1198
1199
1200//*************************************************************************************************
1217template< typename MT1 // Type of the adapted matrix
1218 , bool SO1 // Storage order of the adapted matrix
1219 , bool DF // Density flag
1220 , typename MT2 // Type of the right-hand side matrix
1221 , bool SO2 > // Storage order of the right-hand side matrix
1222inline bool trySubAssign( const StrictlyLowerMatrix<MT1,SO1,DF>& lhs,
1223 const Matrix<MT2,SO2>& rhs, size_t row, size_t column )
1224{
1225 return tryAssign( lhs, *rhs, row, column );
1226}
1228//*************************************************************************************************
1229
1230
1231//*************************************************************************************************
1248template< typename MT // Type of the adapted matrix
1249 , bool SO // Storage order of the adapted matrix
1250 , bool DF // Density flag
1251 , typename VT // Type of the right-hand side vector
1252 , bool TF > // Transpose flag of the right-hand side vector
1253inline bool tryBitorAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
1254 const Vector<VT,TF>& rhs, size_t row, size_t column )
1255{
1256 return tryAssign( lhs, *rhs, row, column );
1257}
1259//*************************************************************************************************
1260
1261
1262//*************************************************************************************************
1279template< typename MT // Type of the adapted matrix
1280 , bool SO // Storage order of the adapted matrix
1281 , bool DF // Density flag
1282 , typename VT // Type of the right-hand side vector
1283 , bool TF > // Transpose flag of the right-hand side vector
1284inline bool tryBitorAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs, const Vector<VT,TF>& rhs,
1285 ptrdiff_t band, size_t row, size_t column )
1286{
1287 return tryAssign( lhs, *rhs, band, row, column );
1288}
1290//*************************************************************************************************
1291
1292
1293//*************************************************************************************************
1310template< typename MT1 // Type of the adapted matrix
1311 , bool SO1 // Storage order of the adapted matrix
1312 , bool DF // Density flag
1313 , typename MT2 // Type of the right-hand side matrix
1314 , bool SO2 > // Storage order of the right-hand side matrix
1315inline bool tryBitorAssign( const StrictlyLowerMatrix<MT1,SO1,DF>& lhs,
1316 const Matrix<MT2,SO2>& rhs, size_t row, size_t column )
1317{
1318 return tryAssign( lhs, *rhs, row, column );
1319}
1321//*************************************************************************************************
1322
1323
1324//*************************************************************************************************
1341template< typename MT // Type of the adapted matrix
1342 , bool SO // Storage order of the adapted matrix
1343 , bool DF // Density flag
1344 , typename VT // Type of the right-hand side vector
1345 , bool TF > // Transpose flag of the right-hand side vector
1346inline bool tryBitxorAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs,
1347 const Vector<VT,TF>& rhs, size_t row, size_t column )
1348{
1349 return tryAssign( lhs, *rhs, row, column );
1350}
1352//*************************************************************************************************
1353
1354
1355//*************************************************************************************************
1372template< typename MT // Type of the adapted matrix
1373 , bool SO // Storage order of the adapted matrix
1374 , bool DF // Density flag
1375 , typename VT // Type of the right-hand side vector
1376 , bool TF > // Transpose flag of the right-hand side vector
1377inline bool tryBitxorAssign( const StrictlyLowerMatrix<MT,SO,DF>& lhs, const Vector<VT,TF>& rhs,
1378 ptrdiff_t band, size_t row, size_t column )
1379{
1380 return tryAssign( lhs, *rhs, band, row, column );
1381}
1383//*************************************************************************************************
1384
1385
1386//*************************************************************************************************
1403template< typename MT1 // Type of the adapted matrix
1404 , bool SO1 // Storage order of the adapted matrix
1405 , bool DF // Density flag
1406 , typename MT2 // Type of the right-hand side matrix
1407 , bool SO2 > // Storage order of the right-hand side matrix
1408inline bool tryBitxorAssign( const StrictlyLowerMatrix<MT1,SO1,DF>& lhs,
1409 const Matrix<MT2,SO2>& rhs, size_t row, size_t column )
1410{
1411 return tryAssign( lhs, *rhs, row, column );
1412}
1414//*************************************************************************************************
1415
1416
1417//*************************************************************************************************
1431template< typename MT // Type of the adapted matrix
1432 , bool SO // Storage order of the adapted matrix
1433 , bool DF > // Density flag
1434inline MT& derestrict( StrictlyLowerMatrix<MT,SO,DF>& m )
1435{
1436 return m.matrix_;
1437}
1439//*************************************************************************************************
1440
1441
1442
1443
1444//=================================================================================================
1445//
1446// SIZE SPECIALIZATIONS
1447//
1448//=================================================================================================
1449
1450//*************************************************************************************************
1452template< typename MT, bool SO, bool DF >
1453struct Size< StrictlyLowerMatrix<MT,SO,DF>, 0UL >
1454 : public Size<MT,0UL>
1455{};
1456
1457template< typename MT, bool SO, bool DF >
1458struct Size< StrictlyLowerMatrix<MT,SO,DF>, 1UL >
1459 : public Size<MT,1UL>
1460{};
1462//*************************************************************************************************
1463
1464
1465
1466
1467//=================================================================================================
1468//
1469// MAXSIZE SPECIALIZATIONS
1470//
1471//=================================================================================================
1472
1473//*************************************************************************************************
1475template< typename MT, bool SO, bool DF >
1476struct MaxSize< StrictlyLowerMatrix<MT,SO,DF>, 0UL >
1477 : public MaxSize<MT,0UL>
1478{};
1479
1480template< typename MT, bool SO, bool DF >
1481struct MaxSize< StrictlyLowerMatrix<MT,SO,DF>, 1UL >
1482 : public MaxSize<MT,1UL>
1483{};
1485//*************************************************************************************************
1486
1487
1488
1489
1490//=================================================================================================
1491//
1492// ISSQUARE SPECIALIZATIONS
1493//
1494//=================================================================================================
1495
1496//*************************************************************************************************
1498template< typename MT, bool SO, bool DF >
1499struct IsSquare< StrictlyLowerMatrix<MT,SO,DF> >
1500 : public TrueType
1501{};
1503//*************************************************************************************************
1504
1505
1506
1507
1508//=================================================================================================
1509//
1510// ISUNIFORM SPECIALIZATIONS
1511//
1512//=================================================================================================
1513
1514//*************************************************************************************************
1516template< typename MT, bool SO, bool DF >
1517struct IsUniform< StrictlyLowerMatrix<MT,SO,DF> >
1518 : public IsUniform<MT>
1519{};
1521//*************************************************************************************************
1522
1523
1524
1525
1526//=================================================================================================
1527//
1528// ISSYMMETRIC SPECIALIZATIONS
1529//
1530//=================================================================================================
1531
1532//*************************************************************************************************
1534template< typename MT, bool SO, bool DF >
1535struct IsSymmetric< StrictlyLowerMatrix<MT,SO,DF> >
1536 : public IsUniform<MT>
1537{};
1539//*************************************************************************************************
1540
1541
1542
1543
1544//=================================================================================================
1545//
1546// ISHERMITIAN SPECIALIZATIONS
1547//
1548//=================================================================================================
1549
1550//*************************************************************************************************
1552template< typename MT, bool SO, bool DF >
1553struct IsHermitian< StrictlyLowerMatrix<MT,SO,DF> >
1554 : public IsUniform<MT>
1555{};
1557//*************************************************************************************************
1558
1559
1560
1561
1562//=================================================================================================
1563//
1564// ISSTRICTLYLOWER SPECIALIZATIONS
1565//
1566//=================================================================================================
1567
1568//*************************************************************************************************
1570template< typename MT, bool SO, bool DF >
1571struct IsStrictlyLower< StrictlyLowerMatrix<MT,SO,DF> >
1572 : public TrueType
1573{};
1575//*************************************************************************************************
1576
1577
1578
1579
1580//=================================================================================================
1581//
1582// ISSTRICTLYUPPER SPECIALIZATIONS
1583//
1584//=================================================================================================
1585
1586//*************************************************************************************************
1588template< typename MT, bool SO, bool DF >
1589struct IsStrictlyUpper< StrictlyLowerMatrix<MT,SO,DF> >
1590 : public IsUniform<MT>
1591{};
1593//*************************************************************************************************
1594
1595
1596
1597
1598//=================================================================================================
1599//
1600// ISADAPTOR SPECIALIZATIONS
1601//
1602//=================================================================================================
1603
1604//*************************************************************************************************
1606template< typename MT, bool SO, bool DF >
1607struct IsAdaptor< StrictlyLowerMatrix<MT,SO,DF> >
1608 : public TrueType
1609{};
1611//*************************************************************************************************
1612
1613
1614
1615
1616//=================================================================================================
1617//
1618// ISRESTRICTED SPECIALIZATIONS
1619//
1620//=================================================================================================
1621
1622//*************************************************************************************************
1624template< typename MT, bool SO, bool DF >
1625struct IsRestricted< StrictlyLowerMatrix<MT,SO,DF> >
1626 : public TrueType
1627{};
1629//*************************************************************************************************
1630
1631
1632
1633
1634//=================================================================================================
1635//
1636// HASCONSTDATAACCESS SPECIALIZATIONS
1637//
1638//=================================================================================================
1639
1640//*************************************************************************************************
1642template< typename MT, bool SO >
1643struct HasConstDataAccess< StrictlyLowerMatrix<MT,SO,true> >
1644 : public TrueType
1645{};
1647//*************************************************************************************************
1648
1649
1650
1651
1652//=================================================================================================
1653//
1654// ISALIGNED SPECIALIZATIONS
1655//
1656//=================================================================================================
1657
1658//*************************************************************************************************
1660template< typename MT, bool SO, bool DF >
1661struct IsAligned< StrictlyLowerMatrix<MT,SO,DF> >
1662 : public IsAligned<MT>
1663{};
1665//*************************************************************************************************
1666
1667
1668
1669
1670//=================================================================================================
1671//
1672// ISCONTIGUOUS SPECIALIZATIONS
1673//
1674//=================================================================================================
1675
1676//*************************************************************************************************
1678template< typename MT, bool SO, bool DF >
1679struct IsContiguous< StrictlyLowerMatrix<MT,SO,DF> >
1680 : public IsContiguous<MT>
1681{};
1683//*************************************************************************************************
1684
1685
1686
1687
1688//=================================================================================================
1689//
1690// ISPADDED SPECIALIZATIONS
1691//
1692//=================================================================================================
1693
1694//*************************************************************************************************
1696template< typename MT, bool SO, bool DF >
1697struct IsPadded< StrictlyLowerMatrix<MT,SO,DF> >
1698 : public IsPadded<MT>
1699{};
1701//*************************************************************************************************
1702
1703
1704
1705
1706//=================================================================================================
1707//
1708// REMOVEADAPTOR SPECIALIZATIONS
1709//
1710//=================================================================================================
1711
1712//*************************************************************************************************
1714template< typename MT, bool SO, bool DF >
1715struct RemoveAdaptor< StrictlyLowerMatrix<MT,SO,DF> >
1716{
1717 using Type = MT;
1718};
1720//*************************************************************************************************
1721
1722
1723
1724
1725//=================================================================================================
1726//
1727// ADDTRAIT SPECIALIZATIONS
1728//
1729//=================================================================================================
1730
1731//*************************************************************************************************
1733template< typename T1, typename T2 >
1734struct AddTraitEval1< T1, T2
1735 , EnableIf_t< IsMatrix_v<T1> &&
1736 IsMatrix_v<T2> &&
1737 ( IsStrictlyLower_v<T1> && IsStrictlyLower_v<T2> ) &&
1738 !( IsZero_v<T1> || IsZero_v<T2> ) > >
1739{
1740 using Type = StrictlyLowerMatrix< typename AddTraitEval2<T1,T2>::Type >;
1741};
1743//*************************************************************************************************
1744
1745
1746
1747
1748//=================================================================================================
1749//
1750// SUBTRAIT SPECIALIZATIONS
1751//
1752//=================================================================================================
1753
1754//*************************************************************************************************
1756template< typename T1, typename T2 >
1757struct SubTraitEval1< T1, T2
1758 , EnableIf_t< IsMatrix_v<T1> &&
1759 IsMatrix_v<T2> &&
1760 ( ( IsUniLower_v<T1> && IsUniLower_v<T2> ) ||
1761 ( IsStrictlyLower_v<T1> && IsStrictlyLower_v<T2> ) ) &&
1762 !( IsIdentity_v<T1> && IsIdentity_v<T2> ) &&
1763 !( IsZero_v<T1> || IsZero_v<T2> ) > >
1764{
1765 using Type = StrictlyLowerMatrix< typename SubTraitEval2<T1,T2>::Type >;
1766};
1768//*************************************************************************************************
1769
1770
1771
1772
1773//=================================================================================================
1774//
1775// SCHURTRAIT SPECIALIZATIONS
1776//
1777//=================================================================================================
1778
1779//*************************************************************************************************
1781template< typename T1, typename T2 >
1782struct SchurTraitEval1< T1, T2
1783 , EnableIf_t< IsMatrix_v<T1> &&
1784 IsMatrix_v<T2> &&
1785 ( ( IsStrictlyLower_v<T1> && !IsUpper_v<T2> ) ||
1786 ( !IsUpper_v<T1> && IsStrictlyLower_v<T2> ) ) &&
1787 !( IsZero_v<T1> || IsZero_v<T2> ) > >
1788{
1789 using Type = StrictlyLowerMatrix< typename SchurTraitEval2<T1,T2>::Type >;
1790};
1792//*************************************************************************************************
1793
1794
1795
1796
1797//=================================================================================================
1798//
1799// MULTTRAIT SPECIALIZATIONS
1800//
1801//=================================================================================================
1802
1803//*************************************************************************************************
1805template< typename T1, typename T2 >
1806struct MultTraitEval1< T1, T2
1807 , EnableIf_t< IsMatrix_v<T1> &&
1808 IsScalar_v<T2> &&
1809 ( IsStrictlyLower_v<T1> && !IsUniform_v<T1> ) > >
1810{
1811 using Type = StrictlyLowerMatrix< typename MultTraitEval2<T1,T2>::Type >;
1812};
1813
1814template< typename T1, typename T2 >
1815struct MultTraitEval1< T1, T2
1816 , EnableIf_t< IsScalar_v<T1> &&
1817 IsMatrix_v<T2> &&
1818 ( IsStrictlyLower_v<T2> && !IsUniform_v<T2> ) > >
1819{
1820 using Type = StrictlyLowerMatrix< typename MultTraitEval2<T1,T2>::Type >;
1821};
1822
1823template< typename T1, typename T2 >
1824struct MultTraitEval1< T1, T2
1825 , EnableIf_t< IsMatrix_v<T1> &&
1826 IsMatrix_v<T2> &&
1827 ( ( IsStrictlyLower_v<T1> && IsLower_v<T2> ) ||
1828 ( IsLower_v<T1> && IsStrictlyLower_v<T2> ) ) &&
1829 !( IsIdentity_v<T1> || IsIdentity_v<T2> ) &&
1830 !( IsZero_v<T1> || IsZero_v<T2> ) > >
1831{
1832 using Type = StrictlyLowerMatrix< typename MultTraitEval2<T1,T2>::Type >;
1833};
1835//*************************************************************************************************
1836
1837
1838
1839
1840//=================================================================================================
1841//
1842// KRONTRAIT SPECIALIZATIONS
1843//
1844//=================================================================================================
1845
1846//*************************************************************************************************
1848template< typename T1, typename T2 >
1849struct KronTraitEval1< T1, T2
1850 , EnableIf_t< IsMatrix_v<T1> &&
1851 IsMatrix_v<T2> &&
1852 ( ( IsStrictlyLower_v<T1> ) ||
1853 ( IsLower_v<T1> && IsStrictlyLower_v<T2> ) ) &&
1854 !( IsZero_v<T1> || IsZero_v<T2> ) > >
1855{
1856 using Type = StrictlyLowerMatrix< typename KronTraitEval2<T1,T2>::Type >;
1857};
1859//*************************************************************************************************
1860
1861
1862
1863
1864//=================================================================================================
1865//
1866// DIVTRAIT SPECIALIZATIONS
1867//
1868//=================================================================================================
1869
1870//*************************************************************************************************
1872template< typename T1, typename T2 >
1873struct DivTraitEval1< T1, T2
1874 , EnableIf_t< IsStrictlyLower_v<T1> && IsScalar_v<T2> > >
1875{
1876 using Type = StrictlyLowerMatrix< typename DivTraitEval2<T1,T2>::Type >;
1877};
1879//*************************************************************************************************
1880
1881
1882
1883
1884//=================================================================================================
1885//
1886// MAPTRAIT SPECIALIZATIONS
1887//
1888//=================================================================================================
1889
1890//*************************************************************************************************
1892template< typename T, typename OP >
1893struct UnaryMapTraitEval1< T, OP
1895 !YieldsZero_v<OP,T> > >
1896{
1897 using Type = StrictlyLowerMatrix< typename UnaryMapTraitEval2<T,OP>::Type, StorageOrder_v<T> >;
1898};
1900//*************************************************************************************************
1901
1902
1903//*************************************************************************************************
1905template< typename T1, typename T2, typename OP >
1906struct BinaryMapTraitEval1< T1, T2, OP
1907 , EnableIf_t< YieldsStrictlyLower_v<OP,T1,T2> &&
1908 !YieldsDiagonal_v<OP,T1,T2> > >
1909{
1910 using Type = StrictlyLowerMatrix< typename BinaryMapTraitEval2<T1,T2,OP>::Type >;
1911};
1913//*************************************************************************************************
1914
1915
1916
1917
1918//=================================================================================================
1919//
1920// DECLSYMTRAIT SPECIALIZATIONS
1921//
1922//=================================================================================================
1923
1924//*************************************************************************************************
1926template< typename MT, bool SO, bool DF >
1927struct DeclSymTrait< StrictlyLowerMatrix<MT,SO,DF> >
1928{
1929 using Type = ZeroMatrix< typename MT::ElementType, SO >;
1930};
1932//*************************************************************************************************
1933
1934
1935
1936
1937//=================================================================================================
1938//
1939// DECLHERMTRAIT SPECIALIZATIONS
1940//
1941//=================================================================================================
1942
1943//*************************************************************************************************
1945template< typename MT, bool SO, bool DF >
1946struct DeclHermTrait< StrictlyLowerMatrix<MT,SO,DF> >
1947{
1948 using Type = ZeroMatrix< typename MT::ElementType, SO >;
1949};
1951//*************************************************************************************************
1952
1953
1954
1955
1956//=================================================================================================
1957//
1958// DECLLOWTRAIT SPECIALIZATIONS
1959//
1960//=================================================================================================
1961
1962//*************************************************************************************************
1964template< typename MT, bool SO, bool DF >
1965struct DeclLowTrait< StrictlyLowerMatrix<MT,SO,DF> >
1966{
1967 using Type = StrictlyLowerMatrix<MT,SO,DF>;
1968};
1970//*************************************************************************************************
1971
1972
1973
1974
1975//=================================================================================================
1976//
1977// DECLUNILOWTRAIT SPECIALIZATIONS
1978//
1979//=================================================================================================
1980
1981//*************************************************************************************************
1983template< typename MT, bool SO, bool DF >
1984struct DeclUniLowTrait< StrictlyLowerMatrix<MT,SO,DF> >
1985{
1986 using Type = INVALID_TYPE;
1987};
1989//*************************************************************************************************
1990
1991
1992
1993
1994//=================================================================================================
1995//
1996// DECLSTRLOWTRAIT SPECIALIZATIONS
1997//
1998//=================================================================================================
1999
2000//*************************************************************************************************
2002template< typename MT, bool SO, bool DF >
2003struct DeclStrLowTrait< StrictlyLowerMatrix<MT,SO,DF> >
2004{
2005 using Type = StrictlyLowerMatrix<MT,SO,DF>;
2006};
2008//*************************************************************************************************
2009
2010
2011
2012
2013//=================================================================================================
2014//
2015// DECLUPPTRAIT SPECIALIZATIONS
2016//
2017//=================================================================================================
2018
2019//*************************************************************************************************
2021template< typename MT, bool SO, bool DF >
2022struct DeclUppTrait< StrictlyLowerMatrix<MT,SO,DF> >
2023{
2024 using Type = ZeroMatrix< typename MT::ElementType, SO >;
2025};
2027//*************************************************************************************************
2028
2029
2030
2031
2032//=================================================================================================
2033//
2034// DECLUNIUPPTRAIT SPECIALIZATIONS
2035//
2036//=================================================================================================
2037
2038//*************************************************************************************************
2040template< typename MT, bool SO, bool DF >
2041struct DeclUniUppTrait< StrictlyLowerMatrix<MT,SO,DF> >
2042{
2043 using Type = INVALID_TYPE;
2044};
2046//*************************************************************************************************
2047
2048
2049
2050
2051//=================================================================================================
2052//
2053// DECLSTRUPPTRAIT SPECIALIZATIONS
2054//
2055//=================================================================================================
2056
2057//*************************************************************************************************
2059template< typename MT, bool SO, bool DF >
2060struct DeclStrUppTrait< StrictlyLowerMatrix<MT,SO,DF> >
2061{
2062 using Type = ZeroMatrix< typename MT::ElementType, SO >;
2063};
2065//*************************************************************************************************
2066
2067
2068
2069
2070//=================================================================================================
2071//
2072// DECLDIAGTRAIT SPECIALIZATIONS
2073//
2074//=================================================================================================
2075
2076//*************************************************************************************************
2078template< typename MT, bool SO, bool DF >
2079struct DeclDiagTrait< StrictlyLowerMatrix<MT,SO,DF> >
2080{
2081 using Type = ZeroMatrix< typename MT::ElementType, SO >;
2082};
2084//*************************************************************************************************
2085
2086
2087
2088
2089//=================================================================================================
2090//
2091// HIGHTYPE SPECIALIZATIONS
2092//
2093//=================================================================================================
2094
2095//*************************************************************************************************
2097template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2098struct HighType< StrictlyLowerMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
2099{
2100 using Type = StrictlyLowerMatrix< typename HighType<MT1,MT2>::Type >;
2101};
2103//*************************************************************************************************
2104
2105
2106
2107
2108//=================================================================================================
2109//
2110// LOWTYPE SPECIALIZATIONS
2111//
2112//=================================================================================================
2113
2114//*************************************************************************************************
2116template< typename MT1, bool SO1, bool DF1, typename MT2, bool SO2, bool DF2 >
2117struct LowType< StrictlyLowerMatrix<MT1,SO1,DF1>, StrictlyLowerMatrix<MT2,SO2,DF2> >
2118{
2119 using Type = StrictlyLowerMatrix< typename LowType<MT1,MT2>::Type >;
2120};
2122//*************************************************************************************************
2123
2124
2125
2126
2127//=================================================================================================
2128//
2129// SUBMATRIXTRAIT SPECIALIZATIONS
2130//
2131//=================================================================================================
2132
2133//*************************************************************************************************
2135template< typename MT, size_t I, size_t N >
2136struct SubmatrixTraitEval1< MT, I, I, N, N
2137 , EnableIf_t< I != inf && N != inf &&
2138 IsStrictlyLower_v<MT> &&
2139 !IsZero_v<MT> > >
2140{
2141 using Type = StrictlyLowerMatrix< typename SubmatrixTraitEval2<MT,I,I,N,N>::Type >;
2142};
2144//*************************************************************************************************
2145
2146} // namespace blaze
2147
2148#endif
Header file for the addition trait.
Header file for run time assertion macros.
Header file for the decldiag trait.
Header file for the declherm trait.
Header file for the decllow trait.
Header file for the declstrlow trait.
Header file for the declstrupp trait.
Header file for the declsym trait.
Header file for the declunilow trait.
Header file for the decluniupp trait.
Header file for the declupp trait.
Header file for the division trait.
Header file for the EnableIf class template.
Header file for the HasConstDataAccess type trait.
Header file for the HighType type trait.
Header file for the IntegralConstant class template.
Utility type for generic codes.
Header file for the IsAdaptor type trait.
Header file for the IsAligned type trait.
Header file for the IsContiguous type trait.
Header file for the isDefault shim.
Header file for the IsHermitian type trait.
Header file for the IsIdentity type trait.
Header file for the IsLower type trait.
Header file for the IsMatrix type trait.
Header file for the IsPadded type trait.
Header file for the IsRestricted type trait.
Header file for the IsScalar type trait.
Header file for the IsSquare type trait.
Header file for the IsStrictlyLower type trait.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Header file for the IsUniLower type trait.
Header file for the IsUniform type trait.
Header file for the IsUpper type trait.
Header file for the Kron product trait.
Header file for the LowType type trait.
Header file for the map trait.
Header file for the MaxSize type trait.
Header file for the MAYBE_UNUSED function template.
Header file for the multiplication trait.
Header file for the relaxation flag enumeration.
Header file for the RemoveAdaptor type trait.
Header file for the Schur product trait.
Header file for the subtraction trait.
Header file for the submatrix trait.
Header file for the YieldsDiagonal type trait.
Header file for the YieldsStrictlyLower type trait.
Header file for the YieldsZero type trait.
Header file for the implementation of the base template of the StrictlyLowerMatrix.
StrictlyLowerMatrix specialization for dense matrices.
StrictlyLowerMatrix specialization for sparse matrices.
Pointer difference type of the Blaze library.
Constraint on the data type.
decltype(auto) band(Matrix< MT, SO > &matrix, RBAs... args)
Creating a view on a specific band of the given matrix.
Definition: Band.h:140
decltype(auto) column(Matrix< MT, SO > &matrix, RCAs... args)
Creating a view on a specific column of the given matrix.
Definition: Column.h:137
decltype(auto) min(const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs)
Computes the componentwise minimum of the dense matrices lhs and rhs.
Definition: DMatDMatMapExpr.h:1339
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:207
void swap(DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b) noexcept
Swapping the contents of two matrices.
Definition: DiagonalMatrix.h:225
bool isDefault(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the given diagonal matrix is in default state.
Definition: DiagonalMatrix.h:169
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.
Definition: RequiresEvaluation.h:81
constexpr bool YieldsStrictlyLower_v
Auxiliary variable template for the YieldsStrictlyLower type trait.
Definition: YieldsStrictlyLower.h:124
constexpr bool IsScalar_v
Auxiliary variable template for the IsScalar type trait.
Definition: IsScalar.h:104
constexpr bool IsStrictlyLower_v
Auxiliary variable template for the IsStrictlyLower type trait.
Definition: IsStrictlyLower.h:173
constexpr ptrdiff_t DefaultSize_v
Default size of the Size type trait.
Definition: Size.h:72
constexpr bool IsMatrix_v
Auxiliary variable template for the IsMatrix type trait.
Definition: IsMatrix.h:124
RelaxationFlag
Relaxation flag for strict or relaxed semantics.
Definition: RelaxationFlag.h:66
constexpr Infinity inf
Global Infinity instance.
Definition: Infinity.h:1080
decltype(auto) row(Matrix< MT, SO > &, RRAs...)
Creating a view on a specific row of the given matrix.
Definition: Row.h:137
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.
Definition: Assert.h:101
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
BoolConstant< true > TrueType
Type traits base class.
Definition: IntegralConstant.h:132
typename EnableIf< Condition, T >::Type EnableIf_t
Auxiliary type for the EnableIf class template.
Definition: EnableIf.h:138
constexpr void MAYBE_UNUSED(const Args &...)
Suppression of unused parameter warnings.
Definition: MaybeUnused.h:81
Header file for all forward declarations of the math module.
Header file for the Size type trait.
Header file for the StorageOrder type trait.
Header file for the IsZero type trait.
Header file for the generic min algorithm.