35#ifndef _BLAZE_MATH_VIEWS_ELEMENTS_H_
36#define _BLAZE_MATH_VIEWS_ELEMENTS_H_
148 return ReturnType( *vector, args... );
197 using ReturnType =
const Elements_<
const VT,
index_sequence<I,Is...> >;
198 return ReturnType( *vector, args... );
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... );
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
807 return elements<CEAs...>( (*vector).leftOperand(), args... ) +
808 elements<CEAs...>( (*vector).rightOperand(), args... );
827template<
size_t... CEAs
834 return elements<CEAs...>( (*vector).leftOperand(), args... ) -
835 elements<CEAs...>( (*vector).rightOperand(), args... );
854template<
size_t... CEAs
861 return elements<CEAs...>( (*vector).leftOperand(), args... ) *
862 elements<CEAs...>( (*vector).rightOperand(), 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... );
933 decltype(
auto) lhs( (*vector).leftOperand() );
934 decltype(
auto) rhs( (*vector).rightOperand() );
936 const size_t N( rhs.size() );
941 for(
size_t i=0UL; i<n; ++i ) {
942 lhsIndices.pushBack( indices[i] / 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... );
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 >
1014 return elements<CEAs...>( (*vector).leftOperand(), args... ) /
1015 elements<CEAs...>( (*vector).rightOperand(), args... );
1034template<
size_t... CEAs
1036 ,
typename... REAs >
1041 return elements<CEAs...>( (*vector).leftOperand(), args... ) * (*vector).rightOperand();
1060template<
size_t... CEAs
1062 ,
typename... REAs >
1067 return elements<CEAs...>( (*vector).leftOperand(), args... ) / (*vector).rightOperand();
1086template<
size_t... CEAs
1088 ,
typename... REAs >
1112template<
size_t... CEAs
1114 ,
typename... REAs >
1121 (*vector).operation() );
1140template<
size_t... CEAs
1142 ,
typename... REAs >
1166template<
size_t... CEAs
1168 ,
typename... REAs >
1192template<
size_t... CEAs
1194 ,
typename... REAs >
1218template<
size_t... CEAs
1220 ,
typename... REAs >
1244template<
size_t... CEAs
1246 ,
typename... REAs >
1274 ,
typename... REAs >
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)
1324 for(
size_t i=0UL; i<n; ++i ) {
1325 if( (*vector).size() <=
size_t( indices[i] ) ) {
1333 for(
size_t& index : newIndices ) {
1334 index = index % (*vector).operand().size();
1358template<
typename VT
1361 ,
typename... REAs >
1362inline decltype(
auto)
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 ) {
1411inline decltype(
auto)
elements( VT&& e, REAs... args )
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
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] ) ) {
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
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) ) ) {
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 );
1574inline decltype(
auto)
subvector( VT&& e, RSAs... args )
1608inline decltype(
auto)
subvector( VT&& e,
size_t index,
size_t size, RSAs... args )
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 )
1705 ,
typename... CEAs >
1706inline bool isDefault(
const Elements<VT,TF,false,CEAs...>& e )
1710 for(
const auto& element : *e )
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 >
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 >
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,
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,
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,
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,
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,
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,
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,
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,
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,
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 >
3057template<
typename VT,
bool TF,
typename... CEAs >
3075template<
typename VT,
bool TF,
typename... CEAs >
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
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
Base class for N-dimensional vectors.
Definition Vector.h:82
Index sequence type of the Blaze library.
Initializer list 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(Vector< VT, TF > &vector, REAs... args)
Creating a view on a selection of elements of the given vector.
Definition Elements.h:143
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
constexpr bool IsPointer_v
Auxiliary variable template for the IsPointer type trait.
Definition IsPointer.h:95
typename RemoveReference< T >::Type RemoveReference_t
Auxiliary alias declaration for the RemoveReference type trait.
Definition RemoveReference.h:95
IntegralConstant< ptrdiff_t, N > Ptrdiff_t
Compile time integral constant wrapper for ptrdiff_t.
Definition IntegralConstant.h:237
decltype(shift< Offset >(make_index_sequence< N >())) make_shifted_index_sequence
Auxiliary alias declaration for the setup of shifted index sequences.
Definition IntegerSequence.h:227
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
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.
Compile time check for low-level access to constant data.
Definition HasConstDataAccess.h:76
Compile time check for low-level access to mutable data.
Definition HasMutableDataAccess.h:76
Compile time check for data types with restricted data access.
Definition IsRestricted.h:83
Compile time evaluation of the maximum size of vectors and matrices.
Definition MaxSize.h:118
Compile time evaluation of the size of vectors and matrices.
Definition Size.h:119
Base class for all vector evaluation expression templates.
Definition VecEvalExpr.h:69
Base class for all unary vector map expression templates.
Definition VecMapExpr.h:68
Base class for all vector no-alias expression templates.
Definition VecNoAliasExpr.h:68
Base class for all vector no-SIMD expression templates.
Definition VecNoSIMDExpr.h:88
Base class for all vector repeater expression templates.
Definition VecRepeatExpr.h:69
Base class for all vector/scalar division expression templates.
Definition VecScalarDivExpr.h:75
Base class for all vector/scalar multiplication expression templates.
Definition VecScalarMultExpr.h:76
Base class for all vector serial evaluation expression templates.
Definition VecSerialExpr.h:69
Base class for all vector transposition expression templates.
Definition VecTransExpr.h:69
Base class for all vector/vector addition expression templates.
Definition VecVecAddExpr.h:68
Base class for all vector/vector division expression templates.
Definition VecVecDivExpr.h:68
Base class for all vector/vector Kronecker expression templates.
Definition VecVecKronExpr.h:69
Base class for all binary vector map expression templates.
Definition VecVecMapExpr.h:68
Base class for all vector/vector multiplication expression templates.
Definition VecVecMultExpr.h:68
Base class for all vector/vector subtraction expression templates.
Definition VecVecSubExpr.h:68
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.