35 #ifndef _BLAZE_MATH_VIEWS_SPARSESUBVECTOR_H_
36 #define _BLAZE_MATH_VIEWS_SPARSESUBVECTOR_H_
379 template<
typename VT
381 ,
bool TF = IsRowVector<VT>::value >
382 class SparseSubvector :
public SparseVector< SparseSubvector<VT,AF,TF>, TF >
422 ,
typename IteratorType >
530 return pos_->value();
556 ,
typename IteratorType >
601 template<
typename VectorType2,
typename IteratorType2 >
657 template<
typename VectorType2,
typename IteratorType2 >
669 template<
typename VectorType2,
typename IteratorType2 >
671 return !( *
this == rhs );
691 inline IteratorType
base()
const {
724 enum { smpAssignable = VT::smpAssignable };
763 template<
typename Other >
765 operator*=( Other rhs );
767 template<
typename Other >
769 operator/=( Other rhs );
776 inline size_t size()
const;
781 inline void erase (
size_t index );
784 inline void reserve(
size_t n );
785 template<
typename Other >
inline SparseSubvector& scale ( Other scalar );
811 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
812 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
837 template<
bool AF1,
typename VT2,
bool AF2,
bool TF2 >
841 template<
typename VT2,
bool AF2,
bool TF2 >
844 template<
typename VT2,
bool AF2,
bool TF2 >
847 template<
typename VT2,
bool AF2,
bool TF2 >
885 template<
typename VT
893 if( index + n > vector.size() )
894 throw std::invalid_argument(
"Invalid subvector specification" );
913 template<
typename VT
920 return vector_[offset_+index];
931 template<
typename VT
938 return const_cast<const VT&
>( vector_ )[offset_+index];
950 template<
typename VT
956 return Iterator( vector_.begin(), offset_ );
958 return Iterator( vector_.lowerBound( offset_ ), offset_ );
970 template<
typename VT
978 return ConstIterator( vector_.lowerBound( offset_ ), offset_ );
990 template<
typename VT
998 return ConstIterator( vector_.lowerBound( offset_ ), offset_ );
1010 template<
typename VT
1015 if( offset_ + size_ == vector_.size() )
1016 return Iterator( vector_.end(), offset_ );
1018 return Iterator( vector_.lowerBound( offset_ + size_ ), offset_ );
1030 template<
typename VT
1035 if( offset_ + size_ == vector_.size() )
1038 return ConstIterator( vector_.lowerBound( offset_ + size_ ), offset_ );
1050 template<
typename VT
1055 if( offset_ + size_ == vector_.size() )
1058 return ConstIterator( vector_.lowerBound( offset_ + size_ ), offset_ );
1081 template<
typename VT
1092 if(
this == &rhs || ( &vector_ == &rhs.vector_ && offset_ == rhs.offset_ ) )
1095 if( size() != rhs.size() )
1096 throw std::invalid_argument(
"Vector sizes do not match" );
1098 if( rhs.canAlias( &vector_ ) ) {
1123 template<
typename VT
1126 template<
typename VT2 >
1136 if( size() != (~rhs).size() )
1137 throw std::invalid_argument(
"Vector sizes do not match" );
1164 template<
typename VT
1167 template<
typename VT2 >
1177 if( size() != (~rhs).size() )
1178 throw std::invalid_argument(
"Vector sizes do not match" );
1205 template<
typename VT
1208 template<
typename VT2 >
1214 if( size() != (~rhs).size() )
1215 throw std::invalid_argument(
"Vector sizes do not match" );
1234 template<
typename VT
1237 template<
typename VT2 >
1243 if( size() != (~rhs).size() )
1244 throw std::invalid_argument(
"Vector sizes do not match" );
1264 template<
typename VT
1267 template<
typename VT2 >
1271 if( size() != (~rhs).size() )
1272 throw std::invalid_argument(
"Vector sizes do not match" );
1280 const MultType tmp( *
this * (~rhs) );
1300 template<
typename VT
1303 template<
typename Other >
1308 for(
Iterator element=begin(); element!=last; ++element )
1309 element->value() *= rhs;
1327 template<
typename VT
1330 template<
typename Other >
1344 const Tmp tmp( Tmp(1)/static_cast<Tmp>( rhs ) );
1345 for(
Iterator element=begin(); element!=last; ++element )
1346 element->value() *= tmp;
1349 for(
Iterator element=begin(); element!=last; ++element )
1350 element->value() /= rhs;
1371 template<
typename VT
1386 template<
typename VT
1391 return nonZeros() + vector_.capacity() - vector_.nonZeros();
1403 template<
typename VT
1408 return end() - begin();
1418 template<
typename VT
1423 vector_.erase( vector_.lowerBound( offset_ ), vector_.lowerBound( offset_ + size_ ) );
1440 template<
typename VT
1446 return Iterator( vector_.insert( offset_ + index, value ), offset_ );
1459 template<
typename VT
1464 vector_.erase( offset_ + index );
1477 template<
typename VT
1482 return Iterator( vector_.erase( pos.base() ), offset_ );
1496 template<
typename VT
1502 return Iterator( vector_.erase( first.base(), last.base() ), offset_ );
1516 template<
typename VT
1521 const size_t current(
capacity() );
1524 vector_.reserve( vector_.capacity() + n - current );
1536 template<
typename VT
1539 template<
typename Other >
1542 for(
Iterator element=begin(); element!=end(); ++element )
1543 element->value() *= scalar;
1570 template<
typename VT
1576 const typename VT::Iterator pos( vector_.find( offset_ + index ) );
1578 if( pos != vector_.end() )
1599 template<
typename VT
1607 if( pos != vector_.end() )
1627 template<
typename VT
1633 return Iterator( vector_.lowerBound( offset_ + index ), offset_ );
1650 template<
typename VT
1656 return ConstIterator( vector_.lowerBound( offset_ + index ), offset_ );
1673 template<
typename VT
1679 return Iterator( vector_.upperBound( offset_ + index ), offset_ );
1696 template<
typename VT
1702 return ConstIterator( vector_.upperBound( offset_ + index ), offset_ );
1739 template<
typename VT
1744 if( offset_ + size_ == vector_.size() )
1745 vector_.append( offset_ + index, value, check );
1746 else if( !check || !
isDefault( value ) )
1747 vector_.insert( offset_ + index, value );
1770 template<
typename VT
1773 template<
typename Other >
1776 return vector_.isAliased( alias );
1791 template<
typename VT
1794 template<
typename Other >
1797 return vector_.isAliased( alias );
1812 template<
typename VT
1833 template<
typename VT
1836 template<
typename VT2 >
1842 reserve( (~rhs).size() );
1844 for(
size_t i=0UL; i<size(); ++i ) {
1845 append( i, (~rhs)[i],
true );
1862 template<
typename VT
1865 template<
typename VT2 >
1873 for(
typename VT2::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element ) {
1874 append( element->index(), element->value(), true );
1891 template<
typename VT
1894 template<
typename VT2 >
1905 const AddType tmp(
serial( *
this + (~rhs) ) );
1923 template<
typename VT
1926 template<
typename VT2 >
1937 const AddType tmp(
serial( *
this + (~rhs) ) );
1955 template<
typename VT
1958 template<
typename VT2 >
1969 const SubType tmp(
serial( *
this - (~rhs) ) );
1987 template<
typename VT
1990 template<
typename VT2 >
2001 const SubType tmp(
serial( *
this - (~rhs) ) );
2023 template<
typename VT,
bool AF,
bool TF >
2026 template<
typename VT,
bool AF,
bool TF >
2029 template<
typename VT,
bool AF,
bool TF >
2032 template<
typename VT,
bool AF,
bool TF >
2035 template<
typename VT,
bool AF,
bool TF >
2038 template<
typename VT,
bool AF,
bool TF >
2051 template<
typename VT
2070 template<
typename VT
2098 template<
typename VT
2105 const ConstIterator end( sv.end() );
2106 for( ConstIterator element=sv.begin(); element!=end; ++element )
2107 if( !
isDefault( element->value() ) )
return false;
2125 template<
typename VT,
bool AF,
bool TF >
2128 return (
isSame( a.vector_, ~b ) && ( a.size() == (~b).size() ) );
2145 template<
typename VT,
bool AF,
bool TF >
2148 return (
isSame( ~a, b.vector_ ) && ( (~a).size() == b.size() ) );
2165 template<
typename VT,
bool AF,
bool TF >
2168 return (
isSame( a.vector_, b.vector_ ) && ( a.offset_ == b.offset_ ) && ( a.size_ == b.size_ ) );
2198 inline const SparseSubvector<VT,AF1,TF>
2199 subvector(
const SparseSubvector<VT,AF2,TF>& sv,
size_t index,
size_t size )
2203 if( index + size > sv.size() )
2204 throw std::invalid_argument(
"Invalid subvector specification" );
2206 return SparseSubvector<VT,AF1,TF>( sv.vector_, sv.offset_ + index, size );
2222 template<
typename VT,
bool AF,
bool TF >
2223 struct SubvectorTrait< SparseSubvector<VT,AF,TF> >
2241 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2242 struct SubvectorExprTrait< SparseSubvector<VT,AF1,TF>, AF2 >
2244 typedef SparseSubvector<VT,AF2,TF> Type;
2252 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2253 struct SubvectorExprTrait< const SparseSubvector<VT,AF1,TF>, AF2 >
2255 typedef SparseSubvector<VT,AF2,TF> Type;
2263 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2264 struct SubvectorExprTrait< volatile SparseSubvector<VT,AF1,TF>, AF2 >
2266 typedef SparseSubvector<VT,AF2,TF> Type;
2274 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2275 struct SubvectorExprTrait< const volatile SparseSubvector<VT,AF1,TF>, AF2 >
2277 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:404
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:388
size_t offset_
Offset within the according sparse vector.
Definition: SparseSubvector.h:547
void reset(DynamicMatrix< Type, SO > &m)
Resetting the given dense matrix.
Definition: DynamicMatrix.h:4599
#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:681
ValueType PointerType
Pointer return type.
Definition: SparseSubvector.h:563
Header file for the SparseVector base class.
const size_t offset_
The offset of the subvector within the sparse vector.
Definition: SparseSubvector.h:830
VT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: SparseSubvector.h:408
IteratorType base() const
Access to the current position of the submatrix iterator.
Definition: SparseSubvector.h:691
bool isDefault(const DynamicMatrix< Type, SO > &m)
Returns whether the given dense matrix is in default state.
Definition: DynamicMatrix.h:4642
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:199
bool operator==(const SubvectorIterator< VectorType2, IteratorType2 > &rhs) const
Equality comparison between two SubvectorIterator objects.
Definition: SparseSubvector.h:658
#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:953
SubvectorElement< VectorType, IteratorType > ValueType
Type of the underlying elements.
Definition: SparseSubvector.h:562
ValueType value_type
Type of the underlying elements.
Definition: SparseSubvector.h:569
Header file for the IsRowVector type trait.
SparseSubvector(Operand vector, size_t index, size_t n)
The constructor for SparseSubvector.
Definition: SparseSubvector.h:888
VT::ConstReference ConstReference
Reference to a constant subvector value.
Definition: SparseSubvector.h:412
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:690
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:1631
#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:670
size_t size() const
Returns the size/dimension of the sparse subvector.
Definition: SparseSubvector.h:1374
size_t offset_
The offset of the subvector within the sparse vector.
Definition: SparseSubvector.h:709
SelectType< returnConst, const ElementType &, ElementType & >::Type ReferenceType
Return type of the value member function.
Definition: SparseSubvector.h:439
void reserve(size_t n)
Setting the minimum capacity of the sparse subvector.
Definition: SparseSubvector.h:1519
IteratorCategory iterator_category
The iterator category.
Definition: SparseSubvector.h:568
void clear(DynamicMatrix< Type, SO > &m)
Clearing the given dense matrix.
Definition: DynamicMatrix.h:4615
bool isSame(const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b)
Returns whether the two given matrices represent the same observable state.
Definition: Matrix.h:409
PointerType operator->() const
Direct access to the current sparse subvector element.
Definition: SparseSubvector.h:646
SubvectorElement & operator*=(const T &v)
Multiplication assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:496
SubvectorElement & operator/=(const T &v)
Division assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:508
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:406
SubvectorElement & operator-=(const T &v)
Subtraction assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:484
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:636
SubvectorElement & operator+=(const T &v)
Addition assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:472
Iterator end()
Returns an iterator just past the last element of the subvector.
Definition: SparseSubvector.h:1013
ReferenceType reference
Reference return type.
Definition: SparseSubvector.h:571
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:719
std::forward_iterator_tag IteratorCategory
The iterator category.
Definition: SparseSubvector.h:561
SubvectorIterator< const VT, typename VT::ConstIterator > ConstIterator
Iterator over constant elements.
Definition: SparseSubvector.h:716
Header file for the multiplication trait.
void erase(size_t index)
Erasing an element from the sparse subvector.
Definition: SparseSubvector.h:1462
size_t capacity() const
Returns the maximum capacity of the sparse subvector.
Definition: SparseSubvector.h:1389
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:829
Header file for the IsFloatingPoint type trait.
bool canSMPAssign() const
Returns whether the subvector can be used in SMP assignments.
Definition: SparseSubvector.h:1815
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2412
SubvectorIterator & operator++()
Pre-increment operator.
Definition: SparseSubvector.h:613
Header file for the Or class template.
size_t nonZeros(const Matrix< MT, SO > &m)
Returns the total number of non-zero elements in the matrix.
Definition: Matrix.h:224
SubvectorIterator()
Default constructor for the SubvectorIterator class.
Definition: SparseSubvector.h:578
void assign(const DenseVector< VT2, TF > &rhs)
Default implementation of the assignment of a dense vector.
Definition: SparseSubvector.h:1837
PointerType pointer
Pointer return type.
Definition: SparseSubvector.h:570
size_t index() const
Access to the current index of the sparse element.
Definition: SparseSubvector.h:539
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:519
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:271
Access proxy for a specific element of the sparse subvector.
Definition: SparseSubvector.h:423
void append(size_t index, const ElementType &value, bool check=false)
Appending an element to the sparse subvector.
Definition: SparseSubvector.h:1742
SubvectorIterator(IteratorType iterator, size_t index)
Constructor for the SubvectorIterator class.
Definition: SparseSubvector.h:590
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:1959
Constraint on the data type.
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: SparseSubvector.h:565
SubvectorTrait< VT >::Type ResultType
Result type for expression template evaluations.
Definition: SparseSubvector.h:405
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:701
Iterator upperBound(size_t index)
Returns an iterator to the first index greater then the given index.
Definition: SparseSubvector.h:1677
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2406
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:2410
Header file for the EnableIf class template.
VT::ElementType ElementType
Type of the subvector elements.
Definition: SparseSubvector.h:407
SubvectorElement & operator=(const T &v)
Assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:460
Header file for the serial shim.
DifferenceType difference_type
Difference between two iterators.
Definition: SparseSubvector.h:572
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:917
SubvectorIterator(const SubvectorIterator< VectorType2, IteratorType2 > &it)
Conversion constructor from different SubvectorIterator instances.
Definition: SparseSubvector.h:602
ValueType ReferenceType
Reference return type.
Definition: SparseSubvector.h:564
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2407
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:301
ReferenceType value() const
Access to the current value of the sparse subvector element.
Definition: SparseSubvector.h:529
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:831
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:135
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:331
bool canAlias(const Other *alias) const
Returns whether the sparse subvector can alias with the given address alias.
Definition: SparseSubvector.h:1774
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2411
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:1795
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:73
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:1574
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:1406
#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:409
ConstIterator cbegin() const
Returns an iterator to the first element of the subvector.
Definition: SparseSubvector.h:993
Iterator insert(size_t index, const ElementType &value)
Inserting an element into the sparse subvector.
Definition: SparseSubvector.h:1444
const SubvectorIterator operator++(int)
Post-increment operator.
Definition: SparseSubvector.h:624
Base class for N-dimensional vectors.The Vector class is a base class for all arbitrarily sized (N-di...
Definition: Forward.h:151
IteratorType pos_
Iterator to the current sparse element.
Definition: SparseSubvector.h:708
Iterator over the elements of the sparse subvector.
Definition: SparseSubvector.h:557
SubvectorElement(IteratorType pos, size_t offset)
Constructor for the SubvectorElement class.
Definition: SparseSubvector.h:448
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:108
#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:2403
Header file for basic type definitions.
void reset()
Reset to the default initial values.
Definition: SparseSubvector.h:1421
Header file for the SubvectorExprTrait class template.
SparseSubvector & operator=(const SparseSubvector &rhs)
Copy assignment operator for SparseSubvector.
Definition: SparseSubvector.h:1085
ConstIterator cend() const
Returns an iterator just past the last element of the subvector.
Definition: SparseSubvector.h:1053
void addAssign(const DenseVector< VT2, TF > &rhs)
Default implementation of the addition assignment of a dense vector.
Definition: SparseSubvector.h:1895
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:415
#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
size_t capacity(const Matrix< MT, SO > &m)
Returns the maximum capacity of the matrix.
Definition: Matrix.h:186
IteratorType pos_
Iterator to the current position within the sparse subvector.
Definition: SparseSubvector.h:546
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.