35 #ifndef _BLAZE_MATH_VIEWS_ELEMENTS_H_ 36 #define _BLAZE_MATH_VIEWS_ELEMENTS_H_ 263 template<
typename VT
267 inline decltype(
auto)
elements(
Vector<VT,TF>& vector, const T* indices,
size_t n, REAs... args )
272 return ReturnType( ~vector, indices, n, args... );
316 template<
typename VT
320 inline decltype(
auto)
elements( const
Vector<VT,TF>& vector, const T* indices,
size_t n, REAs... args )
325 return ReturnType( ~vector, indices, n, args... );
346 template<
typename VT
350 inline decltype(
auto)
elements(
Vector<VT,TF>&& vector, const T* indices,
size_t n, REAs... args )
355 return ReturnType( ~vector, indices, n, args... );
397 template<
typename VT
401 , EnableIf_t< !IsPointer_v<P> >* =
nullptr >
402 inline decltype(
auto)
elements(
Vector<VT,TF>& vector, P p,
size_t n, REAs... args )
451 template<
typename VT
455 , EnableIf_t< !IsPointer_v<P> >* =
nullptr >
456 inline decltype(
auto)
elements( const
Vector<VT,TF>& vector, P p,
size_t n, REAs... args )
460 using ReturnType =
const Elements_<const VT,P>;
482 template<
typename VT
486 , EnableIf_t< !IsPointer_v<P> >* =
nullptr >
487 inline decltype(
auto)
elements(
Vector<VT,TF>&& vector, P p,
size_t n, REAs... args )
534 template<
typename VT
537 inline decltype(
auto)
elements( VT&& vector, index_sequence<Is...> indices, REAs... args )
543 return elements<Is...>( std::forward<VT>( vector ), args... );
584 template<
typename VT
591 return elements( std::forward<VT>( vector ), indices.begin(), indices.size(), args... );
633 template<
typename VT
637 inline decltype(
auto)
elements( VT&& vector, const
std::array<T,N>& indices, REAs... args )
641 return elements( std::forward<VT>( vector ), indices.data(), N, args... );
683 template<
typename VT
686 inline decltype(
auto)
elements( VT&& vector, const
std::vector<T>& indices, REAs... args )
690 return elements( std::forward<VT>( vector ), indices.data(), indices.size(), args... );
732 template<
typename VT
740 return elements( std::forward<VT>( vector ), indices.data(), indices.size(), args... );
760 template<
typename VT
764 inline decltype(
auto)
elements( VT&& vector, const
std::pair<T1,T2>& pair, REAs... args )
768 return elements( std::forward<VT>( vector ), pair.first, pair.second, args... );
794 template<
typename... CEAs
797 inline decltype(
auto)
elements( const VecVecAddExpr<VT>& vector, REAs... args )
801 return elements<CEAs...>( (~vector).leftOperand(), args... ) +
802 elements<CEAs...>( (~vector).rightOperand(), args... );
820 template<
typename... CEAs
823 inline decltype(
auto)
elements( const VecVecSubExpr<VT>& vector, REAs... args )
827 return elements<CEAs...>( (~vector).leftOperand(), args... ) -
828 elements<CEAs...>( (~vector).rightOperand(), args... );
846 template<
typename... CEAs
849 inline decltype(
auto)
elements( const VecVecMultExpr<VT>& vector, REAs... args )
853 return elements<CEAs...>( (~vector).leftOperand(), args... ) *
854 elements<CEAs...>( (~vector).rightOperand(), args... );
872 template<
typename... CEAs
875 inline decltype(
auto)
elements( const VecVecDivExpr<VT>& vector, REAs... args )
879 return elements<CEAs...>( (~vector).leftOperand(), args... ) /
880 elements<CEAs...>( (~vector).rightOperand(), args... );
898 template<
typename... CEAs
901 inline decltype(
auto)
elements( const CrossExpr<VT>& vector, REAs... args )
905 using ReturnType = Elements_< VectorType_t<VT>, CEAs... >;
924 template<
typename... CEAs
927 inline decltype(
auto)
elements( const VecScalarMultExpr<VT>& vector, REAs... args )
931 return elements<CEAs...>( (~vector).leftOperand(), args... ) * (~vector).rightOperand();
949 template<
typename... CEAs
952 inline decltype(
auto)
elements( const VecScalarDivExpr<VT>& vector, REAs... args )
956 return elements<CEAs...>( (~vector).leftOperand(), args... ) / (~vector).rightOperand();
974 template<
typename... CEAs
977 inline decltype(
auto)
elements( const VecMapExpr<VT>& vector, REAs... args )
981 return map( elements<CEAs...>( (~vector).operand(), args... ), (~vector).operation() );
999 template<
typename... CEAs
1001 ,
typename... REAs >
1002 inline decltype(
auto)
elements( const VecVecMapExpr<VT>& vector, REAs... args )
1006 return map( elements<CEAs...>( (~vector).leftOperand(), args... ),
1007 elements<CEAs...>( (~vector).rightOperand(), args... ),
1008 (~vector).operation() );
1026 template<
typename... CEAs
1028 ,
typename... REAs >
1029 inline decltype(
auto)
elements( const VecEvalExpr<VT>& vector, REAs... args )
1033 return eval( elements<CEAs...>( (~vector).operand(), args... ) );
1051 template<
typename... CEAs
1053 ,
typename... REAs >
1054 inline decltype(
auto)
elements( const VecSerialExpr<VT>& vector, REAs... args )
1058 return serial( elements<CEAs...>( (~vector).operand(), args... ) );
1076 template<
typename... CEAs
1078 ,
typename... REAs >
1079 inline decltype(
auto)
elements( const VecTransExpr<VT>& vector, REAs... args )
1083 return trans( elements<CEAs...>( (~vector).operand(), args... ) );
1109 ,
typename... REAs >
1110 inline decltype(
auto)
elements( Elements<VT,TF,DF,index_sequence<I2,Is2...>,CEAs...>& e, REAs... args )
1114 static constexpr
size_t indices[] = { I2, Is2... };
1115 return elements< indices[I1], indices[Is1]... >( e.operand(), args... );
1141 ,
typename... REAs >
1142 inline decltype(
auto)
elements( const Elements<VT,TF,DF,index_sequence<I2,Is2...>,CEAs...>& e, REAs... args )
1146 static constexpr
size_t indices[] = { I2, Is2... };
1147 return elements< indices[I1], indices[Is1]... >( e.operand(), args... );
1173 ,
typename... REAs >
1174 inline decltype(
auto)
elements( Elements<VT,TF,DF,index_sequence<I2,Is2...>,CEAs...>&& e, REAs... args )
1178 static constexpr
size_t indices[] = { I2, Is2... };
1179 return elements< indices[I1], indices[Is1]... >( e.operand(), args... );
1204 ,
typename... REAs >
1205 inline decltype(
auto)
elements( Elements<VT,TF,DF,CEAs...>& e, REAs... args )
1212 static constexpr
size_t indices[] = { I, Is... };
1213 for(
size_t i=0UL; i<
sizeof...(Is)+1UL; ++i ) {
1214 if( e.size() <= indices[i] ) {
1220 return elements( e.operand(), { e.idx(I), e.idx(Is)... }, args... );
1245 ,
typename... REAs >
1246 inline decltype(
auto)
elements( const Elements<VT,TF,DF,CEAs...>& e, REAs... args )
1253 static constexpr
size_t indices[] = { I, Is... };
1254 for(
size_t i=0UL; i<
sizeof...(Is)+1UL; ++i ) {
1255 if( e.size() <= indices[i] ) {
1261 return elements( e.operand(), { e.idx(I), e.idx(Is)... }, args... );
1286 ,
typename... REAs >
1287 inline decltype(
auto)
elements( Elements<VT,TF,DF,CEAs...>&& e, REAs... args )
1294 static constexpr
size_t indices[] = { I, Is... };
1295 for(
size_t i=0UL; i<
sizeof...(Is)+1UL; ++i ) {
1296 if( e.size() <= indices[i] ) {
1302 return elements( e.operand(), { e.idx(I), e.idx(Is)... }, args... );
1323 template<
typename VT
1328 ,
typename... REAs >
1329 inline decltype(
auto)
elements( Elements<VT,TF,DF,CEAs...>& e,
1330 const T* indices,
size_t n, REAs... args )
1337 for(
size_t i=0UL; i<n; ++i ) {
1338 if( e.size() <= size_t( indices[i] ) ) {
1344 SmallArray<size_t,128UL> newIndices;
1345 newIndices.reserve( n );
1347 for(
size_t i=0UL; i<n; ++i ) {
1348 newIndices.pushBack( e.idx( indices[i] ) );
1351 return elements( e.operand(), newIndices.data(), newIndices.size(), args... );
1372 template<
typename VT
1377 ,
typename... REAs >
1378 inline decltype(
auto)
elements( const Elements<VT,TF,DF,CEAs...>& e,
1379 const T* indices,
size_t n, REAs... args )
1386 for(
size_t i=0UL; i<n; ++i ) {
1387 if( e.size() <= size_t( indices[i] ) ) {
1393 SmallArray<size_t,128UL> newIndices;
1394 newIndices.reserve( n );
1396 for(
size_t i=0UL; i<n; ++i ) {
1397 newIndices.pushBack( e.idx( indices[i] ) );
1400 return elements( e.operand(), newIndices.data(), newIndices.size(), args... );
1421 template<
typename VT
1426 ,
typename... REAs >
1427 inline decltype(
auto)
elements( Elements<VT,TF,DF,CEAs...>&& e,
1428 const T* indices,
size_t n, REAs... args )
1435 for(
size_t i=0UL; i<n; ++i ) {
1436 if( e.size() <= size_t( indices[i] ) ) {
1442 SmallArray<size_t,128UL> newIndices;
1443 newIndices.reserve( n );
1445 for(
size_t i=0UL; i<n; ++i ) {
1446 newIndices.pushBack( e.idx( indices[i] ) );
1449 return elements( e.operand(), newIndices.data(), newIndices.size(), args... );
1470 template<
typename VT
1476 , EnableIf_t< !IsPointer_v<P> >* =
nullptr >
1477 inline decltype(
auto)
elements( Elements<VT,TF,DF,CEAs...>& e,
1478 P p,
size_t n, REAs... args )
1485 for(
size_t i=0UL; i<n; ++i ) {
1486 if( e.size() <= size_t( p(i) ) ) {
1492 SmallArray<size_t,128UL> newIndices;
1493 newIndices.reserve( n );
1495 for(
size_t i=0UL; i<n; ++i ) {
1496 newIndices.pushBack( e.idx( p(i) ) );
1499 return elements( e.operand(), newIndices.data(), newIndices.size(), args... );
1520 template<
typename VT
1526 , EnableIf_t< !IsPointer_v<P> >* =
nullptr >
1527 inline decltype(
auto)
elements( const Elements<VT,TF,DF,CEAs...>& e,
1528 P p,
size_t n, REAs... args )
1535 for(
size_t i=0UL; i<n; ++i ) {
1536 if( e.size() <= size_t( p(i) ) ) {
1542 SmallArray<size_t,128UL> newIndices;
1543 newIndices.reserve( n );
1545 for(
size_t i=0UL; i<n; ++i ) {
1546 newIndices.pushBack( e.idx( p(i) ) );
1549 return elements( e.operand(), newIndices.data(), newIndices.size(), args... );
1570 template<
typename VT
1576 , EnableIf_t< !IsPointer_v<P> >* =
nullptr >
1577 inline decltype(
auto)
elements( Elements<VT,TF,DF,CEAs...>&& e,
1578 P p,
size_t n, REAs... args )
1585 for(
size_t i=0UL; i<n; ++i ) {
1586 if( e.size() <= size_t( p(i) ) ) {
1592 SmallArray<size_t,128UL> newIndices;
1593 newIndices.reserve( n );
1595 for(
size_t i=0UL; i<n; ++i ) {
1596 newIndices.pushBack( e.idx( p(i) ) );
1599 return elements( e.operand(), newIndices.data(), newIndices.size(), args... );
1632 ,
typename... RSAs >
1633 inline decltype(
auto)
subvector( Elements<VT,TF,DF,CEAs...>& e, RSAs... args )
1637 return elements( e, make_shifted_index_sequence<I,N>(), args... );
1662 ,
typename... RSAs >
1663 inline decltype(
auto)
subvector( const Elements<VT,TF,DF,CEAs...>& e, RSAs... args )
1667 return elements( e, make_shifted_index_sequence<I,N>(), args... );
1692 ,
typename... RSAs >
1693 inline decltype(
auto)
subvector( Elements<VT,TF,DF,CEAs...>&& e, RSAs... args )
1697 return elements( e, make_shifted_index_sequence<I,N>(), args... );
1722 ,
typename... RSAs >
1723 inline decltype(
auto)
1724 subvector( Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size, RSAs... args )
1728 SmallArray<size_t,128UL> indices(
size );
1729 std::iota( indices.begin(), indices.end(), index );
1731 return elements( e, indices.data(), indices.size(), args... );
1756 ,
typename... RSAs >
1757 inline decltype(
auto)
1758 subvector( const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size, RSAs... args )
1762 SmallArray<size_t,128UL> indices(
size );
1763 std::iota( indices.begin(), indices.end(), index );
1765 return elements( e, indices.data(), indices.size(), args... );
1790 ,
typename... RSAs >
1791 inline decltype(
auto)
1792 subvector( Elements<VT,TF,DF,CEAs...>&& e,
size_t index,
size_t size, RSAs... args )
1796 SmallArray<size_t,128UL> indices(
size );
1797 std::iota( indices.begin(), indices.end(), index );
1799 return elements( std::move( e ), indices.data(), indices.size(), args... );
1821 template<
typename VT
1824 ,
typename... CEAs >
1825 inline void reset( Elements<VT,TF,DF,CEAs...>& e )
1841 template<
typename VT
1844 ,
typename... CEAs >
1845 inline void reset( Elements<VT,TF,DF,CEAs...>&& e )
1861 template<
typename VT
1864 ,
typename... CEAs >
1865 inline void clear( Elements<VT,TF,DF,CEAs...>& e )
1881 template<
typename VT
1884 ,
typename... CEAs >
1885 inline void clear( Elements<VT,TF,DF,CEAs...>&& e )
1922 ,
typename... CEAs >
1923 inline bool isDefault(
const Elements<VT,TF,true,CEAs...>& e )
1927 for(
size_t i=0UL; i<e.size(); ++i )
1928 if( !isDefault<RF>( e[i] ) )
return false;
1964 ,
typename... CEAs >
1965 inline bool isDefault(
const Elements<VT,TF,false,CEAs...>& e )
1969 for(
const auto& element : ~e )
1970 if( !isDefault<RF>( element.value() ) )
return false;
1995 template<
typename VT
1998 ,
typename... CEAs >
1999 inline bool isIntact(
const Elements<VT,TF,DF,CEAs...>& e ) noexcept
2001 return ( e.size() <= e.operand().size() &&
isIntact( e.operand() ) );
2021 template<
typename VT
2024 ,
typename... CEAs >
2025 inline bool isSame(
const Elements<VT,TF,DF,CEAs...>& a,
const Vector<VT,TF>& b ) noexcept
2027 if( !
isSame( a.operand(), ~b ) || ( a.size() != (~b).
size() ) )
2030 for(
size_t i=0UL; i<a.size(); ++i ) {
2055 template<
typename VT
2058 ,
typename... CEAs >
2059 inline bool isSame(
const Vector<VT,TF>& a,
const Elements<VT,TF,DF,CEAs...>& b ) noexcept
2081 template<
typename VT1
2088 inline bool isSame(
const Elements<VT1,TF,DF,CEAs...>& a,
const Subvector<VT2,AF,TF,DF,CSAs...>& b ) noexcept
2090 if( !
isSame( a.operand(), b.operand() ) || ( a.size() != b.size() ) )
2093 for(
size_t i=0UL; i<a.size(); ++i ) {
2094 if( a.idx(i) != b.offset()+i )
2118 template<
typename VT1
2124 ,
typename... CEAs >
2125 inline bool isSame(
const Subvector<VT1,AF,TF,DF,CSAs...>& a,
const Elements<VT2,TF,DF,CEAs...>& b ) noexcept
2146 template<
typename VT1
2153 ,
typename... CEAs2 >
2154 inline bool isSame(
const Elements<VT1,TF1,DF1,CEAs1...>& a,
2155 const Elements<VT2,TF2,DF2,CEAs2...>& b ) noexcept
2157 if( !
isSame( a.operand(), b.operand() ) || a.size() != b.size() )
2160 for(
size_t i=0UL; i<a.size(); ++i ) {
2161 if( a.idx(i) != b.idx(i) )
2186 template<
typename VT
2191 inline bool trySet(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2195 return trySet( e.operand(), e.idx(index), value );
2216 template<
typename VT
2221 inline bool tryAdd(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2225 return tryAdd( e.operand(), e.idx(index), value );
2246 template<
typename VT
2251 inline bool trySub(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2255 return trySub( e.operand(), e.idx(index), value );
2276 template<
typename VT
2281 inline bool tryMult(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2285 return tryMult( e.operand(), e.idx(index), value );
2307 template<
typename VT
2313 tryMult(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2318 const size_t iend( index +
size );
2320 for(
size_t i=index; i<iend; ++i ) {
2321 if( !tryMult( e.operand(), e.idx(i), value ) )
2346 template<
typename VT
2351 inline bool tryDiv(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
2355 return tryDiv( e.operand(), e.idx(index), value );
2377 template<
typename VT
2383 tryDiv(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
2388 const size_t iend( index +
size );
2390 for(
size_t i=index; i<iend; ++i ) {
2391 if( !tryDiv( e.operand(), e.idx(i), value ) )
2416 template<
typename VT1
2421 inline bool tryAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2422 const Vector<VT2,TF>& rhs,
size_t index )
2427 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2428 if( !trySet( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2454 template<
typename VT1
2459 inline bool tryAddAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2460 const Vector<VT2,TF>& rhs,
size_t index )
2465 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2466 if( !tryAdd( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2492 template<
typename VT1
2497 inline bool trySubAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2498 const Vector<VT2,TF>& rhs,
size_t index )
2503 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2504 if( !trySub( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2530 template<
typename VT1
2535 inline bool tryMultAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2536 const Vector<VT2,TF>& rhs,
size_t index )
2541 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2542 if( !tryMult( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2568 template<
typename VT1
2573 inline bool tryDivAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2574 const Vector<VT2,TF>& rhs,
size_t index )
2579 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2580 if( !tryDiv( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2605 template<
typename VT
2608 ,
typename... CEAs >
2609 inline decltype(
auto) derestrict( Elements<VT,TF,DF,CEAs...>& e )
2632 template<
typename VT
2635 ,
typename... CEAs >
2636 inline decltype(
auto) derestrict( Elements<VT,TF,DF,CEAs...>&& e )
2654 template<
typename VT,
bool TF,
bool DF,
size_t I,
size_t... Is,
typename... CEAs >
2655 struct Size< Elements<VT,TF,DF,index_sequence<I,Is...>,CEAs...>, 0UL >
2656 :
public PtrdiffT<1UL+sizeof...(Is)>
2672 template<
typename VT,
bool TF,
bool DF,
size_t I,
size_t... Is,
typename... CEAs >
2673 struct MaxSize< Elements<VT,TF,DF,index_sequence<I,Is...>,CEAs...>, 0UL >
2674 :
public PtrdiffT<1UL+sizeof...(Is)>
2690 template<
typename VT,
bool TF,
bool DF,
typename... CEAs >
2691 struct IsRestricted< Elements<VT,TF,DF,CEAs...> >
2692 :
public IsRestricted<VT>
2708 template<
typename VT,
bool TF,
typename... CEAs >
2709 struct HasConstDataAccess< Elements<VT,TF,true,CEAs...> >
2710 :
public HasConstDataAccess<VT>
2726 template<
typename VT,
bool TF,
typename... CEAs >
2727 struct HasMutableDataAccess< Elements<VT,TF,true,CEAs...> >
2728 :
public HasMutableDataAccess<VT>
decltype(auto) subvector(Vector< VT, TF > &, RSAs...)
Creating a view on a specific subvector of the given vector.
Definition: Subvector.h:329
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 UNUSED_PARAMETER function template.
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.
Header file for the serial shim.
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:591
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
Header file for the extended initializer_list functionality.
Index sequence type of the Blaze library.
constexpr void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
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:139
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:135
Header file for the exception macros of the math module.
Header file for the VecVecMultExpr base class.
Header file for the VecVecSubExpr base class.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:611
Header file for the CrossExpr base class.
Header file for the HasConstDataAccess type trait.
IntegralConstant< ptrdiff_t, N > PtrdiffT
Compile time integral constant wrapper for ptrdiff_t.The PtrdiffT class template represents an integr...
Definition: PtrdiffT.h:72
Header file for the VecSerialExpr base class.
Header file for the PtrdiffT class template.
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.
Elements specialization for dense vectors.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3081
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:186
Initializer list type of the Blaze library.
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:263
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:631
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, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
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:1110