35 #ifndef _BLAZE_MATH_VIEWS_SPARSESUBVECTOR_H_
36 #define _BLAZE_MATH_VIEWS_SPARSESUBVECTOR_H_
378 template<
typename VT
380 ,
bool TF = IsRowVector<VT>::value >
381 class SparseSubvector :
public SparseVector< SparseSubvector<VT,AF,TF>, TF >
421 ,
typename IteratorType >
529 return pos_->value();
555 ,
typename IteratorType >
600 template<
typename VectorType2,
typename IteratorType2 >
656 template<
typename VectorType2,
typename IteratorType2 >
668 template<
typename VectorType2,
typename IteratorType2 >
670 return !( *
this == rhs );
690 inline IteratorType
base()
const {
723 enum { smpAssignable = 0 };
762 template<
typename Other >
764 operator*=( Other rhs );
766 template<
typename Other >
768 operator/=( Other rhs );
775 inline size_t size()
const;
780 inline void erase (
size_t index );
783 inline void reserve(
size_t n );
784 template<
typename Other >
inline SparseSubvector& scale ( Other scalar );
810 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
811 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
833 template<
bool AF1,
typename VT2,
bool AF2,
bool TF2 >
872 template<
typename VT
880 if( index + n > vector.size() )
881 throw std::invalid_argument(
"Invalid subvector specification" );
900 template<
typename VT
907 return vector_[offset_+index];
918 template<
typename VT
925 return const_cast<const VT&
>( vector_ )[offset_+index];
937 template<
typename VT
943 return Iterator( vector_.begin(), offset_ );
945 return Iterator( vector_.lowerBound( offset_ ), offset_ );
957 template<
typename VT
965 return ConstIterator( vector_.lowerBound( offset_ ), offset_ );
977 template<
typename VT
985 return ConstIterator( vector_.lowerBound( offset_ ), offset_ );
997 template<
typename VT
1002 if( offset_ + size_ == vector_.size() )
1003 return Iterator( vector_.end(), offset_ );
1005 return Iterator( vector_.lowerBound( offset_ + size_ ), offset_ );
1017 template<
typename VT
1022 if( offset_ + size_ == vector_.size() )
1025 return ConstIterator( vector_.lowerBound( offset_ + size_ ), offset_ );
1037 template<
typename VT
1042 if( offset_ + size_ == vector_.size() )
1045 return ConstIterator( vector_.lowerBound( offset_ + size_ ), offset_ );
1068 template<
typename VT
1079 if(
this == &rhs || ( &vector_ == &rhs.vector_ && offset_ == rhs.offset_ ) )
1082 if( size() != rhs.size() )
1083 throw std::invalid_argument(
"Vector sizes do not match" );
1085 if( rhs.canAlias( &vector_ ) ) {
1110 template<
typename VT
1113 template<
typename VT2 >
1123 if( size() != (~rhs).size() )
1124 throw std::invalid_argument(
"Vector sizes do not match" );
1151 template<
typename VT
1154 template<
typename VT2 >
1164 if( size() != (~rhs).size() )
1165 throw std::invalid_argument(
"Vector sizes do not match" );
1192 template<
typename VT
1195 template<
typename VT2 >
1201 if( size() != (~rhs).size() )
1202 throw std::invalid_argument(
"Vector sizes do not match" );
1221 template<
typename VT
1224 template<
typename VT2 >
1230 if( size() != (~rhs).size() )
1231 throw std::invalid_argument(
"Vector sizes do not match" );
1251 template<
typename VT
1254 template<
typename VT2 >
1258 if( size() != (~rhs).size() )
1259 throw std::invalid_argument(
"Vector sizes do not match" );
1267 const MultType tmp( *
this * (~rhs) );
1287 template<
typename VT
1290 template<
typename Other >
1295 for(
Iterator element=begin(); element!=last; ++element )
1296 element->value() *= rhs;
1314 template<
typename VT
1317 template<
typename Other >
1331 const Tmp tmp( Tmp(1)/static_cast<Tmp>( rhs ) );
1332 for(
Iterator element=begin(); element!=last; ++element )
1333 element->value() *= tmp;
1336 for(
Iterator element=begin(); element!=last; ++element )
1337 element->value() /= rhs;
1358 template<
typename VT
1373 template<
typename VT
1378 return nonZeros() + vector_.capacity() - vector_.nonZeros();
1390 template<
typename VT
1395 return end() - begin();
1405 template<
typename VT
1410 vector_.erase( vector_.lowerBound( offset_ ), vector_.lowerBound( offset_ + size_ ) );
1427 template<
typename VT
1433 return Iterator( vector_.insert( offset_ + index, value ), offset_ );
1446 template<
typename VT
1451 vector_.erase( offset_ + index );
1464 template<
typename VT
1469 return Iterator( vector_.erase( pos.base() ), offset_ );
1483 template<
typename VT
1489 return Iterator( vector_.erase( first.base(), last.base() ), offset_ );
1503 template<
typename VT
1508 const size_t current( capacity() );
1511 vector_.reserve( vector_.capacity() + n - current );
1523 template<
typename VT
1526 template<
typename Other >
1529 for(
Iterator element=begin(); element!=end(); ++element )
1530 element->value() *= scalar;
1557 template<
typename VT
1563 const typename VT::Iterator pos( vector_.find( offset_ + index ) );
1565 if( pos != vector_.end() )
1586 template<
typename VT
1594 if( pos != vector_.end() )
1614 template<
typename VT
1620 return Iterator( vector_.lowerBound( offset_ + index ), offset_ );
1637 template<
typename VT
1643 return ConstIterator( vector_.lowerBound( offset_ + index ), offset_ );
1660 template<
typename VT
1666 return Iterator( vector_.upperBound( offset_ + index ), offset_ );
1683 template<
typename VT
1689 return ConstIterator( vector_.upperBound( offset_ + index ), offset_ );
1726 template<
typename VT
1731 if( offset_ + size_ == vector_.size() )
1732 vector_.append( offset_ + index, value, check );
1733 else if( !check || !
isDefault( value ) )
1734 vector_.insert( offset_ + index, value );
1757 template<
typename VT
1760 template<
typename Other >
1763 return static_cast<const void*
>( &vector_ ) == static_cast<const void*>( alias );
1778 template<
typename VT
1781 template<
typename Other >
1784 return static_cast<const void*
>( &vector_ ) == static_cast<const void*>( alias );
1800 template<
typename VT
1803 template<
typename VT2 >
1809 reserve( (~rhs).size() );
1811 for(
size_t i=0UL; i<size(); ++i ) {
1812 append( i, (~rhs)[i],
true );
1829 template<
typename VT
1832 template<
typename VT2 >
1838 reserve( (~rhs).nonZeros() );
1840 for(
typename VT2::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element ) {
1841 append( element->index(), element->value(), true );
1858 template<
typename VT
1861 template<
typename VT2 >
1872 const AddType tmp( *
this + (~rhs) );
1890 template<
typename VT
1893 template<
typename VT2 >
1904 const AddType tmp( *
this + (~rhs) );
1922 template<
typename VT
1925 template<
typename VT2 >
1936 const SubType tmp( *
this - (~rhs) );
1954 template<
typename VT
1957 template<
typename VT2 >
1968 const SubType tmp( *
this - (~rhs) );
1990 template<
typename VT,
bool AF,
bool TF >
1993 template<
typename VT,
bool AF,
bool TF >
1996 template<
typename VT,
bool AF,
bool TF >
2009 template<
typename VT
2028 template<
typename VT
2056 template<
typename VT
2063 const ConstIterator end( sv.end() );
2064 for( ConstIterator element=sv.begin(); element!=end; ++element )
2065 if( !
isDefault( element->value() ) )
return false;
2096 inline const SparseSubvector<VT,AF1,TF>
2097 subvector(
const SparseSubvector<VT,AF2,TF>& sv,
size_t index,
size_t size )
2101 if( index + size > sv.size() )
2102 throw std::invalid_argument(
"Invalid subvector specification" );
2104 return SparseSubvector<VT,AF1,TF>( sv.vector_, sv.offset_ + index, size );
2120 template<
typename VT,
bool AF,
bool TF >
2121 struct SubvectorTrait< SparseSubvector<VT,AF,TF> >
2139 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2140 struct SubvectorExprTrait< SparseSubvector<VT,AF1,TF>, AF2 >
2142 typedef SparseSubvector<VT,AF2,TF> Type;
2150 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2151 struct SubvectorExprTrait< const SparseSubvector<VT,AF1,TF>, AF2 >
2153 typedef SparseSubvector<VT,AF2,TF> Type;
2161 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2162 struct SubvectorExprTrait< volatile SparseSubvector<VT,AF1,TF>, AF2 >
2164 typedef SparseSubvector<VT,AF2,TF> Type;
2172 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2173 struct SubvectorExprTrait< const volatile SparseSubvector<VT,AF1,TF>, AF2 >
2175 typedef SparseSubvector<VT,AF2,TF> Type;
Constraint on the data type.
Pointer difference type of the Blaze library.
View on a specific subvector of a sparse vector.The SparseSubvector template represents a view on a s...
Definition: Forward.h:54
SparseSubvector< VT, AF, TF > This
Type of this SparseSubvector instance.
Definition: SparseSubvector.h:403
Compile time check for numeric types.This type trait tests whether or not the given template paramete...
Definition: IsNumeric.h:98
SelectType< IsExpression< VT >::value, VT, VT & >::Type Operand
Composite data type of the sparse vector expression.
Definition: SparseSubvector.h:387
size_t offset_
Offset within the according sparse vector.
Definition: SparseSubvector.h:546
void reset(DynamicMatrix< Type, SO > &m)
Resetting the given dense matrix.
Definition: DynamicMatrix.h:4579
#define BLAZE_USER_ASSERT(expr, msg)
Run time assertion macro for user checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_USER_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERT flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:117
Header file for the subvector/submatrix alignment flag values.
Compile time type selection.The If class template selects one of the two given types T2 and T3 depend...
Definition: If.h:112
Header file for the subtraction trait.
DifferenceType operator-(const SubvectorIterator &rhs) const
Calculating the number of elements between two subvector iterators.
Definition: SparseSubvector.h:680
ValueType PointerType
Pointer return type.
Definition: SparseSubvector.h:562
Header file for the SparseVector base class.
const size_t offset_
The offset of the subvector within the sparse vector.
Definition: SparseSubvector.h:826
VT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: SparseSubvector.h:407
IteratorType base() const
Access to the current position of the submatrix iterator.
Definition: SparseSubvector.h:690
bool isDefault(const DynamicMatrix< Type, SO > &m)
Returns whether the given dense matrix is in default state.
Definition: DynamicMatrix.h:4622
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:197
bool operator==(const SubvectorIterator< VectorType2, IteratorType2 > &rhs) const
Equality comparison between two SubvectorIterator objects.
Definition: SparseSubvector.h:657
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T)
Constraint on the data type.In case the given data type T is a computational expression (i...
Definition: Computation.h:118
Iterator begin()
Returns an iterator to the first element of the subvector.
Definition: SparseSubvector.h:940
SubvectorElement< VectorType, IteratorType > ValueType
Type of the underlying elements.
Definition: SparseSubvector.h:561
ValueType value_type
Type of the underlying elements.
Definition: SparseSubvector.h:568
Header file for the IsRowVector type trait.
SparseSubvector(Operand vector, size_t index, size_t n)
The constructor for SparseSubvector.
Definition: SparseSubvector.h:875
VT::ConstReference ConstReference
Reference to a constant subvector value.
Definition: SparseSubvector.h:411
Access proxy for sparse, matrices.The MatrixAccessProxy provides safe access to the elements of a no...
Definition: MatrixAccessProxy.h:86
Iterator lowerBound(size_t index)
Returns an iterator to the first index not less then the given index.
Definition: SparseSubvector.h:1618
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TRANSEXPR_TYPE(T)
Constraint on the data type.In case the given data type T is a transposition expression (i...
Definition: TransExpr.h:118
Header file for the RequiresEvaluation type trait.
bool operator!=(const SubvectorIterator< VectorType2, IteratorType2 > &rhs) const
Inequality comparison between two SubvectorIterator objects.
Definition: SparseSubvector.h:669
size_t size() const
Returns the size/dimension of the sparse subvector.
Definition: SparseSubvector.h:1361
size_t offset_
The offset of the subvector within the sparse vector.
Definition: SparseSubvector.h:708
SelectType< returnConst, const ElementType &, ElementType & >::Type ReferenceType
Return type of the value member function.
Definition: SparseSubvector.h:438
void reserve(size_t n)
Setting the minimum capacity of the sparse subvector.
Definition: SparseSubvector.h:1506
IteratorCategory iterator_category
The iterator category.
Definition: SparseSubvector.h:567
void clear(DynamicMatrix< Type, SO > &m)
Clearing the given dense matrix.
Definition: DynamicMatrix.h:4595
PointerType operator->() const
Direct access to the current sparse subvector element.
Definition: SparseSubvector.h:645
SubvectorElement & operator*=(const T &v)
Multiplication assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:495
SubvectorElement & operator/=(const T &v)
Division assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:507
Base template for the SubvectorTrait class.
Definition: SubvectorTrait.h:122
Constraint on the data type.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SparseSubvector.h:405
SubvectorElement & operator-=(const T &v)
Subtraction assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:483
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:90
ReferenceType operator*() const
Direct access to the current sparse subvector element.
Definition: SparseSubvector.h:635
SubvectorElement & operator+=(const T &v)
Addition assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:471
Iterator end()
Returns an iterator just past the last element of the subvector.
Definition: SparseSubvector.h:1000
ReferenceType reference
Reference return type.
Definition: SparseSubvector.h:570
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
SelectType< useConst, ConstIterator, SubvectorIterator< VT, typename VT::Iterator > >::Type Iterator
Iterator over non-constant elements.
Definition: SparseSubvector.h:718
std::forward_iterator_tag IteratorCategory
The iterator category.
Definition: SparseSubvector.h:560
SubvectorIterator< const VT, typename VT::ConstIterator > ConstIterator
Iterator over constant elements.
Definition: SparseSubvector.h:715
Header file for the multiplication trait.
void erase(size_t index)
Erasing an element from the sparse subvector.
Definition: SparseSubvector.h:1449
size_t capacity() const
Returns the maximum capacity of the sparse subvector.
Definition: SparseSubvector.h:1376
Header file for the If class template.
Header file for the Subvector base class.
Operand vector_
The sparse vector containing the subvector.
Definition: SparseSubvector.h:825
Header file for the IsFloatingPoint type trait.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2388
SubvectorIterator & operator++()
Pre-increment operator.
Definition: SparseSubvector.h:612
Header file for the Or class template.
SubvectorIterator()
Default constructor for the SubvectorIterator class.
Definition: SparseSubvector.h:577
void assign(const DenseVector< VT2, TF > &rhs)
Default implementation of the assignment of a dense vector.
Definition: SparseSubvector.h:1804
PointerType pointer
Pointer return type.
Definition: SparseSubvector.h:569
size_t index() const
Access to the current index of the sparse element.
Definition: SparseSubvector.h:538
Header file for the subvector trait.
const SubvectorElement * operator->() const
Direct access to the sparse subvector element at the current iterator position.
Definition: SparseSubvector.h:518
void assign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the assignment of a matrix to a matrix.
Definition: Matrix.h:179
Access proxy for a specific element of the sparse subvector.
Definition: SparseSubvector.h:422
void append(size_t index, const ElementType &value, bool check=false)
Appending an element to the sparse subvector.
Definition: SparseSubvector.h:1729
SubvectorIterator(IteratorType iterator, size_t index)
Constructor for the SubvectorIterator class.
Definition: SparseSubvector.h:589
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional vector type...
Definition: SparseVector.h:79
Constraint on the data type.
Header file for the SparseElement base class.
Constraint on the data type.
void subAssign(const DenseVector< VT2, TF > &rhs)
Default implementation of the subtraction assignment of a dense vector.
Definition: SparseSubvector.h:1926
Constraint on the data type.
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: SparseSubvector.h:564
SubvectorTrait< VT >::Type ResultType
Result type for expression template evaluations.
Definition: SparseSubvector.h:404
Compile time check for floating point data types.This type trait tests whether or not the given templ...
Definition: IsFloatingPoint.h:94
size_t offset() const
Access to the offset of the submatrix iterator.
Definition: SparseSubvector.h:700
Iterator upperBound(size_t index)
Returns an iterator to the first index greater then the given index.
Definition: SparseSubvector.h:1664
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2382
Constraint on the data type.
Header file for the SelectType class template.
Constraint on the data type.
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2386
Header file for the EnableIf class template.
VT::ElementType ElementType
Type of the subvector elements.
Definition: SparseSubvector.h:406
SubvectorElement & operator=(const T &v)
Assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:459
DifferenceType difference_type
Difference between two iterators.
Definition: SparseSubvector.h:571
const bool unaligned
Alignment flag for unaligned subvectors and submatrices.
Definition: AlignmentFlag.h:63
Header file for the IsNumeric type trait.
Reference operator[](size_t index)
Subscript operator for the direct access to the subvector elements.
Definition: SparseSubvector.h:904
SubvectorIterator(const SubvectorIterator< VectorType2, IteratorType2 > &it)
Conversion constructor from different SubvectorIterator instances.
Definition: SparseSubvector.h:601
ValueType ReferenceType
Reference return type.
Definition: SparseSubvector.h:563
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2383
Header file for the IsConst type trait.
Header file for run time assertion macros.
Base template for the AddTrait class.
Definition: AddTrait.h:141
Base template for the MultTrait class.
Definition: MultTrait.h:141
Header file for the addition trait.
Header file for the division trait.
void addAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the addition assignment of a matrix to a matrix.
Definition: Matrix.h:209
ReferenceType value() const
Access to the current value of the sparse subvector element.
Definition: SparseSubvector.h:528
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
const size_t size_
The size of the subvector.
Definition: SparseSubvector.h:827
SubvectorExprTrait< VT, unaligned >::Type subvector(Vector< VT, TF > &vector, size_t index, size_t size)
Creating a view on a specific subvector of the given vector.
Definition: Subvector.h:133
void subAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the subtraction assignment of a matrix to matrix.
Definition: Matrix.h:239
bool canAlias(const Other *alias) const
Returns whether the sparse subvector can alias with the given address alias.
Definition: SparseSubvector.h:1761
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2387
Header file for the isDefault shim.
bool isAliased(const Other *alias) const
Returns whether the sparse subvector is aliased with the given address alias.
Definition: SparseSubvector.h:1782
Base class for all sparse element types.The SparseElement class is the base class for all sparse elem...
Definition: SparseElement.h:57
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.In case the given data type T requires an intermediate evaluation within ...
Definition: RequiresEvaluation.h:118
VT VectorType
Type of the vector.
Definition: Vector.h:72
Compile time check for constant data types.The IsConst type trait tests whether or not the given temp...
Definition: IsConst.h:94
Iterator find(size_t index)
Searches for a specific subvector element.
Definition: SparseSubvector.h:1561
Base template for the DivTrait class.
Definition: DivTrait.h:141
size_t nonZeros() const
Returns the number of non-zero elements in the subvector.
Definition: SparseSubvector.h:1393
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional vector type...
Definition: DenseVector.h:79
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SUBVECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is a subvector type (i.e. a dense or sparse subvector), a compilation error is created.
Definition: Subvector.h:118
const SparseSubvector & CompositeType
Data type for composite expression templates.
Definition: SparseSubvector.h:408
ConstIterator cbegin() const
Returns an iterator to the first element of the subvector.
Definition: SparseSubvector.h:980
Iterator insert(size_t index, const ElementType &value)
Inserting an element into the sparse subvector.
Definition: SparseSubvector.h:1431
const SubvectorIterator operator++(int)
Post-increment operator.
Definition: SparseSubvector.h:623
Base class for N-dimensional vectors.The Vector class is a base class for all arbitrarily sized (N-di...
Definition: Forward.h:147
IteratorType pos_
Iterator to the current sparse element.
Definition: SparseSubvector.h:707
Iterator over the elements of the sparse subvector.
Definition: SparseSubvector.h:556
SubvectorElement(IteratorType pos, size_t offset)
Constructor for the SubvectorElement class.
Definition: SparseSubvector.h:447
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:105
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2379
Header file for basic type definitions.
void reset()
Reset to the default initial values.
Definition: SparseSubvector.h:1408
Header file for the SubvectorExprTrait class template.
SparseSubvector & operator=(const SparseSubvector &rhs)
Copy assignment operator for SparseSubvector.
Definition: SparseSubvector.h:1072
ConstIterator cend() const
Returns an iterator just past the last element of the subvector.
Definition: SparseSubvector.h:1040
void addAssign(const DenseVector< VT2, TF > &rhs)
Default implementation of the addition assignment of a dense vector.
Definition: SparseSubvector.h:1862
Base template for the SubTrait class.
Definition: SubTrait.h:141
SelectType< useConst, ConstReference, typename VT::Reference >::Type Reference
Reference to a non-constant subvector value.
Definition: SparseSubvector.h:414
#define BLAZE_CONSTRAINT_MUST_BE_VECTOR_WITH_TRANSPOSE_FLAG(T, TF)
Constraint on the data type.In case the given data type T is not a dense or sparse vector type and in...
Definition: TransposeFlag.h:238
#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
IteratorType pos_
Iterator to the current position within the sparse subvector.
Definition: SparseSubvector.h:545
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.