Blaze 3.9
Row.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_VIEWS_ROW_H_
36#define _BLAZE_MATH_VIEWS_ROW_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
83#include <blaze/util/Assert.h>
84#include <blaze/util/EnableIf.h>
87#include <blaze/util/Types.h>
88
89
90namespace blaze {
91
92//=================================================================================================
93//
94// GLOBAL FUNCTIONS
95//
96//=================================================================================================
97
98//*************************************************************************************************
133template< size_t I // Row index
134 , typename MT // Type of the matrix
135 , bool SO // Storage order
136 , typename... RRAs > // Optional row arguments
137inline decltype(auto) row( Matrix<MT,SO>& matrix, RRAs... args )
138{
140
141 using ReturnType = Row_<MT,I>;
142 return ReturnType( *matrix, args... );
143}
144//*************************************************************************************************
145
146
147//*************************************************************************************************
182template< size_t I // Row index
183 , typename MT // Type of the matrix
184 , bool SO // Storage order
185 , typename... RRAs > // Optional row arguments
186inline decltype(auto) row( const Matrix<MT,SO>& matrix, RRAs... args )
187{
189
190 using ReturnType = const Row_<const MT,I>;
191 return ReturnType( *matrix, args... );
192}
193//*************************************************************************************************
194
195
196//*************************************************************************************************
210template< size_t I // Row index
211 , typename MT // Type of the matrix
212 , bool SO // Storage order
213 , typename... RRAs > // Optional row arguments
214inline decltype(auto) row( Matrix<MT,SO>&& matrix, RRAs... args )
215{
217
218 using ReturnType = Row_<MT,I>;
219 return ReturnType( *matrix, args... );
220}
221//*************************************************************************************************
222
223
224//*************************************************************************************************
260template< typename MT // Type of the matrix
261 , bool SO // Storage order
262 , typename... RRAs > // Optional row arguments
263inline decltype(auto) row( Matrix<MT,SO>& matrix, size_t index, RRAs... args )
264{
266
267 using ReturnType = Row_<MT>;
268 return ReturnType( *matrix, index, args... );
269}
270//*************************************************************************************************
271
272
273//*************************************************************************************************
309template< typename MT // Type of the matrix
310 , bool SO // Storage order
311 , typename... RRAs > // Optional row arguments
312inline decltype(auto) row( const Matrix<MT,SO>& matrix, size_t index, RRAs... args )
313{
315
316 using ReturnType = const Row_<const MT>;
317 return ReturnType( *matrix, index, args... );
318}
319//*************************************************************************************************
320
321
322//*************************************************************************************************
337template< typename MT // Type of the matrix
338 , bool SO // Storage order
339 , typename... RRAs > // Optional row arguments
340inline decltype(auto) row( Matrix<MT,SO>&& matrix, size_t index, RRAs... args )
341{
343
344 using ReturnType = Row_<MT>;
345 return ReturnType( *matrix, index, args... );
346}
347//*************************************************************************************************
348
349
350
351
352//=================================================================================================
353//
354// GLOBAL RESTRUCTURING FUNCTIONS
355//
356//=================================================================================================
357
358//*************************************************************************************************
371template< size_t... CRAs // Compile time row arguments
372 , typename MT // Matrix base type of the expression
373 , typename... RRAs > // Runtime row arguments
374inline decltype(auto) row( const MatMatAddExpr<MT>& matrix, RRAs... args )
375{
377
378 return row<CRAs...>( (*matrix).leftOperand(), args... ) +
379 row<CRAs...>( (*matrix).rightOperand(), args... );
380}
382//*************************************************************************************************
383
384
385//*************************************************************************************************
398template< size_t... CRAs // Compile time row arguments
399 , typename MT // Matrix base type of the expression
400 , typename... RRAs > // Runtime row arguments
401inline decltype(auto) row( const MatMatSubExpr<MT>& matrix, RRAs... args )
402{
404
405 return row<CRAs...>( (*matrix).leftOperand(), args... ) -
406 row<CRAs...>( (*matrix).rightOperand(), args... );
407}
409//*************************************************************************************************
410
411
412//*************************************************************************************************
424template< size_t... CRAs // Compile time row arguments
425 , typename MT // Matrix base type of the expression
426 , typename... RRAs > // Runtime row arguments
427inline decltype(auto) row( const SchurExpr<MT>& matrix, RRAs... args )
428{
430
431 return row<CRAs...>( (*matrix).leftOperand(), args... ) *
432 row<CRAs...>( (*matrix).rightOperand(), args... );
433}
435//*************************************************************************************************
436
437
438//*************************************************************************************************
451template< size_t... CRAs // Compile time row arguments
452 , typename MT // Matrix base type of the expression
453 , typename... RRAs > // Runtime row arguments
454inline decltype(auto) row( const MatMatMultExpr<MT>& matrix, RRAs... args )
455{
457
458 return row<CRAs...>( (*matrix).leftOperand(), args... ) * (*matrix).rightOperand();
459}
461//*************************************************************************************************
462
463
464//*************************************************************************************************
477template< size_t... CRAs // Compile time row arguments
478 , typename MT // Matrix base type of the expression
479 , typename... RRAs > // Runtime row arguments
480inline decltype(auto) row( const MatMatKronExpr<MT>& matrix, RRAs... args )
481{
483
484 const RowData<CRAs...> rd( args... );
485
486 if( isChecked( args... ) ) {
487 if( (*matrix).rows() <= rd.row() ) {
488 BLAZE_THROW_INVALID_ARGUMENT( "Invalid row access index" );
489 }
490 }
491
492 const size_t rows( (*matrix).rightOperand().rows() );
493
494 return kron( row( (*matrix).leftOperand(), rd.row()/rows, unchecked ),
495 row( (*matrix).rightOperand(), rd.row()%rows, unchecked ) );
496}
498//*************************************************************************************************
499
500
501//*************************************************************************************************
513template< size_t I // Row index
514 , typename MT // Matrix base type of the expression
515 , typename... RRAs > // Optional row arguments
516inline decltype(auto) row( const VecTVecMultExpr<MT>& matrix, RRAs... args )
517{
519
520 if( isChecked( args... ) ) {
521 if( (*matrix).rows() <= I ) {
522 BLAZE_THROW_INVALID_ARGUMENT( "Invalid row access index" );
523 }
524 }
525
526 return (*matrix).leftOperand()[I] * (*matrix).rightOperand();
527}
529//*************************************************************************************************
530
531
532//*************************************************************************************************
545template< typename MT // Matrix base type of the expression
546 , typename... RRAs > // Optional row arguments
547inline decltype(auto) row( const VecTVecMultExpr<MT>& matrix, size_t index, RRAs... args )
548{
550
551 if( isChecked( args... ) ) {
552 if( (*matrix).rows() <= index ) {
553 BLAZE_THROW_INVALID_ARGUMENT( "Invalid row access index" );
554 }
555 }
556
557 return (*matrix).leftOperand()[index] * (*matrix).rightOperand();
558}
560//*************************************************************************************************
561
562
563//*************************************************************************************************
576template< size_t... CRAs // Compile time row arguments
577 , typename MT // Matrix base type of the expression
578 , typename... RRAs > // Runtime row arguments
579inline decltype(auto) row( const MatScalarMultExpr<MT>& matrix, RRAs... args )
580{
582
583 return row<CRAs...>( (*matrix).leftOperand(), args... ) * (*matrix).rightOperand();
584}
586//*************************************************************************************************
587
588
589//*************************************************************************************************
602template< size_t... CRAs // Compile time row arguments
603 , typename MT // Matrix base type of the expression
604 , typename... RRAs > // Runtime row arguments
605inline decltype(auto) row( const MatScalarDivExpr<MT>& matrix, RRAs... args )
606{
608
609 return row<CRAs...>( (*matrix).leftOperand(), args... ) / (*matrix).rightOperand();
610}
612//*************************************************************************************************
613
614
615//*************************************************************************************************
628template< size_t... CRAs // Compile time row arguments
629 , typename MT // Matrix base type of the expression
630 , typename... RRAs > // Runtime row arguments
631inline decltype(auto) row( const MatMapExpr<MT>& matrix, RRAs... args )
632{
634
635 return map( row<CRAs...>( (*matrix).operand(), args... ), (*matrix).operation() );
636}
638//*************************************************************************************************
639
640
641//*************************************************************************************************
654template< size_t... CRAs // Compile time row arguments
655 , typename MT // Matrix base type of the expression
656 , typename... RRAs > // Runtime row arguments
657inline decltype(auto) row( const MatMatMapExpr<MT>& matrix, RRAs... args )
658{
660
661 return map( row<CRAs...>( (*matrix).leftOperand(), args... ),
662 row<CRAs...>( (*matrix).rightOperand(), args... ),
663 (*matrix).operation() );
664}
666//*************************************************************************************************
667
668
669//*************************************************************************************************
682template< size_t I // Row index
683 , typename MT // Matrix base type of the expression
684 , typename... RRAs > // Optional row arguments
685inline decltype(auto) row( const VecTVecMapExpr<MT>& matrix, RRAs... args )
686{
688
689 if( isChecked( args... ) ) {
690 if( (*matrix).rows() <= I ) {
691 BLAZE_THROW_INVALID_ARGUMENT( "Invalid row access index" );
692 }
693 }
694
695 return map( (*matrix).rightOperand(),
696 blaze::bind2nd( (*matrix).operation(), (*matrix).leftOperand()[I] ) );
697}
699//*************************************************************************************************
700
701
702//*************************************************************************************************
716template< typename MT // Matrix base type of the expression
717 , typename... RRAs > // Optional row arguments
718inline decltype(auto) row( const VecTVecMapExpr<MT>& matrix, size_t index, RRAs... args )
719{
721
722 if( isChecked( args... ) ) {
723 if( (*matrix).rows() <= index ) {
724 BLAZE_THROW_INVALID_ARGUMENT( "Invalid row access index" );
725 }
726 }
727
728 return map( (*matrix).rightOperand(),
729 blaze::bind2nd( (*matrix).operation(), (*matrix).leftOperand()[index] ) );
730}
732//*************************************************************************************************
733
734
735//*************************************************************************************************
748template< size_t... CRAs // Compile time row arguments
749 , typename MT // Matrix base type of the expression
750 , typename... RRAs > // Runtime row arguments
751inline decltype(auto) row( const MatEvalExpr<MT>& matrix, RRAs... args )
752{
754
755 return eval( row<CRAs...>( (*matrix).operand(), args... ) );
756}
758//*************************************************************************************************
759
760
761//*************************************************************************************************
774template< size_t... CRAs // Compile time row arguments
775 , typename MT // Matrix base type of the expression
776 , typename... RRAs > // Runtime row arguments
777inline decltype(auto) row( const MatSerialExpr<MT>& matrix, RRAs... args )
778{
780
781 return serial( row<CRAs...>( (*matrix).operand(), args... ) );
782}
784//*************************************************************************************************
785
786
787//*************************************************************************************************
800template< size_t... CRAs // Compile time row arguments
801 , typename MT // Matrix base type of the expression
802 , typename... RRAs > // Runtime row arguments
803inline decltype(auto) row( const MatNoAliasExpr<MT>& matrix, RRAs... args )
804{
806
807 return noalias( row<CRAs...>( (*matrix).operand(), args... ) );
808}
810//*************************************************************************************************
811
812
813//*************************************************************************************************
826template< size_t... CRAs // Compile time row arguments
827 , typename MT // Matrix base type of the expression
828 , typename... RRAs > // Runtime row arguments
829inline decltype(auto) row( const MatNoSIMDExpr<MT>& matrix, RRAs... args )
830{
832
833 return nosimd( row<CRAs...>( (*matrix).operand(), args... ) );
834}
836//*************************************************************************************************
837
838
839//*************************************************************************************************
852template< size_t... CRAs // Compile time row arguments
853 , typename MT // Matrix base type of the expression
854 , typename... RRAs > // Runtime row arguments
855inline decltype(auto) row( const DeclExpr<MT>& matrix, RRAs... args )
856{
858
859 return row<CRAs...>( (*matrix).operand(), args... );
860}
862//*************************************************************************************************
863
864
865//*************************************************************************************************
878template< size_t... CRAs // Compile time row arguments
879 , typename MT // Matrix base type of the expression
880 , typename... RRAs > // Runtime row arguments
881inline decltype(auto) row( const MatTransExpr<MT>& matrix, RRAs... args )
882{
884
885 try {
886 return trans( column<CRAs...>( (*matrix).operand(), args... ) );
887 }
888 catch( ... ) {
889 BLAZE_THROW_INVALID_ARGUMENT( "Invalid row access index" );
890 }
891}
893//*************************************************************************************************
894
895
896//*************************************************************************************************
909template< size_t... CRAs // Compile time row arguments
910 , typename MT // Matrix base type of the expression
911 , size_t... CEAs // Compile time expansion arguments
912 , typename... RRAs // Runtime row arguments
913 , EnableIf_t< IsRowMajorMatrix_v<MT> >* = nullptr >
914inline decltype(auto) row( const VecExpandExpr<MT,CEAs...>& matrix, RRAs... args )
915{
917
918 if( isChecked( args... ) ) {
919 const RowData<CRAs...> rd( args... );
920 if( (*matrix).rows() <= rd.row() ) {
921 BLAZE_THROW_INVALID_ARGUMENT( "Invalid row access index" );
922 }
923 }
924
925 return subvector( (*matrix).operand(), 0UL, (*matrix).columns(), unchecked );
926}
928//*************************************************************************************************
929
930
931//*************************************************************************************************
944template< size_t... CRAs // Compile time row arguments
945 , typename MT // Matrix base type of the expression
946 , size_t... CEAs // Compile time expansion arguments
947 , typename... RRAs // Runtime row arguments
948 , EnableIf_t< !IsRowMajorMatrix_v<MT> >* = nullptr >
949inline decltype(auto) row( const VecExpandExpr<MT,CEAs...>& matrix, RRAs... args )
950{
952
953 const RowData<CRAs...> rd( args... );
954
955 if( isChecked( args... ) ) {
956 if( (*matrix).rows() <= rd.row() ) {
957 BLAZE_THROW_INVALID_ARGUMENT( "Invalid row access index" );
958 }
959 }
960
961 using ET = ElementType_t< MatrixType_t<MT> >;
962
963 return UniformVector<ET,rowVector>( (*matrix).columns(), (*matrix).operand()[rd.row()] );
964}
966//*************************************************************************************************
967
968
969//*************************************************************************************************
982template< size_t... CRAs1 // Compile time row arguments
983 , typename MT // Matrix base type of the expression
984 , size_t... CRAs2 // Compile time repeater arguments
985 , typename... RRAs > // Runtime row arguments
986inline decltype(auto) row( const MatRepeatExpr<MT,CRAs2...>& matrix, RRAs... args )
987{
989
990 const RowData<CRAs1...> rd( args... );
991
992 if( isChecked( args... ) ) {
993 if( (*matrix).rows() <= rd.row() ) {
994 BLAZE_THROW_INVALID_ARGUMENT( "Invalid row access index" );
995 }
996 }
997
998 return repeat( row( (*matrix).operand()
999 , rd.row() % (*matrix).operand().rows()
1000 , unchecked )
1001 , (*matrix).template repetitions<1UL>() );
1002}
1004//*************************************************************************************************
1005
1006
1007
1008
1009//=================================================================================================
1010//
1011// ROW OPERATORS
1012//
1013//=================================================================================================
1014
1015//*************************************************************************************************
1041template< RelaxationFlag RF // Relaxation flag
1042 , typename MT // Type of the matrix
1043 , bool SO // Storage order
1044 , bool SF // Symmetry flag
1045 , size_t... CRAs > // Compile time row arguments
1046inline bool isDefault( const Row<MT,SO,true,SF,CRAs...>& row )
1047{
1048 using blaze::isDefault;
1049
1050 for( size_t i=0UL; i<row.size(); ++i )
1051 if( !isDefault<RF>( row[i] ) ) return false;
1052 return true;
1053}
1055//*************************************************************************************************
1056
1057
1058//*************************************************************************************************
1084template< RelaxationFlag RF // Relaxation flag
1085 , typename MT // Type of the matrix
1086 , bool SO // Storage order
1087 , bool SF // Symmetry flag
1088 , size_t... CRAs > // Compile time row arguments
1089inline bool isDefault( const Row<MT,SO,false,SF,CRAs...>& row )
1090{
1091 using blaze::isDefault;
1092
1093 for( const auto& element : row )
1094 if( !isDefault<RF>( element.value() ) ) return false;
1095 return true;
1096}
1098//*************************************************************************************************
1099
1100
1101//*************************************************************************************************
1119template< typename MT // Type of the matrix
1120 , bool SO // Storage order
1121 , bool DF // Density flag
1122 , bool SF // Symmetry flag
1123 , size_t... CRAs > // Compile time row arguments
1124inline bool isIntact( const Row<MT,SO,DF,SF,CRAs...>& row ) noexcept
1125{
1126 return ( row.row() < row.operand().rows() &&
1127 isIntact( row.operand() ) );
1128}
1130//*************************************************************************************************
1131
1132
1133//*************************************************************************************************
1146template< typename MT1 // Type of the matrix of the left-hand side row
1147 , bool SO // Storage order
1148 , bool DF // Density flag
1149 , bool SF1 // Symmetry flag of the left-hand side row
1150 , size_t... CRAs1 // Compile time row arguments of the left-hand side row
1151 , typename MT2 // Type of the matrix of the right-hand side row
1152 , bool SF2 // Symmetry flag of the right-hand side row
1153 , size_t... CRAs2 > // Compile time row arguments of the right-hand side row
1154inline bool isSame( const Row<MT1,SO,DF,SF1,CRAs1...>& a,
1155 const Row<MT2,SO,DF,SF2,CRAs2...>& b ) noexcept
1156{
1157 return ( isSame( a.operand(), b.operand() ) && ( a.row() == b.row() ) );
1158}
1160//*************************************************************************************************
1161
1162
1163//*************************************************************************************************
1178template< typename MT // Type of the matrix
1179 , bool SO // Storage order
1180 , bool DF // Density flag
1181 , bool SF // Symmetry flag
1182 , size_t... CRAs // Compile time row arguments
1183 , typename ET > // Type of the element
1184inline bool trySet( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1185{
1186 BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1187
1188 return trySet( row.operand(), row.row(), index, value );
1189}
1191//*************************************************************************************************
1192
1193
1194//*************************************************************************************************
1210template< typename MT // Type of the matrix
1211 , bool SO // Storage order
1212 , bool DF // Density flag
1213 , bool SF // Symmetry flag
1214 , size_t... CRAs // Compile time row arguments
1215 , typename ET > // Type of the element
1217 trySet( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1218{
1219 BLAZE_INTERNAL_ASSERT( index <= (*row).size(), "Invalid vector access index" );
1220 BLAZE_INTERNAL_ASSERT( index + size <= (*row).size(), "Invalid range size" );
1221
1222 return trySet( row.operand(), row.row(), index, 1UL, size, value );
1223}
1225//*************************************************************************************************
1226
1227
1228//*************************************************************************************************
1243template< typename MT // Type of the matrix
1244 , bool SO // Storage order
1245 , bool DF // Density flag
1246 , bool SF // Symmetry flag
1247 , size_t... CRAs // Compile time row arguments
1248 , typename ET > // Type of the element
1249inline bool tryAdd( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1250{
1251 BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1252
1253 return tryAdd( row.operand(), row.row(), index, value );
1254}
1256//*************************************************************************************************
1257
1258
1259//*************************************************************************************************
1275template< typename MT // Type of the matrix
1276 , bool SO // Storage order
1277 , bool DF // Density flag
1278 , bool SF // Symmetry flag
1279 , size_t... CRAs // Compile time row arguments
1280 , typename ET > // Type of the element
1282 tryAdd( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1283{
1284 BLAZE_INTERNAL_ASSERT( index <= (*row).size(), "Invalid vector access index" );
1285 BLAZE_INTERNAL_ASSERT( index + size <= (*row).size(), "Invalid range size" );
1286
1287 return tryAdd( row.operand(), row.row(), index, 1UL, size, value );
1288}
1290//*************************************************************************************************
1291
1292
1293//*************************************************************************************************
1308template< typename MT // Type of the matrix
1309 , bool SO // Storage order
1310 , bool DF // Density flag
1311 , bool SF // Symmetry flag
1312 , size_t... CRAs // Compile time row arguments
1313 , typename ET > // Type of the element
1314inline bool trySub( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1315{
1316 BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1317
1318 return trySub( row.operand(), row.row(), index, value );
1319}
1321//*************************************************************************************************
1322
1323
1324//*************************************************************************************************
1340template< typename MT // Type of the matrix
1341 , bool SO // Storage order
1342 , bool DF // Density flag
1343 , bool SF // Symmetry flag
1344 , size_t... CRAs // Compile time row arguments
1345 , typename ET > // Type of the element
1347 trySub( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1348{
1349 BLAZE_INTERNAL_ASSERT( index <= (*row).size(), "Invalid vector access index" );
1350 BLAZE_INTERNAL_ASSERT( index + size <= (*row).size(), "Invalid range size" );
1351
1352 return trySub( row.operand(), row.row(), index, 1UL, size, value );
1353}
1355//*************************************************************************************************
1356
1357
1358//*************************************************************************************************
1373template< typename MT // Type of the matrix
1374 , bool SO // Storage order
1375 , bool DF // Density flag
1376 , bool SF // Symmetry flag
1377 , size_t... CRAs // Compile time row arguments
1378 , typename ET > // Type of the element
1379inline bool tryMult( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1380{
1381 BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1382
1383 return tryMult( row.operand(), row.row(), index, value );
1384}
1386//*************************************************************************************************
1387
1388
1389//*************************************************************************************************
1405template< typename MT // Type of the matrix
1406 , bool SO // Storage order
1407 , bool DF // Density flag
1408 , bool SF // Symmetry flag
1409 , size_t... CRAs // Compile time row arguments
1410 , typename ET > // Type of the element
1412 tryMult( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1413{
1414 BLAZE_INTERNAL_ASSERT( index <= (*row).size(), "Invalid vector access index" );
1415 BLAZE_INTERNAL_ASSERT( index + size <= (*row).size(), "Invalid range size" );
1416
1417 return tryMult( row.operand(), row.row(), index, 1UL, size, value );
1418}
1420//*************************************************************************************************
1421
1422
1423//*************************************************************************************************
1438template< typename MT // Type of the matrix
1439 , bool SO // Storage order
1440 , bool DF // Density flag
1441 , bool SF // Symmetry flag
1442 , size_t... CRAs // Compile time row arguments
1443 , typename ET > // Type of the element
1444inline bool tryDiv( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1445{
1446 BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1447
1448 return tryDiv( row.operand(), row.row(), index, value );
1449}
1451//*************************************************************************************************
1452
1453
1454//*************************************************************************************************
1470template< typename MT // Type of the matrix
1471 , bool SO // Storage order
1472 , bool DF // Density flag
1473 , bool SF // Symmetry flag
1474 , size_t... CRAs // Compile time row arguments
1475 , typename ET > // Type of the element
1477 tryDiv( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1478{
1479 BLAZE_INTERNAL_ASSERT( index <= (*row).size(), "Invalid vector access index" );
1480 BLAZE_INTERNAL_ASSERT( index + size <= (*row).size(), "Invalid range size" );
1481
1482 return tryDiv( row.operand(), row.row(), index, 1UL, size, value );
1483}
1485//*************************************************************************************************
1486
1487
1488//*************************************************************************************************
1503template< typename MT // Type of the matrix
1504 , bool SO // Storage order
1505 , bool DF // Density flag
1506 , bool SF // Symmetry flag
1507 , size_t... CRAs > // Compile time row arguments
1508inline bool tryShift( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, int count )
1509{
1510 BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1511
1512 return tryShift( row.operand(), row.row(), index, count );
1513}
1515//*************************************************************************************************
1516
1517
1518//*************************************************************************************************
1534template< typename MT // Type of the matrix
1535 , bool SO // Storage order
1536 , bool DF // Density flag
1537 , bool SF // Symmetry flag
1538 , size_t... CRAs > // Compile time row arguments
1540 tryShift( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, int count )
1541{
1542 BLAZE_INTERNAL_ASSERT( index <= (*row).size(), "Invalid vector access index" );
1543 BLAZE_INTERNAL_ASSERT( index + size <= (*row).size(), "Invalid range size" );
1544
1545 return tryShift( row.operand(), row.row(), index, 1UL, size, count );
1546}
1548//*************************************************************************************************
1549
1550
1551//*************************************************************************************************
1566template< typename MT // Type of the matrix
1567 , bool SO // Storage order
1568 , bool DF // Density flag
1569 , bool SF // Symmetry flag
1570 , size_t... CRAs // Compile time row arguments
1571 , typename ET > // Type of the element
1572inline bool tryBitand( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1573{
1574 BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1575
1576 return tryBitand( row.operand(), row.row(), index, value );
1577}
1579//*************************************************************************************************
1580
1581
1582//*************************************************************************************************
1598template< typename MT // Type of the matrix
1599 , bool SO // Storage order
1600 , bool DF // Density flag
1601 , bool SF // Symmetry flag
1602 , size_t... CRAs // Compile time row arguments
1603 , typename ET > // Type of the element
1605 tryBitand( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1606{
1607 BLAZE_INTERNAL_ASSERT( index <= (*row).size(), "Invalid vector access index" );
1608 BLAZE_INTERNAL_ASSERT( index + size <= (*row).size(), "Invalid range size" );
1609
1610 return tryBitand( row.operand(), row.row(), index, 1UL, size, value );
1611}
1613//*************************************************************************************************
1614
1615
1616//*************************************************************************************************
1631template< typename MT // Type of the matrix
1632 , bool SO // Storage order
1633 , bool DF // Density flag
1634 , bool SF // Symmetry flag
1635 , size_t... CRAs // Compile time row arguments
1636 , typename ET > // Type of the element
1637inline bool tryBitor( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1638{
1639 BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1640
1641 return tryBitor( row.operand(), row.row(), index, value );
1642}
1644//*************************************************************************************************
1645
1646
1647//*************************************************************************************************
1663template< typename MT // Type of the matrix
1664 , bool SO // Storage order
1665 , bool DF // Density flag
1666 , bool SF // Symmetry flag
1667 , size_t... CRAs // Compile time row arguments
1668 , typename ET > // Type of the element
1670 tryBitor( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1671{
1672 BLAZE_INTERNAL_ASSERT( index <= (*row).size(), "Invalid vector access index" );
1673 BLAZE_INTERNAL_ASSERT( index + size <= (*row).size(), "Invalid range size" );
1674
1675 return tryBitor( row.operand(), row.row(), index, 1UL, size, value );
1676}
1678//*************************************************************************************************
1679
1680
1681//*************************************************************************************************
1696template< typename MT // Type of the matrix
1697 , bool SO // Storage order
1698 , bool DF // Density flag
1699 , bool SF // Symmetry flag
1700 , size_t... CRAs // Compile time row arguments
1701 , typename ET > // Type of the element
1702inline bool tryBitxor( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1703{
1704 BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1705
1706 return tryBitxor( row.operand(), row.row(), index, value );
1707}
1709//*************************************************************************************************
1710
1711
1712//*************************************************************************************************
1728template< typename MT // Type of the matrix
1729 , bool SO // Storage order
1730 , bool DF // Density flag
1731 , bool SF // Symmetry flag
1732 , size_t... CRAs // Compile time row arguments
1733 , typename ET > // Type of the element
1735 tryBitxor( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1736{
1737 BLAZE_INTERNAL_ASSERT( index <= (*row).size(), "Invalid vector access index" );
1738 BLAZE_INTERNAL_ASSERT( index + size <= (*row).size(), "Invalid range size" );
1739
1740 return tryBitxor( row.operand(), row.row(), index, 1UL, size, value );
1741}
1743//*************************************************************************************************
1744
1745
1746//*************************************************************************************************
1761template< typename MT // Type of the matrix
1762 , bool SO // Storage order
1763 , bool DF // Density flag
1764 , bool SF // Symmetry flag
1765 , size_t... CRAs // Compile time row arguments
1766 , typename VT > // Type of the right-hand side vector
1767inline bool tryAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1768 const Vector<VT,true>& rhs, size_t index )
1769{
1770 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1771 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1772
1773 return tryAssign( lhs.operand(), *rhs, lhs.row(), index );
1774}
1776//*************************************************************************************************
1777
1778
1779//*************************************************************************************************
1794template< typename MT // Type of the matrix
1795 , bool SO // Storage order
1796 , bool DF // Density flag
1797 , bool SF // Symmetry flag
1798 , size_t... CRAs // Compile time row arguments
1799 , typename VT > // Type of the right-hand side vector
1800inline bool tryAddAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1801 const Vector<VT,true>& rhs, size_t index )
1802{
1803 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1804 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1805
1806 return tryAddAssign( lhs.operand(), *rhs, lhs.row(), index );
1807}
1809//*************************************************************************************************
1810
1811
1812//*************************************************************************************************
1827template< typename MT // Type of the matrix
1828 , bool SO // Storage order
1829 , bool DF // Density flag
1830 , bool SF // Symmetry flag
1831 , size_t... CRAs // Compile time row arguments
1832 , typename VT > // Type of the right-hand side vector
1833inline bool trySubAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1834 const Vector<VT,true>& rhs, size_t index )
1835{
1836 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1837 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1838
1839 return trySubAssign( lhs.operand(), *rhs, lhs.row(), index );
1840}
1842//*************************************************************************************************
1843
1844
1845//*************************************************************************************************
1860template< typename MT // Type of the matrix
1861 , bool SO // Storage order
1862 , bool DF // Density flag
1863 , bool SF // Symmetry flag
1864 , size_t... CRAs // Compile time row arguments
1865 , typename VT > // Type of the right-hand side vector
1866inline bool tryMultAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1867 const Vector<VT,true>& rhs, size_t index )
1868{
1869 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1870 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1871
1872 return tryMultAssign( lhs.operand(), *rhs, lhs.row(), index );
1873}
1875//*************************************************************************************************
1876
1877
1878//*************************************************************************************************
1893template< typename MT // Type of the matrix
1894 , bool SO // Storage order
1895 , bool DF // Density flag
1896 , bool SF // Symmetry flag
1897 , size_t... CRAs // Compile time row arguments
1898 , typename VT > // Type of the right-hand side vector
1899inline bool tryDivAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1900 const Vector<VT,true>& rhs, size_t index )
1901{
1902 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1903 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1904
1905 return tryDivAssign( lhs.operand(), *rhs, lhs.row(), index );
1906}
1908//*************************************************************************************************
1909
1910
1911//*************************************************************************************************
1926template< typename MT // Type of the matrix
1927 , bool SO // Storage order
1928 , bool DF // Density flag
1929 , bool SF // Symmetry flag
1930 , size_t... CRAs // Compile time row arguments
1931 , typename VT > // Type of the right-hand side vector
1932inline bool tryShiftAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1933 const Vector<VT,true>& rhs, size_t index )
1934{
1935 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1936 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1937
1938 return tryShiftAssign( lhs.operand(), *rhs, lhs.row(), index );
1939}
1941//*************************************************************************************************
1942
1943
1944//*************************************************************************************************
1959template< typename MT // Type of the matrix
1960 , bool SO // Storage order
1961 , bool DF // Density flag
1962 , bool SF // Symmetry flag
1963 , size_t... CRAs // Compile time row arguments
1964 , typename VT > // Type of the right-hand side vector
1965inline bool tryBitandAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1966 const Vector<VT,true>& rhs, size_t index )
1967{
1968 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1969 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1970
1971 return tryBitandAssign( lhs.operand(), *rhs, lhs.row(), index );
1972}
1974//*************************************************************************************************
1975
1976
1977//*************************************************************************************************
1992template< typename MT // Type of the matrix
1993 , bool SO // Storage order
1994 , bool DF // Density flag
1995 , bool SF // Symmetry flag
1996 , size_t... CRAs // Compile time row arguments
1997 , typename VT > // Type of the right-hand side vector
1998inline bool tryBitorAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1999 const Vector<VT,true>& rhs, size_t index )
2000{
2001 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
2002 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
2003
2004 return tryBitorAssign( lhs.operand(), *rhs, lhs.row(), index );
2005}
2007//*************************************************************************************************
2008
2009
2010//*************************************************************************************************
2025template< typename MT // Type of the matrix
2026 , bool SO // Storage order
2027 , bool DF // Density flag
2028 , bool SF // Symmetry flag
2029 , size_t... CRAs // Compile time row arguments
2030 , typename VT > // Type of the right-hand side vector
2031inline bool tryBitxorAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
2032 const Vector<VT,true>& rhs, size_t index )
2033{
2034 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
2035 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
2036
2037 return tryBitxorAssign( lhs.operand(), *rhs, lhs.row(), index );
2038}
2040//*************************************************************************************************
2041
2042
2043//*************************************************************************************************
2058template< typename MT // Type of the matrix
2059 , bool SO // Storage order
2060 , bool DF // Density flag
2061 , bool SF // Symmetry flag
2062 , size_t I > // Row index
2063inline decltype(auto) derestrict( Row<MT,SO,DF,SF,I>& r )
2064{
2065 return row<I>( derestrict( r.operand() ), unchecked );
2066}
2068//*************************************************************************************************
2069
2070
2071//*************************************************************************************************
2086template< typename MT // Type of the matrix
2087 , bool SO // Storage order
2088 , bool DF // Density flag
2089 , bool SF // Symmetry flag
2090 , size_t I > // Row index
2091inline decltype(auto) derestrict( Row<MT,SO,DF,SF,I>&& r )
2092{
2093 return row<I>( derestrict( r.operand() ), unchecked );
2094}
2096//*************************************************************************************************
2097
2098
2099//*************************************************************************************************
2114template< typename MT // Type of the matrix
2115 , bool SO // Storage order
2116 , bool DF // Density flag
2117 , bool SF > // Symmetry flag
2118inline decltype(auto) derestrict( Row<MT,SO,DF,SF>& r )
2119{
2120 return row( derestrict( r.operand() ), r.row(), unchecked );
2121}
2123//*************************************************************************************************
2124
2125
2126//*************************************************************************************************
2141template< typename MT // Type of the matrix
2142 , bool SO // Storage order
2143 , bool DF // Density flag
2144 , bool SF > // Symmetry flag
2145inline decltype(auto) derestrict( Row<MT,SO,DF,SF>&& r )
2146{
2147 return row( derestrict( r.operand() ), r.row(), unchecked );
2148}
2150//*************************************************************************************************
2151
2152
2153//*************************************************************************************************
2166template< typename MT // Type of the matrix
2167 , bool SO // Storage order
2168 , bool DF // Density flag
2169 , bool SF // Symmetry flag
2170 , size_t... CRAs > // Compile time row arguments
2171inline decltype(auto) unview( Row<MT,SO,DF,SF,CRAs...>& r )
2172{
2173 return r.operand();
2174}
2176//*************************************************************************************************
2177
2178
2179//*************************************************************************************************
2192template< typename MT // Type of the matrix
2193 , bool SO // Storage order
2194 , bool DF // Density flag
2195 , bool SF // Symmetry flag
2196 , size_t... CRAs > // Compile time row arguments
2197inline decltype(auto) unview( const Row<MT,SO,DF,SF,CRAs...>& r )
2198{
2199 return r.operand();
2200}
2202//*************************************************************************************************
2203
2204
2205
2206
2207//=================================================================================================
2208//
2209// SIZE SPECIALIZATIONS
2210//
2211//=================================================================================================
2212
2213//*************************************************************************************************
2215template< typename MT, bool SO, bool DF, bool SF, size_t... CRAs >
2216struct Size< Row<MT,SO,DF,SF,CRAs...>, 0UL >
2217 : public Size<MT,1UL>
2218{};
2220//*************************************************************************************************
2221
2222
2223
2224
2225//=================================================================================================
2226//
2227// MAXSIZE SPECIALIZATIONS
2228//
2229//=================================================================================================
2230
2231//*************************************************************************************************
2233template< typename MT, bool SO, bool DF, bool SF, size_t... CRAs >
2234struct MaxSize< Row<MT,SO,DF,SF,CRAs...>, 0UL >
2235 : public MaxSize<MT,1UL>
2236{};
2238//*************************************************************************************************
2239
2240
2241
2242
2243//=================================================================================================
2244//
2245// ISRESTRICTED SPECIALIZATIONS
2246//
2247//=================================================================================================
2248
2249//*************************************************************************************************
2251template< typename MT, bool SO, bool DF, bool SF, size_t... CRAs >
2252struct IsRestricted< Row<MT,SO,DF,SF,CRAs...> >
2253 : public IsRestricted<MT>
2254{};
2256//*************************************************************************************************
2257
2258
2259
2260
2261//=================================================================================================
2262//
2263// HASCONSTDATAACCESS SPECIALIZATIONS
2264//
2265//=================================================================================================
2266
2267//*************************************************************************************************
2269template< typename MT, bool SO, bool SF, size_t... CRAs >
2270struct HasConstDataAccess< Row<MT,SO,true,SF,CRAs...> >
2271 : public HasConstDataAccess<MT>
2272{};
2274//*************************************************************************************************
2275
2276
2277
2278
2279//=================================================================================================
2280//
2281// HASMUTABLEDATAACCESS SPECIALIZATIONS
2282//
2283//=================================================================================================
2284
2285//*************************************************************************************************
2287template< typename MT, bool SO, bool SF, size_t... CRAs >
2288struct HasMutableDataAccess< Row<MT,SO,true,SF,CRAs...> >
2289 : public HasMutableDataAccess<MT>
2290{};
2292//*************************************************************************************************
2293
2294
2295
2296
2297//=================================================================================================
2298//
2299// ISALIGNED SPECIALIZATIONS
2300//
2301//=================================================================================================
2302
2303//*************************************************************************************************
2305template< typename MT, bool SO, bool SF, size_t... CRAs >
2306struct IsAligned< Row<MT,SO,true,SF,CRAs...> >
2307 : public BoolConstant< IsAligned_v<MT> && ( IsRowMajorMatrix_v<MT> || IsSymmetric_v<MT> ) >
2308{};
2310//*************************************************************************************************
2311
2312
2313
2314
2315//=================================================================================================
2316//
2317// ISCONTIGUOUS SPECIALIZATIONS
2318//
2319//=================================================================================================
2320
2321//*************************************************************************************************
2323template< typename MT, bool SF, size_t... CRAs >
2324struct IsContiguous< Row<MT,true,true,SF,CRAs...> >
2325 : public IsContiguous<MT>
2326{};
2328//*************************************************************************************************
2329
2330
2331
2332
2333//=================================================================================================
2334//
2335// ISPADDED SPECIALIZATIONS
2336//
2337//=================================================================================================
2338
2339//*************************************************************************************************
2341template< typename MT, bool SO, bool SF, size_t... CRAs >
2342struct IsPadded< Row<MT,SO,true,SF,CRAs...> >
2343 : public BoolConstant< IsPadded_v<MT> && ( IsRowMajorMatrix_v<MT> || IsSymmetric_v<MT> ) >
2344{};
2346//*************************************************************************************************
2347
2348
2349
2350
2351//=================================================================================================
2352//
2353// ISOPPOSEDVIEW SPECIALIZATIONS
2354//
2355//=================================================================================================
2356
2357//*************************************************************************************************
2359template< typename MT, bool DF, size_t... CRAs >
2360struct IsOpposedView< Row<MT,false,DF,false,CRAs...> >
2361 : public TrueType
2362{};
2364//*************************************************************************************************
2365
2366} // namespace blaze
2367
2368#endif
Header file for run time assertion macros.
Header file for the Bind2nd functor.
Header file for the blaze::checked and blaze::unchecked instances.
Header file for the EnableIf class template.
Header file for the function trace functionality.
Header file for the HasConstDataAccess type trait.
Header file for the HasMutableDataAccess type trait.
Header file for the IntegralConstant class template.
Header file for the IsAligned type trait.
Header file for the IsContiguous type trait.
Header file for the isDefault shim.
Header file for the IsOpposedView type trait.
Header file for the IsPadded type trait.
Header file for the IsRowMajorMatrix type trait.
Header file for the IsSymmetric type trait.
Header file for the MaxSize type trait.
Header file for the relaxation flag enumeration.
Header file for the implementation of the RowData class template.
Base class for matrices.
Definition: Matrix.h:85
Header file for the implementation of a uniform vector.
Header file for the DeclExpr base class.
Header file for the MatEvalExpr base class.
Header file for the MatMapExpr base class.
Header file for the MatMatAddExpr base class.
Header file for the MatMatKronExpr base class.
Header file for the MatMatMapExpr base class.
Header file for the MatMatMultExpr base class.
Header file for the MatMatSubExpr base class.
Header file for the MatNoAliasExpr base class.
Header file for the MatNoSIMDExpr base class.
Header file for the MatRepeatExpr base class.
Header file for the MatScalarDivExpr base class.
Header file for the MatScalarMultExpr base class.
Header file for the MatSerialExpr base class.
Header file for the MatTransExpr base class.
Header file for the Matrix base class.
Header file for the SchurExpr base class.
Header file for the VecExpandExpr base class.
Header file for the VecTVecMapExpr base class.
Header file for the VecTVecMultExpr base class.
decltype(auto) noalias(const DenseMatrix< MT, SO > &dm)
Forces the non-aliased evaluation of the given dense matrix expression dm.
Definition: DMatNoAliasExpr.h:679
decltype(auto) eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:790
decltype(auto) repeat(const DenseMatrix< MT, SO > &dm, size_t m, size_t n)
Repeats the given dense matrix.
Definition: DMatRepeatExpr.h:543
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:766
decltype(auto) map(const DenseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs, OP op)
Elementwise evaluation of the given binary operation on each single element of the dense matrices lhs...
Definition: DMatDMatMapExpr.h:1144
decltype(auto) nosimd(const DenseMatrix< MT, SO > &dm)
Disables the SIMD evaluation of the given dense matrix expression dm.
Definition: DMatNoSIMDExpr.h:717
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:812
decltype(auto) kron(const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs)
Computes the Kronecker product of two dense matrices ( ).
Definition: DMatDMatKronExpr.h:957
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:207
bool isDefault(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the given diagonal matrix is in default state.
Definition: DiagonalMatrix.h:169
constexpr Bind2nd< OP, A2 > bind2nd(const OP &op, const A2 &a2)
Binds the given object/value to the 2nd parameter of the given operation.
Definition: Bind2nd.h:155
RelaxationFlag
Relaxation flag for strict or relaxed semantics.
Definition: RelaxationFlag.h:66
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:644
bool isSame(const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b) noexcept
Returns whether the two given matrices represent the same observable state.
Definition: Matrix.h:1424
constexpr size_t size(const Matrix< MT, SO > &matrix) noexcept
Returns the total number of elements of the matrix.
Definition: Matrix.h:676
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
decltype(auto) subvector(Vector< VT, TF > &, RSAs...)
Creating a view on a specific subvector of the given vector.
Definition: Subvector.h:158
#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
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.
Definition: IntegralConstant.h:110
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.
Definition: Exception.h:235
#define BLAZE_FUNCTION_TRACE
Function trace macro.
Definition: FunctionTrace.h:94
constexpr bool isChecked(const Ts &... args)
Extracting blaze::Check arguments from a given list of arguments.
Definition: Check.h:225
constexpr Unchecked unchecked
Global Unchecked instance.
Definition: Check.h:146
Header file for the exception macros of the math module.
Header file for the Size type trait.
Header file for basic type definitions.
Header file for the implementation of the Row base template.
Row specialization for dense matrices.
Row specialization for sparse matrices.