35 #ifndef _BLAZE_MATH_VIEWS_ELEMENTS_H_ 36 #define _BLAZE_MATH_VIEWS_ELEMENTS_H_ 188 using ReturnType =
const Elements_<
const VT,I,Is...>;
262 template<
typename VT
266 inline decltype(
auto)
elements(
Vector<VT,TF>& vector, const T* indices,
size_t n, REAs... args )
271 return ReturnType( ~vector, indices, n, args... );
315 template<
typename VT
319 inline decltype(
auto)
elements( const
Vector<VT,TF>& vector, const T* indices,
size_t n, REAs... args )
324 return ReturnType( ~vector, indices, n, args... );
345 template<
typename VT
349 inline decltype(
auto)
elements(
Vector<VT,TF>&& vector, const T* indices,
size_t n, REAs... args )
354 return ReturnType( ~vector, indices, n, args... );
375 template<
typename VT
384 return elements<Is...>( std::forward<VT>( vector ), args... );
406 template<
typename VT
413 return elements( std::forward<VT>( vector ), indices.begin(), indices.size(), args... );
435 template<
typename VT
439 inline decltype(
auto)
elements( VT&& vector,
const std::array<T,N>& indices, REAs... args )
443 return elements( std::forward<VT>( vector ), indices.data(), N, args... );
465 template<
typename VT
468 inline decltype(
auto)
elements( VT&& vector,
const std::vector<T>& indices, REAs... args )
472 return elements( std::forward<VT>( vector ), indices.data(), indices.size(), args... );
494 template<
typename VT
502 return elements( std::forward<VT>( vector ), indices.
data(), indices.
size(), args... );
528 template<
size_t... CEAs
535 return elements<CEAs...>( (~vector).leftOperand(), args... ) +
536 elements<CEAs...>( (~vector).rightOperand(), args... );
554 template<
size_t... CEAs
561 return elements<CEAs...>( (~vector).leftOperand(), args... ) -
562 elements<CEAs...>( (~vector).rightOperand(), args... );
580 template<
size_t... CEAs
587 return elements<CEAs...>( (~vector).leftOperand(), args... ) *
588 elements<CEAs...>( (~vector).rightOperand(), args... );
606 template<
size_t... CEAs
613 return elements<CEAs...>( (~vector).leftOperand(), args... ) /
614 elements<CEAs...>( (~vector).rightOperand(), args... );
632 template<
size_t... CEAs
639 using ReturnType = Elements_< VectorType_<VT>, CEAs... >;
658 template<
size_t... CEAs
665 return elements<CEAs...>( (~vector).leftOperand(), args... ) * (~vector).rightOperand();
683 template<
size_t... CEAs
690 return elements<CEAs...>( (~vector).leftOperand(), args... ) / (~vector).rightOperand();
708 template<
size_t... CEAs
715 return map( elements<CEAs...>( (~vector).operand(), args... ), (~vector).operation() );
733 template<
size_t... CEAs
740 return map( elements<CEAs...>( (~vector).leftOperand(), args... ),
741 elements<CEAs...>( (~vector).rightOperand(), args... ),
742 (~vector).operation() );
760 template<
size_t... CEAs
767 return eval( elements<CEAs...>( (~vector).operand(), args... ) );
785 template<
size_t... CEAs
792 return serial( elements<CEAs...>( (~vector).operand(), args... ) );
810 template<
size_t... CEAs
817 return trans( elements<CEAs...>( (~vector).operand(), args... ) );
843 inline decltype(
auto)
elements( Elements<VT,TF,DF,I2,Is2...>& e, REAs... args )
847 static constexpr
size_t indices[] = { I2, Is2... };
848 return elements< indices[I1], indices[Is1]... >( e.operand(), args... );
874 inline decltype(
auto)
elements(
const Elements<VT,TF,DF,I2,Is2...>& e, REAs... args )
878 static constexpr
size_t indices[] = { I2, Is2... };
879 return elements< indices[I1], indices[Is1]... >( e.operand(), args... );
905 inline decltype(
auto)
elements( Elements<VT,TF,DF,I2,Is2...>&& e, REAs... args )
909 static constexpr
size_t indices[] = { I2, Is2... };
910 return elements< indices[I1], indices[Is1]... >( e.operand(), args... );
935 inline decltype(
auto)
elements( Elements<VT,TF,DF>& e, REAs... args )
942 static constexpr
size_t indices[] = { I, Is... };
943 for(
size_t i=0UL; i<
sizeof...(Is)+1UL; ++i ) {
944 if( e.size() <= indices[i] ) {
950 decltype(
auto) indices( e.idces() );
951 return elements( e.operand(), { indices[I], indices[Is]... }, args... );
976 inline decltype(
auto)
elements(
const Elements<VT,TF,DF>& e, REAs... args )
983 static constexpr
size_t indices[] = { I, Is... };
984 for(
size_t i=0UL; i<
sizeof...(Is)+1UL; ++i ) {
985 if( e.size() <= indices[i] ) {
991 decltype(
auto) indices( e.idces() );
992 return elements( e.operand(), { indices[I], indices[Is]... }, args... );
1016 ,
typename... REAs >
1017 inline decltype(
auto)
elements( Elements<VT,TF,DF>&& e, REAs... args )
1024 static constexpr
size_t indices[] = { I, Is... };
1025 for(
size_t i=0UL; i<
sizeof...(Is)+1UL; ++i ) {
1026 if( e.size() <= indices[i] ) {
1032 decltype(
auto) indices( e.idces() );
1033 return elements( e.operand(), { indices[I], indices[Is]... }, args... );
1054 template<
typename VT
1059 ,
typename... REAs >
1060 inline decltype(
auto)
elements( Elements<VT,TF,DF,CEAs...>& e,
1061 const T* indices,
size_t n, REAs... args )
1068 for(
size_t i=0UL; i<n; ++i ) {
1069 if( e.size() <= indices[i] ) {
1075 decltype(
auto) oldIndices( e.idces() );
1079 for(
size_t i=0UL; i<n; ++i ) {
1080 newIndices.pushBack( oldIndices[indices[i]] );
1083 return elements( e.operand(), newIndices.data(), newIndices.size(), args... );
1104 template<
typename VT
1109 ,
typename... REAs >
1110 inline decltype(
auto)
elements(
const Elements<VT,TF,DF,CEAs...>& e,
1111 const T* indices,
size_t n, REAs... args )
1118 for(
size_t i=0UL; i<n; ++i ) {
1119 if( e.size() <= indices[i] ) {
1125 decltype(
auto) oldIndices( e.idces() );
1129 for(
size_t i=0UL; i<n; ++i ) {
1130 newIndices.pushBack( oldIndices[indices[i]] );
1133 return elements( e.operand(), newIndices.data(), newIndices.size(), args... );
1154 template<
typename VT
1159 ,
typename... REAs >
1160 inline decltype(
auto)
elements( Elements<VT,TF,DF,CEAs...>&& e,
1161 const T* indices,
size_t n, REAs... args )
1168 for(
size_t i=0UL; i<n; ++i ) {
1169 if( e.size() <= indices[i] ) {
1175 decltype(
auto) oldIndices( e.idces() );
1179 for(
size_t i=0UL; i<n; ++i ) {
1180 newIndices.pushBack( oldIndices[indices[i]] );
1183 return elements( e.operand(), newIndices.data(), newIndices.size(), args... );
1216 ,
typename... RSAs >
1217 inline decltype(
auto)
subvector( Elements<VT,TF,DF,CEAs...>& e, RSAs... args )
1246 ,
typename... RSAs >
1247 inline decltype(
auto)
subvector(
const Elements<VT,TF,DF,CEAs...>& e, RSAs... args )
1276 ,
typename... RSAs >
1277 inline decltype(
auto)
subvector( Elements<VT,TF,DF,CEAs...>&& e, RSAs... args )
1306 ,
typename... RSAs >
1307 inline decltype(
auto)
1308 subvector( Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size, RSAs... args )
1313 std::iota( indices.
begin(), indices.
end(), index );
1340 ,
typename... RSAs >
1341 inline decltype(
auto)
1342 subvector(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size, RSAs... args )
1347 std::iota( indices.
begin(), indices.
end(), index );
1374 ,
typename... RSAs >
1375 inline decltype(
auto)
1376 subvector( Elements<VT,TF,DF,CEAs...>&& e,
size_t index,
size_t size, RSAs... args )
1381 std::iota( indices.
begin(), indices.
end(), index );
1383 return elements( std::move( e ), indices.
data(), indices.
size(), args... );
1405 template<
typename VT
1409 inline void reset( Elements<VT,TF,DF,CEAs...>& e )
1425 template<
typename VT
1429 inline void reset( Elements<VT,TF,DF,CEAs...>&& e )
1445 template<
typename VT
1449 inline void clear( Elements<VT,TF,DF,CEAs...>& e )
1465 template<
typename VT
1469 inline void clear( Elements<VT,TF,DF,CEAs...>&& e )
1507 inline bool isDefault(
const Elements<VT,TF,true,CEAs...>& e )
1511 for(
size_t i=0UL; i<e.size(); ++i )
1512 if( !isDefault<RF>( e[i] ) )
return false;
1549 inline bool isDefault(
const Elements<VT,TF,false,CEAs...>& e )
1553 for(
const auto& element : ~e )
1554 if( !isDefault<RF>( element.value() ) )
return false;
1579 template<
typename VT
1583 inline bool isIntact(
const Elements<VT,TF,DF,CEAs...>& e ) noexcept
1585 return ( e.size() <= e.operand().size() &&
isIntact( e.operand() ) );
1605 template<
typename VT
1609 inline bool isSame(
const Elements<VT,TF,DF,CEAs...>& a,
const Vector<VT,TF>& b ) noexcept
1611 if( !
isSame( a.operand(), ~b ) || ( a.size() != (~b).
size() ) )
1614 decltype(
auto) indices( a.idces() );
1615 for(
size_t i=0UL; i<a.size(); ++i ) {
1616 if( indices[i] != i )
1640 template<
typename VT
1644 inline bool isSame(
const Vector<VT,TF>& a,
const Elements<VT,TF,DF,CEAs...>& b ) noexcept
1666 template<
typename VT1
1673 inline bool isSame(
const Elements<VT1,TF,DF,CEAs...>& a,
const Subvector<VT2,AF,TF,DF,CSAs...>& b ) noexcept
1675 if( !
isSame( a.operand(), b.operand() ) || ( a.size() != b.size() ) )
1678 decltype(
auto) indices( a.idces() );
1679 for(
size_t i=0UL; i<a.size(); ++i ) {
1680 if( indices[i] != b.offset()+i )
1704 template<
typename VT1
1711 inline bool isSame(
const Subvector<VT1,AF,TF,DF,CSAs...>& a,
const Elements<VT2,TF,DF,CEAs...>& b ) noexcept
1732 template<
typename VT1
1740 inline bool isSame(
const Elements<VT1,TF1,DF1,CEAs1...>& a,
1741 const Elements<VT2,TF2,DF2,CEAs2...>& b ) noexcept
1743 if( !
isSame( a.operand(), b.operand() ) || a.size() != b.size() )
1746 decltype(
auto) indices1( a.idces() );
1747 decltype(
auto) indices2( b.idces() );
1749 return std::equal( indices1.begin(), indices1.end(), indices2.begin() );
1770 template<
typename VT
1775 inline bool trySet(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
1779 return trySet( e.operand(), e.idx(index), value );
1800 template<
typename VT
1805 inline bool tryAdd(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
1809 return tryAdd( e.operand(), e.idx(index), value );
1830 template<
typename VT
1835 inline bool trySub(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
1839 return trySub( e.operand(), e.idx(index), value );
1860 template<
typename VT
1865 inline bool tryMult(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
1869 return tryMult( e.operand(), e.idx(index), value );
1891 template<
typename VT
1897 tryMult(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
1902 const size_t iend( index + size );
1904 for(
size_t i=index; i<iend; ++i ) {
1905 if( !tryMult( e.operand(), e.idx(i), value ) )
1930 template<
typename VT
1935 inline bool tryDiv(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
const ET& value )
1939 return tryDiv( e.operand(), e.idx(index), value );
1961 template<
typename VT
1967 tryDiv(
const Elements<VT,TF,DF,CEAs...>& e,
size_t index,
size_t size,
const ET& value )
1972 const size_t iend( index + size );
1974 for(
size_t i=index; i<iend; ++i ) {
1975 if( !tryDiv( e.operand(), e.idx(i), value ) )
2000 template<
typename VT1
2005 inline bool tryAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2011 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2012 if( !trySet( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2038 template<
typename VT1
2043 inline bool tryAddAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2049 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2050 if( !tryAdd( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2076 template<
typename VT1
2081 inline bool trySubAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2087 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2088 if( !trySub( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2114 template<
typename VT1
2119 inline bool tryMultAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2125 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2126 if( !tryMult( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2152 template<
typename VT1
2157 inline bool tryDivAssign(
const Elements<VT1,TF,DF,CEAs...>& lhs,
2163 for(
size_t i=0UL; i<(~rhs).
size(); ++i ) {
2164 if( !tryDiv( lhs.operand(), lhs.idx(i+index), (~rhs)[i] ) )
2189 template<
typename VT
2194 inline decltype(
auto) derestrict( Elements<VT,TF,DF,I,Is...>& e )
2217 template<
typename VT
2222 inline decltype(
auto) derestrict( Elements<VT,TF,DF,I,Is...>&& e )
2245 template<
typename VT
2248 inline decltype(
auto) derestrict( Elements<VT,TF,DF>& e )
2250 decltype(
auto) indices( e.idces() );
2251 return elements( derestrict( e.operand() ), indices.data(), indices.size(),
unchecked );
2272 template<
typename VT
2275 inline decltype(
auto) derestrict( Elements<VT,TF,DF>&& e )
2277 decltype(
auto) indices( e.idces() );
2278 return elements( derestrict( e.operand() ), indices.data(), indices.size(),
unchecked );
2294 template<
typename VT,
bool TF,
bool DF,
size_t I,
size_t... Is >
2295 struct Size< Elements<VT,TF,DF,I,Is...>, 0UL >
2296 :
public PtrdiffT<1UL+sizeof...(Is)>
2312 template<
typename VT,
bool TF,
bool DF,
size_t... CEAs >
2330 template<
typename VT,
bool TF,
size_t... CEAs >
2348 template<
typename VT,
bool TF,
size_t... CEAs >
2366 template<
typename VT,
bool TF,
bool DF,
size_t... CEAs,
size_t... CSAs >
2385 template<
typename VT,
bool TF,
bool DF,
size_t... CEAs1,
size_t... CEAs2 >
2386 struct ElementsTrait< Elements<VT,TF,DF,CEAs1...>, CEAs2... >
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.
Compile time check for low-level access to constant data.This type trait tests whether the given data...
Definition: HasConstDataAccess.h:75
Base class for all vector transposition expression templates.The VecTransExpr class serves as a tag f...
Definition: VecTransExpr.h:66
Header file for the alignment flag values.
Header file for the UNUSED_PARAMETER function template.
Header file for the VecVecDivExpr base class.
BLAZE_ALWAYS_INLINE 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:949
Header file for basic type definitions.
Base class for all vector evaluation expression templates.The VecEvalExpr class serves as a tag for a...
Definition: VecEvalExpr.h:66
constexpr bool equal(const T1 &a, const T2 &b)
Generic equality check.
Definition: Equal.h:76
Header file for the serial shim.
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:265
Base class for all cross product expression templates.The CrossExpr class serves as a tag for all exp...
Definition: CrossExpr.h:66
Iterator end() noexcept
Returns an iterator just past the last element of the small vector.
Definition: SmallVector.h:620
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:588
Implementation of a dynamic vector with small vector optimization.The SmallVector class template is a...
Definition: SmallVector.h:80
Base class for all vector serial evaluation expression templates.The VecSerialExpr class serves as a ...
Definition: VecSerialExpr.h:67
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
typename ElementsTrait< VT, CEAs... >::Type ElementsTrait_
Auxiliary alias declaration for the ElementsTrait type trait.The ElementsTrait_ alias declaration pro...
Definition: ElementsTrait.h:144
Header file for the extended initializer_list functionality.
Base class for all vector/scalar division expression templates.The VecScalarDivExpr class serves as a...
Definition: VecScalarDivExpr.h:66
Index sequence type of the Blaze library.
Header file for the VecEvalExpr base class.
Header file for the VecScalarMultExpr base class.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:343
Header file for the elements trait.
Header file for the VecVecMapExpr base class.
Elements specialization for sparse vectors.
Compile time check for data types with restricted data access.This type trait tests whether the given...
Definition: IsRestricted.h:82
Base template for the SubvectorTrait class.
Definition: SubvectorTrait.h:109
Compile time check for low-level access to mutable data.This type trait tests whether the given data ...
Definition: HasMutableDataAccess.h:75
Pointer data() noexcept
Low-level data access to the vector elements.
Definition: SmallVector.h:538
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.
Base class for all vector/vector division expression templates.The VecVecDivExpr class serves as a ta...
Definition: VecVecDivExpr.h:66
Header file for the subvector trait.
Header file for the implementation of the Elements base template.
decltype(shift< Offset >(make_index_sequence< N >())) make_shifted_index_sequence
Auxiliary alias declaration for the setup of shifted index sequences.The make_shifted_index_sequence ...
Definition: IntegerSequence.h:158
Implementation of a type list.The TypeList class template represents a list of data types of arbitrar...
Definition: TypeList.h:119
decltype(auto) eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:794
decltype(auto) elements(Vector< VT, TF > &vector, REAs... args)
Creating a view on a selection of elements of the given vector.
Definition: Elements.h:134
Base class for all unary vector map expression templates.The VecMapExpr class serves as a tag for all...
Definition: VecMapExpr.h:66
Header file for the exception macros of the math module.
Header file for the VecVecMultExpr base class.
Base template for the ElementsTrait class.
Definition: ElementsTrait.h:108
Header file for the VecVecSubExpr base class.
Base class for all vector/vector addition expression templates.The VecVecAddExpr class serves as a ta...
Definition: VecVecAddExpr.h:66
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:608
typename SubvectorTrait< VT, CSAs... >::Type SubvectorTrait_
Auxiliary alias declaration for the SubvectorTrait type trait.The SubvectorTrait_ alias declaration p...
Definition: SubvectorTrait.h:145
Header file for the CrossExpr base class.
Header file for the HasConstDataAccess type trait.
Base class for all vector/scalar multiplication expression templates.The VecScalarMultExpr class serv...
Definition: VecScalarMultExpr.h:67
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.
Compile time integral constant wrapper for ptrdiff_t.The PtrdiffT class template represents an integr...
Definition: PtrdiffT.h:72
#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
size_t size() const noexcept
Returns the current size/dimension of the small vector.
Definition: SmallVector.h:769
Header file for the isDefault shim.
void reserve(size_t n)
Setting the minimum capacity of the vector.
Definition: SmallVector.h:895
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:816
Header file for the HasMutableDataAccess type trait.
Elements specialization for dense vectors.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3080
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:789
Base class for N-dimensional vectors.The Vector class is a base class for all arbitrarily sized (N-di...
Definition: Forward.h:177
Initializer list type of the Blaze library.
Compile time evaluation of the size of vectors and matrices.The Size type trait evaluates the size of...
Definition: Size.h:80
Iterator begin() noexcept
Returns an iterator to the first element of the small vector.
Definition: SmallVector.h:572
Base class for all binary vector map expression templates.The VecVecMapExpr class serves as a tag for...
Definition: VecVecMapExpr.h:66
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:254
Header file for the SmallVector implementation.
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:628
void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
Searching a type list.The Contains class can be used to search the type list for a particular type Ty...
Definition: Contains.h:78
Base class for all vector/vector subtraction expression templates.The VecVecSubExpr class serves as a...
Definition: VecVecSubExpr.h:66
Header file for the IsRestricted type trait.
Header file for the Vector CRTP base class.
Header file for the Size type trait.
Base class for all vector/vector multiplication expression templates.The VecVecMultExpr class serves ...
Definition: VecVecMultExpr.h:66
#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.
Template for the blaze::checked and blaze::unchecked instances.blaze::Check is the template for the b...
Definition: Check.h:56
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:1134