35#ifndef _BLAZE_MATH_VIEWS_ELEMENTS_H_
36#define _BLAZE_MATH_VIEWS_ELEMENTS_H_
147 using ReturnType = Elements_< VT, index_sequence<I,Is...> >;
148 return ReturnType( *vector, args... );
197 using ReturnType =
const Elements_<
const VT, index_sequence<I,Is...> >;
198 return ReturnType( *vector, args... );
226 using ReturnType = Elements_< VT, index_sequence<I,Is...> >;
227 return ReturnType( *vector, args... );
279 using ReturnType = Elements_<VT>;
280 return ReturnType( *vector, indices, n, args... );
332 using ReturnType =
const Elements_<const VT>;
333 return ReturnType( *vector, indices, n, args... );
362 using ReturnType = Elements_<VT>;
363 return ReturnType( *vector, indices, n, args... );
413 using ReturnType = Elements_<VT,P>;
414 return ReturnType( *vector, p, n, args... );
466 using ReturnType =
const Elements_<const VT,P>;
467 return ReturnType( *vector, p, n, args... );
496 using ReturnType = Elements_<VT,P>;
497 return ReturnType( *vector, p, n, args... );
548 return elements<Is...>( std::forward<VT>( vector ), args... );
592inline decltype(
auto)
elements( VT&& vector, initializer_list<T> indices, REAs... args )
596 return elements( std::forward<VT>( vector ), indices.begin(), indices.size(), args... );
642inline decltype(
auto)
elements( VT&& vector,
const std::array<T,N>& indices, REAs... args )
646 return elements( std::forward<VT>( vector ), indices.data(), N, args... );
691inline decltype(
auto)
elements( VT&& vector,
const std::vector<T>& indices, REAs... args )
695 return elements( std::forward<VT>( vector ), indices.data(), indices.size(), args... );
745 return elements( std::forward<VT>( vector ), indices.
data(), indices.
size(), args... );
769inline decltype(
auto)
elements( VT&& vector,
const std::pair<T1,T2>& pair, REAs... args )
773 return elements( std::forward<VT>( vector ), pair.first, pair.second, args... );
800template<
size_t... CEAs
803inline decltype(
auto)
elements(
const VecVecAddExpr<VT>& vector, REAs... args )
807 return elements<CEAs...>( (*vector).leftOperand(), args... ) +
808 elements<CEAs...>( (*vector).rightOperand(), args... );
827template<
size_t... CEAs
830inline decltype(
auto)
elements(
const VecVecSubExpr<VT>& vector, REAs... args )
834 return elements<CEAs...>( (*vector).leftOperand(), args... ) -
835 elements<CEAs...>( (*vector).rightOperand(), args... );
854template<
size_t... CEAs
857inline decltype(
auto)
elements(
const VecVecMultExpr<VT>& vector, REAs... args )
861 return elements<CEAs...>( (*vector).leftOperand(), args... ) *
862 elements<CEAs...>( (*vector).rightOperand(), args... );
885inline decltype(
auto)
elements(
const VecVecKronExpr<VT>& vector, REAs... args )
889 decltype(
auto) lhs( (*vector).leftOperand() );
890 decltype(
auto) rhs( (*vector).rightOperand() );
892 const size_t N( rhs.size() );
894 const auto lhsIndices( [N](
size_t i ) {
895 constexpr size_t indices[] = { I, Is... };
896 return indices[i] / N;
899 const auto rhsIndices( [N](
size_t i ) {
900 constexpr size_t indices[] = { I, Is... };
901 return indices[i] % N;
904 return elements( lhs, lhsIndices,
sizeof...(Is)+1UL, args... ) *
905 elements( rhs, rhsIndices,
sizeof...(Is)+1UL, args... );
929inline decltype(
auto)
elements(
const VecVecKronExpr<VT>& vector, T* indices,
size_t n, REAs... args )
933 decltype(
auto) lhs( (*vector).leftOperand() );
934 decltype(
auto) rhs( (*vector).rightOperand() );
936 const size_t N( rhs.size() );
938 SmallArray<size_t,128UL> lhsIndices;
939 lhsIndices.reserve( n );
941 for(
size_t i=0UL; i<n; ++i ) {
942 lhsIndices.pushBack( indices[i] / N );
945 SmallArray<size_t,128UL> rhsIndices;
946 rhsIndices.reserve( n );
948 for(
size_t i=0UL; i<n; ++i ) {
949 rhsIndices.pushBack( indices[i] % N );
952 return elements( lhs, lhsIndices, n, args... ) *
elements( rhs, rhsIndices, n, args... );
976inline decltype(
auto)
elements(
const VecVecKronExpr<VT>& vector, P p,
size_t n, REAs... args )
980 decltype(
auto) lhs( (*vector).leftOperand() );
981 decltype(
auto) rhs( (*vector).rightOperand() );
983 const size_t N( rhs.size() );
985 const auto lhsIndices( [p,N](
size_t i ) {
return p(i) / N; } );
986 const auto rhsIndices( [p,N](
size_t i ) {
return p(i) % N; } );
988 return elements( lhs, lhsIndices, n, args... ) *
elements( rhs, rhsIndices, n, args... );
1007template<
size_t... CEAs
1009 ,
typename... REAs >
1010inline decltype(
auto)
elements(
const VecVecDivExpr<VT>& vector, REAs... args )
1014 return elements<CEAs...>( (*vector).leftOperand(), args... ) /
1015 elements<CEAs...>( (*vector).rightOperand(), args... );
1034template<
size_t... CEAs
1036 ,
typename... REAs >
1037inline decltype(
auto)
elements(
const VecScalarMultExpr<VT>& vector, REAs... args )
1041 return elements<CEAs...>( (*vector).leftOperand(), args... ) * (*vector).rightOperand();
1060template<
size_t... CEAs
1062 ,
typename... REAs >
1063inline decltype(
auto)
elements(
const VecScalarDivExpr<VT>& vector, REAs... args )
1067 return elements<CEAs...>( (*vector).leftOperand(), args... ) / (*vector).rightOperand();
1086template<
size_t... CEAs
1088 ,
typename... REAs >
1089inline decltype(
auto)
elements(
const VecMapExpr<VT>& vector, REAs... args )
1093 return map( elements<CEAs...>( (*vector).operand(), args... ), (*vector).operation() );
1112template<
size_t... CEAs
1114 ,
typename... REAs >
1115inline decltype(
auto)
elements(
const VecVecMapExpr<VT>& vector, REAs... args )
1119 return map( elements<CEAs...>( (*vector).leftOperand(), args... ),
1120 elements<CEAs...>( (*vector).rightOperand(), args... ),
1121 (*vector).operation() );
1140template<
size_t... CEAs
1142 ,
typename... REAs >
1143inline decltype(
auto)
elements(
const VecEvalExpr<VT>& vector, REAs... args )
1147 return eval( elements<CEAs...>( (*vector).operand(), args... ) );
1166template<
size_t... CEAs
1168 ,
typename... REAs >
1169inline decltype(
auto)
elements(
const VecSerialExpr<VT>& vector, REAs... args )
1173 return serial( elements<CEAs...>( (*vector).operand(), args... ) );
1192template<
size_t... CEAs
1194 ,
typename... REAs >
1195inline decltype(
auto)
elements(
const VecNoAliasExpr<VT>& vector, REAs... args )
1199 return noalias( elements<CEAs...>( (*vector).operand(), args... ) );
1218template<
size_t... CEAs
1220 ,
typename... REAs >
1221inline decltype(
auto)
elements(
const VecNoSIMDExpr<VT>& vector, REAs... args )
1225 return nosimd( elements<CEAs...>( (*vector).operand(), args... ) );
1244template<
size_t... CEAs
1246 ,
typename... REAs >
1247inline decltype(
auto)
elements(
const VecTransExpr<VT>& vector, REAs... args )
1251 return trans( elements<CEAs...>( (*vector).operand(), args... ) );
1274 ,
typename... REAs >
1275inline decltype(
auto)
elements(
const VecRepeatExpr<VT,CRAs...>& vector, REAs... args )
1280 constexpr size_t indices[] = { I, Is... };
1281 for(
size_t i=0UL; i<
sizeof...(Is)+1UL; ++i ) {
1282 if( (*vector).size() <= indices[i] ) {
1288 auto lambda = [
size=(*vector).operand().size()](
size_t i ) {
1289 constexpr size_t indices[] = { I, Is... };
1290 return indices[i] %
size;
1293 return elements( (*vector).operand(), std::move(lambda),
sizeof...(Is)+1UL,
unchecked );
1314template<
typename VT
1317 ,
typename... REAs >
1318inline decltype(
auto)
1319 elements(
const VecRepeatExpr<VT,CRAs...>& vector, T* indices,
size_t n, REAs... args )
1324 for(
size_t i=0UL; i<n; ++i ) {
1325 if( (*vector).size() <=
size_t( indices[i] ) ) {
1331 SmallArray<size_t,128UL> newIndices( indices, indices+n );
1333 for(
size_t& index : newIndices ) {
1334 index = index % (*vector).operand().size();
1358template<
typename VT
1361 ,
typename... REAs >
1362inline decltype(
auto)
1363 elements(
const VecRepeatExpr<VT,CRAs...>& vector, P p,
size_t n, REAs... args )
1368 for(
size_t i=0UL; i<n; ++i ) {
1369 if( (*vector).size() <=
size_t( p(i) ) ) {
1375 auto lambda = [
size=(*vector).operand().size(),p](
size_t i ) {
1409 , EnableIf_t< IsElements_v< RemoveReference_t<VT> > &&
1410 RemoveReference_t<VT>::compileTimeArgs >* =
nullptr >
1411inline decltype(
auto)
elements( VT&& e, REAs... args )
1415 return elements( e.operand(), subsequence<I,Is...>( RemoveReference_t<VT>::idces() ), args... );
1438 , EnableIf_t< IsElements_v< RemoveReference_t<VT> > &&
1439 !RemoveReference_t<VT>::compileTimeArgs >* =
nullptr >
1440inline decltype(
auto)
elements( VT&& e, REAs... args )
1445 constexpr size_t indices[] = { I, Is... };
1446 for(
size_t i=0UL; i<
sizeof...(Is)+1UL; ++i ) {
1447 if( e.size() <= indices[i] ) {
1474template<
typename VT
1477 , EnableIf_t< IsElements_v< RemoveReference_t<VT> > >* =
nullptr >
1478inline decltype(
auto)
elements( VT&& e, T* indices,
size_t n, REAs... args )
1483 for(
size_t i=0UL; i<n; ++i ) {
1484 if( e.size() <=
size_t( indices[i] ) ) {
1490 SmallArray<size_t,128UL> newIndices;
1491 newIndices.reserve( n );
1493 for(
size_t i=0UL; i<n; ++i ) {
1494 newIndices.pushBack( e.idx( indices[i] ) );
1497 return elements( e.operand(), newIndices.data(), newIndices.size(),
unchecked );
1518template<
typename VT
1521 , EnableIf_t< IsElements_v< RemoveReference_t<VT> > && !IsPointer_v<P> >* =
nullptr >
1522inline decltype(
auto)
elements( VT&& e, P p,
size_t n, REAs... args )
1527 for(
size_t i=0UL; i<n; ++i ) {
1528 if( e.size() <=
size_t( p(i) ) ) {
1534 SmallArray<size_t,128UL> newIndices;
1535 newIndices.reserve( n );
1537 for(
size_t i=0UL; i<n; ++i ) {
1538 newIndices.pushBack( e.idx( p(i) ) );
1541 return elements( e.operand(), newIndices.data(), newIndices.size(),
unchecked );
1573 , EnableIf_t< IsElements_v< RemoveReference_t<VT> > >* =
nullptr >
1574inline decltype(
auto)
subvector( VT&& e, RSAs... args )
1579 return elements( std::forward<VT>( e ), make_shifted_index_sequence<I,N>(), args... );
1607 , EnableIf_t< IsElements_v< RemoveReference_t<VT> > >* =
nullptr >
1608inline decltype(
auto)
subvector( VT&& e,
size_t index,
size_t size, RSAs... args )
1612 SmallArray<size_t,128UL> indices(
size );
1613 std::iota( indices.begin(), indices.end(), index );
1616 return elements( std::forward<VT>( e ), indices.data(), indices.size(), args... );
1663 ,
typename... CEAs >
1664inline bool isDefault(
const Elements<VT,TF,true,CEAs...>& e )
1668 for(
size_t i=0UL; i<e.size(); ++i )
1669 if( !isDefault<RF>( e[i] ) )
return false;
1705 ,
typename... CEAs >
1706inline bool isDefault(
const Elements<VT,TF,false,CEAs...>& e )
1710 for(
const auto& element : *e )
1711 if( !isDefault<RF>( element.value() ) )
return false;
1736template<
typename VT
1739 ,
typename... CEAs >
1740inline bool isIntact(
const Elements<VT,TF,DF,CEAs...>& e )
noexcept
1742 return ( e.size() <= e.operand().size() &&
isIntact( e.operand() ) );
1762template<
typename VT
1765 ,
typename... CEAs >
1766inline bool isSame(
const Elements<VT,TF,DF,CEAs...>& a,
const Vector<VT,TF>& b )
noexcept
1768 if( !
isSame( a.operand(), *b ) || ( a.size() != (*b).size() ) )
1771 for(
size_t i=0UL; i<a.size(); ++i ) {
1796template<
typename VT
1799 ,
typename... CEAs >
1800inline bool isSame(
const Vector<VT,TF>& a,
const Elements<VT,TF,DF,CEAs...>& b )
noexcept
1822template<
typename VT1
1829inline bool isSame(
const Elements<VT1,TF,DF,CEAs...>& a,
const Subvector<VT2,AF,TF,DF,CSAs...>& b )
noexcept
1831 if( !
isSame( a.operand(), b.operand() ) || ( a.size() != b.size() ) )
1834 for(
size_t i=0UL; i<a.size(); ++i ) {
1835 if( a.idx(i) != b.offset()+i )
1859template<
typename VT1
1865 ,
typename... CEAs >
1866inline bool isSame(
const Subvector<VT1,AF,TF,DF,CSAs...>& a,
const Elements<VT2,TF,DF,CEAs...>& b )
noexcept
1887template<
typename VT1
1894 ,
typename... CEAs2 >
1895inline bool isSame(
const Elements<VT1,TF1,DF1,CEAs1...>& a,
1896 const Elements<VT2,TF2,DF2,CEAs2...>& b )
noexcept
1898 if( !
isSame( a.operand(), b.operand() ) || a.size() != b.size() )
1901 for(
size_t i=0UL; i<a.size(); ++i ) {
1902 if( a.idx(i) != b.idx(i) )
1927template<
typename VT
1932inline bool trySet(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
1936 return trySet( e.operand(), e.idx(index), value );
1958template<
typename VT
1964 trySet(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
1969 const size_t iend( index +
size );
1971 for(
size_t i=index; i<iend; ++i ) {
1972 if( !trySet( e.operand(), e.idx(i), value ) )
1997template<
typename VT
2002inline bool tryAdd(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2006 return tryAdd( e.operand(), e.idx(index), value );
2028template<
typename VT
2034 tryAdd(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2039 const size_t iend( index +
size );
2041 for(
size_t i=index; i<iend; ++i ) {
2042 if( !tryAdd( e.operand(), e.idx(i), value ) )
2067template<
typename VT
2072inline bool trySub(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2076 return trySub( e.operand(), e.idx(index), value );
2099template<
typename VT
2105 trySub(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2110 const size_t iend( index +
size );
2112 for(
size_t i=index; i<iend; ++i ) {
2113 if( !trySub( e.operand(), e.idx(i), value ) )
2138template<
typename VT
2143inline bool tryMult(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2147 return tryMult( e.operand(), e.idx(index), value );
2169template<
typename VT
2175 tryMult(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2180 const size_t iend( index +
size );
2182 for(
size_t i=index; i<iend; ++i ) {
2183 if( !tryMult( e.operand(), e.idx(i), value ) )
2208template<
typename VT
2213inline bool tryDiv(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2217 return tryDiv( e.operand(), e.idx(index), value );
2239template<
typename VT
2245 tryDiv(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2250 const size_t iend( index +
size );
2252 for(
size_t i=index; i<iend; ++i ) {
2253 if( !tryDiv( e.operand(), e.idx(i), value ) )
2278template<
typename VT
2281 ,
typename... CEAs >
2282inline bool tryShift(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
int count )
2286 return tryShift( e.operand(), e.idx(index), count );
2308template<
typename VT
2311 ,
typename... CEAs >
2313 tryShift(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
int count )
2318 const size_t iend( index +
size );
2320 for(
size_t i=index; i<iend; ++i ) {
2321 if( !tryShift( e.operand(), e.idx(i), count ) )
2347template<
typename VT
2352inline bool tryBitand(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2356 return tryBitand( e.operand(), e.idx(index), value );
2379template<
typename VT
2385 tryBitand(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2390 const size_t iend( index +
size );
2392 for(
size_t i=index; i<iend; ++i ) {
2393 if( !tryBitand( e.operand(), e.idx(i), value ) )
2419template<
typename VT
2424inline bool tryBitor(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2428 return tryBitor( e.operand(), e.idx(index), value );
2451template<
typename VT
2457 tryBitor(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2462 const size_t iend( index +
size );
2464 for(
size_t i=index; i<iend; ++i ) {
2465 if( !tryBitor( e.operand(), e.idx(i), value ) )
2491template<
typename VT
2496inline bool tryBitxor(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2500 return tryBitxor( e.operand(), e.idx(index), value );
2523template<
typename VT
2529 tryBitxor(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2534 const size_t iend( index +
size );
2536 for(
size_t i=index; i<iend; ++i ) {
2537 if( !tryBitxor( e.operand(), e.idx(i), value ) )
2562template<
typename VT1
2567inline bool tryAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2568 const Vector<VT2,TF>& rhs,
size_t index )
2573 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
2574 if( !trySet( lhs.operand(), lhs.idx(i+index), (*rhs)[i] ) )
2600template<
typename VT1
2605inline bool tryAddAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2606 const Vector<VT2,TF>& rhs,
size_t index )
2611 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
2612 if( !tryAdd( lhs.operand(), lhs.idx(i+index), (*rhs)[i] ) )
2638template<
typename VT1
2643inline bool trySubAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2644 const Vector<VT2,TF>& rhs,
size_t index )
2649 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
2650 if( !trySub( lhs.operand(), lhs.idx(i+index), (*rhs)[i] ) )
2676template<
typename VT1
2681inline bool tryMultAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2682 const Vector<VT2,TF>& rhs,
size_t index )
2687 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
2688 if( !tryMult( lhs.operand(), lhs.idx(i+index), (*rhs)[i] ) )
2714template<
typename VT1
2719inline bool tryDivAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2720 const Vector<VT2,TF>& rhs,
size_t index )
2725 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
2726 if( !tryDiv( lhs.operand(), lhs.idx(i+index), (*rhs)[i] ) )
2752template<
typename VT1
2757inline bool tryShiftAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2758 const Vector<VT2,TF>& rhs,
size_t index )
2763 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
2764 if( !tryShift( lhs.operand(), lhs.idx(i+index), (*rhs)[i] ) )
2790template<
typename VT1
2795inline bool tryBitandAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2796 const Vector<VT2,TF>& rhs,
size_t index )
2801 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
2802 if( !tryBitand( lhs.operand(), lhs.idx(i+index), (*rhs)[i] ) )
2828template<
typename VT1
2833inline bool tryBitorAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2834 const Vector<VT2,TF>& rhs,
size_t index )
2839 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
2840 if( !tryBitor( lhs.operand(), lhs.idx(i+index), (*rhs)[i] ) )
2866template<
typename VT1
2871inline bool tryBitxorAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2872 const Vector<VT2,TF>& rhs,
size_t index )
2877 for(
size_t i=0UL; i<(*rhs).size(); ++i ) {
2878 if( !tryBitxor( lhs.operand(), lhs.idx(i+index), (*rhs)[i] ) )
2903template<
typename VT
2906 ,
typename... CEAs >
2907inline decltype(
auto) derestrict( Elements<VT,TF,DF,CEAs...>& e )
2930template<
typename VT
2933 ,
typename... CEAs >
2934inline decltype(
auto) derestrict( Elements<VT,TF,DF,CEAs...>&& e )
2955template<
typename VT
2958 ,
typename... CEAs >
2959inline decltype(
auto) unview( Elements<VT,TF,DF,CEAs...>& e )
2981template<
typename VT
2984 ,
typename... CEAs >
2985inline decltype(
auto) unview(
const Elements<VT,TF,DF,CEAs...>& e )
3003template<
typename VT,
bool TF,
bool DF,
size_t I,
size_t... Is,
typename... CEAs >
3004struct Size< Elements<VT,TF,DF,
index_sequence<I,Is...>,CEAs...>, 0UL >
3005 :
public Ptrdiff_t< static_cast<ptrdiff_t>( 1UL+sizeof...(Is) ) >
3021template<
typename VT,
bool TF,
bool DF,
size_t I,
size_t... Is,
typename... CEAs >
3022struct MaxSize< Elements<VT,TF,DF,
index_sequence<I,Is...>,CEAs...>, 0UL >
3023 :
public Ptrdiff_t< static_cast<ptrdiff_t>( 1UL+sizeof...(Is) ) >
3039template<
typename VT,
bool TF,
bool DF,
typename... CEAs >
3040struct IsRestricted< Elements<VT,TF,DF,CEAs...> >
3041 :
public IsRestricted<VT>
3057template<
typename VT,
bool TF,
typename... CEAs >
3058struct HasConstDataAccess< Elements<VT,TF,true,CEAs...> >
3059 :
public HasConstDataAccess<VT>
3075template<
typename VT,
bool TF,
typename... CEAs >
3076struct HasMutableDataAccess< Elements<VT,TF,true,CEAs...> >
3077 :
public HasMutableDataAccess<VT>
Header file for auxiliary alias declarations.
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 isDefault shim.
Header file for the IsElements type trait.
Header file for the IsPointer type trait.
Header file for the IsRestricted type trait.
Deactivation of problematic macros.
Header file for the MaxSize type trait.
Header file for the MAYBE_UNUSED function template.
Header file for the relaxation flag enumeration.
Header file for the RemoveReference type trait.
Header file for the SmallArray implementation.
Implementation of a dynamic array with small array optimization.
Definition: SmallArray.h:84
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
Base class for N-dimensional vectors.
Definition: Vector.h:82
Index sequence type of the Blaze library.
Size type of the Blaze library.
Header file for the CrossExpr base class.
Header file for the VecEvalExpr base class.
Header file for the VecMapExpr base class.
Header file for the VecNoAliasExpr base class.
Header file for the VecNoSIMDExpr base class.
Header file for the VecRepeatExpr base class.
Header file for the VecScalarDivExpr base class.
Header file for the VecScalarMultExpr base class.
Header file for the VecSerialExpr base class.
Header file for the VecTransExpr base class.
Header file for the VecVecAddExpr base class.
Header file for the VecVecDivExpr base class.
Header file for the VecVecKronExpr base class.
Header file for the VecVecMapExpr base class.
Header file for the VecVecMultExpr base class.
Header file for the VecVecSubExpr base class.
Header file for the Vector CRTP base class.
decltype(auto) noalias(const DenseMatrix< MT, SO > &dm)
Forces the non-aliased evaluation of the given dense matrix expression dm.
Definition: DMatNoAliasExpr.h:679
decltype(auto) eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:790
decltype(auto) 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
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(VT &&vector, const SmallArray< T, N > &indices, REAs... args)
Creating a view on a selection of elements of the given vector.
Definition: Elements.h:741
RelaxationFlag
Relaxation flag for strict or relaxed semantics.
Definition: RelaxationFlag.h:66
AlignmentFlag
Alignment flag for (un-)aligned vectors and matrices.
Definition: AlignmentFlag.h:63
bool isSame(const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b) noexcept
Returns whether the two given matrices represent the same observable state.
Definition: Matrix.h:1424
constexpr size_t size(const Matrix< MT, SO > &matrix) noexcept
Returns the total number of elements of the matrix.
Definition: Matrix.h:676
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.
Definition: Assert.h:101
decltype(auto) subvector(Vector< VT, TF > &, RSAs...)
Creating a view on a specific subvector of the given vector.
Definition: Subvector.h:158
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
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
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.
Definition: Exception.h:235
#define BLAZE_FUNCTION_TRACE
Function trace macro.
Definition: FunctionTrace.h:94
constexpr bool isChecked(const Ts &... args)
Extracting blaze::Check arguments from a given list of arguments.
Definition: Check.h:225
constexpr Unchecked unchecked
Global Unchecked instance.
Definition: Check.h:146
Header file for the exception macros of the math module.
Header file for the extended initializer_list functionality.
Header file for the Size type trait.
Header file for the serial shim.
Header file for basic type definitions.
Header file for the implementation of the Elements base template.
Elements specialization for dense vectors.
Elements specialization for sparse vectors.