35#ifndef _BLAZE_MATH_VIEWS_ROWS_H_
36#define _BLAZE_MATH_VIEWS_ROWS_H_
159 return ReturnType( *matrix, args... );
208 using ReturnType =
const Rows_<
const MT,
index_sequence<I,Is...> >;
209 return ReturnType( *matrix, args... );
238 return ReturnType( *matrix, args... );
290 using ReturnType = Rows_<MT>;
291 return ReturnType( *matrix, indices, n, args... );
344 using ReturnType =
const Rows_<const MT>;
345 return ReturnType( *matrix, indices, n, args... );
373 using ReturnType = Rows_<MT>;
374 return ReturnType( *matrix, indices, n, args... );
424 using ReturnType = Rows_<MT,P>;
425 return ReturnType( *matrix, p, n, args... );
476 using ReturnType =
const Rows_<const MT,P>;
477 return ReturnType( *matrix, p, n, args... );
505 using ReturnType = Rows_<MT,P>;
506 return ReturnType( *matrix, p, n, args... );
557 return rows<Is...>( std::forward<MT>( matrix ), args... );
605 return rows( std::forward<MT>( matrix ), indices.begin(), indices.size(), args... );
652inline decltype(
auto)
rows( MT&& matrix,
const std::array<T,N>& indices, RRAs... args )
656 return rows( std::forward<MT>( matrix ), indices.data(), N, args... );
702inline decltype(
auto)
rows( MT&& matrix,
const std::vector<T>& indices, RRAs... args )
706 return rows( std::forward<MT>( matrix ), indices.data(), indices.size(), args... );
757 return rows( std::forward<MT>( matrix ), indices.
data(), indices.
size(), args... );
782inline decltype(
auto)
rows( MT&& matrix,
const std::pair<T1,T2>& pair, RRAs... args )
786 return rows( std::forward<MT>( matrix ), pair.first, pair.second, args... );
813template<
size_t... CRAs
816 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
821 return rows<CRAs...>( (*matrix).leftOperand(), args... ) +
841template<
size_t... CRAs
844 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
849 return rows<CRAs...>( (*matrix).leftOperand(), args... ) -
850 rows<CRAs...>( (*matrix).rightOperand(), args... );
869template<
size_t... CRAs
872 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
873inline decltype(
auto)
rows( const
SchurExpr<MT>& matrix, RRAs... args )
877 return rows<CRAs...>( (*matrix).leftOperand(), args... ) %
897template<
size_t... CRAs
900 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
905 return rows<CRAs...>( (*matrix).leftOperand(), args... ) * (*matrix).rightOperand();
932 decltype(
auto) lhs( (*matrix).leftOperand() );
933 decltype(
auto) rhs( (*matrix).rightOperand() );
935 const size_t M( rhs.rows() );
936 const size_t N( rhs.columns() );
938 const auto lhsRows( [M](
size_t i ) {
939 constexpr size_t indices[] = { I, Is... };
940 return indices[i] / M;
943 const auto rhsRows( [M](
size_t i ) {
944 constexpr size_t indices[] = { I, Is... };
945 return indices[i] % M;
948 const auto lhsColumns( [N](
size_t i ){
return i / N; } );
949 const auto rhsColumns( [N](
size_t i ){
return i % N; } );
951 return columns(
rows( lhs, lhsRows,
sizeof...(Is)+1UL, args... ), lhsColumns, (*matrix).columns(), args... ) %
952 columns(
rows( rhs, rhsRows,
sizeof...(Is)+1UL, args... ), rhsColumns, (*matrix).columns(), args... );
980 decltype(
auto) lhs( (*matrix).leftOperand() );
981 decltype(
auto) rhs( (*matrix).rightOperand() );
983 const size_t M( rhs.rows() );
984 const size_t N( rhs.columns() );
989 for(
size_t i=0UL; i<n; ++i ) {
990 lhsRows.pushBack( indices[i] / M );
996 for(
size_t i=0UL; i<n; ++i ) {
997 rhsRows.pushBack( indices[i] % M );
1000 const auto lhsColumns( [N](
size_t i ){
return i / N; } );
1001 const auto rhsColumns( [N](
size_t i ){
return i % N; } );
1003 return columns(
rows( lhs, lhsRows, n, args... ), lhsColumns, (*matrix).columns(), args... ) %
1004 columns(
rows( rhs, rhsRows, n, args... ), rhsColumns, (*matrix).columns(), args... );
1025template<
typename MT
1027 ,
typename... RRAs >
1032 decltype(
auto) lhs( (*matrix).leftOperand() );
1033 decltype(
auto) rhs( (*matrix).rightOperand() );
1035 const size_t M( rhs.rows() );
1036 const size_t N( rhs.columns() );
1038 const auto lhsRows( [p,M](
size_t i ) {
return p(i) / M; } );
1039 const auto rhsRows( [p,M](
size_t i ) {
return p(i) % M; } );
1041 const auto lhsColumns( [N](
size_t i ){
return i / N; } );
1042 const auto rhsColumns( [N](
size_t i ){
return i % N; } );
1044 return columns(
rows( lhs, lhsRows, n, args... ), lhsColumns, (*matrix).columns(), args... ) %
1045 columns(
rows( rhs, rhsRows, n, args... ), rhsColumns, (*matrix).columns(), args... );
1064template<
size_t... CRAs
1067 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
1073 return elements<CRAs...>( (*matrix).leftOperand(), args... ) * (*matrix).rightOperand();
1096template<
size_t... CRAs
1099 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
1104 return rows<CRAs...>( (*matrix).leftOperand(), args... ) * (*matrix).rightOperand();
1123template<
size_t... CRAs
1126 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
1131 return rows<CRAs...>( (*matrix).leftOperand(), args... ) / (*matrix).rightOperand();
1150template<
size_t... CRAs
1153 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
1158 return map(
rows<CRAs...>( (*matrix).operand(), args... ), (*matrix).operation() );
1177template<
size_t... CRAs
1180 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
1187 (*matrix).operation() );
1206template<
size_t... CRAs
1209 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
1216 (*matrix).rightOperand(), (*matrix).operation() );
1239template<
size_t... CRAs
1242 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
1266template<
size_t... CRAs
1269 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
1293template<
size_t... CRAs
1296 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
1320template<
size_t... CRAs
1323 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
1347template<
size_t... CRAs
1350 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
1351inline decltype(
auto)
rows( const
DeclExpr<MT>& matrix, RRAs... args )
1355 return rows<CRAs...>( (*matrix).operand(), args... );
1374template<
size_t... CRAs
1377 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) >* =
nullptr >
1406template<
size_t... CRAs
1412inline decltype(
auto)
rows( const
VecExpandExpr<MT,CEAs...>& matrix, RRAs... args )
1417 constexpr size_t indices[] = { CRAs... };
1418 for(
size_t i=0UL; i<
sizeof...(CRAs); ++i ) {
1419 if( (*matrix).rows() <= indices[i] ) {
1420 BLAZE_THROW_INVALID_ARGUMENT(
"Invalid row access index" );
1425 return expand<
sizeof...( CRAs ) >( (*matrix).operand() );
1446template<
typename MT
1450 , EnableIf_t< IsRowMajorMatrix_v<MT> >* =
nullptr >
1451inline decltype(
auto)
rows(
const VecExpandExpr<MT,CEAs...>& matrix, T* indices,
size_t n, RRAs... args )
1456 for(
size_t i=0UL; i<n; ++i ) {
1457 if( (*matrix).rows() <=
size_t( indices[i] ) ) {
1463 return expand( (*matrix).operand(), n );
1484template<
typename MT
1488 , EnableIf_t< IsRowMajorMatrix_v<MT> >* =
nullptr >
1489inline decltype(
auto)
rows(
const VecExpandExpr<MT,CEAs...>& matrix, P p,
size_t n, RRAs... args )
1494 for(
size_t i=0UL; i<n; ++i ) {
1495 if( (*matrix).rows() <=
size_t( p(i) ) ) {
1501 return expand( (*matrix).operand(), n );
1520template<
size_t... CRAs
1524 ,
EnableIf_t< (
sizeof...( CRAs ) +
sizeof...( RRAs ) > 0UL ) &&
1525 !IsRowMajorMatrix_v<MT> >* =
nullptr >
1526inline decltype(
auto) rows( const VecExpandExpr<MT,CEAs...>& matrix, RRAs... args )
1531 return expand<CEAs...>(
elements<CRAs...>( (*matrix).operand(), args... ), (*matrix).expansion() );
1558 ,
typename... RRAs >
1559inline decltype(
auto)
rows(
const MatRepeatExpr<MT,CRAs...>& matrix, RRAs... args )
1564 constexpr size_t indices[] = { I, Is... };
1565 for(
size_t i=0UL; i<
sizeof...(Is)+1UL; ++i ) {
1566 if( (*matrix).rows() <= indices[i] ) {
1572 auto lambda = [
rows=(*matrix).operand().rows()](
size_t i ) {
1573 constexpr size_t indices[] = { I, Is... };
1574 return indices[i] %
rows;
1577 return repeat(
rows( (*matrix).operand(), std::move(lambda),
sizeof...(Is)+1UL, unchecked )
1578 , 1UL, (*matrix).template repetitions<1UL>() );
1599template<
typename MT
1602 ,
typename... RRAs >
1603inline decltype(
auto)
rows(
const MatRepeatExpr<MT,CRAs...>& matrix, T* indices,
size_t n, RRAs... args )
1608 for(
size_t i=0UL; i<n; ++i ) {
1609 if( (*matrix).rows() <=
size_t( indices[i] ) ) {
1615 SmallArray<size_t,128UL> newIndices( indices, indices+n );
1617 for(
size_t& index : newIndices ) {
1618 index = index % (*matrix).operand().rows();
1621 return repeat(
rows( (*matrix).operand(), newIndices, unchecked )
1622 , 1UL, (*matrix).template repetitions<1UL>() );
1643template<
typename MT
1646 ,
typename... RRAs >
1647inline decltype(
auto)
rows(
const MatRepeatExpr<MT,CRAs...>& matrix, P p,
size_t n, RRAs... args )
1652 for(
size_t i=0UL; i<n; ++i ) {
1653 if( (*matrix).rows() <=
size_t( p(i) ) ) {
1659 auto lambda = [
rows=(*matrix).operand().rows(),p](
size_t i ) {
1663 return repeat(
rows( (*matrix).operand(), std::move(lambda), n, unchecked )
1664 , 1UL, (*matrix).template repetitions<1UL>() );
1693 , EnableIf_t< IsRows_v< RemoveReference_t<MT> > &&
1694 RemoveReference_t<MT>::compileTimeArgs >* =
nullptr >
1695inline decltype(
auto)
rows( MT&& r, RRAs... args )
1699 return rows( r.operand(), subsequence<I,Is...>( RemoveReference_t<MT>::idces() ), args... );
1721 , EnableIf_t< IsRows_v< RemoveReference_t<MT> > &&
1722 !RemoveReference_t<MT>::compileTimeArgs >* =
nullptr >
1723inline decltype(
auto)
rows( MT&& r, RRAs... args )
1728 constexpr size_t indices[] = { I, Is... };
1729 for(
size_t i=0UL; i<
sizeof...(Is)+1UL; ++i ) {
1730 if( r.rows() <= indices[i] ) {
1736 return rows( r.operand(), { r.idx(I), r.idx(Is)... }, unchecked );
1756template<
typename MT
1759 , EnableIf_t< IsRows_v< RemoveReference_t<MT> > >* =
nullptr >
1760inline decltype(
auto)
rows( MT&& r, T* indices,
size_t n, RRAs... args )
1765 for(
size_t i=0UL; i<n; ++i ) {
1766 if( r.rows() <=
size_t( indices[i] ) ) {
1772 SmallArray<size_t,128UL> newIndices;
1773 newIndices.reserve( n );
1775 for(
size_t i=0UL; i<n; ++i ) {
1776 newIndices.pushBack( r.idx( indices[i] ) );
1779 return rows( r.operand(), newIndices.data(), newIndices.size(), unchecked );
1799template<
typename MT
1802 , EnableIf_t< IsRows_v< RemoveReference_t<MT> > && !IsPointer_v<P> >* =
nullptr >
1803inline decltype(
auto)
rows( MT&& r, P p,
size_t n, RRAs... args )
1808 for(
size_t i=0UL; i<n; ++i ) {
1809 if( r.rows() <=
size_t( p(i) ) ) {
1815 SmallArray<size_t,128UL> newIndices;
1816 newIndices.reserve( n );
1818 for(
size_t i=0UL; i<n; ++i ) {
1819 newIndices.pushBack( r.idx( p(i) ) );
1822 return rows( r.operand(), newIndices.data(), newIndices.size(), unchecked );
1849template<
size_t... CEAs
1851 ,
typename... REAs >
1852inline decltype(
auto)
elements(
const MatVecMultExpr<VT>& vector, REAs... args )
1857 return rows<CEAs...>( (*vector).leftOperand(), args... ) * (*vector).rightOperand();
1881template<
size_t... CEAs
1883 ,
typename... REAs >
1884inline decltype(
auto)
elements(
const MatReduceExpr<VT,rowwise>& vector, REAs... args )
1889 return reduce<rowwise>( rows<CEAs...>( (*vector).operand(), args... ), (*vector).operation() );
1921 , EnableIf_t< IsRows_v< RemoveReference_t<MT> > &&
1922 RemoveReference_t<MT>::compileTimeArgs >* =
nullptr >
1923inline decltype(
auto)
row( MT&& rows, RRAs... args )
1927 return row< RemoveReference_t<MT>::idx(I) >(
rows.operand(), args... );
1945template<
size_t... CRAs
1948 , EnableIf_t< IsRows_v< RemoveReference_t<MT> > &&
1949 (
sizeof...( CRAs ) == 0UL || !RemoveReference_t<MT>::compileTimeArgs ) >* =
nullptr >
1950inline decltype(
auto) row( MT&& rows, RRAs... args )
1954 const RowData<CRAs...> rd( args... );
1957 if(
rows.rows() <= rd.row() ) {
1962 return row(
rows.operand(),
rows.idx( rd.row() ), unchecked );
1988template<
size_t... CCAs
1991 , EnableIf_t< IsRows_v< RemoveReference_t<MT> > >* =
nullptr >
1992inline decltype(
auto)
column( MT&& rows, RCAs... args )
1996 return elements( column<CCAs...>(
rows.operand(), args... ),
rows.idces() );
2040 ,
typename... CRAs >
2041inline bool isDefault(
const Rows<MT,SO,true,SF,CRAs...>& rows )
2046 for(
size_t i=0UL; i<
rows.rows(); ++i )
2047 for(
size_t j=0UL; j<
rows.columns(); ++j )
2048 if( !isDefault<RF>(
rows(i,j) ) )
2052 for(
size_t j=0UL; j<
rows.columns(); ++j )
2053 for(
size_t i=0UL; i<
rows.rows(); ++i )
2054 if( !isDefault<RF>(
rows(i,j) ) )
2094 ,
typename... CRAs >
2095inline bool isDefault(
const Rows<MT,SO,false,SF,CRAs...>& rows )
2099 for(
size_t i=0UL; i<
rows.rows(); ++i ) {
2100 for(
auto element=
rows.cbegin(i); element!=
rows.cend(i); ++element )
2101 if( !isDefault<RF>( element->value() ) )
return false;
2129template<
typename MT
2133 ,
typename... CRAs >
2134inline bool isIntact(
const Rows<MT,SO,DF,SF,CRAs...>& rows )
noexcept
2136 return (
rows.rows() <=
rows.operand().rows() &&
2137 rows.columns() ==
rows.operand().columns() &&
2157template<
typename MT
2163inline bool isSame(
const Rows<MT,SO1,DF,SF,CRAs...>& a,
const Matrix<MT,SO2>& b )
noexcept
2165 if( !
isSame( a.operand(), *b ) || ( a.rows() != (*b).rows() ) || ( a.columns() != (*b).columns() ) )
2168 for(
size_t i=0UL; i<a.rows(); ++i ) {
2192template<
typename MT
2198inline bool isSame(
const Matrix<MT,SO1>& a,
const Rows<MT,SO2,DF,SF,CRAs...>& b )
noexcept
2219template<
typename MT
2227inline bool isSame(
const Rows<MT,SO1,DF,SF,CRAs...>& a,
const Submatrix<MT,AF,SO2,DF,CSAs...>& b )
noexcept
2229 if( !
isSame( a.operand(), b.operand() ) || ( a.rows() != (*b).rows() ) || ( a.columns() != (*b).columns() ) )
2232 for(
size_t i=0UL; i<a.rows(); ++i ) {
2233 if( a.idx(i) != b.row()+i )
2256template<
typename MT
2263 ,
typename... CRAs >
2264inline bool isSame(
const Submatrix<MT,AF,SO1,DF,CSAs...>& a,
const Rows<MT,SO2,DF,SF,CRAs...>& b )
noexcept
2285template<
typename MT
2290 ,
typename... CRAs2 >
2291inline bool isSame(
const Rows<MT,SO,DF,SF,CRAs1...>& a,
2292 const Rows<MT,SO,DF,SF,CRAs2...>& b )
noexcept
2294 if( !
isSame( a.operand(), b.operand() ) || a.rows() != b.rows() || a.columns() != b.columns() )
2297 for(
size_t i=0UL; i<a.rows(); ++i ) {
2298 if( a.idx(i) != b.idx(i) )
2351 ,
typename... CRAs >
2352inline auto invert( Rows<MT,SO,true,SF,CRAs...>& r )
2353 -> DisableIf_t< HasMutableDataAccess_v<MT> >
2355 using RT =
ResultType_t< Rows<MT,SO,
true,SF,CRAs...> >;
2384template<
typename MT
2390inline bool trySet(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t i,
size_t j,
const ET& value )
2395 return trySet( r.operand(), r.idx(i), j, value );
2419template<
typename MT
2426 trySet(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t row,
size_t column,
size_t m,
size_t n,
const ET& value )
2433 const size_t iend( row + m );
2435 for(
size_t i=row; i<iend; ++i ) {
2436 if( !trySet( r.operand(), r.idx(i), column, 1UL, n, value ) )
2462template<
typename MT
2468inline bool tryAdd(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t i,
size_t j,
const ET& value )
2473 return tryAdd( r.operand(), r.idx(i), j, value );
2497template<
typename MT
2504 tryAdd(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t row,
size_t column,
size_t m,
size_t n,
const ET& value )
2511 const size_t iend( row + m );
2513 for(
size_t i=row; i<iend; ++i ) {
2514 if( !tryAdd( r.operand(), r.idx(i), column, 1UL, n, value ) )
2540template<
typename MT
2546inline bool trySub(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t i,
size_t j,
const ET& value )
2551 return trySub( r.operand(), r.idx(i), j, value );
2575template<
typename MT
2582 trySub(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t row,
size_t column,
size_t m,
size_t n,
const ET& value )
2589 const size_t iend( row + m );
2591 for(
size_t i=row; i<iend; ++i ) {
2592 if( !trySub( r.operand(), r.idx(i), column, 1UL, n, value ) )
2618template<
typename MT
2624inline bool tryMult(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t i,
size_t j,
const ET& value )
2629 return tryMult( r.operand(), r.idx(i), j, value );
2653template<
typename MT
2660 tryMult(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t row,
size_t column,
size_t m,
size_t n,
const ET& value )
2667 const size_t iend( row + m );
2669 for(
size_t i=row; i<iend; ++i ) {
2670 if( !tryMult( r.operand(), r.idx(i), column, 1UL, n, value ) )
2696template<
typename MT
2702inline bool tryDiv(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t i,
size_t j,
const ET& value )
2707 return tryDiv( r.operand(), r.idx(i), j, value );
2731template<
typename MT
2738 tryDiv(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t row,
size_t column,
size_t m,
size_t n,
const ET& value )
2745 const size_t iend( row + m );
2747 for(
size_t i=row; i<iend; ++i ) {
2748 if( !tryDiv( r.operand(), r.idx(i), column, 1UL, n, value ) )
2774template<
typename MT
2778 ,
typename... CRAs >
2779inline bool tryShift(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t i,
size_t j,
int count )
2784 return tryShift( r.operand(), r.idx(i), j, count );
2808template<
typename MT
2812 ,
typename... CRAs >
2814 tryShift(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t row,
size_t column,
size_t m,
size_t n,
int count )
2821 const size_t iend( row + m );
2823 for(
size_t i=row; i<iend; ++i ) {
2824 if( !tryShift( r.operand(), r.idx(i), column, 1UL, n, count ) )
2850template<
typename MT
2856inline bool tryBitand(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t i,
size_t j,
const ET& value )
2861 return tryBitand( r.operand(), r.idx(i), j, value );
2885template<
typename MT
2892 tryBitand(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t row,
size_t column,
size_t m,
size_t n,
const ET& value )
2899 const size_t iend( row + m );
2901 for(
size_t i=row; i<iend; ++i ) {
2902 if( !tryBitand( r.operand(), r.idx(i), column, 1UL, n, value ) )
2928template<
typename MT
2934inline bool tryBitor(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t i,
size_t j,
const ET& value )
2939 return tryBitor( r.operand(), r.idx(i), j, value );
2963template<
typename MT
2970 tryBitor(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t row,
size_t column,
size_t m,
size_t n,
const ET& value )
2977 const size_t iend( row + m );
2979 for(
size_t i=row; i<iend; ++i ) {
2980 if( !tryBitor( r.operand(), r.idx(i), column, 1UL, n, value ) )
3006template<
typename MT
3012inline bool tryBitxor(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t i,
size_t j,
const ET& value )
3017 return tryBitxor( r.operand(), r.idx(i), j, value );
3041template<
typename MT
3048 tryBitxor(
const Rows<MT,SO,DF,SF,CRAs...>& r,
size_t row,
size_t column,
size_t m,
size_t n,
const ET& value )
3055 const size_t iend( row + m );
3057 for(
size_t i=row; i<iend; ++i ) {
3058 if( !tryBitxor( r.operand(), r.idx(i), column, 1UL, n, value ) )
3084template<
typename MT
3090inline bool tryAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3091 const Vector<VT,false>& rhs,
size_t row,
size_t column )
3097 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
3098 if( !trySet( lhs.operand(), lhs.idx( row+i ), column, (*rhs)[i] ) )
3124template<
typename MT
3130inline bool tryAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3131 const Vector<VT,true>& rhs,
size_t row,
size_t column )
3137 return tryAssign( lhs.operand(), *rhs, lhs.idx( row ), column );
3160template<
typename MT
3167inline bool tryAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3168 const Vector<VT,TF>& rhs,
ptrdiff_t band,
size_t row,
size_t column )
3177 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
3178 if( !trySet( lhs.operand(), lhs.idx( row+i ), column+i, (*rhs)[i] ) )
3204template<
typename MT1
3211inline bool tryAssign(
const Rows<MT1,SO1,DF,SF,CRAs...>& lhs,
3212 const Matrix<MT2,SO2>& rhs,
size_t row,
size_t column )
3219 for(
size_t i=0UL; i<(*rhs).rows(); ++i ) {
3220 if( !tryAssign( lhs.operand(),
blaze::row( *rhs, i, unchecked ), lhs.idx( row+i ), column ) )
3247template<
typename MT
3253inline bool tryAddAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3254 const Vector<VT,false>& rhs,
size_t row,
size_t column )
3260 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
3261 if( !tryAdd( lhs.operand(), lhs.idx( row+i ), column, (*rhs)[i] ) )
3287template<
typename MT
3293inline bool tryAddAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3294 const Vector<VT,true>& rhs,
size_t row,
size_t column )
3300 return tryAddAssign( lhs.operand(), *rhs, lhs.idx( row ), column );
3324template<
typename MT
3331inline bool tryAddAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3332 const Vector<VT,TF>& rhs,
ptrdiff_t band,
size_t row,
size_t column )
3341 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
3342 if( !tryAdd( lhs.operand(), lhs.idx( row+i ), column+i, (*rhs)[i] ) )
3368template<
typename MT1
3375inline bool tryAddAssign(
const Rows<MT1,SO1,DF,SF,CRAs...>& lhs,
3376 const Matrix<MT2,SO2>& rhs,
size_t row,
size_t column )
3383 for(
size_t i=0UL; i<(*rhs).rows(); ++i ) {
3384 if( !tryAddAssign( lhs.operand(),
blaze::row( *rhs, i, unchecked ), lhs.idx( row+i ), column ) )
3411template<
typename MT
3417inline bool trySubAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3418 const Vector<VT,false>& rhs,
size_t row,
size_t column )
3424 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
3425 if( !trySub( lhs.operand(), lhs.idx( row+i ), column, (*rhs)[i] ) )
3452template<
typename MT
3458inline bool trySubAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3459 const Vector<VT,true>& rhs,
size_t row,
size_t column )
3465 return trySubAssign( lhs.operand(), *rhs, lhs.idx( row ), column );
3489template<
typename MT
3496inline bool trySubAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3497 const Vector<VT,TF>& rhs,
ptrdiff_t band,
size_t row,
size_t column )
3506 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
3507 if( !trySub( lhs.operand(), lhs.idx( row+i ), column+i, (*rhs)[i] ) )
3533template<
typename MT1
3540inline bool trySubAssign(
const Rows<MT1,SO1,DF,SF,CRAs...>& lhs,
3541 const Matrix<MT2,SO2>& rhs,
size_t row,
size_t column )
3548 for(
size_t i=0UL; i<(*rhs).rows(); ++i ) {
3549 if( !trySubAssign( lhs.operand(),
blaze::row( *rhs, i, unchecked ), lhs.idx( row+i ), column ) )
3576template<
typename MT
3582inline bool tryMultAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3583 const Vector<VT,false>& rhs,
size_t row,
size_t column )
3589 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
3590 if( !tryMult( lhs.operand(), lhs.idx( row+i ), column, (*rhs)[i] ) )
3617template<
typename MT
3623inline bool tryMultAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3624 const Vector<VT,true>& rhs,
size_t row,
size_t column )
3630 return tryMultAssign( lhs.operand(), *rhs, lhs.idx( row ), column );
3654template<
typename MT
3661inline bool tryMultAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3662 const Vector<VT,TF>& rhs,
ptrdiff_t band,
size_t row,
size_t column )
3671 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
3672 if( !tryMult( lhs.operand(), lhs.idx( row+i ), column+i, (*rhs)[i] ) )
3699template<
typename MT1
3706inline bool trySchurAssign(
const Rows<MT1,SO1,DF,SF,CRAs...>& lhs,
3707 const Matrix<MT2,SO2>& rhs,
size_t row,
size_t column )
3714 for(
size_t i=0UL; i<(*rhs).rows(); ++i ) {
3715 if( !tryMultAssign( lhs.operand(),
blaze::row( *rhs, i, unchecked ), lhs.idx( row+i ), column ) )
3742template<
typename MT
3748inline bool tryDivAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3749 const Vector<VT,false>& rhs,
size_t row,
size_t column )
3755 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
3756 if( !tryDiv( lhs.operand(), lhs.idx( row+i ), column, (*rhs)[i] ) )
3782template<
typename MT
3788inline bool tryDivAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3789 const Vector<VT,true>& rhs,
size_t row,
size_t column )
3795 return tryDivAssign( lhs.operand(), *rhs, lhs.idx( row ), column );
3819template<
typename MT
3826inline bool tryDivAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3827 const Vector<VT,TF>& rhs,
ptrdiff_t band,
size_t row,
size_t column )
3836 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
3837 if( !tryDiv( lhs.operand(), lhs.idx( row+i ), column+i, (*rhs)[i] ) )
3864template<
typename MT
3870inline bool tryShiftAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3871 const Vector<VT,false>& rhs,
size_t row,
size_t column )
3877 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
3878 if( !tryShift( lhs.operand(), lhs.idx( row+i ), column, (*rhs)[i] ) )
3904template<
typename MT
3910inline bool tryShiftAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3911 const Vector<VT,true>& rhs,
size_t row,
size_t column )
3917 return tryShiftAssign( lhs.operand(), *rhs, lhs.idx( row ), column );
3941template<
typename MT
3948inline bool tryShiftAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
3949 const Vector<VT,TF>& rhs,
ptrdiff_t band,
size_t row,
size_t column )
3958 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
3959 if( !tryShift( lhs.operand(), lhs.idx( row+i ), column+i, (*rhs)[i] ) )
3985template<
typename MT1
3992inline bool tryShiftAssign(
const Rows<MT1,SO1,DF,SF,CRAs...>& lhs,
3993 const Matrix<MT2,SO2>& rhs,
size_t row,
size_t column )
4000 for(
size_t i=0UL; i<(*rhs).rows(); ++i ) {
4001 if( !tryShiftAssign( lhs.operand(),
blaze::row( *rhs, i, unchecked ), lhs.idx( row+i ), column ) )
4028template<
typename MT
4034inline bool tryBitandAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
4035 const Vector<VT,false>& rhs,
size_t row,
size_t column )
4041 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
4042 if( !tryBitand( lhs.operand(), lhs.idx( row+i ), column, (*rhs)[i] ) )
4069template<
typename MT
4075inline bool tryBitandAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
4076 const Vector<VT,true>& rhs,
size_t row,
size_t column )
4082 return tryBitandAssign( lhs.operand(), *rhs, lhs.idx( row ), column );
4106template<
typename MT
4113inline bool tryBitandAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
4114 const Vector<VT,TF>& rhs,
ptrdiff_t band,
size_t row,
size_t column )
4123 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
4124 if( !tryBitand( lhs.operand(), lhs.idx( row+i ), column+i, (*rhs)[i] ) )
4150template<
typename MT1
4157inline bool tryBitandAssign(
const Rows<MT1,SO1,DF,SF,CRAs...>& lhs,
4158 const Matrix<MT2,SO2>& rhs,
size_t row,
size_t column )
4165 for(
size_t i=0UL; i<(*rhs).rows(); ++i ) {
4166 if( !tryBitandAssign( lhs.operand(),
blaze::row( *rhs, i, unchecked ), lhs.idx( row+i ), column ) )
4193template<
typename MT
4199inline bool tryBitorAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
4200 const Vector<VT,false>& rhs,
size_t row,
size_t column )
4206 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
4207 if( !tryBitor( lhs.operand(), lhs.idx( row+i ), column, (*rhs)[i] ) )
4234template<
typename MT
4240inline bool tryBitorAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
4241 const Vector<VT,true>& rhs,
size_t row,
size_t column )
4247 return tryBitorAssign( lhs.operand(), *rhs, lhs.idx( row ), column );
4271template<
typename MT
4278inline bool tryBitorAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
4279 const Vector<VT,TF>& rhs,
ptrdiff_t band,
size_t row,
size_t column )
4288 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
4289 if( !tryBitor( lhs.operand(), lhs.idx( row+i ), column+i, (*rhs)[i] ) )
4315template<
typename MT1
4322inline bool tryBitorAssign(
const Rows<MT1,SO1,DF,SF,CRAs...>& lhs,
4323 const Matrix<MT2,SO2>& rhs,
size_t row,
size_t column )
4330 for(
size_t i=0UL; i<(*rhs).rows(); ++i ) {
4331 if( !tryBitorAssign( lhs.operand(),
blaze::row( *rhs, i, unchecked ), lhs.idx( row+i ), column ) )
4358template<
typename MT
4364inline bool tryBitxorAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
4365 const Vector<VT,false>& rhs,
size_t row,
size_t column )
4371 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
4372 if( !tryBitxor( lhs.operand(), lhs.idx( row+i ), column, (*rhs)[i] ) )
4399template<
typename MT
4405inline bool tryBitxorAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
4406 const Vector<VT,true>& rhs,
size_t row,
size_t column )
4412 return tryBitxorAssign( lhs.operand(), *rhs, lhs.idx( row ), column );
4436template<
typename MT
4443inline bool tryBitxorAssign(
const Rows<MT,SO,DF,SF,CRAs...>& lhs,
4444 const Vector<VT,TF>& rhs,
ptrdiff_t band,
size_t row,
size_t column )
4453 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
4454 if( !tryBitxor( lhs.operand(), lhs.idx( row+i ), column+i, (*rhs)[i] ) )
4480template<
typename MT1
4487inline bool tryBitxorAssign(
const Rows<MT1,SO1,DF,SF,CRAs...>& lhs,
4488 const Matrix<MT2,SO2>& rhs,
size_t row,
size_t column )
4495 for(
size_t i=0UL; i<(*rhs).rows(); ++i ) {
4496 if( !tryBitxorAssign( lhs.operand(),
blaze::row( *rhs, i, unchecked ), lhs.idx( row+i ), column ) )
4521template<
typename MT
4525 ,
typename... CRAs >
4526inline decltype(
auto) derestrict( Rows<MT,SO,DF,SF,CRAs...>& r )
4528 return rows( derestrict( r.operand() ), r.idces(), unchecked );
4549template<
typename MT
4553 ,
typename... CRAs >
4554inline decltype(
auto) derestrict( Rows<MT,SO,DF,SF,CRAs...>&& r )
4556 return rows( derestrict( r.operand() ), r.idces(), unchecked );
4575template<
typename MT
4579 ,
typename... CRAs >
4580inline decltype(
auto) unview( Rows<MT,SO,DF,SF,CRAs...>& r )
4602template<
typename MT
4606 ,
typename... CRAs >
4607inline decltype(
auto) unview(
const Rows<MT,SO,DF,SF,CRAs...>& r )
4625template<
typename MT,
bool SO,
bool DF,
bool SF,
size_t I,
size_t... Is,
typename... CRAs >
4626struct Size< Rows<MT,SO,DF,SF,
index_sequence<I,Is...>,CRAs...>, 0UL >
4627 :
public Ptrdiff_t< static_cast<ptrdiff_t>( 1UL+sizeof...(Is) ) >
4630template<
typename MT,
bool SO,
bool DF,
bool SF,
typename... CRAs >
4631struct Size< Rows<MT,SO,DF,SF,CRAs...>, 1UL >
4632 :
public Size<MT,1UL>
4648template<
typename MT,
bool SO,
bool DF,
bool SF,
size_t I,
size_t... Is,
typename... CRAs >
4649struct MaxSize< Rows<MT,SO,DF,SF,
index_sequence<I,Is...>,CRAs...>, 0UL >
4650 :
public Ptrdiff_t< static_cast<ptrdiff_t>( 1UL+sizeof...(Is) ) >
4653template<
typename MT,
bool SO,
bool DF,
bool SF,
typename... CRAs >
4654struct MaxSize< Rows<MT,SO,DF,SF,CRAs...>, 1UL >
4655 :
public MaxSize<MT,1UL>
4671template<
typename MT,
bool SO,
bool DF,
bool SF,
typename... CRAs >
4672struct IsRestricted< Rows<MT,SO,DF,SF,CRAs...> >
4673 :
public IsRestricted<MT>
4689template<
typename MT,
bool SO,
bool SF,
typename... CRAs >
4690struct HasConstDataAccess< Rows<MT,SO,true,SF,CRAs...> >
4691 :
public HasConstDataAccess<MT>
4707template<
typename MT,
bool SO,
bool SF,
typename... CRAs >
4708struct HasMutableDataAccess< Rows<MT,SO,true,SF,CRAs...> >
4709 :
public HasMutableDataAccess<MT>
4725template<
typename MT,
bool SO,
bool SF,
typename... CRAs >
4726struct IsAligned< Rows<MT,SO,true,SF,CRAs...> >
4727 :
public IsAligned<MT>
Header file for auxiliary alias declarations.
typename T::ResultType ResultType_t
Alias declaration for nested ResultType type definitions.
Definition Aliases.h:450
Header file for the alignment flag enumeration.
Header file for run time assertion macros.
Header file for the blaze::checked and blaze::unchecked instances.
Header file for the EnableIf class template.
Header file for the function trace functionality.
Header file for the HasConstDataAccess type trait.
Header file for the HasMutableDataAccess type trait.
Header file for the integer_sequence and index_sequence aliases.
Header file for the IntegralConstant class template.
Header file for the dense matrix inversion flags.
Header file for the IsAligned type trait.
Header file for the isDefault shim.
Header file for the IsPointer type trait.
Header file for the IsRestricted type trait.
Header file for the IsRowMajorMatrix type trait.
Header file for the IsRows type trait.
Header file for the MaxSize type trait.
Header file for the MAYBE_UNUSED function template.
Constraint on the data type.
Header file for the reduction flags.
Header file for the relaxation flag enumeration.
Header file for the RemoveReference type trait.
Header file for the implementation of the RowData class template.
Header file for the SmallArray implementation.
Base class for matrices.
Definition Matrix.h:85
Implementation of a dynamic array with small array optimization.
Definition SmallArray.h:84
void reserve(size_t n)
Setting the minimum capacity of the array.
Definition SmallArray.h:887
Pointer data() noexcept
Low-level data access to the array elements.
Definition SmallArray.h:531
size_t size() const noexcept
Returns the current size/dimension of the small array.
Definition SmallArray.h:767
Index sequence type of the Blaze library.
Initializer list type of the Blaze library.
Pointer difference type of the Blaze library.
Constraint on the data type.
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 MatReduceExpr 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 MatVecMultExpr 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, RCAs... args)
Creating a view on a specific column of the given matrix.
Definition Column.h:137
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) expand(const DenseVector< VT, TF > &dv, size_t expansion)
Expansion of the given dense vector.
Definition DVecExpandExpr.h:746
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
decltype(auto) elements(Vector< VT, TF > &vector, REAs... args)
Creating a view on a selection of elements of the given vector.
Definition Elements.h:143
void invert(const HermitianProxy< MT > &proxy)
In-place inversion of the represented element.
Definition HermitianProxy.h:693
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.
Definition RequiresEvaluation.h:81
#define BLAZE_CONSTRAINT_MUST_HAVE_MUTABLE_DATA_ACCESS(T)
Constraint on the data type.
Definition MutableDataAccess.h:61
constexpr bool IsRowMajorMatrix_v
Auxiliary variable template for the IsRowMajorMatrix type trait.
Definition IsRowMajorMatrix.h:129
RelaxationFlag
Relaxation flag for strict or relaxed semantics.
Definition RelaxationFlag.h:66
InversionFlag
Inversion flag.
Definition InversionFlag.h:102
AlignmentFlag
Alignment flag for (un-)aligned vectors and matrices.
Definition AlignmentFlag.h:63
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition Matrix.h:644
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
decltype(auto) row(Matrix< MT, SO > &, RRAs...)
Creating a view on a specific row of the given matrix.
Definition Row.h:137
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.
Definition Assert.h:101
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition Inline.h:85
IntegralConstant< ptrdiff_t, N > Ptrdiff_t
Compile time integral constant wrapper for ptrdiff_t.
Definition IntegralConstant.h:237
constexpr void MAYBE_UNUSED(const Args &...)
Suppression of unused parameter warnings.
Definition MaybeUnused.h:81
typename EnableIf< Condition, T >::Type EnableIf_t
Auxiliary type for the EnableIf class template.
Definition EnableIf.h:138
#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
Header file for the exception macros of the math module.
Header file for the extended initializer_list functionality.
Header file for the matrix storage order types.
Header file for the Size type trait.
Header file for all forward declarations for views.
Header file for the serial shim.
Base class for all matrix for-each expression templates.
Definition DeclExpr.h:68
Base class for all matrix evaluation expression templates.
Definition MatEvalExpr.h:69
Base class for all unary matrix map expression templates.
Definition MatMapExpr.h:68
Base class for all matrix/matrix addition expression templates.
Definition MatMatAddExpr.h:68
Base class for all matrix/matrix Kronecker expression templates.
Definition MatMatKronExpr.h:69
Base class for all binary matrix map expression templates.
Definition MatMatMapExpr.h:68
Base class for all matrix/matrix multiplication expression templates.
Definition MatMatMultExpr.h:71
Base class for all matrix/matrix subtraction expression templates.
Definition MatMatSubExpr.h:69
Base class for all matrix no-alias expression templates.
Definition MatNoAliasExpr.h:68
Base class for all matrix no-SIMD expression templates.
Definition MatNoSIMDExpr.h:95
Base class for all matrix/scalar division expression templates.
Definition MatScalarDivExpr.h:75
Base class for all matrix/scalar multiplication expression templates.
Definition MatScalarMultExpr.h:77
Base class for all matrix serial evaluation expression templates.
Definition MatSerialExpr.h:69
Base class for all matrix transposition expression templates.
Definition MatTransExpr.h:69
Base class for all Schur product expression templates.
Definition SchurExpr.h:68
Base class for all vector expansion expression templates.
Definition VecExpandExpr.h:69
Base class for all outer map expression templates.
Definition VecTVecMapExpr.h:68
Base class for all outer product expression templates.
Definition VecTVecMultExpr.h:69
Header file for basic type definitions.
Header file for the implementation of the Rows base template.
Rows specialization for dense matrices.
Rows specialization for sparse matrices.