Blaze 3.9
Column.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_VIEWS_COLUMN_H_
36#define _BLAZE_MATH_VIEWS_COLUMN_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 // Column index
134 , typename MT // Type of the matrix
135 , bool SO // Storage order
136 , typename... RCAs > // Optional column arguments
137inline decltype(auto) column( Matrix<MT,SO>& matrix, RCAs... args )
138{
140
141 using ReturnType = Column_<MT,I>;
142 return ReturnType( *matrix, args... );
143}
144//*************************************************************************************************
145
146
147//*************************************************************************************************
182template< size_t I // Column index
183 , typename MT // Type of the matrix
184 , bool SO // Storage order
185 , typename... RCAs > // Optional column arguments
186inline decltype(auto) column( const Matrix<MT,SO>& matrix, RCAs... args )
187{
189
190 using ReturnType = const Column_<const MT,I>;
191 return ReturnType( *matrix, args... );
192}
193//*************************************************************************************************
194
195
196//*************************************************************************************************
210template< size_t I // Column index
211 , typename MT // Type of the matrix
212 , bool SO // Storage order
213 , typename... RCAs > // Optional column arguments
214inline decltype(auto) column( Matrix<MT,SO>&& matrix, RCAs... args )
215{
217
218 using ReturnType = Column_<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... RCAs > // Optional column arguments
263inline decltype(auto) column( Matrix<MT,SO>& matrix, size_t index, RCAs... args )
264{
266
267 using ReturnType = Column_<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... RCAs > // Optional column arguments
312inline decltype(auto) column( const Matrix<MT,SO>& matrix, size_t index, RCAs... args )
313{
315
316 using ReturnType = const Column_<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... RCAs > // Optional column arguments
340inline decltype(auto) column( Matrix<MT,SO>&& matrix, size_t index, RCAs... args )
341{
343
344 using ReturnType = Column_<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... CCAs // Compile time column arguments
372 , typename MT // Matrix base type of the expression
373 , typename... RCAs > // Runtime column arguments
374inline decltype(auto) column( const MatMatAddExpr<MT>& matrix, RCAs... args )
375{
377
378 return column<CCAs...>( (*matrix).leftOperand(), args... ) +
379 column<CCAs...>( (*matrix).rightOperand(), args... );
380}
382//*************************************************************************************************
383
384
385//*************************************************************************************************
398template< size_t... CCAs // Compile time column arguments
399 , typename MT // Matrix base type of the expression
400 , typename... RCAs > // Runtime column arguments
401inline decltype(auto) column( const MatMatSubExpr<MT>& matrix, RCAs... args )
402{
404
405 return column<CCAs...>( (*matrix).leftOperand(), args... ) -
406 column<CCAs...>( (*matrix).rightOperand(), args... );
407}
409//*************************************************************************************************
410
411
412//*************************************************************************************************
425template< size_t... CCAs // Compile time column arguments
426 , typename MT // Matrix base type of the expression
427 , typename... RCAs > // Runtime column arguments
428inline decltype(auto) column( const SchurExpr<MT>& matrix, RCAs... args )
429{
431
432 return column<CCAs...>( (*matrix).leftOperand(), args... ) *
433 column<CCAs...>( (*matrix).rightOperand(), args... );
434}
436//*************************************************************************************************
437
438
439//*************************************************************************************************
452template< size_t... CCAs // Compile time column arguments
453 , typename MT // Matrix base type of the expression
454 , typename... RCAs > // Runtime column arguments
455inline decltype(auto) column( const MatMatMultExpr<MT>& matrix, RCAs... args )
456{
458
459 return (*matrix).leftOperand() * column<CCAs...>( (*matrix).rightOperand(), args... );
460}
462//*************************************************************************************************
463
464
465//*************************************************************************************************
478template< size_t... CCAs // Compile time column arguments
479 , typename MT // Matrix base type of the expression
480 , typename... RCAs > // Runtime column arguments
481inline decltype(auto) column( const MatMatKronExpr<MT>& matrix, RCAs... args )
482{
484
485 const ColumnData<CCAs...> cd( args... );
486
487 if( isChecked( args... ) ) {
488 if( (*matrix).columns() <= cd.column() ) {
489 BLAZE_THROW_INVALID_ARGUMENT( "Invalid column access index" );
490 }
491 }
492
493 const size_t columns( (*matrix).rightOperand().columns() );
494
495 return kron( column( (*matrix).leftOperand(), cd.column()/columns, unchecked ),
496 column( (*matrix).rightOperand(), cd.column()%columns, unchecked ) );
497}
499//*************************************************************************************************
500
501
502//*************************************************************************************************
515template< size_t I // Column index
516 , typename MT // Matrix base type of the expression
517 , typename... RCAs > // Optional column arguments
518inline decltype(auto) column( const VecTVecMultExpr<MT>& matrix, RCAs... args )
519{
521
522 if( isChecked( args... ) ) {
523 if( (*matrix).columns() <= I ) {
524 BLAZE_THROW_INVALID_ARGUMENT( "Invalid column access index" );
525 }
526 }
527
528 return (*matrix).leftOperand() * (*matrix).rightOperand()[I];
529}
531//*************************************************************************************************
532
533
534//*************************************************************************************************
548template< typename MT // Matrix base type of the expression
549 , typename... RCAs > // Optional column arguments
550inline decltype(auto) column( const VecTVecMultExpr<MT>& matrix, size_t index, RCAs... args )
551{
553
554 if( isChecked( args... ) ) {
555 if( (*matrix).columns() <= index ) {
556 BLAZE_THROW_INVALID_ARGUMENT( "Invalid column access index" );
557 }
558 }
559
560 return (*matrix).leftOperand() * (*matrix).rightOperand()[index];
561}
563//*************************************************************************************************
564
565
566//*************************************************************************************************
579template< size_t... CCAs // Compile time column arguments
580 , typename MT // Matrix base type of the expression
581 , typename... RCAs > // Runtime column arguments
582inline decltype(auto) column( const MatScalarMultExpr<MT>& matrix, RCAs... args )
583{
585
586 return column<CCAs...>( (*matrix).leftOperand(), args... ) * (*matrix).rightOperand();
587}
589//*************************************************************************************************
590
591
592//*************************************************************************************************
605template< size_t... CCAs // Compile time column arguments
606 , typename MT // Matrix base type of the expression
607 , typename... RCAs > // Runtime column arguments
608inline decltype(auto) column( const MatScalarDivExpr<MT>& matrix, RCAs... args )
609{
611
612 return column<CCAs...>( (*matrix).leftOperand(), args... ) / (*matrix).rightOperand();
613}
615//*************************************************************************************************
616
617
618//*************************************************************************************************
631template< size_t... CCAs // Compile time column arguments
632 , typename MT // Matrix base type of the expression
633 , typename... RCAs > // Runtime column arguments
634inline decltype(auto) column( const MatMapExpr<MT>& matrix, RCAs... args )
635{
637
638 return map( column<CCAs...>( (*matrix).operand(), args... ), (*matrix).operation() );
639}
641//*************************************************************************************************
642
643
644//*************************************************************************************************
657template< size_t... CCAs // Compile time column arguments
658 , typename MT // Matrix base type of the expression
659 , typename... RCAs > // Runtime column arguments
660inline decltype(auto) column( const MatMatMapExpr<MT>& matrix, RCAs... args )
661{
663
664 return map( column<CCAs...>( (*matrix).leftOperand(), args... ),
665 column<CCAs...>( (*matrix).rightOperand(), args... ),
666 (*matrix).operation() );
667}
669//*************************************************************************************************
670
671
672//*************************************************************************************************
686template< size_t I // Column index
687 , typename MT // Matrix base type of the expression
688 , typename... RCAs > // Optional column arguments
689inline decltype(auto) column( const VecTVecMapExpr<MT>& matrix, RCAs... args )
690{
692
693 if( isChecked( args... ) ) {
694 if( (*matrix).columns() <= I ) {
695 BLAZE_THROW_INVALID_ARGUMENT( "Invalid column access index" );
696 }
697 }
698
699 return map( (*matrix).leftOperand(),
700 blaze::bind2nd( (*matrix).operation(), (*matrix).rightOperand()[I] ) );
701}
703//*************************************************************************************************
704
705
706//*************************************************************************************************
720template< typename MT // Matrix base type of the expression
721 , typename... RCAs > // Optional column arguments
722inline decltype(auto) column( const VecTVecMapExpr<MT>& matrix, size_t index, RCAs... args )
723{
725
726 if( isChecked( args... ) ) {
727 if( (*matrix).columns() <= index ) {
728 BLAZE_THROW_INVALID_ARGUMENT( "Invalid column access index" );
729 }
730 }
731
732 return map( (*matrix).leftOperand(),
733 blaze::bind2nd( (*matrix).operation(), (*matrix).rightOperand()[index] ) );
734}
736//*************************************************************************************************
737
738
739//*************************************************************************************************
752template< size_t... CCAs // Compile time column arguments
753 , typename MT // Matrix base type of the expression
754 , typename... RCAs > // Runtime column arguments
755inline decltype(auto) column( const MatEvalExpr<MT>& matrix, RCAs... args )
756{
758
759 return eval( column<CCAs...>( (*matrix).operand(), args... ) );
760}
762//*************************************************************************************************
763
764
765//*************************************************************************************************
778template< size_t... CCAs // Compile time column arguments
779 , typename MT // Matrix base type of the expression
780 , typename... RCAs > // Runtime column arguments
781inline decltype(auto) column( const MatSerialExpr<MT>& matrix, RCAs... args )
782{
784
785 return serial( column<CCAs...>( (*matrix).operand(), args... ) );
786}
788//*************************************************************************************************
789
790
791//*************************************************************************************************
804template< size_t... CCAs // Compile time column arguments
805 , typename MT // Matrix base type of the expression
806 , typename... RCAs > // Runtime column arguments
807inline decltype(auto) column( const MatNoAliasExpr<MT>& matrix, RCAs... args )
808{
810
811 return noalias( column<CCAs...>( (*matrix).operand(), args... ) );
812}
814//*************************************************************************************************
815
816
817//*************************************************************************************************
830template< size_t... CCAs // Compile time column arguments
831 , typename MT // Matrix base type of the expression
832 , typename... RCAs > // Runtime column arguments
833inline decltype(auto) column( const MatNoSIMDExpr<MT>& matrix, RCAs... args )
834{
836
837 return nosimd( column<CCAs...>( (*matrix).operand(), args... ) );
838}
840//*************************************************************************************************
841
842
843//*************************************************************************************************
856template< size_t... CCAs // Compile time column arguments
857 , typename MT // Matrix base type of the expression
858 , typename... RCAs > // Runtime column arguments
859inline decltype(auto) column( const DeclExpr<MT>& matrix, RCAs... args )
860{
862
863 return column<CCAs...>( (*matrix).operand(), args... );
864}
866//*************************************************************************************************
867
868
869//*************************************************************************************************
882template< size_t... CCAs // Compile time column arguments
883 , typename MT // Matrix base type of the expression
884 , typename... RCAs > // Runtime column arguments
885inline decltype(auto) column( const MatTransExpr<MT>& matrix, RCAs... args )
886{
888
889 try {
890 return trans( row<CCAs...>( (*matrix).operand(), args... ) );
891 }
892 catch( ... ) {
893 BLAZE_THROW_INVALID_ARGUMENT( "Invalid column access index" );
894 }
895}
897//*************************************************************************************************
898
899
900//*************************************************************************************************
913template< size_t... CCAs // Compile time column arguments
914 , typename MT // Matrix base type of the expression
915 , size_t... CEAs // Compile time expansion arguments
916 , typename... RCAs // Runtime column arguments
917 , EnableIf_t< IsColumnMajorMatrix_v<MT> >* = nullptr >
918inline decltype(auto) column( const VecExpandExpr<MT,CEAs...>& matrix, RCAs... args )
919{
921
922 if( isChecked( args... ) ) {
923 const ColumnData<CCAs...> cd( args... );
924 if( (*matrix).columns() <= cd.column() ) {
925 BLAZE_THROW_INVALID_ARGUMENT( "Invalid column access index" );
926 }
927 }
928
929 return subvector( (*matrix).operand(), 0UL, (*matrix).rows(), unchecked );
930}
932//*************************************************************************************************
933
934
935//*************************************************************************************************
948template< size_t... CCAs // Compile time column arguments
949 , typename MT // Matrix base type of the expression
950 , size_t... CEAs // Compile time expansion arguments
951 , typename... RCAs // Runtime column arguments
952 , EnableIf_t< !IsColumnMajorMatrix_v<MT> >* = nullptr >
953inline decltype(auto) column( const VecExpandExpr<MT,CEAs...>& matrix, RCAs... args )
954{
956
957 const ColumnData<CCAs...> cd( args... );
958
959 if( isChecked( args... ) ) {
960 if( (*matrix).columns() <= cd.column() ) {
961 BLAZE_THROW_INVALID_ARGUMENT( "Invalid column access index" );
962 }
963 }
964
965 using ET = ElementType_t< MatrixType_t<MT> >;
966
967 return UniformVector<ET,columnVector>( (*matrix).rows(), (*matrix).operand()[cd.column()] );
968}
970//*************************************************************************************************
971
972
973//*************************************************************************************************
986template< size_t... CCAs // Compile time column arguments
987 , typename MT // Matrix base type of the expression
988 , size_t... CRAs // Compile time repeater arguments
989 , typename... RCAs > // Runtime column arguments
990inline decltype(auto) column( const MatRepeatExpr<MT,CRAs...>& matrix, RCAs... args )
991{
993
994 const ColumnData<CCAs...> cd( args... );
995
996 if( isChecked( args... ) ) {
997 if( (*matrix).columns() <= cd.column() ) {
998 BLAZE_THROW_INVALID_ARGUMENT( "Invalid column access index" );
999 }
1000 }
1001
1002 return repeat( column( (*matrix).operand()
1003 , cd.column() % (*matrix).operand().columns()
1004 , unchecked )
1005 , (*matrix).template repetitions<0UL>() );
1006}
1008//*************************************************************************************************
1009
1010
1011
1012
1013//=================================================================================================
1014//
1015// COLUMN OPERATORS
1016//
1017//=================================================================================================
1018
1019//*************************************************************************************************
1045template< RelaxationFlag RF // Relaxation flag
1046 , typename MT // Type of the dense matrix
1047 , bool SO // Storage order
1048 , bool SF // Symmetry flag
1049 , size_t... CCAs > // Compile time column arguments
1050inline bool isDefault( const Column<MT,SO,true,SF,CCAs...>& column )
1051{
1052 using blaze::isDefault;
1053
1054 for( size_t i=0UL; i<column.size(); ++i )
1055 if( !isDefault<RF>( column[i] ) ) return false;
1056 return true;
1057}
1059//*************************************************************************************************
1060
1061
1062//*************************************************************************************************
1088template< RelaxationFlag RF // Relaxation flag
1089 , typename MT // Type of the sparse matrix
1090 , bool SO // Storage order
1091 , bool SF // Symmetry flag
1092 , size_t... CCAs > // Compile time column arguments
1093inline bool isDefault( const Column<MT,SO,false,SF,CCAs...>& column )
1094{
1095 using blaze::isDefault;
1096
1097 for( const auto& element : column )
1098 if( !isDefault<RF>( element.value() ) ) return false;
1099 return true;
1100}
1102//*************************************************************************************************
1103
1104
1105//*************************************************************************************************
1123template< typename MT // Type of the matrix
1124 , bool SO // Storage order
1125 , bool DF // Density flag
1126 , bool SF // Symmetry flag
1127 , size_t... CCAs > // Compile time column arguments
1128inline bool isIntact( const Column<MT,SO,DF,SF,CCAs...>& column ) noexcept
1129{
1130 return ( column.column() < column.operand().columns() &&
1131 isIntact( column.operand() ) );
1132}
1134//*************************************************************************************************
1135
1136
1137//*************************************************************************************************
1150template< typename MT1 // Type of the matrix of the left-hand side column
1151 , bool SO // Storage order
1152 , bool DF // Density flag
1153 , bool SF1 // Symmetry flag of the left-hand side column
1154 , size_t... CCAs1 // Compile time column arguments of the left-hand side column
1155 , typename MT2 // Type of the matrix of the right-hand side column
1156 , bool SF2 // Symmetry flag of the right-hand side column
1157 , size_t... CCAs2 > // Compile time column arguments of the right-hand side column
1158inline bool isSame( const Column<MT1,SO,DF,SF1,CCAs1...>& a,
1159 const Column<MT2,SO,DF,SF2,CCAs2...>& b ) noexcept
1160{
1161 return ( isSame( a.operand(), b.operand() ) && ( a.column() == b.column() ) );
1162}
1164//*************************************************************************************************
1165
1166
1167//*************************************************************************************************
1182template< typename MT // Type of the matrix
1183 , bool SO // Storage order
1184 , bool DF // Density flag
1185 , bool SF // Symmetry flag
1186 , size_t... CCAs // Compile time column arguments
1187 , typename ET > // Type of the element
1188inline bool trySet( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, const ET& value )
1189{
1190 BLAZE_INTERNAL_ASSERT( index < column.size(), "Invalid vector access index" );
1191
1192 return trySet( column.operand(), index, column.column(), value );
1193}
1195//*************************************************************************************************
1196
1197
1198//*************************************************************************************************
1214template< typename MT // Type of the matrix
1215 , bool SO // Storage order
1216 , bool DF // Density flag
1217 , bool SF // Symmetry flag
1218 , size_t... CCAs // Compile time column arguments
1219 , typename ET > // Type of the element
1221 trySet( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, size_t size, const ET& value )
1222{
1223 BLAZE_INTERNAL_ASSERT( index <= (*column).size(), "Invalid vector access index" );
1224 BLAZE_INTERNAL_ASSERT( index + size <= (*column).size(), "Invalid range size" );
1225
1226 return trySet( column.operand(), index, column.column(), size, 1UL, value );
1227}
1229//*************************************************************************************************
1230
1231
1232//*************************************************************************************************
1247template< typename MT // Type of the matrix
1248 , bool SO // Storage order
1249 , bool DF // Density flag
1250 , bool SF // Symmetry flag
1251 , size_t... CCAs // Compile time column arguments
1252 , typename ET > // Type of the element
1253inline bool tryAdd( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, const ET& value )
1254{
1255 BLAZE_INTERNAL_ASSERT( index < column.size(), "Invalid vector access index" );
1256
1257 return tryAdd( column.operand(), index, column.column(), value );
1258}
1260//*************************************************************************************************
1261
1262
1263//*************************************************************************************************
1279template< typename MT // Type of the matrix
1280 , bool SO // Storage order
1281 , bool DF // Density flag
1282 , bool SF // Symmetry flag
1283 , size_t... CCAs // Compile time column arguments
1284 , typename ET > // Type of the element
1286 tryAdd( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, size_t size, const ET& value )
1287{
1288 BLAZE_INTERNAL_ASSERT( index <= (*column).size(), "Invalid vector access index" );
1289 BLAZE_INTERNAL_ASSERT( index + size <= (*column).size(), "Invalid range size" );
1290
1291 return tryAdd( column.operand(), index, column.column(), size, 1UL, value );
1292}
1294//*************************************************************************************************
1295
1296
1297//*************************************************************************************************
1312template< typename MT // Type of the matrix
1313 , bool SO // Storage order
1314 , bool DF // Density flag
1315 , bool SF // Symmetry flag
1316 , size_t... CCAs // Compile time column arguments
1317 , typename ET > // Type of the element
1318inline bool trySub( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, const ET& value )
1319{
1320 BLAZE_INTERNAL_ASSERT( index < column.size(), "Invalid vector access index" );
1321
1322 return trySub( column.operand(), index, column.column(), value );
1323}
1325//*************************************************************************************************
1326
1327
1328//*************************************************************************************************
1344template< typename MT // Type of the matrix
1345 , bool SO // Storage order
1346 , bool DF // Density flag
1347 , bool SF // Symmetry flag
1348 , size_t... CCAs // Compile time column arguments
1349 , typename ET > // Type of the element
1351 trySub( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, size_t size, const ET& value )
1352{
1353 BLAZE_INTERNAL_ASSERT( index <= (*column).size(), "Invalid vector access index" );
1354 BLAZE_INTERNAL_ASSERT( index + size <= (*column).size(), "Invalid range size" );
1355
1356 return trySub( column.operand(), index, column.column(), size, 1UL, value );
1357}
1359//*************************************************************************************************
1360
1361
1362//*************************************************************************************************
1377template< typename MT // Type of the matrix
1378 , bool SO // Storage order
1379 , bool DF // Density flag
1380 , bool SF // Symmetry flag
1381 , size_t... CCAs // Compile time column arguments
1382 , typename ET > // Type of the element
1383inline bool tryMult( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, const ET& value )
1384{
1385 BLAZE_INTERNAL_ASSERT( index < column.size(), "Invalid vector access index" );
1386
1387 return tryMult( column.operand(), index, column.column(), value );
1388}
1390//*************************************************************************************************
1391
1392
1393//*************************************************************************************************
1409template< typename MT // Type of the matrix
1410 , bool SO // Storage order
1411 , bool DF // Density flag
1412 , bool SF // Symmetry flag
1413 , size_t... CCAs // Compile time column arguments
1414 , typename ET > // Type of the element
1416 tryMult( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, size_t size, const ET& value )
1417{
1418 BLAZE_INTERNAL_ASSERT( index <= (*column).size(), "Invalid vector access index" );
1419 BLAZE_INTERNAL_ASSERT( index + size <= (*column).size(), "Invalid range size" );
1420
1421 return tryMult( column.operand(), index, column.column(), size, 1UL, value );
1422}
1424//*************************************************************************************************
1425
1426
1427//*************************************************************************************************
1442template< typename MT // Type of the matrix
1443 , bool SO // Storage order
1444 , bool DF // Density flag
1445 , bool SF // Symmetry flag
1446 , size_t... CCAs // Compile time column arguments
1447 , typename ET > // Type of the element
1448inline bool tryDiv( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, const ET& value )
1449{
1450 BLAZE_INTERNAL_ASSERT( index < column.size(), "Invalid vector access index" );
1451
1452 return tryDiv( column.operand(), index, column.column(), value );
1453}
1455//*************************************************************************************************
1456
1457
1458//*************************************************************************************************
1474template< typename MT // Type of the matrix
1475 , bool SO // Storage order
1476 , bool DF // Density flag
1477 , bool SF // Symmetry flag
1478 , size_t... CCAs // Compile time column arguments
1479 , typename ET > // Type of the element
1481 tryDiv( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, size_t size, const ET& value )
1482{
1483 BLAZE_INTERNAL_ASSERT( index <= (*column).size(), "Invalid vector access index" );
1484 BLAZE_INTERNAL_ASSERT( index + size <= (*column).size(), "Invalid range size" );
1485
1486 return tryDiv( column.operand(), index, column.column(), size, 1UL, value );
1487}
1489//*************************************************************************************************
1490
1491
1492//*************************************************************************************************
1507template< typename MT // Type of the matrix
1508 , bool SO // Storage order
1509 , bool DF // Density flag
1510 , bool SF // Symmetry flag
1511 , size_t... CCAs > // Compile time column arguments
1512inline bool tryShift( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, int count )
1513{
1514 BLAZE_INTERNAL_ASSERT( index < column.size(), "Invalid vector access index" );
1515
1516 return tryShift( column.operand(), index, column.column(), count );
1517}
1519//*************************************************************************************************
1520
1521
1522//*************************************************************************************************
1538template< typename MT // Type of the matrix
1539 , bool SO // Storage order
1540 , bool DF // Density flag
1541 , bool SF // Symmetry flag
1542 , size_t... CCAs > // Compile time column arguments
1544 tryShift( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, size_t size, int count )
1545{
1546 BLAZE_INTERNAL_ASSERT( index <= (*column).size(), "Invalid vector access index" );
1547 BLAZE_INTERNAL_ASSERT( index + size <= (*column).size(), "Invalid range size" );
1548
1549 return tryShift( column.operand(), index, column.column(), size, 1UL, count );
1550}
1552//*************************************************************************************************
1553
1554
1555//*************************************************************************************************
1570template< typename MT // Type of the matrix
1571 , bool SO // Storage order
1572 , bool DF // Density flag
1573 , bool SF // Symmetry flag
1574 , size_t... CCAs // Compile time column arguments
1575 , typename ET > // Type of the element
1576inline bool tryBitand( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, const ET& value )
1577{
1578 BLAZE_INTERNAL_ASSERT( index < column.size(), "Invalid vector access index" );
1579
1580 return tryBitand( column.operand(), index, column.column(), value );
1581}
1583//*************************************************************************************************
1584
1585
1586//*************************************************************************************************
1602template< typename MT // Type of the matrix
1603 , bool SO // Storage order
1604 , bool DF // Density flag
1605 , bool SF // Symmetry flag
1606 , size_t... CCAs // Compile time column arguments
1607 , typename ET > // Type of the element
1609 tryBitand( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, size_t size, const ET& value )
1610{
1611 BLAZE_INTERNAL_ASSERT( index <= (*column).size(), "Invalid vector access index" );
1612 BLAZE_INTERNAL_ASSERT( index + size <= (*column).size(), "Invalid range size" );
1613
1614 return tryBitand( column.operand(), index, column.column(), size, 1UL, value );
1615}
1617//*************************************************************************************************
1618
1619
1620//*************************************************************************************************
1635template< typename MT // Type of the matrix
1636 , bool SO // Storage order
1637 , bool DF // Density flag
1638 , bool SF // Symmetry flag
1639 , size_t... CCAs // Compile time column arguments
1640 , typename ET > // Type of the element
1641inline bool tryBitor( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, const ET& value )
1642{
1643 BLAZE_INTERNAL_ASSERT( index < column.size(), "Invalid vector access index" );
1644
1645 return tryBitor( column.operand(), index, column.column(), value );
1646}
1648//*************************************************************************************************
1649
1650
1651//*************************************************************************************************
1667template< typename MT // Type of the matrix
1668 , bool SO // Storage order
1669 , bool DF // Density flag
1670 , bool SF // Symmetry flag
1671 , size_t... CCAs // Compile time column arguments
1672 , typename ET > // Type of the element
1674 tryBitor( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, size_t size, const ET& value )
1675{
1676 BLAZE_INTERNAL_ASSERT( index <= (*column).size(), "Invalid vector access index" );
1677 BLAZE_INTERNAL_ASSERT( index + size <= (*column).size(), "Invalid range size" );
1678
1679 return tryBitor( column.operand(), index, column.column(), size, 1UL, value );
1680}
1682//*************************************************************************************************
1683
1684
1685//*************************************************************************************************
1700template< typename MT // Type of the matrix
1701 , bool SO // Storage order
1702 , bool DF // Density flag
1703 , bool SF // Symmetry flag
1704 , size_t... CCAs // Compile time column arguments
1705 , typename ET > // Type of the element
1706inline bool tryBitxor( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, const ET& value )
1707{
1708 BLAZE_INTERNAL_ASSERT( index < column.size(), "Invalid vector access index" );
1709
1710 return tryBitxor( column.operand(), index, column.column(), value );
1711}
1713//*************************************************************************************************
1714
1715
1716//*************************************************************************************************
1732template< typename MT // Type of the matrix
1733 , bool SO // Storage order
1734 , bool DF // Density flag
1735 , bool SF // Symmetry flag
1736 , size_t... CCAs // Compile time column arguments
1737 , typename ET > // Type of the element
1739 tryBitxor( const Column<MT,SO,DF,SF,CCAs...>& column, size_t index, size_t size, const ET& value )
1740{
1741 BLAZE_INTERNAL_ASSERT( index <= (*column).size(), "Invalid vector access index" );
1742 BLAZE_INTERNAL_ASSERT( index + size <= (*column).size(), "Invalid range size" );
1743
1744 return tryBitxor( column.operand(), index, column.column(), size, 1UL, value );
1745}
1747//*************************************************************************************************
1748
1749
1750//*************************************************************************************************
1765template< typename MT // Type of the matrix
1766 , bool SO // Storage order
1767 , bool DF // Density flag
1768 , bool SF // Symmetry flag
1769 , size_t... CCAs // Compile time column arguments
1770 , typename VT > // Type of the right-hand side vector
1771inline bool tryAssign( const Column<MT,SO,DF,SF,CCAs...>& lhs,
1772 const Vector<VT,false>& rhs, size_t index )
1773{
1774 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1775 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1776
1777 return tryAssign( lhs.operand(), *rhs, index, lhs.column() );
1778}
1780//*************************************************************************************************
1781
1782
1783//*************************************************************************************************
1798template< typename MT // Type of the matrix
1799 , bool SO // Storage order
1800 , bool DF // Density flag
1801 , bool SF // Symmetry flag
1802 , size_t... CCAs // Compile time column arguments
1803 , typename VT > // Type of the right-hand side vector
1804inline bool tryAddAssign( const Column<MT,SO,SF,SF,CCAs...>& lhs,
1805 const Vector<VT,false>& rhs, size_t index )
1806{
1807 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1808 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1809
1810 return tryAddAssign( lhs.operand(), *rhs, index, lhs.column() );
1811}
1813//*************************************************************************************************
1814
1815
1816//*************************************************************************************************
1831template< typename MT // Type of the matrix
1832 , bool SO // Storage order
1833 , bool DF // Density flag
1834 , bool SF // Symmetry flag
1835 , size_t... CCAs // Compile time column arguments
1836 , typename VT > // Type of the right-hand side vector
1837inline bool trySubAssign( const Column<MT,SO,DF,SF,CCAs...>& lhs,
1838 const Vector<VT,false>& rhs, size_t index )
1839{
1840 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1841 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1842
1843 return trySubAssign( lhs.operand(), *rhs, index, lhs.column() );
1844}
1846//*************************************************************************************************
1847
1848
1849//*************************************************************************************************
1864template< typename MT // Type of the matrix
1865 , bool SO // Storage order
1866 , bool DF // Density flag
1867 , bool SF // Symmetry flag
1868 , size_t... CCAs // Compile time column arguments
1869 , typename VT > // Type of the right-hand side vector
1870inline bool tryMultAssign( const Column<MT,SO,DF,SF,CCAs...>& lhs,
1871 const Vector<VT,false>& rhs, size_t index )
1872{
1873 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1874 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1875
1876 return tryMultAssign( lhs.operand(), *rhs, index, lhs.column() );
1877}
1879//*************************************************************************************************
1880
1881
1882//*************************************************************************************************
1897template< typename MT // Type of the matrix
1898 , bool SO // Storage order
1899 , bool DF // Density flag
1900 , bool SF // Symmetry flag
1901 , size_t... CCAs // Compile time column arguments
1902 , typename VT > // Type of the right-hand side vector
1903inline bool tryDivAssign( const Column<MT,SO,DF,SF,CCAs...>& lhs,
1904 const Vector<VT,false>& rhs, size_t index )
1905{
1906 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1907 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1908
1909 return tryDivAssign( lhs.operand(), *rhs, index, lhs.column() );
1910}
1912//*************************************************************************************************
1913
1914
1915//*************************************************************************************************
1930template< typename MT // Type of the matrix
1931 , bool SO // Storage order
1932 , bool DF // Density flag
1933 , bool SF // Symmetry flag
1934 , size_t... CCAs // Compile time column arguments
1935 , typename VT > // Type of the right-hand side vector
1936inline bool tryShiftAssign( const Column<MT,SO,SF,SF,CCAs...>& lhs,
1937 const Vector<VT,false>& rhs, size_t index )
1938{
1939 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1940 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1941
1942 return tryShiftAssign( lhs.operand(), *rhs, index, lhs.column() );
1943}
1945//*************************************************************************************************
1946
1947
1948//*************************************************************************************************
1963template< typename MT // Type of the matrix
1964 , bool SO // Storage order
1965 , bool DF // Density flag
1966 , bool SF // Symmetry flag
1967 , size_t... CCAs // Compile time column arguments
1968 , typename VT > // Type of the right-hand side vector
1969inline bool tryBitandAssign( const Column<MT,SO,SF,SF,CCAs...>& lhs,
1970 const Vector<VT,false>& rhs, size_t index )
1971{
1972 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1973 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
1974
1975 return tryBitandAssign( lhs.operand(), *rhs, index, lhs.column() );
1976}
1978//*************************************************************************************************
1979
1980
1981//*************************************************************************************************
1996template< typename MT // Type of the matrix
1997 , bool SO // Storage order
1998 , bool DF // Density flag
1999 , bool SF // Symmetry flag
2000 , size_t... CCAs // Compile time column arguments
2001 , typename VT > // Type of the right-hand side vector
2002inline bool tryBitorAssign( const Column<MT,SO,SF,SF,CCAs...>& lhs,
2003 const Vector<VT,false>& rhs, size_t index )
2004{
2005 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
2006 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
2007
2008 return tryBitorAssign( lhs.operand(), *rhs, index, lhs.column() );
2009}
2011//*************************************************************************************************
2012
2013
2014//*************************************************************************************************
2029template< typename MT // Type of the matrix
2030 , bool SO // Storage order
2031 , bool DF // Density flag
2032 , bool SF // Symmetry flag
2033 , size_t... CCAs // Compile time column arguments
2034 , typename VT > // Type of the right-hand side vector
2035inline bool tryBitxorAssign( const Column<MT,SO,SF,SF,CCAs...>& lhs,
2036 const Vector<VT,false>& rhs, size_t index )
2037{
2038 BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
2039 BLAZE_INTERNAL_ASSERT( index + (*rhs).size() <= lhs.size(), "Invalid vector size" );
2040
2041 return tryBitxorAssign( lhs.operand(), *rhs, index, lhs.column() );
2042}
2044//*************************************************************************************************
2045
2046
2047//*************************************************************************************************
2062template< typename MT // Type of the matrix
2063 , bool SO // Storage order
2064 , bool DF // Density flag
2065 , bool SF // Symmetry flag
2066 , size_t I > // Compile time column arguments
2067inline decltype(auto) derestrict( Column<MT,SO,DF,SF,I>& c )
2068{
2069 return column<I>( derestrict( c.operand() ), unchecked );
2070}
2072//*************************************************************************************************
2073
2074
2075//*************************************************************************************************
2090template< typename MT // Type of the matrix
2091 , bool SO // Storage order
2092 , bool DF // Density flag
2093 , bool SF // Symmetry flag
2094 , size_t I > // Compile time column arguments
2095inline decltype(auto) derestrict( Column<MT,SO,DF,SF,I>&& c )
2096{
2097 return column<I>( derestrict( c.operand() ), unchecked );
2098}
2100//*************************************************************************************************
2101
2102
2103//*************************************************************************************************
2118template< typename MT // Type of the matrix
2119 , bool SO // Storage order
2120 , bool DF // Density flag
2121 , bool SF > // Symmetry flag
2122inline decltype(auto) derestrict( Column<MT,SO,DF,SF>& c )
2123{
2124 return column( derestrict( c.operand() ), c.column(), unchecked );
2125}
2127//*************************************************************************************************
2128
2129
2130//*************************************************************************************************
2145template< typename MT // Type of the matrix
2146 , bool SO // Storage order
2147 , bool DF // Density flag
2148 , bool SF > // Symmetry flag
2149inline decltype(auto) derestrict( Column<MT,SO,DF,SF>&& c )
2150{
2151 return column( derestrict( c.operand() ), c.column(), unchecked );
2152}
2154//*************************************************************************************************
2155
2156
2157//*************************************************************************************************
2170template< typename MT // Type of the matrix
2171 , bool SO // Storage order
2172 , bool DF // Density flag
2173 , bool SF // Symmetry flag
2174 , size_t... CCAs > // Compile time column arguments
2175inline decltype(auto) unview( Column<MT,SO,DF,SF,CCAs...>& c )
2176{
2177 return c.operand();
2178}
2180//*************************************************************************************************
2181
2182
2183//*************************************************************************************************
2196template< typename MT // Type of the matrix
2197 , bool SO // Storage order
2198 , bool DF // Density flag
2199 , bool SF // Symmetry flag
2200 , size_t... CCAs > // Compile time column arguments
2201inline decltype(auto) unview( const Column<MT,SO,DF,SF,CCAs...>& c )
2202{
2203 return c.operand();
2204}
2206//*************************************************************************************************
2207
2208
2209
2210
2211//=================================================================================================
2212//
2213// SIZE SPECIALIZATIONS
2214//
2215//=================================================================================================
2216
2217//*************************************************************************************************
2219template< typename MT, bool SO, bool DF, bool SF, size_t... CRAs >
2220struct Size< Column<MT,SO,DF,SF,CRAs...>, 0UL >
2221 : public Size<MT,0UL>
2222{};
2224//*************************************************************************************************
2225
2226
2227
2228
2229//=================================================================================================
2230//
2231// MAXSIZE SPECIALIZATIONS
2232//
2233//=================================================================================================
2234
2235//*************************************************************************************************
2237template< typename MT, bool SO, bool DF, bool SF, size_t... CRAs >
2238struct MaxSize< Column<MT,SO,DF,SF,CRAs...>, 0UL >
2239 : public MaxSize<MT,0UL>
2240{};
2242//*************************************************************************************************
2243
2244
2245
2246
2247//=================================================================================================
2248//
2249// ISRESTRICTED SPECIALIZATIONS
2250//
2251//=================================================================================================
2252
2253//*************************************************************************************************
2255template< typename MT, bool SO, bool DF, bool SF, size_t... CCAs >
2256struct IsRestricted< Column<MT,SO,DF,SF,CCAs...> >
2257 : public IsRestricted<MT>
2258{};
2260//*************************************************************************************************
2261
2262
2263
2264
2265//=================================================================================================
2266//
2267// HASCONSTDATAACCESS SPECIALIZATIONS
2268//
2269//=================================================================================================
2270
2271//*************************************************************************************************
2273template< typename MT, bool SO, bool SF, size_t... CCAs >
2274struct HasConstDataAccess< Column<MT,SO,true,SF,CCAs...> >
2275 : public HasConstDataAccess<MT>
2276{};
2278//*************************************************************************************************
2279
2280
2281
2282
2283//=================================================================================================
2284//
2285// HASMUTABLEDATAACCESS SPECIALIZATIONS
2286//
2287//=================================================================================================
2288
2289//*************************************************************************************************
2291template< typename MT, bool SO, bool SF, size_t... CCAs >
2292struct HasMutableDataAccess< Column<MT,SO,true,SF,CCAs...> >
2293 : public HasMutableDataAccess<MT>
2294{};
2296//*************************************************************************************************
2297
2298
2299
2300
2301//=================================================================================================
2302//
2303// ISALIGNED SPECIALIZATIONS
2304//
2305//=================================================================================================
2306
2307//*************************************************************************************************
2309template< typename MT, bool SO, bool SF, size_t... CCAs >
2310struct IsAligned< Column<MT,SO,true,SF,CCAs...> >
2311 : public BoolConstant< IsAligned_v<MT> && ( IsColumnMajorMatrix_v<MT> || IsSymmetric_v<MT> ) >
2312{};
2314//*************************************************************************************************
2315
2316
2317
2318
2319//=================================================================================================
2320//
2321// ISCONTIGOUS SPECIALIZATIONS
2322//
2323//=================================================================================================
2324
2325//*************************************************************************************************
2327template< typename MT, bool SF, size_t... CCAs >
2328struct IsContiguous< Column<MT,true,true,SF,CCAs...> >
2329 : public IsContiguous<MT>
2330{};
2332//*************************************************************************************************
2333
2334
2335
2336
2337//=================================================================================================
2338//
2339// ISPADDED SPECIALIZATIONS
2340//
2341//=================================================================================================
2342
2343//*************************************************************************************************
2345template< typename MT, bool SO, bool SF, size_t... CCAs >
2346struct IsPadded< Column<MT,SO,true,SF,CCAs...> >
2347 : BoolConstant< IsPadded_v<MT> && ( IsColumnMajorMatrix_v<MT> || IsSymmetric_v<MT> ) >
2348{};
2350//*************************************************************************************************
2351
2352
2353
2354
2355//=================================================================================================
2356//
2357// ISOPPOSEDVIEW SPECIALIZATIONS
2358//
2359//=================================================================================================
2360
2361//*************************************************************************************************
2363template< typename MT, bool DF, size_t... CCAs >
2364struct IsOpposedView< Column<MT,false,DF,false,CCAs...> >
2365 : public TrueType
2366{};
2368//*************************************************************************************************
2369
2370} // namespace blaze
2371
2372#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 implementation of the ColumnData class template.
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 IsColumnMajorMatrix 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 IsSymmetric type trait.
Header file for the MaxSize type trait.
Header file for the relaxation flag enumeration.
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) column(Matrix< MT, SO > &&matrix, size_t index, RCAs... args)
Creating a view on a specific column of the given temporary matrix.
Definition: Column.h:340
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 columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:660
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
#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 Column base template.
Column specialization for dense matrices.
Column specialization for sparse matrices.