Blaze  3.6
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 
44 #include <blaze/math/Exception.h>
72 #include <blaze/math/views/Check.h>
77 #include <blaze/util/Assert.h>
78 #include <blaze/util/EnableIf.h>
81 #include <blaze/util/MaybeUnused.h>
82 #include <blaze/util/TypeList.h>
83 #include <blaze/util/Types.h>
84 
85 
86 namespace blaze {
87 
88 //=================================================================================================
89 //
90 // GLOBAL FUNCTIONS
91 //
92 //=================================================================================================
93 
94 //*************************************************************************************************
129 template< size_t I // Row index
130  , typename MT // Type of the matrix
131  , bool SO // Storage order
132  , typename... RRAs > // Optional row arguments
133 inline decltype(auto) row( Matrix<MT,SO>& matrix, RRAs... args )
134 {
136 
137  using ReturnType = Row_<MT,I>;
138  return ReturnType( ~matrix, args... );
139 }
140 //*************************************************************************************************
141 
142 
143 //*************************************************************************************************
178 template< size_t I // Row index
179  , typename MT // Type of the matrix
180  , bool SO // Storage order
181  , typename... RRAs > // Optional row arguments
182 inline decltype(auto) row( const Matrix<MT,SO>& matrix, RRAs... args )
183 {
185 
186  using ReturnType = const Row_<const MT,I>;
187  return ReturnType( ~matrix, args... );
188 }
189 //*************************************************************************************************
190 
191 
192 //*************************************************************************************************
206 template< size_t I // Row index
207  , typename MT // Type of the matrix
208  , bool SO // Storage order
209  , typename... RRAs > // Optional row arguments
210 inline decltype(auto) row( Matrix<MT,SO>&& matrix, RRAs... args )
211 {
213 
214  using ReturnType = Row_<MT,I>;
215  return ReturnType( ~matrix, args... );
216 }
217 //*************************************************************************************************
218 
219 
220 //*************************************************************************************************
256 template< typename MT // Type of the matrix
257  , bool SO // Storage order
258  , typename... RRAs > // Optional row arguments
259 inline decltype(auto) row( Matrix<MT,SO>& matrix, size_t index, RRAs... args )
260 {
262 
263  using ReturnType = Row_<MT>;
264  return ReturnType( ~matrix, index, args... );
265 }
266 //*************************************************************************************************
267 
268 
269 //*************************************************************************************************
305 template< typename MT // Type of the matrix
306  , bool SO // Storage order
307  , typename... RRAs > // Optional row arguments
308 inline decltype(auto) row( const Matrix<MT,SO>& matrix, size_t index, RRAs... args )
309 {
311 
312  using ReturnType = const Row_<const MT>;
313  return ReturnType( ~matrix, index, args... );
314 }
315 //*************************************************************************************************
316 
317 
318 //*************************************************************************************************
333 template< typename MT // Type of the matrix
334  , bool SO // Storage order
335  , typename... RRAs > // Optional row arguments
336 inline decltype(auto) row( Matrix<MT,SO>&& matrix, size_t index, RRAs... args )
337 {
339 
340  using ReturnType = Row_<MT>;
341  return ReturnType( ~matrix, index, args... );
342 }
343 //*************************************************************************************************
344 
345 
346 
347 
348 //=================================================================================================
349 //
350 // GLOBAL RESTRUCTURING FUNCTIONS
351 //
352 //=================================================================================================
353 
354 //*************************************************************************************************
366 template< size_t... CRAs // Compile time row arguments
367  , typename MT // Matrix base type of the expression
368  , typename... RRAs > // Runtime row arguments
369 inline decltype(auto) row( const MatMatAddExpr<MT>& matrix, RRAs... args )
370 {
372 
373  return row<CRAs...>( (~matrix).leftOperand(), args... ) +
374  row<CRAs...>( (~matrix).rightOperand(), args... );
375 }
377 //*************************************************************************************************
378 
379 
380 //*************************************************************************************************
392 template< size_t... CRAs // Compile time row arguments
393  , typename MT // Matrix base type of the expression
394  , typename... RRAs > // Runtime row arguments
395 inline decltype(auto) row( const MatMatSubExpr<MT>& matrix, RRAs... args )
396 {
398 
399  return row<CRAs...>( (~matrix).leftOperand(), args... ) -
400  row<CRAs...>( (~matrix).rightOperand(), args... );
401 }
403 //*************************************************************************************************
404 
405 
406 //*************************************************************************************************
417 template< size_t... CRAs // Compile time row arguments
418  , typename MT // Matrix base type of the expression
419  , typename... RRAs > // Runtime row arguments
420 inline decltype(auto) row( const SchurExpr<MT>& matrix, RRAs... args )
421 {
423 
424  return row<CRAs...>( (~matrix).leftOperand(), args... ) *
425  row<CRAs...>( (~matrix).rightOperand(), args... );
426 }
428 //*************************************************************************************************
429 
430 
431 //*************************************************************************************************
443 template< size_t... CRAs // Compile time row arguments
444  , typename MT // Matrix base type of the expression
445  , typename... RRAs > // Runtime row arguments
446 inline decltype(auto) row( const MatMatMultExpr<MT>& matrix, RRAs... args )
447 {
449 
450  return row<CRAs...>( (~matrix).leftOperand(), args... ) * (~matrix).rightOperand();
451 }
453 //*************************************************************************************************
454 
455 
456 //*************************************************************************************************
468 template< size_t... CRAs // Compile time row arguments
469  , typename MT // Matrix base type of the expression
470  , typename... RRAs > // Runtime row arguments
471 inline decltype(auto) row( const MatMatKronExpr<MT>& matrix, RRAs... args )
472 {
474 
475  MAYBE_UNUSED( args... );
476 
477  const RowData<CRAs...> rd( args... );
478 
479  if( !Contains_v< TypeList<RRAs...>, Unchecked > ) {
480  if( (~matrix).rows() <= rd.row() ) {
481  BLAZE_THROW_INVALID_ARGUMENT( "Invalid row access index" );
482  }
483  }
484 
485  const size_t rows( (~matrix).rightOperand().rows() );
486 
487  return kron( row( (~matrix).leftOperand(), rd.row()/rows ),
488  row( (~matrix).rightOperand(), rd.row()%rows ) );
489 }
491 //*************************************************************************************************
492 
493 
494 //*************************************************************************************************
506 template< size_t I // Row index
507  , typename MT // Matrix base type of the expression
508  , typename... RRAs > // Optional row arguments
509 inline decltype(auto) row( const VecTVecMultExpr<MT>& matrix, RRAs... args )
510 {
512 
513  MAYBE_UNUSED( args... );
514 
515  if( !Contains_v< TypeList<RRAs...>, Unchecked > ) {
516  if( (~matrix).rows() <= I ) {
517  BLAZE_THROW_INVALID_ARGUMENT( "Invalid row access index" );
518  }
519  }
520 
521  return (~matrix).leftOperand()[I] * (~matrix).rightOperand();
522 }
524 //*************************************************************************************************
525 
526 
527 //*************************************************************************************************
540 template< typename MT // Matrix base type of the expression
541  , typename... RRAs > // Optional row arguments
542 inline decltype(auto) row( const VecTVecMultExpr<MT>& matrix, size_t index, RRAs... args )
543 {
545 
546  MAYBE_UNUSED( args... );
547 
548  if( !Contains_v< TypeList<RRAs...>, Unchecked > ) {
549  if( (~matrix).rows() <= index ) {
550  BLAZE_THROW_INVALID_ARGUMENT( "Invalid row access index" );
551  }
552  }
553 
554  return (~matrix).leftOperand()[index] * (~matrix).rightOperand();
555 }
557 //*************************************************************************************************
558 
559 
560 //*************************************************************************************************
572 template< size_t... CRAs // Compile time row arguments
573  , typename MT // Matrix base type of the expression
574  , typename... RRAs > // Runtime row arguments
575 inline decltype(auto) row( const MatScalarMultExpr<MT>& matrix, RRAs... args )
576 {
578 
579  return row<CRAs...>( (~matrix).leftOperand(), args... ) * (~matrix).rightOperand();
580 }
582 //*************************************************************************************************
583 
584 
585 //*************************************************************************************************
597 template< size_t... CRAs // Compile time row arguments
598  , typename MT // Matrix base type of the expression
599  , typename... RRAs > // Runtime row arguments
600 inline decltype(auto) row( const MatScalarDivExpr<MT>& matrix, RRAs... args )
601 {
603 
604  return row<CRAs...>( (~matrix).leftOperand(), args... ) / (~matrix).rightOperand();
605 }
607 //*************************************************************************************************
608 
609 
610 //*************************************************************************************************
622 template< size_t... CRAs // Compile time row arguments
623  , typename MT // Matrix base type of the expression
624  , typename... RRAs > // Runtime row arguments
625 inline decltype(auto) row( const MatMapExpr<MT>& matrix, RRAs... args )
626 {
628 
629  return map( row<CRAs...>( (~matrix).operand(), args... ), (~matrix).operation() );
630 }
632 //*************************************************************************************************
633 
634 
635 //*************************************************************************************************
647 template< size_t... CRAs // Compile time row arguments
648  , typename MT // Matrix base type of the expression
649  , typename... RRAs > // Runtime row arguments
650 inline decltype(auto) row( const MatMatMapExpr<MT>& matrix, RRAs... args )
651 {
653 
654  return map( row<CRAs...>( (~matrix).leftOperand(), args... ),
655  row<CRAs...>( (~matrix).rightOperand(), args... ),
656  (~matrix).operation() );
657 }
659 //*************************************************************************************************
660 
661 
662 //*************************************************************************************************
674 template< size_t... CRAs // Compile time row arguments
675  , typename MT // Matrix base type of the expression
676  , typename... RRAs > // Runtime row arguments
677 inline decltype(auto) row( const MatEvalExpr<MT>& matrix, RRAs... args )
678 {
680 
681  return eval( row<CRAs...>( (~matrix).operand(), args... ) );
682 }
684 //*************************************************************************************************
685 
686 
687 //*************************************************************************************************
699 template< size_t... CRAs // Compile time row arguments
700  , typename MT // Matrix base type of the expression
701  , typename... RRAs > // Runtime row arguments
702 inline decltype(auto) row( const MatSerialExpr<MT>& matrix, RRAs... args )
703 {
705 
706  return serial( row<CRAs...>( (~matrix).operand(), args... ) );
707 }
709 //*************************************************************************************************
710 
711 
712 //*************************************************************************************************
724 template< size_t... CRAs // Compile time row arguments
725  , typename MT // Matrix base type of the expression
726  , typename... RRAs > // Runtime row arguments
727 inline decltype(auto) row( const DeclExpr<MT>& matrix, RRAs... args )
728 {
730 
731  return row<CRAs...>( (~matrix).operand(), args... );
732 }
734 //*************************************************************************************************
735 
736 
737 //*************************************************************************************************
749 template< size_t... CRAs // Compile time row arguments
750  , typename MT // Matrix base type of the expression
751  , typename... RRAs > // Runtime row arguments
752 inline decltype(auto) row( const MatTransExpr<MT>& matrix, RRAs... args )
753 {
755 
756  return trans( column<CRAs...>( (~matrix).operand(), args... ) );
757 }
759 //*************************************************************************************************
760 
761 
762 //*************************************************************************************************
774 template< size_t... CRAs // Compile time row arguments
775  , typename MT // Matrix base type of the expression
776  , size_t... CEAs // Compile time expansion arguments
777  , typename... RRAs // Runtime row arguments
778  , EnableIf_t< IsRowMajorMatrix_v<MT> >* = nullptr >
779 inline decltype(auto) row( const VecExpandExpr<MT,CEAs...>& matrix, RRAs... args )
780 {
782 
783  MAYBE_UNUSED( args... );
784 
785  return subvector( (~matrix).operand(), 0UL, (~matrix).columns() );
786 }
788 //*************************************************************************************************
789 
790 
791 //*************************************************************************************************
803 template< size_t... CRAs // Compile time row arguments
804  , typename MT // Matrix base type of the expression
805  , size_t... CEAs // Compile time expansion arguments
806  , typename... RRAs // Runtime row arguments
807  , EnableIf_t< !IsRowMajorMatrix_v<MT> >* = nullptr >
808 inline decltype(auto) row( const VecExpandExpr<MT,CEAs...>& matrix, RRAs... args )
809 {
811 
812  using ET = ElementType_t< MatrixType_t<MT> >;
813 
814  const RowData<CRAs...> rd( args... );
815 
816  return UniformVector<ET,rowVector>( (~matrix).columns(), (~matrix).operand()[rd.row()] );
817 }
819 //*************************************************************************************************
820 
821 
822 
823 
824 //=================================================================================================
825 //
826 // ROW OPERATORS
827 //
828 //=================================================================================================
829 
830 //*************************************************************************************************
838 template< typename MT // Type of the matrix
839  , bool SO // Storage order
840  , bool DF // Density flag
841  , bool SF // Symmetry flag
842  , size_t... CRAs > // Compile time row arguments
843 inline void reset( Row<MT,SO,DF,SF,CRAs...>& row )
844 {
845  row.reset();
846 }
848 //*************************************************************************************************
849 
850 
851 //*************************************************************************************************
859 template< typename MT // Type of the matrix
860  , bool SO // Storage order
861  , bool DF // Density flag
862  , bool SF // Symmetry flag
863  , size_t... CRAs > // Compile time row arguments
864 inline void reset( Row<MT,SO,DF,SF,CRAs...>&& row )
865 {
866  row.reset();
867 }
869 //*************************************************************************************************
870 
871 
872 //*************************************************************************************************
882 template< typename MT // Type of the matrix
883  , bool SO // Storage order
884  , bool DF // Density flag
885  , bool SF // Symmetry flag
886  , size_t... CRAs > // Compile time row arguments
887 inline void clear( Row<MT,SO,DF,SF,CRAs...>& row )
888 {
889  row.reset();
890 }
892 //*************************************************************************************************
893 
894 
895 //*************************************************************************************************
905 template< typename MT // Type of the matrix
906  , bool SO // Storage order
907  , bool DF // Density flag
908  , bool SF // Symmetry flag
909  , size_t... CRAs > // Compile time row arguments
910 inline void clear( Row<MT,SO,DF,SF,CRAs...>&& row )
911 {
912  row.reset();
913 }
915 //*************************************************************************************************
916 
917 
918 //*************************************************************************************************
944 template< bool RF // Relaxation flag
945  , typename MT // Type of the matrix
946  , bool SO // Storage order
947  , bool SF // Symmetry flag
948  , size_t... CRAs > // Compile time row arguments
949 inline bool isDefault( const Row<MT,SO,true,SF,CRAs...>& row )
950 {
951  using blaze::isDefault;
952 
953  for( size_t i=0UL; i<row.size(); ++i )
954  if( !isDefault<RF>( row[i] ) ) return false;
955  return true;
956 }
958 //*************************************************************************************************
959 
960 
961 //*************************************************************************************************
987 template< bool RF // Relaxation flag
988  , typename MT // Type of the matrix
989  , bool SO // Storage order
990  , bool SF // Symmetry flag
991  , size_t... CRAs > // Compile time row arguments
992 inline bool isDefault( const Row<MT,SO,false,SF,CRAs...>& row )
993 {
994  using blaze::isDefault;
995 
996  for( const auto& element : row )
997  if( !isDefault<RF>( element.value() ) ) return false;
998  return true;
999 }
1001 //*************************************************************************************************
1002 
1003 
1004 //*************************************************************************************************
1022 template< typename MT // Type of the matrix
1023  , bool SO // Storage order
1024  , bool DF // Density flag
1025  , bool SF // Symmetry flag
1026  , size_t... CRAs > // Compile time row arguments
1027 inline bool isIntact( const Row<MT,SO,DF,SF,CRAs...>& row ) noexcept
1028 {
1029  return ( row.row() < row.operand().rows() &&
1030  isIntact( row.operand() ) );
1031 }
1033 //*************************************************************************************************
1034 
1035 
1036 //*************************************************************************************************
1049 template< typename MT1 // Type of the matrix of the left-hand side row
1050  , bool SO // Storage order
1051  , bool DF // Density flag
1052  , bool SF1 // Symmetry flag of the left-hand side row
1053  , size_t... CRAs1 // Compile time row arguments of the left-hand side row
1054  , typename MT2 // Type of the matrix of the right-hand side row
1055  , bool SF2 // Symmetry flag of the right-hand side row
1056  , size_t... CRAs2 > // Compile time row arguments of the right-hand side row
1057 inline bool isSame( const Row<MT1,SO,DF,SF1,CRAs1...>& a,
1058  const Row<MT2,SO,DF,SF2,CRAs2...>& b ) noexcept
1059 {
1060  return ( isSame( a.operand(), b.operand() ) && ( a.row() == b.row() ) );
1061 }
1063 //*************************************************************************************************
1064 
1065 
1066 //*************************************************************************************************
1081 template< typename MT // Type of the matrix
1082  , bool SO // Storage order
1083  , bool DF // Density flag
1084  , bool SF // Symmetry flag
1085  , size_t... CRAs // Compile time row arguments
1086  , typename ET > // Type of the element
1087 inline bool trySet( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1088 {
1089  BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1090 
1091  return trySet( row.operand(), row.row(), index, value );
1092 }
1094 //*************************************************************************************************
1095 
1096 
1097 //*************************************************************************************************
1113 template< typename MT // Type of the matrix
1114  , bool SO // Storage order
1115  , bool DF // Density flag
1116  , bool SF // Symmetry flag
1117  , size_t... CRAs // Compile time row arguments
1118  , typename ET > // Type of the element
1120  trySet( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1121 {
1122  BLAZE_INTERNAL_ASSERT( index <= (~row).size(), "Invalid vector access index" );
1123  BLAZE_INTERNAL_ASSERT( index + size <= (~row).size(), "Invalid range size" );
1124 
1125  return trySet( row.operand(), row.row(), index, 1UL, size, value );
1126 }
1128 //*************************************************************************************************
1129 
1130 
1131 //*************************************************************************************************
1146 template< typename MT // Type of the matrix
1147  , bool SO // Storage order
1148  , bool DF // Density flag
1149  , bool SF // Symmetry flag
1150  , size_t... CRAs // Compile time row arguments
1151  , typename ET > // Type of the element
1152 inline bool tryAdd( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1153 {
1154  BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1155 
1156  return tryAdd( row.operand(), row.row(), index, value );
1157 }
1159 //*************************************************************************************************
1160 
1161 
1162 //*************************************************************************************************
1178 template< 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
1185  tryAdd( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1186 {
1187  BLAZE_INTERNAL_ASSERT( index <= (~row).size(), "Invalid vector access index" );
1188  BLAZE_INTERNAL_ASSERT( index + size <= (~row).size(), "Invalid range size" );
1189 
1190  return tryAdd( row.operand(), row.row(), index, 1UL, size, value );
1191 }
1193 //*************************************************************************************************
1194 
1195 
1196 //*************************************************************************************************
1211 template< typename MT // Type of the matrix
1212  , bool SO // Storage order
1213  , bool DF // Density flag
1214  , bool SF // Symmetry flag
1215  , size_t... CRAs // Compile time row arguments
1216  , typename ET > // Type of the element
1217 inline bool trySub( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1218 {
1219  BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1220 
1221  return trySub( row.operand(), row.row(), index, value );
1222 }
1224 //*************************************************************************************************
1225 
1226 
1227 //*************************************************************************************************
1243 template< 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
1250  trySub( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1251 {
1252  BLAZE_INTERNAL_ASSERT( index <= (~row).size(), "Invalid vector access index" );
1253  BLAZE_INTERNAL_ASSERT( index + size <= (~row).size(), "Invalid range size" );
1254 
1255  return trySub( row.operand(), row.row(), index, 1UL, size, value );
1256 }
1258 //*************************************************************************************************
1259 
1260 
1261 //*************************************************************************************************
1276 template< typename MT // Type of the matrix
1277  , bool SO // Storage order
1278  , bool DF // Density flag
1279  , bool SF // Symmetry flag
1280  , size_t... CRAs // Compile time row arguments
1281  , typename ET > // Type of the element
1282 inline bool tryMult( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1283 {
1284  BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1285 
1286  return tryMult( row.operand(), row.row(), index, value );
1287 }
1289 //*************************************************************************************************
1290 
1291 
1292 //*************************************************************************************************
1308 template< 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
1315  tryMult( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1316 {
1317  BLAZE_INTERNAL_ASSERT( index <= (~row).size(), "Invalid vector access index" );
1318  BLAZE_INTERNAL_ASSERT( index + size <= (~row).size(), "Invalid range size" );
1319 
1320  return tryMult( row.operand(), row.row(), index, 1UL, size, value );
1321 }
1323 //*************************************************************************************************
1324 
1325 
1326 //*************************************************************************************************
1341 template< typename MT // Type of the matrix
1342  , bool SO // Storage order
1343  , bool DF // Density flag
1344  , bool SF // Symmetry flag
1345  , size_t... CRAs // Compile time row arguments
1346  , typename ET > // Type of the element
1347 inline bool tryDiv( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1348 {
1349  BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1350 
1351  return tryDiv( row.operand(), row.row(), index, value );
1352 }
1354 //*************************************************************************************************
1355 
1356 
1357 //*************************************************************************************************
1373 template< 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
1380  tryDiv( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1381 {
1382  BLAZE_INTERNAL_ASSERT( index <= (~row).size(), "Invalid vector access index" );
1383  BLAZE_INTERNAL_ASSERT( index + size <= (~row).size(), "Invalid range size" );
1384 
1385  return tryDiv( row.operand(), row.row(), index, 1UL, size, value );
1386 }
1388 //*************************************************************************************************
1389 
1390 
1391 //*************************************************************************************************
1406 template< typename MT // Type of the matrix
1407  , bool SO // Storage order
1408  , bool DF // Density flag
1409  , bool SF // Symmetry flag
1410  , size_t... CRAs > // Compile time row arguments
1411 inline bool tryShift( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, int count )
1412 {
1413  BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1414 
1415  return tryShift( row.operand(), row.row(), index, count );
1416 }
1418 //*************************************************************************************************
1419 
1420 
1421 //*************************************************************************************************
1437 template< typename MT // Type of the matrix
1438  , bool SO // Storage order
1439  , bool DF // Density flag
1440  , bool SF // Symmetry flag
1441  , size_t... CRAs > // Compile time row arguments
1443  tryShift( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, int count )
1444 {
1445  BLAZE_INTERNAL_ASSERT( index <= (~row).size(), "Invalid vector access index" );
1446  BLAZE_INTERNAL_ASSERT( index + size <= (~row).size(), "Invalid range size" );
1447 
1448  return tryShift( row.operand(), row.row(), index, 1UL, size, count );
1449 }
1451 //*************************************************************************************************
1452 
1453 
1454 //*************************************************************************************************
1469 template< typename MT // Type of the matrix
1470  , bool SO // Storage order
1471  , bool DF // Density flag
1472  , bool SF // Symmetry flag
1473  , size_t... CRAs // Compile time row arguments
1474  , typename ET > // Type of the element
1475 inline bool tryBitand( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1476 {
1477  BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1478 
1479  return tryBitand( row.operand(), row.row(), index, value );
1480 }
1482 //*************************************************************************************************
1483 
1484 
1485 //*************************************************************************************************
1501 template< typename MT // Type of the matrix
1502  , bool SO // Storage order
1503  , bool DF // Density flag
1504  , bool SF // Symmetry flag
1505  , size_t... CRAs // Compile time row arguments
1506  , typename ET > // Type of the element
1508  tryBitand( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1509 {
1510  BLAZE_INTERNAL_ASSERT( index <= (~row).size(), "Invalid vector access index" );
1511  BLAZE_INTERNAL_ASSERT( index + size <= (~row).size(), "Invalid range size" );
1512 
1513  return tryBitand( row.operand(), row.row(), index, 1UL, size, value );
1514 }
1516 //*************************************************************************************************
1517 
1518 
1519 //*************************************************************************************************
1534 template< 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
1539  , typename ET > // Type of the element
1540 inline bool tryBitor( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1541 {
1542  BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1543 
1544  return tryBitor( row.operand(), row.row(), index, value );
1545 }
1547 //*************************************************************************************************
1548 
1549 
1550 //*************************************************************************************************
1566 template< 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
1573  tryBitor( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1574 {
1575  BLAZE_INTERNAL_ASSERT( index <= (~row).size(), "Invalid vector access index" );
1576  BLAZE_INTERNAL_ASSERT( index + size <= (~row).size(), "Invalid range size" );
1577 
1578  return tryBitor( row.operand(), row.row(), index, 1UL, size, value );
1579 }
1581 //*************************************************************************************************
1582 
1583 
1584 //*************************************************************************************************
1599 template< typename MT // Type of the matrix
1600  , bool SO // Storage order
1601  , bool DF // Density flag
1602  , bool SF // Symmetry flag
1603  , size_t... CRAs // Compile time row arguments
1604  , typename ET > // Type of the element
1605 inline bool tryBitxor( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, const ET& value )
1606 {
1607  BLAZE_INTERNAL_ASSERT( index < row.size(), "Invalid vector access index" );
1608 
1609  return tryBitxor( row.operand(), row.row(), index, value );
1610 }
1612 //*************************************************************************************************
1613 
1614 
1615 //*************************************************************************************************
1631 template< 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
1638  tryBitxor( const Row<MT,SO,DF,SF,CRAs...>& row, size_t index, size_t size, const ET& value )
1639 {
1640  BLAZE_INTERNAL_ASSERT( index <= (~row).size(), "Invalid vector access index" );
1641  BLAZE_INTERNAL_ASSERT( index + size <= (~row).size(), "Invalid range size" );
1642 
1643  return tryBitxor( row.operand(), row.row(), index, 1UL, size, value );
1644 }
1646 //*************************************************************************************************
1647 
1648 
1649 //*************************************************************************************************
1664 template< typename MT // Type of the matrix
1665  , bool SO // Storage order
1666  , bool DF // Density flag
1667  , bool SF // Symmetry flag
1668  , size_t... CRAs // Compile time row arguments
1669  , typename VT > // Type of the right-hand side vector
1670 inline bool tryAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1671  const Vector<VT,true>& rhs, size_t index )
1672 {
1673  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1674  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= lhs.size(), "Invalid vector size" );
1675 
1676  return tryAssign( lhs.operand(), ~rhs, lhs.row(), index );
1677 }
1679 //*************************************************************************************************
1680 
1681 
1682 //*************************************************************************************************
1697 template< typename MT // Type of the matrix
1698  , bool SO // Storage order
1699  , bool DF // Density flag
1700  , bool SF // Symmetry flag
1701  , size_t... CRAs // Compile time row arguments
1702  , typename VT > // Type of the right-hand side vector
1703 inline bool tryAddAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1704  const Vector<VT,true>& rhs, size_t index )
1705 {
1706  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1707  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= lhs.size(), "Invalid vector size" );
1708 
1709  return tryAddAssign( lhs.operand(), ~rhs, lhs.row(), index );
1710 }
1712 //*************************************************************************************************
1713 
1714 
1715 //*************************************************************************************************
1730 template< typename MT // Type of the matrix
1731  , bool SO // Storage order
1732  , bool DF // Density flag
1733  , bool SF // Symmetry flag
1734  , size_t... CRAs // Compile time row arguments
1735  , typename VT > // Type of the right-hand side vector
1736 inline bool trySubAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1737  const Vector<VT,true>& rhs, size_t index )
1738 {
1739  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1740  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= lhs.size(), "Invalid vector size" );
1741 
1742  return trySubAssign( lhs.operand(), ~rhs, lhs.row(), index );
1743 }
1745 //*************************************************************************************************
1746 
1747 
1748 //*************************************************************************************************
1763 template< typename MT // Type of the matrix
1764  , bool SO // Storage order
1765  , bool DF // Density flag
1766  , bool SF // Symmetry flag
1767  , size_t... CRAs // Compile time row arguments
1768  , typename VT > // Type of the right-hand side vector
1769 inline bool tryMultAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1770  const Vector<VT,true>& rhs, size_t index )
1771 {
1772  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1773  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= lhs.size(), "Invalid vector size" );
1774 
1775  return tryMultAssign( lhs.operand(), ~rhs, lhs.row(), index );
1776 }
1778 //*************************************************************************************************
1779 
1780 
1781 //*************************************************************************************************
1796 template< typename MT // Type of the matrix
1797  , bool SO // Storage order
1798  , bool DF // Density flag
1799  , bool SF // Symmetry flag
1800  , size_t... CRAs // Compile time row arguments
1801  , typename VT > // Type of the right-hand side vector
1802 inline bool tryDivAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1803  const Vector<VT,true>& rhs, size_t index )
1804 {
1805  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1806  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= lhs.size(), "Invalid vector size" );
1807 
1808  return tryDivAssign( lhs.operand(), ~rhs, lhs.row(), index );
1809 }
1811 //*************************************************************************************************
1812 
1813 
1814 //*************************************************************************************************
1829 template< typename MT // Type of the matrix
1830  , bool SO // Storage order
1831  , bool DF // Density flag
1832  , bool SF // Symmetry flag
1833  , size_t... CRAs // Compile time row arguments
1834  , typename VT > // Type of the right-hand side vector
1835 inline bool tryShiftAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1836  const Vector<VT,true>& rhs, size_t index )
1837 {
1838  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1839  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= lhs.size(), "Invalid vector size" );
1840 
1841  return tryShiftAssign( lhs.operand(), ~rhs, lhs.row(), index );
1842 }
1844 //*************************************************************************************************
1845 
1846 
1847 //*************************************************************************************************
1862 template< typename MT // Type of the matrix
1863  , bool SO // Storage order
1864  , bool DF // Density flag
1865  , bool SF // Symmetry flag
1866  , size_t... CRAs // Compile time row arguments
1867  , typename VT > // Type of the right-hand side vector
1868 inline bool tryBitandAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1869  const Vector<VT,true>& rhs, size_t index )
1870 {
1871  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1872  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= lhs.size(), "Invalid vector size" );
1873 
1874  return tryBitandAssign( lhs.operand(), ~rhs, lhs.row(), index );
1875 }
1877 //*************************************************************************************************
1878 
1879 
1880 //*************************************************************************************************
1895 template< typename MT // Type of the matrix
1896  , bool SO // Storage order
1897  , bool DF // Density flag
1898  , bool SF // Symmetry flag
1899  , size_t... CRAs // Compile time row arguments
1900  , typename VT > // Type of the right-hand side vector
1901 inline bool tryBitorAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1902  const Vector<VT,true>& rhs, size_t index )
1903 {
1904  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1905  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= lhs.size(), "Invalid vector size" );
1906 
1907  return tryBitorAssign( lhs.operand(), ~rhs, lhs.row(), index );
1908 }
1910 //*************************************************************************************************
1911 
1912 
1913 //*************************************************************************************************
1928 template< typename MT // Type of the matrix
1929  , bool SO // Storage order
1930  , bool DF // Density flag
1931  , bool SF // Symmetry flag
1932  , size_t... CRAs // Compile time row arguments
1933  , typename VT > // Type of the right-hand side vector
1934 inline bool tryBitxorAssign( const Row<MT,SO,DF,SF,CRAs...>& lhs,
1935  const Vector<VT,true>& rhs, size_t index )
1936 {
1937  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
1938  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= lhs.size(), "Invalid vector size" );
1939 
1940  return tryBitxorAssign( lhs.operand(), ~rhs, lhs.row(), index );
1941 }
1943 //*************************************************************************************************
1944 
1945 
1946 //*************************************************************************************************
1961 template< typename MT // Type of the matrix
1962  , bool SO // Storage order
1963  , bool DF // Density flag
1964  , bool SF // Symmetry flag
1965  , size_t I > // Row index
1966 inline decltype(auto) derestrict( Row<MT,SO,DF,SF,I>& r )
1967 {
1968  return row<I>( derestrict( r.operand() ), unchecked );
1969 }
1971 //*************************************************************************************************
1972 
1973 
1974 //*************************************************************************************************
1989 template< typename MT // Type of the matrix
1990  , bool SO // Storage order
1991  , bool DF // Density flag
1992  , bool SF // Symmetry flag
1993  , size_t I > // Row index
1994 inline decltype(auto) derestrict( Row<MT,SO,DF,SF,I>&& r )
1995 {
1996  return row<I>( derestrict( r.operand() ), unchecked );
1997 }
1999 //*************************************************************************************************
2000 
2001 
2002 //*************************************************************************************************
2017 template< typename MT // Type of the matrix
2018  , bool SO // Storage order
2019  , bool DF // Density flag
2020  , bool SF > // Symmetry flag
2021 inline decltype(auto) derestrict( Row<MT,SO,DF,SF>& r )
2022 {
2023  return row( derestrict( r.operand() ), r.row(), unchecked );
2024 }
2026 //*************************************************************************************************
2027 
2028 
2029 //*************************************************************************************************
2044 template< typename MT // Type of the matrix
2045  , bool SO // Storage order
2046  , bool DF // Density flag
2047  , bool SF > // Symmetry flag
2048 inline decltype(auto) derestrict( Row<MT,SO,DF,SF>&& r )
2049 {
2050  return row( derestrict( r.operand() ), r.row(), unchecked );
2051 }
2053 //*************************************************************************************************
2054 
2055 
2056 
2057 
2058 //=================================================================================================
2059 //
2060 // SIZE SPECIALIZATIONS
2061 //
2062 //=================================================================================================
2063 
2064 //*************************************************************************************************
2066 template< typename MT, bool SO, bool DF, bool SF, size_t... CRAs >
2067 struct Size< Row<MT,SO,DF,SF,CRAs...>, 0UL >
2068  : public Size<MT,1UL>
2069 {};
2071 //*************************************************************************************************
2072 
2073 
2074 
2075 
2076 //=================================================================================================
2077 //
2078 // MAXSIZE SPECIALIZATIONS
2079 //
2080 //=================================================================================================
2081 
2082 //*************************************************************************************************
2084 template< typename MT, bool SO, bool DF, bool SF, size_t... CRAs >
2085 struct MaxSize< Row<MT,SO,DF,SF,CRAs...>, 0UL >
2086  : public MaxSize<MT,1UL>
2087 {};
2089 //*************************************************************************************************
2090 
2091 
2092 
2093 
2094 //=================================================================================================
2095 //
2096 // ISRESTRICTED SPECIALIZATIONS
2097 //
2098 //=================================================================================================
2099 
2100 //*************************************************************************************************
2102 template< typename MT, bool SO, bool DF, bool SF, size_t... CRAs >
2103 struct IsRestricted< Row<MT,SO,DF,SF,CRAs...> >
2104  : public IsRestricted<MT>
2105 {};
2107 //*************************************************************************************************
2108 
2109 
2110 
2111 
2112 //=================================================================================================
2113 //
2114 // HASCONSTDATAACCESS SPECIALIZATIONS
2115 //
2116 //=================================================================================================
2117 
2118 //*************************************************************************************************
2120 template< typename MT, bool SO, bool SF, size_t... CRAs >
2121 struct HasConstDataAccess< Row<MT,SO,true,SF,CRAs...> >
2122  : public HasConstDataAccess<MT>
2123 {};
2125 //*************************************************************************************************
2126 
2127 
2128 
2129 
2130 //=================================================================================================
2131 //
2132 // HASMUTABLEDATAACCESS SPECIALIZATIONS
2133 //
2134 //=================================================================================================
2135 
2136 //*************************************************************************************************
2138 template< typename MT, bool SO, bool SF, size_t... CRAs >
2139 struct HasMutableDataAccess< Row<MT,SO,true,SF,CRAs...> >
2140  : public HasMutableDataAccess<MT>
2141 {};
2143 //*************************************************************************************************
2144 
2145 
2146 
2147 
2148 //=================================================================================================
2149 //
2150 // ISALIGNED SPECIALIZATIONS
2151 //
2152 //=================================================================================================
2153 
2154 //*************************************************************************************************
2156 template< typename MT, bool SO, bool SF, size_t... CRAs >
2157 struct IsAligned< Row<MT,SO,true,SF,CRAs...> >
2158  : public BoolConstant< IsAligned_v<MT> && ( IsRowMajorMatrix_v<MT> || IsSymmetric_v<MT> ) >
2159 {};
2161 //*************************************************************************************************
2162 
2163 
2164 
2165 
2166 //=================================================================================================
2167 //
2168 // ISCONTIGUOUS SPECIALIZATIONS
2169 //
2170 //=================================================================================================
2171 
2172 //*************************************************************************************************
2174 template< typename MT, bool SF, size_t... CRAs >
2175 struct IsContiguous< Row<MT,true,true,SF,CRAs...> >
2176  : public IsContiguous<MT>
2177 {};
2179 //*************************************************************************************************
2180 
2181 
2182 
2183 
2184 //=================================================================================================
2185 //
2186 // ISPADDED SPECIALIZATIONS
2187 //
2188 //=================================================================================================
2189 
2190 //*************************************************************************************************
2192 template< typename MT, bool SO, bool SF, size_t... CRAs >
2193 struct IsPadded< Row<MT,SO,true,SF,CRAs...> >
2194  : public BoolConstant< IsPadded_v<MT> && ( IsRowMajorMatrix_v<MT> || IsSymmetric_v<MT> ) >
2195 {};
2197 //*************************************************************************************************
2198 
2199 
2200 
2201 
2202 //=================================================================================================
2203 //
2204 // ISOPPOSEDVIEW SPECIALIZATIONS
2205 //
2206 //=================================================================================================
2207 
2208 //*************************************************************************************************
2210 template< typename MT, bool DF, size_t... CRAs >
2211 struct IsOpposedView< Row<MT,false,DF,false,CRAs...> >
2212  : public TrueType
2213 {};
2215 //*************************************************************************************************
2216 
2217 } // namespace blaze
2218 
2219 #endif
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for the blaze::checked and blaze::unchecked instances.
Header file for the implementation of the RowData class template.
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:992
Header file for basic type definitions.
Header file for the implementation of a uniform vector.
Header file for the MatTransExpr base class.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:595
Row specialization for dense matrices.
constexpr Unchecked unchecked
Global Unchecked instance.The blaze::unchecked instance is an optional token for the creation of view...
Definition: Check.h:138
Header file for the MatEvalExpr base class.
decltype(auto) subvector(Vector< VT, TF > &, RSAs...)
Creating a view on a specific subvector of the given vector.
Definition: Subvector.h:154
Header file for the MAYBE_UNUSED function template.
Header file for the MatMatMultExpr base class.
BoolConstant< true > TrueType
Type traits base class.The TrueType class is used as base class for type traits and value traits that...
Definition: IntegralConstant.h:132
Row specialization for sparse matrices.
Header file for the MaxSize type trait.
decltype(auto) kron(const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs)
Computes the Kronecker product of two dense matrices ( ).
Definition: DMatDMatKronExpr.h:954
constexpr size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:514
Header file for the MatMatKronExpr base class.
Header file for the MatMapExpr base class.
Header file for the implementation of the Row base template.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
Header file for the MatMatSubExpr base class.
constexpr bool Contains_v
Auxiliary variable template for the Contains type trait.The Contains_v variable template provides a c...
Definition: Contains.h:138
constexpr void MAYBE_UNUSED(const Args &...)
Suppression of unused parameter warnings.
Definition: MaybeUnused.h:81
Header file for the IsAligned type trait.
Header file for the IsOpposedView type trait.
decltype(auto) eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:786
Header file for the exception macros of the math module.
Header file for the MatSerialExpr base class.
Header file for the VecTVecMultExpr base class.
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:615
Header file for the IsPadded type trait.
Header file for the HasConstDataAccess type trait.
Header file for the DeclExpr base class.
Header file for the Matrix base class.
Header file for the MatScalarMultExpr base class.
Header file for run time assertion macros.
Header file for the Unique class template.
Header file for the IsContiguous type trait.
Check< false > Unchecked
Type of the blaze::unchecked instance.blaze::Unchecked is the type of the blaze::unchecked instance,...
Definition: Check.h:96
Header file for the SchurExpr base class.
decltype(auto) row(Matrix< MT, SO > &, RRAs...)
Creating a view on a specific row of the given matrix.
Definition: Row.h:133
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
Header file for the isDefault shim.
constexpr size_t size(const Matrix< MT, SO > &matrix) noexcept
Returns the total number of elements of the matrix.
Definition: Matrix.h:530
Base class for matrices.The Matrix class is a base class for all dense and sparse matrix classes with...
Definition: Forward.h:114
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:808
Header file for the HasMutableDataAccess type trait.
Header file for the MatMatAddExpr base class.
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant alias template represents ...
Definition: IntegralConstant.h:110
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:498
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:765
Header file for the VecExpandExpr base class.
Header file for the IsRowMajorMatrix type trait.
Header file for the MatMatMapExpr base class.
Header file for the IntegralConstant class template.
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:264
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:635
Header file for the MatScalarDivExpr base class.
Header file for the Size type trait.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression,...
Definition: Assert.h:101
Header file for the function trace functionality.
decltype(auto) map(const DenseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs, OP op)
Evaluates the given binary operation on each single element of the dense matrices lhs and rhs.
Definition: DMatDMatMapExpr.h:1121