35 #ifndef _BLAZE_MATH_VIEWS_SPARSESUBVECTOR_H_
36 #define _BLAZE_MATH_VIEWS_SPARSESUBVECTOR_H_
387 template<
typename VT
389 ,
bool TF = IsRowVector<VT>::value >
390 class SparseSubvector :
public SparseVector< SparseSubvector<VT,AF,TF>, TF >
419 ,
typename IteratorType >
435 typedef typename std::iterator_traits<IteratorType>::value_type
SET;
537 return pos_->value();
563 ,
typename IteratorType >
608 template<
typename VectorType2,
typename IteratorType2 >
664 template<
typename VectorType2,
typename IteratorType2 >
676 template<
typename VectorType2,
typename IteratorType2 >
678 return !( *
this == rhs );
698 inline IteratorType
base()
const {
731 enum { smpAssignable = VT::smpAssignable };
737 explicit inline SparseSubvector( Operand vector,
size_t index,
size_t n );
750 inline ConstReference
operator[](
size_t index )
const;
751 inline Reference
at(
size_t index );
752 inline ConstReference
at(
size_t index )
const;
753 inline Iterator
begin ();
754 inline ConstIterator
begin ()
const;
755 inline ConstIterator
cbegin()
const;
756 inline Iterator
end ();
757 inline ConstIterator
end ()
const;
758 inline ConstIterator
cend ()
const;
771 template<
typename Other >
773 operator*=( Other rhs );
775 template<
typename Other >
777 operator/=( Other rhs );
784 inline size_t size()
const;
788 inline Iterator
set (
size_t index,
const ElementType& value );
789 inline Iterator
insert (
size_t index,
const ElementType& value );
790 inline void erase (
size_t index );
791 inline Iterator
erase ( Iterator pos );
792 inline Iterator
erase ( Iterator first, Iterator last );
793 inline void reserve(
size_t n );
794 template<
typename Other >
inline SparseSubvector& scale (
const Other& scalar );
801 inline Iterator
find (
size_t index );
802 inline ConstIterator
find (
size_t index )
const;
804 inline ConstIterator
lowerBound(
size_t index )
const;
806 inline ConstIterator
upperBound(
size_t index )
const;
813 inline void append(
size_t index,
const ElementType& value,
bool check=
false );
820 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
821 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
846 template<
bool AF1,
typename VT2,
bool AF2,
bool TF2 >
850 template<
typename VT2,
bool AF2,
bool TF2 >
853 template<
typename VT2,
bool AF2,
bool TF2 >
856 template<
typename VT2,
bool AF2,
bool TF2 >
859 template<
typename VT2,
bool AF2,
bool TF2 >
862 template<
typename VT2,
bool AF2,
bool TF2,
typename VT3 >
865 template<
typename VT2,
bool AF2,
bool TF2,
typename VT3 >
868 template<
typename VT2,
bool AF2,
bool TF2,
typename VT3 >
871 template<
typename VT2,
bool AF2,
bool TF2,
typename VT3 >
874 template<
typename VT2,
bool AF2,
bool TF2 >
913 template<
typename VT
921 if( index + n > vector.size() ) {
945 template<
typename VT
952 return vector_[offset_+index];
966 template<
typename VT
973 return const_cast<const VT&
>( vector_ )[offset_+index];
988 template<
typename VT
994 if( index >=
size() ) {
997 return (*
this)[index];
1012 template<
typename VT
1018 if( index >=
size() ) {
1021 return (*
this)[index];
1033 template<
typename VT
1038 if( offset_ == 0UL )
1039 return Iterator( vector_.begin(), offset_ );
1041 return Iterator( vector_.lowerBound( offset_ ), offset_ );
1053 template<
typename VT
1058 if( offset_ == 0UL )
1061 return ConstIterator( vector_.lowerBound( offset_ ), offset_ );
1073 template<
typename VT
1078 if( offset_ == 0UL )
1081 return ConstIterator( vector_.lowerBound( offset_ ), offset_ );
1093 template<
typename VT
1098 if( offset_ + size_ == vector_.size() )
1099 return Iterator( vector_.end(), offset_ );
1101 return Iterator( vector_.lowerBound( offset_ + size_ ), offset_ );
1113 template<
typename VT
1118 if( offset_ + size_ == vector_.size() )
1121 return ConstIterator( vector_.lowerBound( offset_ + size_ ), offset_ );
1133 template<
typename VT
1138 if( offset_ + size_ == vector_.size() )
1141 return ConstIterator( vector_.lowerBound( offset_ + size_ ), offset_ );
1165 template<
typename VT
1171 using blaze::assign;
1176 if(
this == &rhs || ( &vector_ == &rhs.vector_ && offset_ == rhs.offset_ ) )
1179 if(
size() != rhs.size() ) {
1183 if( !tryAssign( vector_, rhs, offset_ ) ) {
1189 if( rhs.canAlias( &vector_ ) ) {
1192 assign( left, tmp );
1196 assign( left, rhs );
1217 template<
typename VT
1220 template<
typename VT2 >
1224 using blaze::assign;
1234 Right right( ~rhs );
1236 if( !tryAssign( vector_, right, offset_ ) ) {
1245 assign( left, tmp );
1249 assign( left, right );
1270 template<
typename VT
1273 template<
typename VT2 >
1277 using blaze::assign;
1292 const AddType tmp( *
this + (~rhs) );
1294 if( !tryAssign( vector_, tmp, offset_ ) ) {
1301 assign( left, tmp );
1321 template<
typename VT
1324 template<
typename VT2 >
1328 using blaze::assign;
1343 const SubType tmp( *
this - (~rhs) );
1345 if( !tryAssign( vector_, tmp, offset_ ) ) {
1352 assign( left, tmp );
1373 template<
typename VT
1376 template<
typename VT2 >
1380 using blaze::assign;
1395 const MultType tmp( *
this * (~rhs) );
1397 if( !tryAssign( vector_, tmp, offset_ ) ) {
1404 assign( left, tmp );
1424 template<
typename VT
1427 template<
typename Other >
1433 element->value() *= rhs;
1451 template<
typename VT
1454 template<
typename Other >
1468 const Tmp tmp( Tmp(1)/static_cast<Tmp>( rhs ) );
1470 element->value() *= tmp;
1474 element->value() /= rhs;
1495 template<
typename VT
1510 template<
typename VT
1515 return nonZeros() + vector_.capacity() - vector_.nonZeros();
1527 template<
typename VT
1542 template<
typename VT
1547 vector_.erase( vector_.lowerBound( offset_ ), vector_.lowerBound( offset_ + size_ ) );
1563 template<
typename VT
1569 return Iterator( vector_.set( offset_ + index, value ), offset_ );
1586 template<
typename VT
1592 return Iterator( vector_.insert( offset_ + index, value ), offset_ );
1605 template<
typename VT
1610 vector_.erase( offset_ + index );
1623 template<
typename VT
1628 return Iterator( vector_.erase( pos.base() ), offset_ );
1642 template<
typename VT
1648 return Iterator( vector_.erase( first.base(), last.base() ), offset_ );
1662 template<
typename VT
1667 const size_t current(
capacity() );
1670 vector_.reserve( vector_.capacity() + n - current );
1682 template<
typename VT
1685 template<
typename Other >
1689 element->value() *= scalar;
1716 template<
typename VT
1722 const typename VT::Iterator pos( vector_.find( offset_ + index ) );
1724 if( pos != vector_.end() )
1745 template<
typename VT
1753 if( pos != vector_.end() )
1773 template<
typename VT
1779 return Iterator( vector_.lowerBound( offset_ + index ), offset_ );
1796 template<
typename VT
1802 return ConstIterator( vector_.lowerBound( offset_ + index ), offset_ );
1819 template<
typename VT
1825 return Iterator( vector_.upperBound( offset_ + index ), offset_ );
1842 template<
typename VT
1848 return ConstIterator( vector_.upperBound( offset_ + index ), offset_ );
1885 template<
typename VT
1890 if( offset_ + size_ == vector_.size() )
1891 vector_.append( offset_ + index, value, check );
1892 else if( !check || !
isDefault( value ) )
1893 vector_.insert( offset_ + index, value );
1916 template<
typename VT
1919 template<
typename Other >
1922 return vector_.isAliased( alias );
1937 template<
typename VT
1940 template<
typename Other >
1943 return vector_.isAliased( alias );
1958 template<
typename VT
1979 template<
typename VT
1982 template<
typename VT2 >
1988 reserve( (~rhs).
size() );
1990 for(
size_t i=0UL; i<
size(); ++i ) {
1991 append( i, (~rhs)[i],
true );
2008 template<
typename VT
2011 template<
typename VT2 >
2020 append( element->index(), element->value(), true );
2037 template<
typename VT
2040 template<
typename VT2 >
2051 const AddType tmp(
serial( *
this + (~rhs) ) );
2069 template<
typename VT
2072 template<
typename VT2 >
2083 const AddType tmp(
serial( *
this + (~rhs) ) );
2101 template<
typename VT
2104 template<
typename VT2 >
2115 const SubType tmp(
serial( *
this - (~rhs) ) );
2133 template<
typename VT
2136 template<
typename VT2 >
2147 const SubType tmp(
serial( *
this - (~rhs) ) );
2169 template<
typename VT,
bool AF,
bool TF >
2172 template<
typename VT,
bool AF,
bool TF >
2175 template<
typename VT,
bool AF,
bool TF >
2178 template<
typename VT,
bool AF,
bool TF >
2181 template<
typename VT,
bool AF,
bool TF >
2184 template<
typename VT,
bool AF,
bool TF >
2187 template<
typename VT,
bool AF,
bool TF >
2200 template<
typename VT
2219 template<
typename VT
2247 template<
typename VT
2254 const ConstIterator
end( sv.end() );
2255 for( ConstIterator element=sv.begin(); element!=
end; ++element )
2256 if( !
isDefault( element->value() ) )
return false;
2280 template<
typename VT
2285 return ( sv.offset_ + sv.size_ <= sv.vector_.size() &&
2303 template<
typename VT
2308 return (
isSame( a.vector_, ~b ) && ( a.size() == (~b).
size() ) );
2325 template<
typename VT
2330 return (
isSame( ~a, b.vector_ ) && ( (~a).size() == b.size() ) );
2347 template<
typename VT
2352 return (
isSame( a.vector_, b.vector_ ) && ( a.offset_ == b.offset_ ) && ( a.size_ == b.size_ ) );
2372 template<
typename VT1
2376 inline bool tryAssign(
const SparseSubvector<VT1,AF,TF>& lhs,
const Vector<VT2,TF>& rhs,
size_t index )
2381 return tryAssign( lhs.vector_, ~rhs, lhs.offset_ + index );
2402 template<
typename VT1
2406 inline bool tryAddAssign(
const SparseSubvector<VT1,AF,TF>& lhs,
const Vector<VT2,TF>& rhs,
size_t index )
2411 return tryAddAssign( lhs.vector_, ~rhs, lhs.offset_ + index );
2433 template<
typename VT1
2437 inline bool trySubAssign(
const SparseSubvector<VT1,AF,TF>& lhs,
const Vector<VT2,TF>& rhs,
size_t index )
2442 return trySubAssign( lhs.vector_, ~rhs, lhs.offset_ + index );
2464 template<
typename VT1
2468 inline bool tryMultAssign(
const SparseSubvector<VT1,AF,TF>& lhs,
const Vector<VT2,TF>& rhs,
size_t index )
2473 return tryMultAssign( lhs.vector_, ~rhs, lhs.offset_ + index );
2494 template<
typename VT
2497 inline typename DerestrictTrait< SparseSubvector<VT,AF,TF> >::Type
2498 derestrict( SparseSubvector<VT,AF,TF>& sv )
2500 typedef typename DerestrictTrait< SparseSubvector<VT,AF,TF> >::Type
ReturnType;
2501 return ReturnType( derestrict( sv.vector_ ), sv.offset_, sv.size_ );
2532 inline const SparseSubvector<VT,AF1,TF>
2533 subvector(
const SparseSubvector<VT,AF2,TF>& sv,
size_t index,
size_t size )
2537 if( index + size > sv.size() ) {
2541 return SparseSubvector<VT,AF1,TF>( sv.vector_, sv.offset_ + index,
size );
2557 template<
typename VT,
bool AF,
bool TF >
2558 struct IsRestricted< SparseSubvector<VT,AF,TF> > :
public If< IsRestricted<VT>, TrueType, FalseType >::Type
2560 enum { value = IsRestricted<VT>::value };
2577 template<
typename VT,
bool AF,
bool TF >
2578 struct DerestrictTrait< SparseSubvector<VT,AF,TF> >
2580 typedef SparseSubvector< typename RemoveReference< typename DerestrictTrait<VT>::Type >::Type, AF, TF > Type;
2596 template<
typename VT,
bool AF,
bool TF,
typename T >
2597 struct AddTrait< SparseSubvector<VT,AF,TF>, T >
2599 typedef typename AddTrait< typename SubvectorTrait<VT>::Type, T >::Type Type;
2602 template<
typename T,
typename VT,
bool AF,
bool TF >
2603 struct AddTrait< T, SparseSubvector<VT,AF,TF> >
2605 typedef typename AddTrait< T, typename SubvectorTrait<VT>::Type >::Type Type;
2621 template<
typename VT,
bool AF,
bool TF,
typename T >
2622 struct SubTrait< SparseSubvector<VT,AF,TF>, T >
2624 typedef typename SubTrait< typename SubvectorTrait<VT>::Type, T >::Type Type;
2627 template<
typename T,
typename VT,
bool AF,
bool TF >
2628 struct SubTrait< T, SparseSubvector<VT,AF,TF> >
2630 typedef typename SubTrait< T, typename SubvectorTrait<VT>::Type >::Type Type;
2646 template<
typename VT,
bool AF,
bool TF,
typename T >
2647 struct MultTrait< SparseSubvector<VT,AF,TF>, T >
2649 typedef typename MultTrait< typename SubvectorTrait<VT>::Type, T >::Type Type;
2652 template<
typename T,
typename VT,
bool AF,
bool TF >
2653 struct MultTrait< T, SparseSubvector<VT,AF,TF> >
2655 typedef typename MultTrait< T, typename SubvectorTrait<VT>::Type >::Type Type;
2671 template<
typename VT,
bool AF,
bool TF,
typename T >
2672 struct CrossTrait< SparseSubvector<VT,AF,TF>, T >
2674 typedef typename CrossTrait< typename SubvectorTrait<VT>::Type, T >::Type Type;
2677 template<
typename T,
typename VT,
bool AF,
bool TF >
2678 struct CrossTrait< T, SparseSubvector<VT,AF,TF> >
2680 typedef typename CrossTrait< T, typename SubvectorTrait<VT>::Type >::Type Type;
2696 template<
typename VT,
bool AF,
bool TF,
typename T >
2697 struct DivTrait< SparseSubvector<VT,AF,TF>, T >
2699 typedef typename DivTrait< typename SubvectorTrait<VT>::Type, T >::Type Type;
2702 template<
typename T,
typename VT,
bool AF,
bool TF >
2703 struct DivTrait< T, SparseSubvector<VT,AF,TF> >
2705 typedef typename DivTrait< T, typename SubvectorTrait<VT>::Type >::Type Type;
2721 template<
typename VT,
bool AF,
bool TF >
2722 struct SubvectorTrait< SparseSubvector<VT,AF,TF> >
2740 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2741 struct SubvectorExprTrait< SparseSubvector<VT,AF1,TF>, AF2 >
2743 typedef SparseSubvector<VT,AF2,TF> Type;
2751 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2752 struct SubvectorExprTrait< const SparseSubvector<VT,AF1,TF>, AF2 >
2754 typedef SparseSubvector<VT,AF2,TF> Type;
2762 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2763 struct SubvectorExprTrait< volatile SparseSubvector<VT,AF1,TF>, AF2 >
2765 typedef SparseSubvector<VT,AF2,TF> Type;
2773 template<
typename VT,
bool AF1,
bool TF,
bool AF2 >
2774 struct SubvectorExprTrait< const volatile SparseSubvector<VT,AF1,TF>, AF2 >
2776 typedef SparseSubvector<VT,AF2,TF> Type;
std::forward_iterator_tag IteratorCategory
The iterator category.
Definition: SparseSubvector.h:568
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exceptionThis macro encapsulates the default way of...
Definition: Exception.h:187
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
If< IsConst< VT >, ConstReference, typename VT::Reference >::Type Reference
Reference to a non-constant subvector value.
Definition: SparseSubvector.h:412
ValueType value_type
Type of the underlying elements.
Definition: SparseSubvector.h:576
#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 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:526
const SparseSubvector & CompositeType
Data type for composite expression templates.
Definition: SparseSubvector.h:406
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector)
Returns the current size/dimension of the vector.
Definition: Vector.h:252
IndexType index() const
Access to the current index of the sparse element.
Definition: SparseSubvector.h:546
size_t offset_
The offset of the subvector within the sparse vector.
Definition: SparseSubvector.h:716
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:250
PointerType pointer
Pointer return type.
Definition: SparseSubvector.h:577
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:207
#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:444
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:647
ReferenceType reference
Reference return type.
Definition: SparseSubvector.h:578
Iterator begin()
Returns an iterator to the first element of the subvector.
Definition: SparseSubvector.h:1036
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:507
CRT ConstReference
Reference-to-const return type.
Definition: SparseSubvector.h:446
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2588
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix)
Returns the maximum capacity of the matrix.
Definition: Matrix.h:340
Header file for the IsRowVector type trait.
SparseSubvector(Operand vector, size_t index, size_t n)
The constructor for SparseSubvector.
Definition: SparseSubvector.h:916
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
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:378
Iterator lowerBound(size_t index)
Returns an iterator to the first index not less then the given index.
Definition: SparseSubvector.h:1777
size_t offset_
Offset within the according sparse vector.
Definition: SparseSubvector.h:554
IfTrue< returnConst, CRT, RT >::Type Reference
Reference return type.
Definition: SparseSubvector.h:445
#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
size_t size() const
Returns the size/dimension of the sparse subvector.
Definition: SparseSubvector.h:1498
If< IsConst< VT >, ConstIterator, SubvectorIterator< VT, typename VT::Iterator > >::Type Iterator
Iterator over non-constant elements.
Definition: SparseSubvector.h:726
void reserve(size_t n)
Setting the minimum capacity of the sparse subvector.
Definition: SparseSubvector.h:1665
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: SparseSubvector.h:572
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:547
DifferenceType operator-(const SubvectorIterator &rhs) const
Calculating the number of elements between two subvector iterators.
Definition: SparseSubvector.h:688
VT::ElementType ElementType
Type of the subvector elements.
Definition: SparseSubvector.h:404
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:631
Iterator end()
Returns an iterator just past the last element of the subvector.
Definition: SparseSubvector.h:1096
IteratorCategory iterator_category
The iterator category.
Definition: SparseSubvector.h:575
Header file for the multiplication trait.
void erase(size_t index)
Erasing an element from the sparse subvector.
Definition: SparseSubvector.h:1608
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:1513
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:723
SET::ValueType ValueType
The value type of the row element.
Definition: SparseSubvector.h:443
Header file for the IsFloatingPoint type trait.
bool canSMPAssign() const
Returns whether the subvector can be used in SMP assignments.
Definition: SparseSubvector.h:1961
SubvectorElement & operator-=(const T &v)
Subtraction assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:491
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2592
Header file for the Or class template.
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exceptionThis macro encapsulates the default way of Bla...
Definition: Exception.h:331
void assign(const DenseVector< VT2, TF > &rhs)
Default implementation of the assignment of a dense vector.
Definition: SparseSubvector.h:1983
SubvectorIterator(const SubvectorIterator< VectorType2, IteratorType2 > &it)
Conversion constructor from different SubvectorIterator instances.
Definition: SparseSubvector.h:609
Header file for the subvector trait.
Access proxy for a specific element of the sparse subvector.
Definition: SparseSubvector.h:420
void append(size_t index, const ElementType &value, bool check=false)
Appending an element to the sparse subvector.
Definition: SparseSubvector.h:1888
bool operator==(const SubvectorIterator< VectorType2, IteratorType2 > &rhs) const
Equality comparison between two SubvectorIterator objects.
Definition: SparseSubvector.h:665
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:403
SubvectorTrait< VT >::Type ResultType
Result type for expression template evaluations.
Definition: SparseSubvector.h:402
Operand vector_
The sparse vector containing the subvector.
Definition: SparseSubvector.h:838
#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:396
SparseSubvector< VT, AF, TF > This
Type of this SparseSubvector instance.
Definition: SparseSubvector.h:401
SubvectorIterator & operator++()
Pre-increment operator.
Definition: SparseSubvector.h:620
const size_t size_
The size of the subvector.
Definition: SparseSubvector.h:840
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:536
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:2105
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:187
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:1823
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2586
IteratorType pos_
Iterator to the current sparse element.
Definition: SparseSubvector.h:715
size_t offset() const
Access to the offset of the subvector iterator.
Definition: SparseSubvector.h:708
const bool unaligned
Alignment flag for unaligned vectors and matrices.Via this flag it is possible to specify subvectors...
Definition: AlignmentFlag.h:64
Constraint on the data type.
Reference at(size_t index)
Checked access to the subvector elements.
Definition: SparseSubvector.h:992
Constraint on the data type.
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2590
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:527
Header file for the serial shim.
Header file for the DerestrictTrait class template.
SET::Reference RT
Reference type of the underlying sparse element.
Definition: SparseSubvector.h:437
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:949
SubvectorElement & operator=(const T &v)
Assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:467
SET::ConstReference CRT
Reference-to-const type of the underlying sparse element.
Definition: SparseSubvector.h:438
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2587
Header file for the IsConst type trait.
ValueType ReferenceType
Reference return type.
Definition: SparseSubvector.h:571
Header file for run time assertion macros.
Base template for the AddTrait class.
Definition: AddTrait.h:138
Base template for the MultTrait class.
Definition: MultTrait.h:138
Header file for the addition trait.
Header file for the cross product trait.
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:143
SubvectorIterator()
Default constructor for the SubvectorIterator class.
Definition: SparseSubvector.h:585
bool canAlias(const Other *alias) const
Returns whether the sparse subvector can alias with the given address alias.
Definition: SparseSubvector.h:1920
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2591
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:1941
Iterator set(size_t index, const ElementType &value)
Setting an element of the sparse subvector.
Definition: SparseSubvector.h:1567
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 IsReference type trait.
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:479
Iterator find(size_t index)
Searches for a specific subvector element.
Definition: SparseSubvector.h:1720
Base template for the DivTrait class.
Definition: DivTrait.h:138
size_t nonZeros() const
Returns the number of non-zero elements in the subvector.
Definition: SparseSubvector.h:1530
IteratorType base() const
Access to the current position of the subvector iterator.
Definition: SparseSubvector.h:698
ReferenceType operator*() const
Direct access to the current sparse subvector element.
Definition: SparseSubvector.h:643
#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:570
ConstIterator cbegin() const
Returns an iterator to the first element of the subvector.
Definition: SparseSubvector.h:1076
Iterator insert(size_t index, const ElementType &value)
Inserting an element into the sparse subvector.
Definition: SparseSubvector.h:1590
Base class for N-dimensional vectors.The Vector class is a base class for all arbitrarily sized (N-di...
Definition: Forward.h:164
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:653
Iterator over the elements of the sparse subvector.
Definition: SparseSubvector.h:564
std::iterator_traits< IteratorType >::value_type SET
Type of the underlying sparse elements.
Definition: SparseSubvector.h:435
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:118
#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:839
SubvectorElement & operator/=(const T &v)
Division assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:515
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2583
SubvectorIterator(IteratorType iterator, size_t index)
Constructor for the SubvectorIterator class.
Definition: SparseSubvector.h:597
VT::ConstReference ConstReference
Reference to a constant subvector value.
Definition: SparseSubvector.h:409
Compile time type check.This class tests whether the given template parameter T is a reference type (...
Definition: IsReference.h:94
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:237
void reset()
Reset to the default initial values.
Definition: SparseSubvector.h:1545
Header file for the SubvectorExprTrait class template.
IteratorType pos_
Iterator to the current position within the sparse subvector.
Definition: SparseSubvector.h:553
SparseSubvector & operator=(const SparseSubvector &rhs)
Copy assignment operator for SparseSubvector.
Definition: SparseSubvector.h:1169
ConstIterator cend() const
Returns an iterator just past the last element of the subvector.
Definition: SparseSubvector.h:1136
void addAssign(const DenseVector< VT2, TF > &rhs)
Default implementation of the addition assignment of a dense vector.
Definition: SparseSubvector.h:2041
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2589
Base template for the SubTrait class.
Definition: SubTrait.h:138
DifferenceType difference_type
Difference between two iterators.
Definition: SparseSubvector.h:579
Header file for exception macros.
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:569
SubvectorElement & operator*=(const T &v)
Multiplication assignment to the accessed sparse subvector element.
Definition: SparseSubvector.h:503
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:81
bool operator!=(const SubvectorIterator< VectorType2, IteratorType2 > &rhs) const
Inequality comparison between two SubvectorIterator objects.
Definition: SparseSubvector.h:677
#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:405
SubvectorElement(IteratorType pos, size_t offset)
Constructor for the SubvectorElement class.
Definition: SparseSubvector.h:455
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.