35 #ifndef _BLAZE_MATH_VIEWS_SPARSESUBVECTOR_H_
36 #define _BLAZE_MATH_VIEWS_SPARSESUBVECTOR_H_
386 template<
typename VT
388 ,
bool TF = IsRowVector<VT>::value >
389 class SparseSubvector :
public SparseVector< SparseSubvector<VT,AF,TF>, TF >
429 ,
typename IteratorType >
445 typedef typename std::iterator_traits<IteratorType>::value_type
SET;
547 return pos_->value();
573 ,
typename IteratorType >
618 template<
typename VectorType2,
typename IteratorType2 >
674 template<
typename VectorType2,
typename IteratorType2 >
686 template<
typename VectorType2,
typename IteratorType2 >
688 return !( *
this == rhs );
708 inline IteratorType
base()
const {
741 enum { smpAssignable = VT::smpAssignable };
747 explicit inline SparseSubvector( Operand vector,
size_t index,
size_t n );
760 inline ConstReference
operator[](
size_t index )
const;
761 inline Iterator
begin ();
762 inline ConstIterator
begin ()
const;
763 inline ConstIterator
cbegin()
const;
764 inline Iterator
end ();
765 inline ConstIterator
end ()
const;
766 inline ConstIterator
cend ()
const;
780 template<
typename Other >
782 operator*=( Other rhs );
784 template<
typename Other >
786 operator/=( Other rhs );
793 inline size_t size()
const;
797 inline Iterator
set (
size_t index,
const ElementType& value );
798 inline Iterator
insert (
size_t index,
const ElementType& value );
799 inline void erase (
size_t index );
800 inline Iterator
erase ( Iterator pos );
801 inline Iterator
erase ( Iterator first, Iterator last );
802 inline void reserve(
size_t n );
803 template<
typename Other >
inline SparseSubvector& scale (
const Other& scalar );
810 inline Iterator
find (
size_t index );
811 inline ConstIterator
find (
size_t index )
const;
813 inline ConstIterator
lowerBound(
size_t index )
const;
815 inline ConstIterator
upperBound(
size_t index )
const;
822 inline void append(
size_t index,
const ElementType& value,
bool check=
false );
829 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
830 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
855 template<
bool AF1,
typename VT2,
bool AF2,
bool TF2 >
859 template<
typename VT2,
bool AF2,
bool TF2 >
862 template<
typename VT2,
bool AF2,
bool TF2 >
865 template<
typename VT2,
bool AF2,
bool TF2 >
868 template<
typename VT2,
bool AF2,
bool TF2 >
907 template<
typename VT
915 if( index + n > vector.size() )
916 throw std::invalid_argument(
"Invalid subvector specification" );
935 template<
typename VT
942 return vector_[offset_+index];
953 template<
typename VT
960 return const_cast<const VT&
>( vector_ )[offset_+index];
972 template<
typename VT
978 return Iterator( vector_.begin(), offset_ );
980 return Iterator( vector_.lowerBound( offset_ ), offset_ );
992 template<
typename VT
1000 return ConstIterator( vector_.lowerBound( offset_ ), offset_ );
1012 template<
typename VT
1017 if( offset_ == 0UL )
1020 return ConstIterator( vector_.lowerBound( offset_ ), offset_ );
1032 template<
typename VT
1037 if( offset_ + size_ == vector_.size() )
1038 return Iterator( vector_.end(), offset_ );
1040 return Iterator( vector_.lowerBound( offset_ + size_ ), offset_ );
1052 template<
typename VT
1057 if( offset_ + size_ == vector_.size() )
1060 return ConstIterator( vector_.lowerBound( offset_ + size_ ), offset_ );
1072 template<
typename VT
1077 if( offset_ + size_ == vector_.size() )
1080 return ConstIterator( vector_.lowerBound( offset_ + size_ ), offset_ );
1103 template<
typename VT
1114 if(
this == &rhs || ( &vector_ == &rhs.vector_ && offset_ == rhs.offset_ ) )
1117 if(
size() != rhs.size() )
1118 throw std::invalid_argument(
"Vector sizes do not match" );
1120 if( rhs.canAlias( &vector_ ) ) {
1145 template<
typename VT
1148 template<
typename VT2 >
1159 throw std::invalid_argument(
"Vector sizes do not match" );
1186 template<
typename VT
1189 template<
typename VT2 >
1200 throw std::invalid_argument(
"Vector sizes do not match" );
1227 template<
typename VT
1230 template<
typename VT2 >
1237 throw std::invalid_argument(
"Vector sizes do not match" );
1256 template<
typename VT
1259 template<
typename VT2 >
1266 throw std::invalid_argument(
"Vector sizes do not match" );
1286 template<
typename VT
1289 template<
typename VT2 >
1294 throw std::invalid_argument(
"Vector sizes do not match" );
1302 const MultType tmp( *
this * (~rhs) );
1322 template<
typename VT
1325 template<
typename Other >
1331 element->value() *= rhs;
1349 template<
typename VT
1352 template<
typename Other >
1366 const Tmp tmp( Tmp(1)/static_cast<Tmp>( rhs ) );
1368 element->value() *= tmp;
1372 element->value() /= rhs;
1393 template<
typename VT
1408 template<
typename VT
1413 return nonZeros() + vector_.capacity() - vector_.nonZeros();
1425 template<
typename VT
1440 template<
typename VT
1445 vector_.erase( vector_.lowerBound( offset_ ), vector_.lowerBound( offset_ + size_ ) );
1461 template<
typename VT
1467 return Iterator( vector_.set( offset_ + index, value ), offset_ );
1484 template<
typename VT
1490 return Iterator( vector_.insert( offset_ + index, value ), offset_ );
1503 template<
typename VT
1508 vector_.erase( offset_ + index );
1521 template<
typename VT
1526 return Iterator( vector_.erase( pos.base() ), offset_ );
1540 template<
typename VT
1546 return Iterator( vector_.erase( first.base(), last.base() ), offset_ );
1560 template<
typename VT
1565 const size_t current(
capacity() );
1568 vector_.reserve( vector_.capacity() + n - current );
1580 template<
typename VT
1583 template<
typename Other >
1587 element->value() *= scalar;
1614 template<
typename VT
1620 const typename VT::Iterator pos( vector_.find( offset_ + index ) );
1622 if( pos != vector_.end() )
1643 template<
typename VT
1651 if( pos != vector_.end() )
1671 template<
typename VT
1677 return Iterator( vector_.lowerBound( offset_ + index ), offset_ );
1694 template<
typename VT
1700 return ConstIterator( vector_.lowerBound( offset_ + index ), offset_ );
1717 template<
typename VT
1723 return Iterator( vector_.upperBound( offset_ + index ), offset_ );
1740 template<
typename VT
1746 return ConstIterator( vector_.upperBound( offset_ + index ), offset_ );
1783 template<
typename VT
1788 if( offset_ + size_ == vector_.size() )
1789 vector_.append( offset_ + index, value, check );
1790 else if( !check || !
isDefault( value ) )
1791 vector_.insert( offset_ + index, value );
1814 template<
typename VT
1817 template<
typename Other >
1820 return vector_.isAliased( alias );
1835 template<
typename VT
1838 template<
typename Other >
1841 return vector_.isAliased( alias );
1856 template<
typename VT
1877 template<
typename VT
1880 template<
typename VT2 >
1886 reserve( (~rhs).
size() );
1888 for(
size_t i=0UL; i<
size(); ++i ) {
1889 append( i, (~rhs)[i],
true );
1906 template<
typename VT
1909 template<
typename VT2 >
1918 append( element->index(), element->value(), true );
1935 template<
typename VT
1938 template<
typename VT2 >
1949 const AddType tmp(
serial( *
this + (~rhs) ) );
1967 template<
typename VT
1970 template<
typename VT2 >
1981 const AddType tmp(
serial( *
this + (~rhs) ) );
1999 template<
typename VT
2002 template<
typename VT2 >
2013 const SubType tmp(
serial( *
this - (~rhs) ) );
2031 template<
typename VT
2034 template<
typename VT2 >
2045 const SubType tmp(
serial( *
this - (~rhs) ) );
2067 template<
typename VT,
bool AF,
bool TF >
2070 template<
typename VT,
bool AF,
bool TF >
2073 template<
typename VT,
bool AF,
bool TF >
2076 template<
typename VT,
bool AF,
bool TF >
2079 template<
typename VT,
bool AF,
bool TF >
2082 template<
typename VT,
bool AF,
bool TF >
2095 template<
typename VT
2114 template<
typename VT
2142 template<
typename VT
2149 const ConstIterator
end( sv.end() );
2150 for( ConstIterator element=sv.begin(); element!=
end; ++element )
2151 if( !
isDefault( element->value() ) )
return false;
2169 template<
typename VT
2174 return (
isSame( a.vector_, ~b ) && ( a.size() == (~b).
size() ) );
2191 template<
typename VT
2196 return (
isSame( ~a, b.vector_ ) && ( (~a).size() == b.size() ) );
2213 template<
typename VT
2218 return (
isSame( a.vector_, b.vector_ ) && ( a.offset_ == b.offset_ ) && ( a.size_ == b.size_ ) );
2238 template<
typename VT
2241 inline typename DerestrictTrait< SparseSubvector<VT,AF,TF> >::Type
2242 derestrict( SparseSubvector<VT,AF,TF>& sv )
2244 typedef typename DerestrictTrait< SparseSubvector<VT,AF,TF> >::Type
ReturnType;
2245 return ReturnType( derestrict( sv.vector_ ), sv.offset_, sv.size_ );
2276 inline const SparseSubvector<VT,AF1,TF>
2277 subvector(
const SparseSubvector<VT,AF2,TF>& sv,
size_t index,
size_t size )
2281 if( index + size > sv.size() )
2282 throw std::invalid_argument(
"Invalid subvector specification" );
2284 return SparseSubvector<VT,AF1,TF>( sv.vector_, sv.offset_ + index,
size );
2300 template<
typename VT,
bool AF,
bool TF >
2301 struct IsRestricted< SparseSubvector<VT,AF,TF> > :
public If< IsRestricted<VT>, TrueType, FalseType >::Type
2303 enum { value = IsRestricted<VT>::value };
2320 template<
typename VT,
bool AF,
bool TF >
2321 struct DerestrictTrait< SparseSubvector<VT,AF,TF> >
2323 typedef SparseSubvector< typename RemoveReference< typename DerestrictTrait<VT>::Type >::Type, AF, TF > Type;
2339 template<
typename VT,
bool AF,
bool TF >
2340 struct SubvectorTrait< SparseSubvector<VT,AF,TF> >
2358 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2359 struct SubvectorExprTrait< SparseSubvector<VT,AF1,TF>, AF2 >
2361 typedef SparseSubvector<VT,AF2,TF> Type;
2369 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2370 struct SubvectorExprTrait< const SparseSubvector<VT,AF1,TF>, AF2 >
2372 typedef SparseSubvector<VT,AF2,TF> Type;
2380 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2381 struct SubvectorExprTrait< volatile SparseSubvector<VT,AF1,TF>, AF2 >
2383 typedef SparseSubvector<VT,AF2,TF> Type;
2391 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2392 struct SubvectorExprTrait< const volatile SparseSubvector<VT,AF1,TF>, AF2 >
2394 typedef SparseSubvector<VT,AF2,TF> Type;
std::forward_iterator_tag IteratorCategory
The iterator category.
Definition: SparseSubvector.h:578
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
Compile time check for numeric types.This type trait tests whether or not the given template paramete...
Definition: IsNumeric.h:98
ValueType value_type
Type of the underlying elements.
Definition: SparseSubvector.h:586
#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.
Header file for basic type definitions.
Header file for the SparseVector base class.
const SubvectorElement * operator->() const
Direct access to the sparse subvector element at the current iterator position.
Definition: SparseSubvector.h:536
const SparseSubvector & CompositeType
Data type for composite expression templates.
Definition: SparseSubvector.h:416
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector)
Returns the current size/dimension of the vector.
Definition: Vector.h:264
IndexType index() const
Access to the current index of the sparse element.
Definition: SparseSubvector.h:556
size_t offset_
The offset of the subvector within the sparse vector.
Definition: SparseSubvector.h:726
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:258
PointerType pointer
Pointer return type.
Definition: SparseSubvector.h:587
IfTrue< useConst, ConstReference, typename VT::Reference >::Type Reference
Reference to a non-constant subvector value.
Definition: SparseSubvector.h:422
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:209
#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
size_t IndexType
The index type of the row element.
Definition: SparseSubvector.h:454
BLAZE_ALWAYS_INLINE 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:946
ReferenceType reference
Reference return type.
Definition: SparseSubvector.h:588
Iterator begin()
Returns an iterator to the first element of the subvector.
Definition: SparseSubvector.h:975
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:821
CRT ConstReference
Reference-to-const return type.
Definition: SparseSubvector.h:456
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix)
Returns the maximum capacity of the matrix.
Definition: Matrix.h:348
Header file for the IsRowVector type trait.
SparseSubvector(Operand vector, size_t index, size_t n)
The constructor for SparseSubvector.
Definition: SparseSubvector.h:910
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:699
BLAZE_ALWAYS_INLINE size_t nonZeros(const Matrix< MT, SO > &matrix)
Returns the total number of non-zero elements in the matrix.
Definition: Matrix.h:386
Iterator lowerBound(size_t index)
Returns an iterator to the first index not less then the given index.
Definition: SparseSubvector.h:1675
size_t offset_
Offset within the according sparse vector.
Definition: SparseSubvector.h:564
IfTrue< returnConst, CRT, RT >::Type Reference
Reference return type.
Definition: SparseSubvector.h:455
#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.
IfTrue< useConst, ConstIterator, SubvectorIterator< VT, typename VT::Iterator > >::Type Iterator
Iterator over non-constant elements.
Definition: SparseSubvector.h:736
size_t size() const
Returns the size/dimension of the sparse subvector.
Definition: SparseSubvector.h:1396
void reserve(size_t n)
Setting the minimum capacity of the sparse subvector.
Definition: SparseSubvector.h:1563
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: SparseSubvector.h:582
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:861
DifferenceType operator-(const SubvectorIterator &rhs) const
Calculating the number of elements between two subvector iterators.
Definition: SparseSubvector.h:698
VT::ElementType ElementType
Type of the subvector elements.
Definition: SparseSubvector.h:414
Base template for the SubvectorTrait class.
Definition: SubvectorTrait.h:123
Constraint on the data type.
const SubvectorIterator operator++(int)
Post-increment operator.
Definition: SparseSubvector.h:641
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:90
Iterator end()
Returns an iterator just past the last element of the subvector.
Definition: SparseSubvector.h:1035
IteratorCategory iterator_category
The iterator category.
Definition: SparseSubvector.h:585
Header file for the multiplication trait.
void erase(size_t index)
Erasing an element from the sparse subvector.
Definition: SparseSubvector.h:1506
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
size_t capacity() const
Returns the maximum capacity of the sparse subvector.
Definition: SparseSubvector.h:1411
Header file for the If class template.
Header file for the Subvector base class.
SubvectorIterator< const VT, typename VT::ConstIterator > ConstIterator
Iterator over constant elements.
Definition: SparseSubvector.h:733
SET::ValueType ValueType
The value type of the row element.
Definition: SparseSubvector.h:453
Header file for the IsFloatingPoint type trait.
bool canSMPAssign() const
Returns whether the subvector can be used in SMP assignments.
Definition: SparseSubvector.h:1859
SubvectorElement & operator-=(const T &v)
Subtraction assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:501
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2511
Header file for the Or class template.
BLAZE_ALWAYS_INLINE 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:635
void assign(const DenseVector< VT2, TF > &rhs)
Default implementation of the assignment of a dense vector.
Definition: SparseSubvector.h:1881
SubvectorIterator(const SubvectorIterator< VectorType2, IteratorType2 > &it)
Conversion constructor from different SubvectorIterator instances.
Definition: SparseSubvector.h:619
Header file for the subvector trait.
Access proxy for a specific element of the sparse subvector.
Definition: SparseSubvector.h:430
void append(size_t index, const ElementType &value, bool check=false)
Appending an element to the sparse subvector.
Definition: SparseSubvector.h:1786
bool operator==(const SubvectorIterator< VectorType2, IteratorType2 > &rhs) const
Equality comparison between two SubvectorIterator objects.
Definition: SparseSubvector.h:675
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SparseSubvector.h:413
SubvectorTrait< VT >::Type ResultType
Result type for expression template evaluations.
Definition: SparseSubvector.h:412
Operand vector_
The sparse vector containing the subvector.
Definition: SparseSubvector.h:847
#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
If< IsExpression< VT >, VT, VT & >::Type Operand
Composite data type of the sparse vector expression.
Definition: SparseSubvector.h:395
SparseSubvector< VT, AF, TF > This
Type of this SparseSubvector instance.
Definition: SparseSubvector.h:411
SubvectorIterator & operator++()
Pre-increment operator.
Definition: SparseSubvector.h:630
const size_t size_
The size of the subvector.
Definition: SparseSubvector.h:849
Constraint on the data type.
Header file for the SparseElement base class.
Reference value() const
Access to the current value of the sparse subvector element.
Definition: SparseSubvector.h:546
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:2003
Constraint on the data type.
BLAZE_ALWAYS_INLINE MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:195
Compile time check for floating point data types.This type trait tests whether or not the given templ...
Definition: IsFloatingPoint.h:94
Iterator upperBound(size_t index)
Returns an iterator to the first index greater then the given index.
Definition: SparseSubvector.h:1721
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2505
IteratorType pos_
Iterator to the current sparse element.
Definition: SparseSubvector.h:725
size_t offset() const
Access to the offset of the subvector iterator.
Definition: SparseSubvector.h:718
Constraint on the data type.
Constraint on the data type.
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2509
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:841
Header file for the serial shim.
Header file for the DerestrictTrait class template.
const bool unaligned
Alignment flag for unaligned subvectors and submatrices.
Definition: AlignmentFlag.h:63
SET::Reference RT
Reference type of the underlying sparse element.
Definition: SparseSubvector.h:447
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:939
SubvectorElement & operator=(const T &v)
Assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:477
SET::ConstReference CRT
Reference-to-const type of the underlying sparse element.
Definition: SparseSubvector.h:448
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2506
Header file for the IsConst type trait.
ValueType ReferenceType
Reference return type.
Definition: SparseSubvector.h:581
Header file for run time assertion macros.
Base template for the AddTrait class.
Definition: AddTrait.h:150
Base template for the MultTrait class.
Definition: MultTrait.h:150
Header file for the addition trait.
BLAZE_ALWAYS_INLINE 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:742
Header file for the division trait.
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
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:140
SubvectorIterator()
Default constructor for the SubvectorIterator class.
Definition: SparseSubvector.h:595
bool canAlias(const Other *alias) const
Returns whether the sparse subvector can alias with the given address alias.
Definition: SparseSubvector.h:1818
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2510
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:1839
Iterator set(size_t index, const ElementType &value)
Setting an element of the sparse subvector.
Definition: SparseSubvector.h:1465
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
Evaluation of the return type of the derestrict function.Via this type trait it is possible to evalua...
Definition: DerestrictTrait.h:74
Header file for the RemoveReference type trait.
Compile time check for constant data types.The IsConst type trait tests whether or not the given temp...
Definition: IsConst.h:94
SubvectorElement & operator+=(const T &v)
Addition assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:489
Iterator find(size_t index)
Searches for a specific subvector element.
Definition: SparseSubvector.h:1618
Base template for the DivTrait class.
Definition: DivTrait.h:150
size_t nonZeros() const
Returns the number of non-zero elements in the subvector.
Definition: SparseSubvector.h:1428
IteratorType base() const
Access to the current position of the subvector iterator.
Definition: SparseSubvector.h:708
ReferenceType operator*() const
Direct access to the current sparse subvector element.
Definition: SparseSubvector.h:653
#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
ValueType PointerType
Pointer return type.
Definition: SparseSubvector.h:580
ConstIterator cbegin() const
Returns an iterator to the first element of the subvector.
Definition: SparseSubvector.h:1015
Iterator insert(size_t index, const ElementType &value)
Inserting an element into the sparse subvector.
Definition: SparseSubvector.h:1488
Base class for N-dimensional vectors.The Vector class is a base class for all arbitrarily sized (N-di...
Definition: Forward.h:151
boost::false_type FalseType
Type/value traits base class.The FalseType class is used as base class for type traits and value trai...
Definition: FalseType.h:61
PointerType operator->() const
Direct access to the current sparse subvector element.
Definition: SparseSubvector.h:663
Iterator over the elements of the sparse subvector.
Definition: SparseSubvector.h:574
std::iterator_traits< IteratorType >::value_type SET
Type of the underlying sparse elements.
Definition: SparseSubvector.h:445
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
const size_t offset_
The offset of the subvector within the sparse vector.
Definition: SparseSubvector.h:848
SubvectorElement & operator/=(const T &v)
Division assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:525
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2502
SubvectorIterator(IteratorType iterator, size_t index)
Constructor for the SubvectorIterator class.
Definition: SparseSubvector.h:607
VT::ConstReference ConstReference
Reference to a constant subvector value.
Definition: SparseSubvector.h:419
void reset()
Reset to the default initial values.
Definition: SparseSubvector.h:1443
Header file for the SubvectorExprTrait class template.
IteratorType pos_
Iterator to the current position within the sparse subvector.
Definition: SparseSubvector.h:563
SparseSubvector & operator=(const SparseSubvector &rhs)
Copy assignment operator for SparseSubvector.
Definition: SparseSubvector.h:1107
ConstIterator cend() const
Returns an iterator just past the last element of the subvector.
Definition: SparseSubvector.h:1075
void addAssign(const DenseVector< VT2, TF > &rhs)
Default implementation of the addition assignment of a dense vector.
Definition: SparseSubvector.h:1939
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2508
Base template for the SubTrait class.
Definition: SubTrait.h:150
DifferenceType difference_type
Difference between two iterators.
Definition: SparseSubvector.h:589
boost::true_type TrueType
Type traits base class.The TrueType class is used as base class for type traits and value traits that...
Definition: TrueType.h:61
SubvectorElement< VectorType, IteratorType > ValueType
Type of the underlying elements.
Definition: SparseSubvector.h:579
SubvectorElement & operator*=(const T &v)
Multiplication assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:513
Header file for the IsRestricted type trait.
#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
bool operator!=(const SubvectorIterator< VectorType2, IteratorType2 > &rhs) const
Inequality comparison between two SubvectorIterator objects.
Definition: SparseSubvector.h:687
#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
VT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: SparseSubvector.h:415
SubvectorElement(IteratorType pos, size_t offset)
Constructor for the SubvectorElement class.
Definition: SparseSubvector.h:465
Compile time type selection.The IfTrue class template selects one of the two given types T1 and T2 de...
Definition: If.h:59
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
BLAZE_ALWAYS_INLINE 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:849