35 #ifndef _BLAZE_MATH_VIEWS_ELEMENTS_H_ 36 #define _BLAZE_MATH_VIEWS_ELEMENTS_H_ 144 return ReturnType( ~vector, args... );
193 using ReturnType =
const Elements_<
const VT,
index_sequence<I,Is...> >;
194 return ReturnType( ~vector, args... );
223 return ReturnType( ~vector, args... );
267 template<
typename VT
271 inline decltype(
auto)
elements(
Vector<VT,TF>& vector, T* indices,
size_t n, REAs... args )
275 using ReturnType = Elements_<VT>;
276 return ReturnType( ~vector, indices, n, args... );
320 template<
typename VT
324 inline decltype(
auto)
elements( const
Vector<VT,TF>& vector, T* indices,
size_t n, REAs... args )
328 using ReturnType =
const Elements_<const VT>;
329 return ReturnType( ~vector, indices, n, args... );
350 template<
typename VT
354 inline decltype(
auto)
elements(
Vector<VT,TF>&& vector, T* indices,
size_t n, REAs... args )
358 using ReturnType = Elements_<VT>;
359 return ReturnType( ~vector, indices, n, args... );
401 template<
typename VT
405 inline decltype(
auto)
elements(
Vector<VT,TF>& vector, P p,
size_t n, REAs... args )
409 using ReturnType = Elements_<VT,P>;
410 return ReturnType( ~vector, p, n, args... );
454 template<
typename VT
458 inline decltype(
auto)
elements( const
Vector<VT,TF>& vector, P p,
size_t n, REAs... args )
462 using ReturnType =
const Elements_<const VT,P>;
463 return ReturnType( ~vector, p, n, args... );
484 template<
typename VT
488 inline decltype(
auto)
elements(
Vector<VT,TF>&& vector, P p,
size_t n, REAs... args )
492 using ReturnType = Elements_<VT,P>;
493 return ReturnType( ~vector, p, n, args... );
535 template<
typename VT
538 inline decltype(
auto)
elements( VT&& vector, index_sequence<Is...> indices, REAs... args )
544 return elements<Is...>( std::forward<VT>( vector ), args... );
585 template<
typename VT
592 return elements( std::forward<VT>( vector ), indices.begin(), indices.size(), args... );
634 template<
typename VT
638 inline decltype(
auto)
elements( VT&& vector, const std::array<T,N>& indices, REAs... args )
642 return elements( std::forward<VT>( vector ), indices.data(), N, args... );
684 template<
typename VT
687 inline decltype(
auto)
elements( VT&& vector, const std::vector<T>& indices, REAs... args )
691 return elements( std::forward<VT>( vector ), indices.data(), indices.size(), args... );
733 template<
typename VT
741 return elements( std::forward<VT>( vector ), indices.data(), indices.size(), args... );
761 template<
typename VT
765 inline decltype(
auto)
elements( VT&& vector, const std::pair<T1,T2>& pair, REAs... args )
769 return elements( std::forward<VT>( vector ), pair.first, pair.second, args... );
795 template<
size_t... CEAs
798 inline decltype(
auto)
elements( const VecVecAddExpr<VT>& vector, REAs... args )
802 return elements<CEAs...>( (~vector).leftOperand(), args... ) +
803 elements<CEAs...>( (~vector).rightOperand(), args... );
821 template<
size_t... CEAs
824 inline decltype(
auto)
elements( const VecVecSubExpr<VT>& vector, REAs... args )
828 return elements<CEAs...>( (~vector).leftOperand(), args... ) -
829 elements<CEAs...>( (~vector).rightOperand(), args... );
847 template<
size_t... CEAs
850 inline decltype(
auto)
elements( const VecVecMultExpr<VT>& vector, REAs... args )
854 return elements<CEAs...>( (~vector).leftOperand(), args... ) *
855 elements<CEAs...>( (~vector).rightOperand(), args... );
877 inline decltype(
auto)
elements( const VecVecKronExpr<VT>& vector, REAs... args )
881 decltype(
auto) lhs( (~vector).leftOperand() );
882 decltype(auto) rhs( (~vector).rightOperand() );
884 const
size_t N( rhs.
size() );
886 const auto lhsIndices( [N](
size_t i ) {
887 static constexpr
size_t indices[] = { I, Is... };
888 return indices[i] / N;
891 const auto rhsIndices( [N](
size_t i ) {
892 static constexpr
size_t indices[] = { I, Is... };
893 return indices[i] % N;
896 return elements( lhs, lhsIndices,
sizeof...(Is)+1UL, args... ) *
897 elements( rhs, rhsIndices,
sizeof...(Is)+1UL, args... );
917 template<
typename VT
920 inline decltype(
auto)
elements( const VecVecKronExpr<VT>& vector, T* indices,
size_t n, REAs... args )
924 decltype(
auto) lhs( (~vector).leftOperand() );
925 decltype(auto) rhs( (~vector).rightOperand() );
927 const
size_t N( rhs.
size() );
929 SmallArray<
size_t,128UL> lhsIndices;
930 lhsIndices.reserve( n );
932 for(
size_t i=0UL; i<n; ++i ) {
933 lhsIndices.pushBack( indices[i] / N );
936 SmallArray<size_t,128UL> rhsIndices;
937 rhsIndices.reserve( n );
939 for(
size_t i=0UL; i<n; ++i ) {
940 rhsIndices.pushBack( indices[i] % N );
943 return elements( lhs, lhsIndices, n, args... ) *
elements( rhs, rhsIndices, n, args... );
963 template<
typename VT
966 inline decltype(
auto)
elements( const VecVecKronExpr<VT>& vector, P p,
size_t n, REAs... args )
970 decltype(
auto) lhs( (~vector).leftOperand() );
971 decltype(auto) rhs( (~vector).rightOperand() );
973 const
size_t N( rhs.
size() );
975 const auto lhsIndices( [p,N](
size_t i ) {
return p(i) / N; } );
976 const auto rhsIndices( [p,N](
size_t i ) {
return p(i) % N; } );
978 return elements( lhs, lhsIndices, n, args... ) *
elements( rhs, rhsIndices, n, args... );
996 template<
size_t... CEAs
999 inline decltype(
auto)
elements( const VecVecDivExpr<VT>& vector, REAs... args )
1003 return elements<CEAs...>( (~vector).leftOperand(), args... ) /
1004 elements<CEAs...>( (~vector).rightOperand(), args... );
1022 template<
size_t... CEAs
1024 ,
typename... REAs >
1025 inline decltype(
auto)
elements( const VecScalarMultExpr<VT>& vector, REAs... args )
1029 return elements<CEAs...>( (~vector).leftOperand(), args... ) * (~vector).rightOperand();
1047 template<
size_t... CEAs
1049 ,
typename... REAs >
1050 inline decltype(
auto)
elements( const VecScalarDivExpr<VT>& vector, REAs... args )
1054 return elements<CEAs...>( (~vector).leftOperand(), args... ) / (~vector).rightOperand();
1072 template<
size_t... CEAs
1074 ,
typename... REAs >
1075 inline decltype(
auto)
elements( const VecMapExpr<VT>& vector, REAs... args )
1079 return map( elements<CEAs...>( (~vector).operand(), args... ), (~vector).operation() );
1097 template<
size_t... CEAs
1099 ,
typename... REAs >
1100 inline decltype(
auto)
elements( const VecVecMapExpr<VT>& vector, REAs... args )
1104 return map( elements<CEAs...>( (~vector).leftOperand(), args... ),
1105 elements<CEAs...>( (~vector).rightOperand(), args... ),
1106 (~vector).operation() );
1124 template<
size_t... CEAs
1126 ,
typename... REAs >
1127 inline decltype(
auto)
elements( const VecEvalExpr<VT>& vector, REAs... args )
1131 return eval( elements<CEAs...>( (~vector).operand(), args... ) );
1149 template<
size_t... CEAs
1151 ,
typename... REAs >
1152 inline decltype(
auto)
elements( const VecSerialExpr<VT>& vector, REAs... args )
1156 return serial( elements<CEAs...>( (~vector).operand(), args... ) );
1174 template<
size_t... CEAs
1176 ,
typename... REAs >
1177 inline decltype(
auto)
elements( const VecTransExpr<VT>& vector, REAs... args )
1181 return trans( elements<CEAs...>( (~vector).operand(), args... ) );
1211 , EnableIf_t< IsElements_v< RemoveReference_t<VT> > &&
1212 RemoveReference_t<VT>::compileTimeArgs >* =
nullptr >
1213 inline decltype(
auto)
elements( VT&& e, REAs... args )
1217 return elements( e.operand(), subsequence<I,Is...>( RemoveReference_t<VT>::idces() ), args... );
1240 , EnableIf_t< IsElements_v< RemoveReference_t<VT> > &&
1241 !RemoveReference_t<VT>::compileTimeArgs >* =
nullptr >
1242 inline decltype(
auto)
elements( VT&& e, REAs... args )
1249 static constexpr
size_t indices[] = { I, Is... };
1250 for(
size_t i=0UL; i<
sizeof...(Is)+1UL; ++i ) {
1251 if( e.size() <= indices[i] ) {
1257 return elements( e.operand(), { e.idx(I), e.idx(Is)... }, args... );
1278 template<
typename VT
1281 , EnableIf_t< IsElements_v< RemoveReference_t<VT> > >* =
nullptr >
1282 inline decltype(
auto)
elements( VT&& e, T* indices,
size_t n, REAs... args )
1289 for(
size_t i=0UL; i<n; ++i ) {
1290 if( e.size() <= size_t( indices[i] ) ) {
1296 SmallArray<size_t,128UL> newIndices;
1297 newIndices.reserve( n );
1299 for(
size_t i=0UL; i<n; ++i ) {
1300 newIndices.pushBack( e.idx( indices[i] ) );
1303 return elements( e.operand(), newIndices.data(), newIndices.size(), args... );
1324 template<
typename VT
1327 , EnableIf_t< IsElements_v< RemoveReference_t<VT> > && !IsPointer_v<P> >* =
nullptr >
1328 inline decltype(
auto)
elements( VT&& e, P p,
size_t n, REAs... args )
1335 for(
size_t i=0UL; i<n; ++i ) {
1336 if( e.size() <= size_t( p(i) ) ) {
1342 SmallArray<size_t,128UL> newIndices;
1343 newIndices.reserve( n );
1345 for(
size_t i=0UL; i<n; ++i ) {
1346 newIndices.pushBack( e.idx( p(i) ) );
1349 return elements( e.operand(), newIndices.data(), newIndices.size(), args... );
1380 , EnableIf_t< IsElements_v< RemoveReference_t<VT> > >* =
nullptr >
1381 inline decltype(
auto)
subvector( VT&& e, RSAs... args )
1385 return elements( std::forward<VT>( e ), make_shifted_index_sequence<I,N>(), args... );
1408 , EnableIf_t< IsElements_v< RemoveReference_t<VT> > >* =
nullptr >
1409 inline decltype(
auto)
subvector( VT&& e,
size_t index,
size_t size, RSAs... args )
1413 SmallArray<size_t,128UL> indices(
size );
1414 std::iota( indices.begin(), indices.end(), index );
1416 return elements( std::forward<VT>( e ), indices.data(), indices.size(), args... );
1438 template<
typename VT
1441 ,
typename... CEAs >
1442 inline void reset( Elements<VT,TF,DF,CEAs...>& e )
1458 template<
typename VT
1461 ,
typename... CEAs >
1462 inline void reset( Elements<VT,TF,DF,CEAs...>&& e )
1478 template<
typename VT
1481 ,
typename... CEAs >
1482 inline void clear( Elements<VT,TF,DF,CEAs...>& e )
1498 template<
typename VT
1501 ,
typename... CEAs >
1502 inline void clear( Elements<VT,TF,DF,CEAs...>&& e )
1539 ,
typename... CEAs >
1540 inline bool isDefault(
const Elements<VT,TF,true,CEAs...>& e )
1544 for(
size_t i=0UL; i<e.size(); ++i )
1545 if( !isDefault<RF>( e[i] ) )
return false;
1581 ,
typename... CEAs >
1582 inline bool isDefault(
const Elements<VT,TF,false,CEAs...>& e )
1586 for(
const auto& element : ~e )
1587 if( !isDefault<RF>( element.value() ) )
return false;
1612 template<
typename VT
1615 ,
typename... CEAs >
1616 inline bool isIntact(
const Elements<VT,TF,DF,CEAs...>& e ) noexcept
1618 return ( e.size() <= e.operand().size() &&
isIntact( e.operand() ) );
1638 template<
typename VT
1641 ,
typename... CEAs >
1642 inline bool isSame(
const Elements<VT,TF,DF,CEAs...>& a,
const Vector<VT,TF>& b ) noexcept
1644 if( !
isSame( a.operand(), ~b ) || ( a.size() != (~b).
size() ) )
1647 for(
size_t i=0UL; i<a.size(); ++i ) {
1672 template<
typename VT
1675 ,
typename... CEAs >
1676 inline bool isSame(
const Vector<VT,TF>& a,
const Elements<VT,TF,DF,CEAs...>& b ) noexcept
1698 template<
typename VT1
1705 inline bool isSame(
const Elements<VT1,TF,DF,CEAs...>& a,
const Subvector<VT2,AF,TF,DF,CSAs...>& b ) noexcept
1707 if( !
isSame( a.operand(), b.operand() ) || ( a.size() != b.size() ) )
1710 for(
size_t i=0UL; i<a.size(); ++i ) {
1711 if( a.idx(i) != b.offset()+i )
1735 template<
typename VT1
1741 ,
typename... CEAs >
1742 inline bool isSame(
const Subvector<VT1,AF,TF,DF,CSAs...>& a,
const Elements<VT2,TF,DF,CEAs...>& b ) noexcept
1763 template<
typename VT1
1770 ,
typename... CEAs2 >
1771 inline bool isSame(
const Elements<VT1,TF1,DF1,CEAs1...>& a,
1772 const Elements<VT2,TF2,DF2,CEAs2...>& b ) noexcept
1774 if( !
isSame( a.operand(), b.operand() ) || a.size() != b.size() )
1777 for(
size_t i=0UL; i<a.size(); ++i ) {
1778 if( a.idx(i) != b.idx(i) )
1803 template<
typename VT
1808 inline bool trySet(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
1812 return trySet( e.operand(), e.idx(index), value );
1834 template<
typename VT
1840 trySet(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
1845 const size_t iend( index +
size );
1847 for(
size_t i=index; i<iend; ++i ) {
1848 if( !trySet( e.operand(), e.idx(i), value ) )
1873 template<
typename VT
1878 inline bool tryAdd(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
1882 return tryAdd( e.operand(), e.idx(index), value );
1904 template<
typename VT
1910 tryAdd(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
1915 const size_t iend( index +
size );
1917 for(
size_t i=index; i<iend; ++i ) {
1918 if( !tryAdd( e.operand(), e.idx(i), value ) )
1943 template<
typename VT
1948 inline bool trySub(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
1952 return trySub( e.operand(), e.idx(index), value );
1975 template<
typename VT
1981 trySub(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
1986 const size_t iend( index +
size );
1988 for(
size_t i=index; i<iend; ++i ) {
1989 if( !trySub( e.operand(), e.idx(i), value ) )
2014 template<
typename VT
2019 inline bool tryMult(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2023 return tryMult( e.operand(), e.idx(index), value );
2045 template<
typename VT
2051 tryMult(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2056 const size_t iend( index +
size );
2058 for(
size_t i=index; i<iend; ++i ) {
2059 if( !tryMult( e.operand(), e.idx(i), value ) )
2084 template<
typename VT
2089 inline bool tryDiv(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2093 return tryDiv( e.operand(), e.idx(index), value );
2115 template<
typename VT
2121 tryDiv(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2126 const size_t iend( index +
size );
2128 for(
size_t i=index; i<iend; ++i ) {
2129 if( !tryDiv( e.operand(), e.idx(i), value ) )
2154 template<
typename VT
2157 ,
typename... CEAs >
2158 inline bool tryShift(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
int count )
2162 return tryShift( e.operand(), e.idx(index), count );
2184 template<
typename VT
2187 ,
typename... CEAs >
2189 tryShift(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
int count )
2194 const size_t iend( index +
size );
2196 for(
size_t i=index; i<iend; ++i ) {
2197 if( !tryShift( e.operand(), e.idx(i), count ) )
2223 template<
typename VT
2228 inline bool tryBitand(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2232 return tryBitand( e.operand(), e.idx(index), value );
2255 template<
typename VT
2261 tryBitand(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2266 const size_t iend( index +
size );
2268 for(
size_t i=index; i<iend; ++i ) {
2269 if( !tryBitand( e.operand(), e.idx(i), value ) )
2295 template<
typename VT
2300 inline bool tryBitor(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2304 return tryBitor( e.operand(), e.idx(index), value );
2327 template<
typename VT
2333 tryBitor(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2338 const size_t iend( index +
size );
2340 for(
size_t i=index; i<iend; ++i ) {
2341 if( !tryBitor( e.operand(), e.idx(i), value ) )
2367 template<
typename VT
2372 inline bool tryBitxor(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2376 return tryBitxor( e.operand(), e.idx(index), value );
2399 template<
typename VT
2405 tryBitxor(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2410 const size_t iend( index +
size );
2412 for(
size_t i=index; i<iend; ++i ) {
2413 if( !tryBitxor( e.operand(), e.idx(i), value ) )
2438 template<
typename VT1
2443 inline bool tryAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2444 const Vector<VT2,TF>& rhs,
size_t index )
2449 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2450 if( !trySet( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2476 template<
typename VT1
2481 inline bool tryAddAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2482 const Vector<VT2,TF>& rhs,
size_t index )
2487 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2488 if( !tryAdd( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2514 template<
typename VT1
2519 inline bool trySubAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2520 const Vector<VT2,TF>& rhs,
size_t index )
2525 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2526 if( !trySub( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2552 template<
typename VT1
2557 inline bool tryMultAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2558 const Vector<VT2,TF>& rhs,
size_t index )
2563 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2564 if( !tryMult( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2590 template<
typename VT1
2595 inline bool tryDivAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2596 const Vector<VT2,TF>& rhs,
size_t index )
2601 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2602 if( !tryDiv( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2628 template<
typename VT1
2633 inline bool tryShiftAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2634 const Vector<VT2,TF>& rhs,
size_t index )
2639 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2640 if( !tryShift( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2666 template<
typename VT1
2671 inline bool tryBitandAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2672 const Vector<VT2,TF>& rhs,
size_t index )
2677 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2678 if( !tryBitand( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2704 template<
typename VT1
2709 inline bool tryBitorAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2710 const Vector<VT2,TF>& rhs,
size_t index )
2715 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2716 if( !tryBitor( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2742 template<
typename VT1
2747 inline bool tryBitxorAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2748 const Vector<VT2,TF>& rhs,
size_t index )
2753 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2754 if( !tryBitxor( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2779 template<
typename VT
2782 ,
typename... CEAs >
2783 inline decltype(
auto) derestrict( Elements<VT,TF,DF,CEAs...>& e )
2806 template<
typename VT
2809 ,
typename... CEAs >
2810 inline decltype(
auto) derestrict( Elements<VT,TF,DF,CEAs...>&& e )
2828 template<
typename VT,
bool TF,
bool DF,
size_t I,
size_t... Is,
typename... CEAs >
2829 struct Size< Elements<VT,TF,DF,index_sequence<I,Is...>,CEAs...>, 0UL >
2846 template<
typename VT,
bool TF,
bool DF,
size_t I,
size_t... Is,
typename... CEAs >
2847 struct MaxSize< Elements<VT,TF,DF,index_sequence<I,Is...>,CEAs...>, 0UL >
2864 template<
typename VT,
bool TF,
bool DF,
typename... CEAs >
2865 struct IsRestricted< Elements<VT,TF,DF,CEAs...> >
2866 :
public IsRestricted<VT>
2882 template<
typename VT,
bool TF,
typename... CEAs >
2883 struct HasConstDataAccess< Elements<VT,TF,true,CEAs...> >
2884 :
public HasConstDataAccess<VT>
2900 template<
typename VT,
bool TF,
typename... CEAs >
2901 struct HasMutableDataAccess< Elements<VT,TF,true,CEAs...> >
2902 :
public HasMutableDataAccess<VT>
AlignmentFlag
Alignment flag for (un-)aligned vectors and matrices.Via these flags it is possible to specify subvec...
Definition: AlignmentFlag.h:62
#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 auxiliary alias declarations.
Header file for the blaze::checked and blaze::unchecked instances.
Header file for the alignment flag values.
Header file for the VecVecDivExpr base class.
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.
IntegralConstant< ptrdiff_t, N > Ptrdiff_t
Compile time integral constant wrapper for ptrdiff_t.The Ptrdiff_t alias template represents an integ...
Definition: IntegralConstant.h:237
Header file for the serial shim.
Header file for the IsElements type trait.
Header file for the VecMapExpr base class.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:595
Header file for the VecScalarDivExpr base class.
constexpr Unchecked unchecked
Global Unchecked instance.The blaze::unchecked instance is an optional token for the creation of view...
Definition: Check.h:138
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 extended initializer_list functionality.
Index sequence type of the Blaze library.
Header file for the VecEvalExpr base class.
Header file for the VecScalarMultExpr base class.
Header file for the MaxSize type trait.
Header file for the VecVecMapExpr base class.
Elements specialization for sparse vectors.
Header file for the SmallArray implementation.
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 VecVecAddExpr base class.
Implementation of a dynamic array with small array optimization.The SmallArray class template is a hy...
Definition: SmallArray.h:81
constexpr bool Contains_v
Auxiliary variable template for the Contains type trait.The Contains_v variable template provides a c...
Definition: Contains.h:138
Header file for the VecVecKronExpr base class.
constexpr void MAYBE_UNUSED(const Args &...)
Suppression of unused parameter warnings.
Definition: MaybeUnused.h:81
Header file for the implementation of the Elements base template.
decltype(auto) eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:786
decltype(auto) elements(Vector< VT, TF > &vector, REAs... args)
Creating a view on a selection of elements of the given vector.
Definition: Elements.h:139
Header file for the exception macros of the math module.
Header file for the VecVecMultExpr base class.
Header file for the VecVecSubExpr 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 CrossExpr base class.
Header file for the HasConstDataAccess type trait.
Header file for the VecSerialExpr base class.
Header file for the VecTransExpr base class.
Header file for run time assertion macros.
Header file for the Unique class template.
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 IsPointer type trait.
#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
Header file for the integer_sequence and index_sequence aliases.
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 RemoveReference type trait.
Elements specialization for dense vectors.
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:765
Base class for N-dimensional vectors.The Vector class is a base class for all arbitrarily sized (N-di...
Definition: Forward.h:198
Initializer list type of the Blaze library.
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 IsRestricted type trait.
Header file for the Vector CRTP 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