35 #ifndef _BLAZE_MATH_VIEWS_SUBVECTOR_DENSE_H_ 36 #define _BLAZE_MATH_VIEWS_SUBVECTOR_DENSE_H_ 111 template<
typename VT
114 class Subvector<VT,
unaligned,TF,true,CSAs...>
115 :
public View< DenseVector< Subvector<VT,unaligned,TF,true,CSAs...>, TF > >
116 ,
private SubvectorData<CSAs...>
120 using DataType = SubvectorData<CSAs...>;
121 using Operand = If_t< IsExpression_v<VT>, VT, VT& >;
127 using This = Subvector<VT,
unaligned,TF,
true,CSAs...>;
129 using BaseType = DenseVector<This,TF>;
130 using ViewedType = VT;
132 using TransposeType = TransposeType_t<ResultType>;
133 using ElementType = ElementType_t<VT>;
134 using SIMDType = SIMDTrait_t<ElementType>;
135 using ReturnType = ReturnType_t<VT>;
136 using CompositeType =
const Subvector&;
139 using ConstReference = ConstReference_t<VT>;
142 using Reference = If_t< IsConst_v<VT>, ConstReference, Reference_t<VT> >;
145 using ConstPointer = ConstPointer_t<VT>;
148 using Pointer = If_t< IsConst_v<VT> || !HasMutableDataAccess_v<VT>, ConstPointer, Pointer_t<VT> >;
154 template<
typename IteratorType >
155 class SubvectorIterator
160 using IteratorCategory =
typename std::iterator_traits<IteratorType>::iterator_category;
163 using ValueType =
typename std::iterator_traits<IteratorType>::value_type;
166 using PointerType =
typename std::iterator_traits<IteratorType>::pointer;
169 using ReferenceType =
typename std::iterator_traits<IteratorType>::reference;
172 using DifferenceType =
typename std::iterator_traits<IteratorType>::difference_type;
175 using iterator_category = IteratorCategory;
176 using value_type = ValueType;
177 using pointer = PointerType;
178 using reference = ReferenceType;
179 using difference_type = DifferenceType;
187 , isAligned_( false )
198 : iterator_ ( iterator )
199 , isAligned_( isMemoryAligned )
208 template<
typename IteratorType2 >
210 : iterator_ ( it.base() )
211 , isAligned_( it.isAligned() )
256 return SubvectorIterator( iterator_++, isAligned_ );
277 return SubvectorIterator( iterator_--, isAligned_ );
311 inline SIMDType load()
const {
331 inline SIMDType
loada()
const {
332 return iterator_.loada();
346 inline SIMDType
loadu()
const {
347 return iterator_.loadu();
362 inline void store(
const SIMDType& value )
const {
383 inline void storea(
const SIMDType& value )
const {
384 iterator_.storea( value );
399 inline void storeu(
const SIMDType& value )
const {
400 iterator_.storeu( value );
415 inline void stream(
const SIMDType& value )
const {
416 iterator_.stream( value );
427 return iterator_ == rhs.iterator_;
438 return iterator_ != rhs.iterator_;
449 return iterator_ < rhs.iterator_;
460 return iterator_ > rhs.iterator_;
471 return iterator_ <= rhs.iterator_;
482 return iterator_ >= rhs.iterator_;
493 return iterator_ - rhs.iterator_;
505 return SubvectorIterator( it.iterator_ + inc, it.isAligned_ );
517 return SubvectorIterator( it.iterator_ + inc, it.isAligned_ );
529 return SubvectorIterator( it.iterator_ - dec, it.isAligned_ );
548 inline bool isAligned()
const {
555 IteratorType iterator_;
563 using ConstIterator = SubvectorIterator< ConstIterator_t<VT> >;
566 using Iterator = If_t< IsConst_v<VT>, ConstIterator, SubvectorIterator< Iterator_t<VT> > >;
571 static constexpr
bool simdEnabled = VT::simdEnabled;
574 static constexpr
bool smpAssignable = VT::smpAssignable;
577 static constexpr
bool compileTimeArgs = DataType::compileTimeArgs;
583 template<
typename... RSAs >
584 explicit inline Subvector( VT& vector, RSAs... args );
586 Subvector(
const Subvector& ) =
default;
593 ~Subvector() =
default;
600 inline Reference operator[](
size_t index );
601 inline ConstReference operator[](
size_t index )
const;
602 inline Reference at(
size_t index );
603 inline ConstReference at(
size_t index )
const;
604 inline Pointer
data () noexcept;
605 inline ConstPointer
data () const noexcept;
606 inline Iterator
begin ();
607 inline ConstIterator
begin () const;
608 inline ConstIterator
cbegin() const;
609 inline Iterator
end ();
610 inline ConstIterator
end () const;
611 inline ConstIterator
cend () const;
618 inline Subvector& operator= ( const ElementType& rhs );
619 inline Subvector& operator= ( initializer_list<ElementType> list );
620 inline Subvector& operator= ( const Subvector& rhs );
621 template< typename VT2 > inline Subvector& operator= ( const Vector<VT2,TF>& rhs );
622 template< typename VT2 > inline Subvector& operator+=( const Vector<VT2,TF>& rhs );
623 template< typename VT2 > inline Subvector& operator-=( const Vector<VT2,TF>& rhs );
624 template< typename VT2 > inline Subvector& operator*=( const Vector<VT2,TF>& rhs );
625 template< typename VT2 > inline Subvector& operator/=( const DenseVector<VT2,TF>& rhs );
626 template< typename VT2 > inline Subvector& operator%=( const Vector<VT2,TF>& rhs );
633 using DataType::offset;
634 using DataType::
size;
636 inline VT& operand() noexcept;
637 inline const VT& operand() const noexcept;
639 inline
size_t spacing() const noexcept;
640 inline
size_t capacity() const noexcept;
649 template< typename Other > inline Subvector& scale( const Other& scalar );
656 template< typename VT2 >
657 static constexpr
bool VectorizedAssign_v =
658 ( useOptimizedKernels &&
659 simdEnabled && VT2::simdEnabled &&
665 template< typename VT2 >
666 static constexpr
bool VectorizedAddAssign_v =
667 ( useOptimizedKernels &&
668 simdEnabled && VT2::simdEnabled &&
675 template< typename VT2 >
676 static constexpr
bool VectorizedSubAssign_v =
677 ( useOptimizedKernels &&
678 simdEnabled && VT2::simdEnabled &&
685 template< typename VT2 >
686 static constexpr
bool VectorizedMultAssign_v =
687 ( useOptimizedKernels &&
688 simdEnabled && VT2::simdEnabled &&
695 template< typename VT2 >
696 static constexpr
bool VectorizedDivAssign_v =
697 ( useOptimizedKernels &&
698 simdEnabled && VT2::simdEnabled &&
705 static constexpr
size_t SIMDSIZE = SIMDTrait<ElementType>::
size;
712 template< typename Other >
713 inline
bool canAlias( const Other* alias ) const noexcept;
715 template< typename VT2,
AlignmentFlag AF2,
bool TF2,
size_t... CSAs2 >
716 inline
bool canAlias( const Subvector<VT2,AF2,TF2,true,CSAs2...>* alias ) const noexcept;
718 template< typename Other >
719 inline
bool isAliased( const Other* alias ) const noexcept;
721 template< typename VT2,
AlignmentFlag AF2,
bool TF2,
size_t... CSAs2 >
722 inline
bool isAliased( const Subvector<VT2,AF2,TF2,true,CSAs2...>* alias ) const noexcept;
724 inline
bool isAligned () const noexcept;
725 inline
bool canSMPAssign() const noexcept;
736 template< typename VT2 >
737 inline auto assign( const DenseVector <VT2,TF>& rhs ) ->
DisableIf_t< VectorizedAssign_v<VT2> >;
739 template< typename VT2 >
740 inline auto assign( const DenseVector <VT2,TF>& rhs ) ->
EnableIf_t< VectorizedAssign_v<VT2> >;
742 template< typename VT2 > inline
void assign( const SparseVector<VT2,TF>& rhs );
744 template< typename VT2 >
745 inline auto addAssign( const DenseVector <VT2,TF>& rhs ) ->
DisableIf_t< VectorizedAddAssign_v<VT2> >;
747 template< typename VT2 >
748 inline auto addAssign ( const DenseVector <VT2,TF>& rhs ) ->
EnableIf_t< VectorizedAddAssign_v<VT2> >;
750 template< typename VT2 > inline
void addAssign( const SparseVector<VT2,TF>& rhs );
752 template< typename VT2 >
753 inline auto subAssign( const DenseVector <VT2,TF>& rhs ) ->
DisableIf_t< VectorizedSubAssign_v<VT2> >;
755 template< typename VT2 >
756 inline auto subAssign( const DenseVector <VT2,TF>& rhs ) ->
EnableIf_t< VectorizedSubAssign_v<VT2> >;
758 template< typename VT2 > inline
void subAssign( const SparseVector<VT2,TF>& rhs );
760 template< typename VT2 >
761 inline auto multAssign( const DenseVector <VT2,TF>& rhs ) ->
DisableIf_t< VectorizedMultAssign_v<VT2> >;
763 template< typename VT2 >
764 inline auto multAssign( const DenseVector <VT2,TF>& rhs ) ->
EnableIf_t< VectorizedMultAssign_v<VT2> >;
766 template< typename VT2 > inline
void multAssign( const SparseVector<VT2,TF>& rhs );
768 template< typename VT2 >
769 inline auto divAssign( const DenseVector <VT2,TF>& rhs ) ->
DisableIf_t< VectorizedDivAssign_v<VT2> >;
771 template< typename VT2 >
772 inline auto divAssign( const DenseVector <VT2,TF>& rhs ) ->
EnableIf_t< VectorizedDivAssign_v<VT2> >;
781 const
bool isAligned_;
792 template< typename VT2,
AlignmentFlag AF2,
bool TF2,
bool DF2,
size_t... CSAs2 > friend class Subvector;
829 template< typename VT
832 template< typename... RSAs >
833 inline Subvector<VT,
unaligned,TF,true,CSAs...>::Subvector( VT& vector, RSAs... args )
834 : DataType ( args... )
840 if( offset() +
size() > vector.size() ) {
870 template<
typename VT
873 inline typename Subvector<VT,
unaligned,TF,
true,CSAs...>::Reference
874 Subvector<VT,unaligned,TF,true,CSAs...>::operator[](
size_t index )
877 return vector_[offset()+index];
893 template<
typename VT
896 inline typename Subvector<VT,
unaligned,TF,
true,CSAs...>::ConstReference
897 Subvector<VT,unaligned,TF,true,CSAs...>::operator[](
size_t index )
const 900 return const_cast<const VT&>( vector_ )[offset()+index];
917 template<
typename VT
920 inline typename Subvector<VT,
unaligned,TF,
true,CSAs...>::Reference
921 Subvector<VT,unaligned,TF,true,CSAs...>::at(
size_t index )
923 if( index >=
size() ) {
926 return (*
this)[index];
943 template<
typename VT
946 inline typename Subvector<VT,
unaligned,TF,
true,CSAs...>::ConstReference
947 Subvector<VT,unaligned,TF,true,CSAs...>::at(
size_t index )
const 949 if( index >=
size() ) {
952 return (*
this)[index];
966 template<
typename VT
969 inline typename Subvector<VT,
unaligned,TF,
true,CSAs...>::Pointer
972 return vector_.data() + offset();
986 template<
typename VT
989 inline typename Subvector<VT,
unaligned,TF,
true,CSAs...>::ConstPointer
992 return vector_.data() + offset();
1006 template<
typename VT
1009 inline typename Subvector<VT,
unaligned,TF,
true,CSAs...>::Iterator
1012 return Iterator( vector_.begin() + offset(), isAligned_ );
1026 template<
typename VT
1029 inline typename Subvector<VT,
unaligned,TF,
true,CSAs...>::ConstIterator
1032 return ConstIterator( vector_.cbegin() + offset(), isAligned_ );
1046 template<
typename VT
1049 inline typename Subvector<VT,
unaligned,TF,
true,CSAs...>::ConstIterator
1052 return ConstIterator( vector_.cbegin() + offset(), isAligned_ );
1066 template<
typename VT
1069 inline typename Subvector<VT,
unaligned,TF,
true,CSAs...>::Iterator
1072 return Iterator( vector_.begin() + offset() +
size(), isAligned_ );
1086 template<
typename VT
1089 inline typename Subvector<VT,
unaligned,TF,
true,CSAs...>::ConstIterator
1092 return ConstIterator( vector_.cbegin() + offset() +
size(), isAligned_ );
1106 template<
typename VT
1109 inline typename Subvector<VT,
unaligned,TF,
true,CSAs...>::ConstIterator
1112 return ConstIterator( vector_.cbegin() + offset() +
size(), isAligned_ );
1133 template<
typename VT
1136 inline Subvector<VT,
unaligned,TF,
true,CSAs...>&
1137 Subvector<VT,unaligned,TF,true,CSAs...>::operator=(
const ElementType& rhs )
1139 const size_t iend( offset() +
size() );
1140 decltype(
auto) left( derestrict( vector_ ) );
1142 for(
size_t i=offset(); i<iend; ++i ) {
1143 if( !IsRestricted_v<VT> || trySet( vector_, i, rhs ) )
1169 template<
typename VT
1172 inline Subvector<VT,
unaligned,TF,
true,CSAs...>&
1173 Subvector<VT,unaligned,TF,true,CSAs...>::operator=( initializer_list<ElementType> list )
1175 if( list.size() >
size() ) {
1179 if( IsRestricted_v<VT> ) {
1180 const InitializerVector<ElementType,TF> tmp( list,
size() );
1181 if( !tryAssign( vector_, tmp, offset() ) ) {
1186 decltype(
auto) left( derestrict( *this ) );
1188 std::fill( std::copy( list.
begin(), list.
end(), left.
begin() ), left.
end(), ElementType() );
1210 template< typename VT
1213 inline Subvector<VT,
unaligned,TF,true,CSAs...>&
1214 Subvector<VT,
unaligned,TF,true,CSAs...>::operator=( const Subvector& rhs )
1219 if( &rhs ==
this || ( &vector_ == &rhs.vector_ && offset() == rhs.offset() ) )
1222 if(
size() != rhs.size() ) {
1226 if( !tryAssign( vector_, rhs, offset() ) ) {
1230 decltype(
auto) left( derestrict( *this ) );
1232 if( rhs.canAlias( &vector_ ) ) {
1233 const ResultType tmp( rhs );
1260 template<
typename VT
1263 template<
typename VT2 >
1264 inline Subvector<VT,
unaligned,TF,
true,CSAs...>&
1265 Subvector<VT,unaligned,TF,true,CSAs...>::operator=(
const Vector<VT2,TF>& rhs )
1274 using Right = If_t< IsRestricted_v<VT>, CompositeType_t<VT2>,
const VT2& >;
1275 Right right( ~rhs );
1277 if( !tryAssign( vector_, right, offset() ) ) {
1281 decltype(
auto) left( derestrict( *this ) );
1284 const ResultType_t<VT2> tmp( right );
1288 if( IsSparseVector_v<VT2> )
1313 template<
typename VT
1316 template<
typename VT2 >
1317 inline Subvector<VT,
unaligned,TF,
true,CSAs...>&
1327 using Right = If_t< IsRestricted_v<VT>, CompositeType_t<VT2>,
const VT2& >;
1328 Right right( ~rhs );
1330 if( !tryAddAssign( vector_, right, offset() ) ) {
1334 decltype(
auto) left( derestrict( *this ) );
1337 const ResultType_t<VT2> tmp( right );
1364 template<
typename VT
1367 template<
typename VT2 >
1368 inline Subvector<VT,
unaligned,TF,
true,CSAs...>&
1378 using Right = If_t< IsRestricted_v<VT>, CompositeType_t<VT2>,
const VT2& >;
1379 Right right( ~rhs );
1381 if( !trySubAssign( vector_, right, offset() ) ) {
1385 decltype(
auto) left( derestrict( *this ) );
1388 const ResultType_t<VT2> tmp( right );
1416 template<
typename VT
1419 template<
typename VT2 >
1420 inline Subvector<VT,
unaligned,TF,
true,CSAs...>&
1430 using Right = If_t< IsRestricted_v<VT>, CompositeType_t<VT2>,
const VT2& >;
1431 Right right( ~rhs );
1433 if( !tryMultAssign( vector_, right, offset() ) ) {
1437 decltype(
auto) left( derestrict( *this ) );
1440 const ResultType_t<VT2> tmp( right );
1467 template<
typename VT
1470 template<
typename VT2 >
1471 inline Subvector<VT,
unaligned,TF,
true,CSAs...>&
1481 using Right = If_t< IsRestricted_v<VT>, CompositeType_t<VT2>,
const VT2& >;
1482 Right right( ~rhs );
1484 if( !tryDivAssign( vector_, right, offset() ) ) {
1488 decltype(
auto) left( derestrict( *this ) );
1491 const ResultType_t<VT2> tmp( right );
1519 template<
typename VT
1522 template<
typename VT2 >
1523 inline Subvector<VT,
unaligned,TF,
true,CSAs...>&
1524 Subvector<VT,unaligned,TF,true,CSAs...>::operator%=(
const Vector<VT2,TF>& rhs )
1526 using blaze::assign;
1531 using CrossType = CrossTrait_t< ResultType, ResultType_t<VT2> >;
1537 if(
size() != 3UL || (~rhs).
size() != 3UL ) {
1541 const CrossType tmp( *
this % (~rhs) );
1543 if( !tryAssign( vector_, tmp, offset() ) ) {
1547 decltype(
auto) left( derestrict( *this ) );
1549 assign( left, tmp );
1573 template< typename VT
1576 inline VT& Subvector<VT,
unaligned,TF,true,CSAs...>::operand() noexcept
1590 template<
typename VT
1593 inline const VT& Subvector<VT,unaligned,TF,true,CSAs...>::operand() const noexcept
1610 template<
typename VT
1615 return vector_.spacing() - offset();
1627 template<
typename VT
1632 return vector_.capacity() - offset();
1647 template<
typename VT
1652 size_t nonzeros( 0 );
1654 const size_t iend( offset() +
size() );
1655 for(
size_t i=offset(); i<iend; ++i ) {
1672 template<
typename VT
1679 const size_t iend( offset() +
size() );
1680 for(
size_t i=offset(); i<iend; ++i )
1681 clear( vector_[i] );
1706 template<
typename VT
1709 template<
typename Other >
1710 inline Subvector<VT,
unaligned,TF,
true,CSAs...>&
1711 Subvector<VT,unaligned,TF,true,CSAs...>::scale(
const Other& scalar )
1713 const size_t iend( offset() +
size() );
1714 for(
size_t i=offset(); i<iend; ++i )
1715 vector_[i] *= scalar;
1741 template<
typename VT
1744 template<
typename Other >
1745 inline bool Subvector<VT,unaligned,TF,true,CSAs...>::canAlias(
const Other* alias )
const noexcept
1747 return vector_.isAliased( alias );
1764 template<
typename VT
1767 template<
typename VT2
1772 Subvector<VT,unaligned,TF,true,CSAs...>::canAlias(
const Subvector<VT2,AF2,TF2,true,CSAs2...>* alias )
const noexcept
1774 return ( vector_.isAliased( &alias->vector_ ) &&
1775 ( offset() +
size() > alias->offset() ) &&
1776 ( offset() < alias->offset() + alias->size() ) );
1793 template<
typename VT
1796 template<
typename Other >
1797 inline bool Subvector<VT,unaligned,TF,true,CSAs...>::isAliased(
const Other* alias )
const noexcept
1799 return vector_.isAliased( alias );
1816 template<
typename VT
1819 template<
typename VT2
1824 Subvector<VT,unaligned,TF,true,CSAs...>::isAliased(
const Subvector<VT2,AF2,TF2,true,CSAs2...>* alias )
const noexcept
1826 return ( vector_.isAliased( &alias->vector_ ) &&
1827 ( offset() +
size() > alias->offset() ) &&
1828 ( offset() < alias->offset() + alias->size() ) );
1844 template<
typename VT
1847 inline bool Subvector<VT,unaligned,TF,true,CSAs...>::isAligned() const noexcept
1866 template<
typename VT
1869 inline bool Subvector<VT,unaligned,TF,true,CSAs...>::canSMPAssign() const noexcept
1871 return (
size() > SMP_DVECASSIGN_THRESHOLD );
1891 template<
typename VT
1895 Subvector<VT,unaligned,TF,true,CSAs...>::load(
size_t index )
const noexcept
1898 return loada( index );
1900 return loadu( index );
1920 template<
typename VT
1932 return vector_.loada( offset()+index );
1952 template<
typename VT
1963 return vector_.loadu( offset()+index );
1984 template<
typename VT
1988 Subvector<VT,unaligned,TF,true,CSAs...>::store(
size_t index,
const SIMDType& value ) noexcept
2014 template<
typename VT
2026 vector_.storea( offset()+index, value );
2047 template<
typename VT
2058 vector_.storeu( offset()+index, value );
2079 template<
typename VT
2092 vector_.stream( offset()+index, value );
2094 vector_.storeu( offset()+index, value );
2112 template<
typename VT
2115 template<
typename VT2 >
2116 inline auto Subvector<VT,unaligned,TF,true,CSAs...>::assign(
const DenseVector<VT2,TF>& rhs )
2117 -> DisableIf_t< VectorizedAssign_v<VT2> >
2121 const size_t ipos(
size() &
size_t(-2) );
2122 for(
size_t i=0UL; i<ipos; i+=2UL ) {
2123 vector_[offset()+i ] = (~rhs)[i ];
2124 vector_[offset()+i+1UL] = (~rhs)[i+1UL];
2126 if( ipos <
size() ) {
2127 vector_[offset()+ipos] = (~rhs)[ipos];
2146 template<
typename VT
2149 template<
typename VT2 >
2150 inline auto Subvector<VT,unaligned,TF,true,CSAs...>::assign(
const DenseVector<VT2,TF>& rhs )
2151 -> EnableIf_t< VectorizedAssign_v<VT2> >
2157 const size_t ipos(
size() &
size_t(-SIMDSIZE) );
2161 Iterator left(
begin() );
2162 ConstIterator_t<VT2> right( (~rhs).
begin() );
2164 if( useStreaming && isAligned_ &&
2165 (
size() > ( cacheSize/(
sizeof(ElementType) * 3UL ) ) ) &&
2166 !(~rhs).isAliased( &vector_ ) )
2168 for( ; i<ipos; i+=SIMDSIZE ) {
2169 left.stream( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2171 for( ; i<
size(); ++i ) {
2177 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
2178 left.store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2179 left.store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2180 left.store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2181 left.store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2183 for( ; i<ipos; i+=SIMDSIZE ) {
2184 left.store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2186 for( ; i<
size(); ++i ) {
2187 *left = *right; ++left; ++right;
2207 template<
typename VT
2210 template<
typename VT2 >
2211 inline void Subvector<VT,unaligned,TF,true,CSAs...>::assign(
const SparseVector<VT2,TF>& rhs )
2215 for( ConstIterator_t<VT2> element=(~rhs).
begin(); element!=(~rhs).
end(); ++element )
2216 vector_[offset()+element->index()] = element->value();
2234 template<
typename VT
2237 template<
typename VT2 >
2238 inline auto Subvector<VT,unaligned,TF,true,CSAs...>::addAssign(
const DenseVector<VT2,TF>& rhs )
2239 -> DisableIf_t< VectorizedAddAssign_v<VT2> >
2243 const size_t ipos(
size() &
size_t(-2) );
2244 for(
size_t i=0UL; i<ipos; i+=2UL ) {
2245 vector_[offset()+i ] += (~rhs)[i ];
2246 vector_[offset()+i+1UL] += (~rhs)[i+1UL];
2248 if( ipos <
size() ) {
2249 vector_[offset()+ipos] += (~rhs)[ipos];
2268 template<
typename VT
2271 template<
typename VT2 >
2272 inline auto Subvector<VT,unaligned,TF,true,CSAs...>::addAssign(
const DenseVector<VT2,TF>& rhs )
2273 -> EnableIf_t< VectorizedAddAssign_v<VT2> >
2279 const size_t ipos(
size() &
size_t(-SIMDSIZE) );
2283 Iterator left(
begin() );
2284 ConstIterator_t<VT2> right( (~rhs).
begin() );
2286 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
2287 left.store( left.load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2288 left.store( left.load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2289 left.store( left.load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2290 left.store( left.load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2292 for( ; i<ipos; i+=SIMDSIZE ) {
2293 left.store( left.load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2295 for( ; i<
size(); ++i ) {
2296 *left += *right; ++left; ++right;
2315 template<
typename VT
2318 template<
typename VT2 >
2319 inline void Subvector<VT,unaligned,TF,true,CSAs...>::addAssign(
const SparseVector<VT2,TF>& rhs )
2323 for( ConstIterator_t<VT2> element=(~rhs).
begin(); element!=(~rhs).
end(); ++element )
2324 vector_[offset()+element->index()] += element->value();
2342 template<
typename VT
2345 template<
typename VT2 >
2346 inline auto Subvector<VT,unaligned,TF,true,CSAs...>::subAssign(
const DenseVector<VT2,TF>& rhs )
2347 -> DisableIf_t< VectorizedSubAssign_v<VT2> >
2351 const size_t ipos(
size() &
size_t(-2) );
2352 for(
size_t i=0UL; i<ipos; i+=2UL ) {
2353 vector_[offset()+i ] -= (~rhs)[i ];
2354 vector_[offset()+i+1UL] -= (~rhs)[i+1UL];
2356 if( ipos <
size() ) {
2357 vector_[offset()+ipos] -= (~rhs)[ipos];
2376 template<
typename VT
2379 template<
typename VT2 >
2380 inline auto Subvector<VT,unaligned,TF,true,CSAs...>::subAssign(
const DenseVector<VT2,TF>& rhs )
2381 -> EnableIf_t< VectorizedSubAssign_v<VT2> >
2387 const size_t ipos(
size() &
size_t(-SIMDSIZE) );
2391 Iterator left(
begin() );
2392 ConstIterator_t<VT2> right( (~rhs).
begin() );
2394 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
2395 left.store( left.load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2396 left.store( left.load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2397 left.store( left.load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2398 left.store( left.load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2400 for( ; i<ipos; i+=SIMDSIZE ) {
2401 left.store( left.load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2403 for( ; i<
size(); ++i ) {
2404 *left -= *right; ++left; ++right;
2423 template<
typename VT
2426 template<
typename VT2 >
2427 inline void Subvector<VT,unaligned,TF,true,CSAs...>::subAssign(
const SparseVector<VT2,TF>& rhs )
2431 for( ConstIterator_t<VT2> element=(~rhs).
begin(); element!=(~rhs).
end(); ++element )
2432 vector_[offset()+element->index()] -= element->value();
2450 template<
typename VT
2453 template<
typename VT2 >
2454 inline auto Subvector<VT,unaligned,TF,true,CSAs...>::multAssign(
const DenseVector<VT2,TF>& rhs )
2455 -> DisableIf_t< VectorizedMultAssign_v<VT2> >
2459 const size_t ipos(
size() &
size_t(-2) );
2460 for(
size_t i=0UL; i<ipos; i+=2UL ) {
2461 vector_[offset()+i ] *= (~rhs)[i ];
2462 vector_[offset()+i+1UL] *= (~rhs)[i+1UL];
2464 if( ipos <
size() ) {
2465 vector_[offset()+ipos] *= (~rhs)[ipos];
2484 template<
typename VT
2487 template<
typename VT2 >
2488 inline auto Subvector<VT,unaligned,TF,true,CSAs...>::multAssign(
const DenseVector<VT2,TF>& rhs )
2489 -> EnableIf_t< VectorizedMultAssign_v<VT2> >
2495 const size_t ipos(
size() &
size_t(-SIMDSIZE) );
2499 Iterator left(
begin() );
2500 ConstIterator_t<VT2> right( (~rhs).
begin() );
2502 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
2503 left.store( left.load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2504 left.store( left.load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2505 left.store( left.load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2506 left.store( left.load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2508 for( ; i<ipos; i+=SIMDSIZE ) {
2509 left.store( left.load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2511 for( ; i<
size(); ++i ) {
2512 *left *= *right; ++left; ++right;
2531 template<
typename VT
2534 template<
typename VT2 >
2535 inline void Subvector<VT,unaligned,TF,true,CSAs...>::multAssign(
const SparseVector<VT2,TF>& rhs )
2543 for( ConstIterator_t<VT2> element=(~rhs).
begin(); element!=(~rhs).
end(); ++element ) {
2544 const size_t index( element->index() );
2545 for( ; i<index; ++i )
2546 reset( vector_[offset()+i] );
2547 vector_[offset()+i] *= element->value();
2551 for( ; i<
size(); ++i ) {
2552 reset( vector_[offset()+i] );
2571 template<
typename VT
2574 template<
typename VT2 >
2575 inline auto Subvector<VT,unaligned,TF,true,CSAs...>::divAssign(
const DenseVector<VT2,TF>& rhs )
2576 -> DisableIf_t< VectorizedDivAssign_v<VT2> >
2580 const size_t ipos(
size() &
size_t(-2) );
2581 for(
size_t i=0UL; i<ipos; i+=2UL ) {
2582 vector_[offset()+i ] /= (~rhs)[i ];
2583 vector_[offset()+i+1UL] /= (~rhs)[i+1UL];
2585 if( ipos <
size() ) {
2586 vector_[offset()+ipos] /= (~rhs)[ipos];
2605 template<
typename VT
2608 template<
typename VT2 >
2609 inline auto Subvector<VT,unaligned,TF,true,CSAs...>::divAssign(
const DenseVector<VT2,TF>& rhs )
2610 -> EnableIf_t< VectorizedDivAssign_v<VT2> >
2616 const size_t ipos(
size() &
size_t(-SIMDSIZE) );
2620 Iterator left(
begin() );
2621 ConstIterator_t<VT2> right( (~rhs).
begin() );
2623 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
2624 left.store( left.load() / right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2625 left.store( left.load() / right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2626 left.store( left.load() / right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2627 left.store( left.load() / right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2629 for( ; i<ipos; i+=SIMDSIZE ) {
2630 left.store( left.load() / right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2632 for( ; i<
size(); ++i ) {
2633 *left /= *right; ++left; ++right;
2660 template<
typename VT
2663 class Subvector<VT,
aligned,TF,true,CSAs...>
2664 :
public View< DenseVector< Subvector<VT,aligned,TF,true,CSAs...>, TF > >
2665 ,
private SubvectorData<CSAs...>
2669 using DataType = SubvectorData<CSAs...>;
2670 using Operand = If_t< IsExpression_v<VT>, VT, VT& >;
2676 using This = Subvector<VT,
aligned,TF,
true,CSAs...>;
2678 using BaseType = DenseVector<This,TF>;
2679 using ViewedType = VT;
2681 using TransposeType = TransposeType_t<ResultType>;
2682 using ElementType = ElementType_t<VT>;
2683 using SIMDType = SIMDTrait_t<ElementType>;
2684 using ReturnType = ReturnType_t<VT>;
2685 using CompositeType =
const Subvector&;
2688 using ConstReference = ConstReference_t<VT>;
2691 using Reference = If_t< IsConst_v<VT>, ConstReference, Reference_t<VT> >;
2694 using ConstPointer = ConstPointer_t<VT>;
2697 using Pointer = If_t< IsConst_v<VT> || !HasMutableDataAccess_v<VT>, ConstPointer, Pointer_t<VT> >;
2700 using ConstIterator = ConstIterator_t<VT>;
2703 using Iterator = If_t< IsConst_v<VT>, ConstIterator, Iterator_t<VT> >;
2708 static constexpr
bool simdEnabled = VT::simdEnabled;
2711 static constexpr
bool smpAssignable = VT::smpAssignable;
2714 static constexpr
bool compileTimeArgs = DataType::compileTimeArgs;
2720 template<
typename... RSAs >
2721 explicit inline Subvector( VT& vector, RSAs... args );
2723 Subvector(
const Subvector& ) =
default;
2730 ~Subvector() =
default;
2737 inline Reference operator[](
size_t index );
2738 inline ConstReference operator[](
size_t index )
const;
2739 inline Reference at(
size_t index );
2740 inline ConstReference at(
size_t index )
const;
2741 inline Pointer
data () noexcept;
2742 inline ConstPointer
data () const noexcept;
2743 inline Iterator
begin ();
2744 inline ConstIterator
begin () const;
2745 inline ConstIterator
cbegin() const;
2746 inline Iterator
end ();
2747 inline ConstIterator
end () const;
2748 inline ConstIterator
cend () const;
2755 inline Subvector& operator= ( const ElementType& rhs );
2756 inline Subvector& operator= ( initializer_list<ElementType> list );
2757 inline Subvector& operator= ( const Subvector& rhs );
2758 template< typename VT2 > inline Subvector& operator= ( const Vector<VT2,TF>& rhs );
2759 template< typename VT2 > inline Subvector& operator+=( const Vector<VT2,TF>& rhs );
2760 template< typename VT2 > inline Subvector& operator-=( const Vector<VT2,TF>& rhs );
2761 template< typename VT2 > inline Subvector& operator*=( const Vector<VT2,TF>& rhs );
2762 template< typename VT2 > inline Subvector& operator/=( const DenseVector<VT2,TF>& rhs );
2763 template< typename VT2 > inline Subvector& operator%=( const Vector<VT2,TF>& rhs );
2770 using DataType::offset;
2771 using DataType::
size;
2773 inline VT& operand() noexcept;
2774 inline const VT& operand() const noexcept;
2776 inline
size_t spacing() const noexcept;
2777 inline
size_t capacity() const noexcept;
2779 inline
void reset();
2786 template< typename Other > inline Subvector& scale( const Other& scalar );
2793 template< typename VT2 >
2794 static constexpr
bool VectorizedAssign_v =
2795 ( useOptimizedKernels &&
2796 simdEnabled && VT2::simdEnabled &&
2802 template< typename VT2 >
2803 static constexpr
bool VectorizedAddAssign_v =
2804 ( useOptimizedKernels &&
2805 simdEnabled && VT2::simdEnabled &&
2812 template< typename VT2 >
2813 static constexpr
bool VectorizedSubAssign_v =
2814 ( useOptimizedKernels &&
2815 simdEnabled && VT2::simdEnabled &&
2822 template< typename VT2 >
2823 static constexpr
bool VectorizedMultAssign_v =
2824 ( useOptimizedKernels &&
2825 simdEnabled && VT2::simdEnabled &&
2832 template< typename VT2 >
2833 static constexpr
bool VectorizedDivAssign_v =
2834 ( useOptimizedKernels &&
2835 simdEnabled && VT2::simdEnabled &&
2842 static constexpr
size_t SIMDSIZE = SIMDTrait<ElementType>::
size;
2849 template< typename Other >
2850 inline
bool canAlias( const Other* alias ) const noexcept;
2852 template< typename VT2,
AlignmentFlag AF2,
bool TF2,
size_t... CSAs2 >
2853 inline
bool canAlias( const Subvector<VT2,AF2,TF2,true,CSAs2...>* alias ) const noexcept;
2855 template< typename Other >
2856 inline
bool isAliased( const Other* alias ) const noexcept;
2858 template< typename VT2,
AlignmentFlag AF2,
bool TF2,
size_t... CSAs2 >
2859 inline
bool isAliased( const Subvector<VT2,AF2,TF2,true,CSAs2...>* alias ) const noexcept;
2861 inline
bool isAligned () const noexcept;
2862 inline
bool canSMPAssign() const noexcept;
2873 template< typename VT2 >
2874 inline auto assign( const DenseVector <VT2,TF>& rhs ) ->
DisableIf_t< VectorizedAssign_v<VT2> >;
2876 template< typename VT2 >
2877 inline auto assign( const DenseVector <VT2,TF>& rhs ) ->
EnableIf_t< VectorizedAssign_v<VT2> >;
2879 template< typename VT2 > inline
void assign( const SparseVector<VT2,TF>& rhs );
2881 template< typename VT2 >
2882 inline auto addAssign( const DenseVector <VT2,TF>& rhs ) ->
DisableIf_t< VectorizedAddAssign_v<VT2> >;
2884 template< typename VT2 >
2885 inline auto addAssign ( const DenseVector <VT2,TF>& rhs ) ->
EnableIf_t< VectorizedAddAssign_v<VT2> >;
2887 template< typename VT2 > inline
void addAssign( const SparseVector<VT2,TF>& rhs );
2889 template< typename VT2 >
2890 inline auto subAssign ( const DenseVector <VT2,TF>& rhs ) ->
DisableIf_t< VectorizedSubAssign_v<VT2> >;
2892 template< typename VT2 >
2893 inline auto subAssign( const DenseVector <VT2,TF>& rhs ) ->
EnableIf_t< VectorizedSubAssign_v<VT2> >;
2895 template< typename VT2 > inline
void subAssign( const SparseVector<VT2,TF>& rhs );
2897 template< typename VT2 >
2898 inline auto multAssign( const DenseVector <VT2,TF>& rhs ) ->
DisableIf_t< VectorizedMultAssign_v<VT2> >;
2900 template< typename VT2 >
2901 inline auto multAssign( const DenseVector <VT2,TF>& rhs ) ->
EnableIf_t< VectorizedMultAssign_v<VT2> >;
2903 template< typename VT2 > inline
void multAssign( const SparseVector<VT2,TF>& rhs );
2905 template< typename VT2 >
2906 inline auto divAssign( const DenseVector <VT2,TF>& rhs ) ->
DisableIf_t< VectorizedDivAssign_v<VT2> >;
2908 template< typename VT2 >
2909 inline auto divAssign( const DenseVector <VT2,TF>& rhs ) ->
EnableIf_t< VectorizedDivAssign_v<VT2> >;
2922 template< typename VT2,
AlignmentFlag AF2,
bool TF2,
bool DF2,
size_t... CSAs2 > friend class Subvector;
2959 template< typename VT
2962 template< typename... RSAs >
2963 inline Subvector<VT,
aligned,TF,true,CSAs...>::Subvector( VT& vector, RSAs... args )
2964 : DataType( args... )
2965 , vector_ ( vector )
2969 if( offset() +
size() > vector.size() ) {
3002 template<
typename VT
3005 inline typename Subvector<VT,
aligned,TF,
true,CSAs...>::Reference
3006 Subvector<VT,aligned,TF,true,CSAs...>::operator[](
size_t index )
3009 return vector_[offset()+index];
3022 template<
typename VT
3025 inline typename Subvector<VT,
aligned,TF,
true,CSAs...>::ConstReference
3026 Subvector<VT,aligned,TF,true,CSAs...>::operator[](
size_t index )
const 3029 return const_cast<const VT&>( vector_ )[offset()+index];
3046 template<
typename VT
3049 inline typename Subvector<VT,
aligned,TF,
true,CSAs...>::Reference
3050 Subvector<VT,aligned,TF,true,CSAs...>::at(
size_t index )
3052 if( index >=
size() ) {
3055 return (*
this)[index];
3072 template<
typename VT
3075 inline typename Subvector<VT,
aligned,TF,
true,CSAs...>::ConstReference
3076 Subvector<VT,aligned,TF,true,CSAs...>::at(
size_t index )
const 3078 if( index >=
size() ) {
3081 return (*
this)[index];
3095 template<
typename VT
3098 inline typename Subvector<VT,
aligned,TF,
true,CSAs...>::Pointer
3101 return vector_.data() + offset();
3115 template<
typename VT
3118 inline typename Subvector<VT,
aligned,TF,
true,CSAs...>::ConstPointer
3121 return vector_.data() + offset();
3135 template<
typename VT
3138 inline typename Subvector<VT,
aligned,TF,
true,CSAs...>::Iterator
3141 return ( vector_.begin() + offset() );
3155 template<
typename VT
3158 inline typename Subvector<VT,
aligned,TF,
true,CSAs...>::ConstIterator
3161 return ( vector_.cbegin() + offset() );
3175 template<
typename VT
3178 inline typename Subvector<VT,
aligned,TF,
true,CSAs...>::ConstIterator
3181 return ( vector_.cbegin() + offset() );
3195 template<
typename VT
3198 inline typename Subvector<VT,
aligned,TF,
true,CSAs...>::Iterator
3201 return ( vector_.begin() + offset() +
size() );
3215 template<
typename VT
3218 inline typename Subvector<VT,
aligned,TF,
true,CSAs...>::ConstIterator
3221 return ( vector_.cbegin() + offset() +
size() );
3235 template<
typename VT
3238 inline typename Subvector<VT,
aligned,TF,
true,CSAs...>::ConstIterator
3241 return ( vector_.cbegin() + offset() +
size() );
3262 template<
typename VT
3265 inline Subvector<VT,
aligned,TF,
true,CSAs...>&
3266 Subvector<VT,aligned,TF,true,CSAs...>::operator=(
const ElementType& rhs )
3268 const size_t iend( offset() +
size() );
3269 decltype(
auto) left( derestrict( vector_ ) );
3271 for(
size_t i=offset(); i<iend; ++i ) {
3272 if( !IsRestricted_v<VT> || trySet( vector_, i, rhs ) )
3295 template<
typename VT
3298 inline Subvector<VT,
aligned,TF,
true,CSAs...>&
3299 Subvector<VT,aligned,TF,true,CSAs...>::operator=( initializer_list<ElementType> list )
3301 if( list.size() >
size() ) {
3305 if( IsRestricted_v<VT> ) {
3306 const InitializerVector<ElementType,TF> tmp( list,
size() );
3307 if( !tryAssign( vector_, tmp, offset() ) ) {
3312 decltype(
auto) left( derestrict( *this ) );
3314 std::fill( std::copy( list.
begin(), list.
end(),
begin() ),
end(), ElementType() );
3336 template< typename VT
3339 inline Subvector<VT,
aligned,TF,true,CSAs...>&
3340 Subvector<VT,
aligned,TF,true,CSAs...>::operator=( const Subvector& rhs )
3345 if( &rhs ==
this || ( &vector_ == &rhs.vector_ && offset() == rhs.offset() ) )
3348 if(
size() != rhs.size() ) {
3352 if( !tryAssign( vector_, rhs, offset() ) ) {
3356 decltype(
auto) left( derestrict( *this ) );
3358 if( rhs.canAlias( &vector_ ) ) {
3359 const ResultType tmp( ~rhs );
3386 template<
typename VT
3389 template<
typename VT2 >
3390 inline Subvector<VT,
aligned,TF,
true,CSAs...>&
3391 Subvector<VT,aligned,TF,true,CSAs...>::operator=(
const Vector<VT2,TF>& rhs )
3400 using Right = If_t< IsRestricted_v<VT>, CompositeType_t<VT2>,
const VT2& >;
3401 Right right( ~rhs );
3403 if( !tryAssign( vector_, right, offset() ) ) {
3407 decltype(
auto) left( derestrict( *this ) );
3410 const ResultType_t<VT2> tmp( right );
3414 if( IsSparseVector_v<VT2> )
3439 template<
typename VT
3442 template<
typename VT2 >
3443 inline Subvector<VT,
aligned,TF,
true,CSAs...>&
3453 using Right = If_t< IsRestricted_v<VT>, CompositeType_t<VT2>,
const VT2& >;
3454 Right right( ~rhs );
3456 if( !tryAddAssign( vector_, right, offset() ) ) {
3460 decltype(
auto) left( derestrict( *this ) );
3463 const ResultType_t<VT2> tmp( right );
3490 template<
typename VT
3493 template<
typename VT2 >
3494 inline Subvector<VT,
aligned,TF,
true,CSAs...>&
3504 using Right = If_t< IsRestricted_v<VT>, CompositeType_t<VT2>,
const VT2& >;
3505 Right right( ~rhs );
3507 if( !trySubAssign( vector_, right, offset() ) ) {
3511 decltype(
auto) left( derestrict( *this ) );
3514 const ResultType_t<VT2> tmp( right );
3542 template<
typename VT
3545 template<
typename VT2 >
3546 inline Subvector<VT,
aligned,TF,
true,CSAs...>&
3556 using Right = If_t< IsRestricted_v<VT>, CompositeType_t<VT2>,
const VT2& >;
3557 Right right( ~rhs );
3559 if( !tryMultAssign( vector_, right, offset() ) ) {
3563 decltype(
auto) left( derestrict( *this ) );
3566 const ResultType_t<VT2> tmp( right );
3593 template<
typename VT
3596 template<
typename VT2 >
3597 inline Subvector<VT,
aligned,TF,
true,CSAs...>&
3607 using Right = If_t< IsRestricted_v<VT>, CompositeType_t<VT2>,
const VT2& >;
3608 Right right( ~rhs );
3610 if( !tryDivAssign( vector_, right, offset() ) ) {
3614 decltype(
auto) left( derestrict( *this ) );
3617 const ResultType_t<VT2> tmp( right );
3645 template<
typename VT
3648 template<
typename VT2 >
3649 inline Subvector<VT,
aligned,TF,
true,CSAs...>&
3650 Subvector<VT,aligned,TF,true,CSAs...>::operator%=(
const Vector<VT2,TF>& rhs )
3652 using blaze::assign;
3657 using CrossType = CrossTrait_t< ResultType, ResultType_t<VT2> >;
3663 if(
size() != 3UL || (~rhs).
size() != 3UL ) {
3667 const CrossType tmp( *
this % (~rhs) );
3669 if( !tryAssign( vector_, tmp, offset() ) ) {
3673 decltype(
auto) left( derestrict( *this ) );
3675 assign( left, tmp );
3699 template< typename VT
3702 inline VT& Subvector<VT,
aligned,TF,true,CSAs...>::operand() noexcept
3716 template<
typename VT
3719 inline const VT& Subvector<VT,aligned,TF,true,CSAs...>::operand() const noexcept
3736 template<
typename VT
3741 return vector_.spacing() - offset();
3753 template<
typename VT
3758 return vector_.capacity() - offset();
3773 template<
typename VT
3778 size_t nonzeros( 0 );
3780 const size_t iend( offset() +
size() );
3781 for(
size_t i=offset(); i<iend; ++i ) {
3798 template<
typename VT
3805 const size_t iend( offset() +
size() );
3806 for(
size_t i=offset(); i<iend; ++i )
3807 clear( vector_[i] );
3832 template<
typename VT
3835 template<
typename Other >
3836 inline Subvector<VT,
aligned,TF,
true,CSAs...>&
3837 Subvector<VT,aligned,TF,true,CSAs...>::scale(
const Other& scalar )
3839 const size_t iend( offset() +
size() );
3840 for(
size_t i=offset(); i<iend; ++i )
3841 vector_[i] *= scalar;
3867 template<
typename VT
3870 template<
typename Other >
3871 inline bool Subvector<VT,aligned,TF,true,CSAs...>::canAlias(
const Other* alias )
const noexcept
3873 return vector_.isAliased( alias );
3890 template<
typename VT
3893 template<
typename VT2
3898 Subvector<VT,aligned,TF,true,CSAs...>::canAlias(
const Subvector<VT2,AF2,TF2,true,CSAs2...>* alias )
const noexcept
3900 return ( vector_.isAliased( &alias->vector_ ) &&
3901 ( offset() +
size() > alias->offset() ) &&
3902 ( offset() < alias->offset() + alias->size() ) );
3919 template<
typename VT
3922 template<
typename Other >
3923 inline bool Subvector<VT,aligned,TF,true,CSAs...>::isAliased(
const Other* alias )
const noexcept
3925 return vector_.isAliased( alias );
3942 template<
typename VT
3945 template<
typename VT2
3950 Subvector<VT,aligned,TF,true,CSAs...>::isAliased(
const Subvector<VT2,AF2,TF2,true,CSAs2...>* alias )
const noexcept
3952 return ( vector_.isAliased( &alias->vector_ ) &&
3953 ( offset() +
size() > alias->offset() ) &&
3954 ( offset() < alias->offset() + alias->size() ) );
3970 template<
typename VT
3973 inline bool Subvector<VT,aligned,TF,true,CSAs...>::isAligned() const noexcept
3992 template<
typename VT
3995 inline bool Subvector<VT,aligned,TF,true,CSAs...>::canSMPAssign() const noexcept
3997 return (
size() > SMP_DVECASSIGN_THRESHOLD );
4017 template<
typename VT
4021 Subvector<VT,aligned,TF,true,CSAs...>::load(
size_t index )
const noexcept
4023 return loada( index );
4043 template<
typename VT
4055 return vector_.loada( offset()+index );
4075 template<
typename VT
4086 return vector_.loadu( offset()+index );
4107 template<
typename VT
4111 Subvector<VT,aligned,TF,true,CSAs...>::store(
size_t index,
const SIMDType& value ) noexcept
4134 template<
typename VT
4146 vector_.storea( offset()+index, value );
4167 template<
typename VT
4178 vector_.storeu( offset()+index, value );
4199 template<
typename VT
4211 vector_.stream( offset()+index, value );
4229 template<
typename VT
4232 template<
typename VT2 >
4233 inline auto Subvector<VT,aligned,TF,true,CSAs...>::assign(
const DenseVector<VT2,TF>& rhs )
4234 -> DisableIf_t< VectorizedAssign_v<VT2> >
4238 const size_t ipos(
size() &
size_t(-2) );
4239 for(
size_t i=0UL; i<ipos; i+=2UL ) {
4240 vector_[offset()+i ] = (~rhs)[i ];
4241 vector_[offset()+i+1UL] = (~rhs)[i+1UL];
4243 if( ipos <
size() ) {
4244 vector_[offset()+ipos] = (~rhs)[ipos];
4263 template<
typename VT
4266 template<
typename VT2 >
4267 inline auto Subvector<VT,aligned,TF,true,CSAs...>::assign(
const DenseVector<VT2,TF>& rhs )
4268 -> EnableIf_t< VectorizedAssign_v<VT2> >
4274 const size_t ipos(
size() &
size_t(-SIMDSIZE) );
4278 Iterator left(
begin() );
4279 ConstIterator_t<VT2> right( (~rhs).
begin() );
4281 if( useStreaming &&
size() > ( cacheSize/(
sizeof(ElementType) * 3UL ) ) && !(~rhs).isAliased( &vector_ ) )
4283 for( ; i<ipos; i+=SIMDSIZE ) {
4284 left.stream( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4286 for( ; i<
size(); ++i ) {
4287 *left = *right; ++left; ++right;
4292 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
4293 left.store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4294 left.store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4295 left.store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4296 left.store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4298 for( ; i<ipos; i+=SIMDSIZE ) {
4299 left.store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4301 for( ; i<
size(); ++i ) {
4302 *left = *right; ++left; ++right;
4322 template<
typename VT
4325 template<
typename VT2 >
4326 inline void Subvector<VT,aligned,TF,true,CSAs...>::assign(
const SparseVector<VT2,TF>& rhs )
4330 for( ConstIterator_t<VT2> element=(~rhs).
begin(); element!=(~rhs).
end(); ++element )
4331 vector_[offset()+element->index()] = element->value();
4349 template<
typename VT
4352 template<
typename VT2 >
4353 inline auto Subvector<VT,aligned,TF,true,CSAs...>::addAssign(
const DenseVector<VT2,TF>& rhs )
4354 -> DisableIf_t< VectorizedAddAssign_v<VT2> >
4358 const size_t ipos(
size() &
size_t(-2) );
4359 for(
size_t i=0UL; i<ipos; i+=2UL ) {
4360 vector_[offset()+i ] += (~rhs)[i ];
4361 vector_[offset()+i+1UL] += (~rhs)[i+1UL];
4363 if( ipos <
size() ) {
4364 vector_[offset()+ipos] += (~rhs)[ipos];
4383 template<
typename VT
4386 template<
typename VT2 >
4387 inline auto Subvector<VT,aligned,TF,true,CSAs...>::addAssign(
const DenseVector<VT2,TF>& rhs )
4388 -> EnableIf_t< VectorizedAddAssign_v<VT2> >
4394 const size_t ipos(
size() &
size_t(-SIMDSIZE) );
4398 Iterator left(
begin() );
4399 ConstIterator_t<VT2> right( (~rhs).
begin() );
4401 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
4402 left.store( left.load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4403 left.store( left.load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4404 left.store( left.load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4405 left.store( left.load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4407 for( ; i<ipos; i+=SIMDSIZE ) {
4408 left.store( left.load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4410 for( ; i<
size(); ++i ) {
4411 *left += *right; ++left; ++right;
4430 template<
typename VT
4433 template<
typename VT2 >
4434 inline void Subvector<VT,aligned,TF,true,CSAs...>::addAssign(
const SparseVector<VT2,TF>& rhs )
4438 for( ConstIterator_t<VT2> element=(~rhs).
begin(); element!=(~rhs).
end(); ++element )
4439 vector_[offset()+element->index()] += element->value();
4457 template<
typename VT
4460 template<
typename VT2 >
4461 inline auto Subvector<VT,aligned,TF,true,CSAs...>::subAssign(
const DenseVector<VT2,TF>& rhs )
4462 -> DisableIf_t< VectorizedSubAssign_v<VT2> >
4466 const size_t ipos(
size() &
size_t(-2) );
4467 for(
size_t i=0UL; i<ipos; i+=2UL ) {
4468 vector_[offset()+i ] -= (~rhs)[i ];
4469 vector_[offset()+i+1UL] -= (~rhs)[i+1UL];
4471 if( ipos <
size() ) {
4472 vector_[offset()+ipos] -= (~rhs)[ipos];
4491 template<
typename VT
4494 template<
typename VT2 >
4495 inline auto Subvector<VT,aligned,TF,true,CSAs...>::subAssign(
const DenseVector<VT2,TF>& rhs )
4496 -> EnableIf_t< VectorizedSubAssign_v<VT2> >
4502 const size_t ipos(
size() &
size_t(-SIMDSIZE) );
4506 Iterator left(
begin() );
4507 ConstIterator_t<VT2> right( (~rhs).
begin() );
4509 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
4510 left.store( left.load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4511 left.store( left.load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4512 left.store( left.load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4513 left.store( left.load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4515 for( ; i<ipos; i+=SIMDSIZE ) {
4516 left.store( left.load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4518 for( ; i<
size(); ++i ) {
4519 *left -= *right; ++left; ++right;
4538 template<
typename VT
4541 template<
typename VT2 >
4542 inline void Subvector<VT,aligned,TF,true,CSAs...>::subAssign(
const SparseVector<VT2,TF>& rhs )
4546 for( ConstIterator_t<VT2> element=(~rhs).
begin(); element!=(~rhs).
end(); ++element )
4547 vector_[offset()+element->index()] -= element->value();
4565 template<
typename VT
4568 template<
typename VT2 >
4569 inline auto Subvector<VT,aligned,TF,true,CSAs...>::multAssign(
const DenseVector<VT2,TF>& rhs )
4570 -> DisableIf_t< VectorizedMultAssign_v<VT2> >
4574 const size_t ipos(
size() &
size_t(-2) );
4575 for(
size_t i=0UL; i<ipos; i+=2UL ) {
4576 vector_[offset()+i ] *= (~rhs)[i ];
4577 vector_[offset()+i+1UL] *= (~rhs)[i+1UL];
4579 if( ipos <
size() ) {
4580 vector_[offset()+ipos] *= (~rhs)[ipos];
4599 template<
typename VT
4602 template<
typename VT2 >
4603 inline auto Subvector<VT,aligned,TF,true,CSAs...>::multAssign(
const DenseVector<VT2,TF>& rhs )
4604 -> EnableIf_t< VectorizedMultAssign_v<VT2> >
4610 const size_t ipos(
size() &
size_t(-SIMDSIZE) );
4614 Iterator left(
begin() );
4615 ConstIterator_t<VT2> right( (~rhs).
begin() );
4617 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
4618 left.store( left.load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4619 left.store( left.load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4620 left.store( left.load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4621 left.store( left.load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4623 for( ; i<ipos; i+=SIMDSIZE ) {
4624 left.store( left.load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4626 for( ; i<
size(); ++i ) {
4627 *left *= *right; ++left; ++right;
4646 template<
typename VT
4649 template<
typename VT2 >
4650 inline void Subvector<VT,aligned,TF,true,CSAs...>::multAssign(
const SparseVector<VT2,TF>& rhs )
4658 for( ConstIterator_t<VT2> element=(~rhs).
begin(); element!=(~rhs).
end(); ++element ) {
4659 const size_t index( element->index() );
4660 for( ; i<index; ++i )
4661 reset( vector_[offset()+i] );
4662 vector_[offset()+i] *= element->value();
4666 for( ; i<
size(); ++i ) {
4667 reset( vector_[offset()+i] );
4686 template<
typename VT
4689 template<
typename VT2 >
4690 inline auto Subvector<VT,aligned,TF,true,CSAs...>::divAssign(
const DenseVector<VT2,TF>& rhs )
4691 -> DisableIf_t< VectorizedDivAssign_v<VT2> >
4695 const size_t ipos(
size() &
size_t(-2) );
4696 for(
size_t i=0UL; i<ipos; i+=2UL ) {
4697 vector_[offset()+i ] /= (~rhs)[i ];
4698 vector_[offset()+i+1UL] /= (~rhs)[i+1UL];
4700 if( ipos <
size() ) {
4701 vector_[offset()+ipos] /= (~rhs)[ipos];
4720 template<
typename VT
4723 template<
typename VT2 >
4724 inline auto Subvector<VT,aligned,TF,true,CSAs...>::divAssign(
const DenseVector<VT2,TF>& rhs )
4725 -> EnableIf_t< VectorizedDivAssign_v<VT2> >
4731 const size_t ipos(
size() &
size_t(-SIMDSIZE) );
4735 Iterator left(
begin() );
4736 ConstIterator_t<VT2> right( (~rhs).
begin() );
4738 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
4739 left.store( left.load() / right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4740 left.store( left.load() / right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4741 left.store( left.load() / right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4742 left.store( left.load() / right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4744 for( ; i<ipos; i+=SIMDSIZE ) {
4745 left.store( left.load() / right.load() ); left += SIMDSIZE; right += SIMDSIZE;
4747 for( ; i<
size(); ++i ) {
4748 *left /= *right; ++left; ++right;
4775 template<
typename VT1
4779 class Subvector< DVecDVecCrossExpr<VT1,VT2,TF>,
unaligned, TF, true, CSAs... >
4780 :
public View< DenseVector< Subvector< DVecDVecCrossExpr<VT1,VT2,TF>, unaligned, TF, true, CSAs... >, TF > >
4781 ,
private SubvectorData<CSAs...>
4785 using CPE = DVecDVecCrossExpr<VT1,VT2,TF>;
4786 using RT = ResultType_t<CPE>;
4787 using DataType = SubvectorData<CSAs...>;
4793 using This = Subvector<CPE,
unaligned,TF,
true,CSAs...>;
4795 using BaseType = DenseVector<This,TF>;
4796 using ViewedType = CPE;
4798 using TransposeType = TransposeType_t<ResultType>;
4799 using ElementType = ElementType_t<CPE>;
4800 using ReturnType = ReturnType_t<CPE>;
4801 using CompositeType =
const ResultType;
4806 static constexpr
bool simdEnabled =
false;
4809 static constexpr
bool smpAssignable =
false;
4812 static constexpr
bool compileTimeArgs = DataType::compileTimeArgs;
4822 template<
typename... RSAs >
4823 explicit inline Subvector(
const CPE& vector, RSAs... args )
4824 : DataType( args... )
4825 , vector_ ( vector )
4828 if( offset() +
size() > vector.size() ) {
4844 inline ReturnType operator[](
size_t index )
const {
4846 return vector_[offset()+index];
4857 inline ReturnType at(
size_t index )
const {
4858 if( index >=
size() ) {
4861 return (*
this)[index];
4866 using DataType::offset;
4875 inline CPE operand() const noexcept {
4886 template<
typename T >
4887 inline bool canAlias(
const T* alias )
const noexcept {
4888 return vector_.canAlias( alias );
4898 template<
typename T >
4899 inline bool isAliased(
const T* alias )
const noexcept {
4900 return vector_.isAliased( alias );
4933 template<
typename VT1
4937 class Subvector< DVecSVecCrossExpr<VT1,VT2,TF>,
unaligned, TF, true, CSAs... >
4938 :
public View< DenseVector< Subvector< DVecSVecCrossExpr<VT1,VT2,TF>, unaligned, TF, true, CSAs... >, TF > >
4939 ,
private SubvectorData<CSAs...>
4943 using CPE = DVecSVecCrossExpr<VT1,VT2,TF>;
4944 using RT = ResultType_t<CPE>;
4945 using DataType = SubvectorData<CSAs...>;
4951 using This = Subvector<CPE,
unaligned,TF,
true,CSAs...>;
4953 using BaseType = DenseVector<This,TF>;
4954 using ViewedType = CPE;
4956 using TransposeType = TransposeType_t<ResultType>;
4957 using ElementType = ElementType_t<CPE>;
4958 using ReturnType = ReturnType_t<CPE>;
4959 using CompositeType =
const ResultType;
4964 static constexpr
bool simdEnabled =
false;
4967 static constexpr
bool smpAssignable =
false;
4970 static constexpr
bool compileTimeArgs = DataType::compileTimeArgs;
4980 template<
typename... RSAs >
4981 explicit inline Subvector(
const CPE& vector, RSAs... args )
4982 : DataType( args... )
4983 , vector_ ( vector )
4986 if( offset() +
size() > vector.size() ) {
5002 inline ReturnType operator[](
size_t index )
const {
5004 return vector_[offset()+index];
5015 inline ReturnType at(
size_t index )
const {
5016 if( index >=
size() ) {
5019 return (*
this)[index];
5024 using DataType::offset;
5033 inline CPE operand() const noexcept {
5044 template<
typename T >
5045 inline bool canAlias(
const T* alias )
const noexcept {
5046 return vector_.canAlias( alias );
5056 template<
typename T >
5057 inline bool isAliased(
const T* alias )
const noexcept {
5058 return vector_.isAliased( alias );
5091 template<
typename VT1
5095 class Subvector< SVecDVecCrossExpr<VT1,VT2,TF>,
unaligned, TF, true, CSAs... >
5096 :
public View< DenseVector< Subvector< SVecDVecCrossExpr<VT1,VT2,TF>, unaligned, TF, true, CSAs... >, TF > >
5097 ,
private SubvectorData<CSAs...>
5101 using CPE = SVecDVecCrossExpr<VT1,VT2,TF>;
5102 using RT = ResultType_t<CPE>;
5103 using DataType = SubvectorData<CSAs...>;
5109 using This = Subvector<CPE,
unaligned,TF,
true,CSAs...>;
5111 using BaseType = DenseVector<This,TF>;
5112 using ViewedType = CPE;
5114 using TransposeType = TransposeType_t<ResultType>;
5115 using ElementType = ElementType_t<CPE>;
5116 using ReturnType = ReturnType_t<CPE>;
5117 using CompositeType =
const ResultType;
5122 static constexpr
bool simdEnabled =
false;
5125 static constexpr
bool smpAssignable =
false;
5128 static constexpr
bool compileTimeArgs = DataType::compileTimeArgs;
5138 template<
typename... RSAs >
5139 explicit inline Subvector(
const CPE& vector, RSAs... args )
5140 : DataType( args... )
5141 , vector_ ( vector )
5144 if( offset() +
size() > vector.size() ) {
5160 inline ReturnType operator[](
size_t index )
const {
5162 return vector_[offset()+index];
5173 inline ReturnType at(
size_t index )
const {
5174 if( index >=
size() ) {
5177 return (*
this)[index];
5182 using DataType::offset;
5191 inline CPE operand() const noexcept {
5202 template<
typename T >
5203 inline bool canAlias(
const T* alias )
const noexcept {
5204 return vector_.canAlias( alias );
5214 template<
typename T >
5215 inline bool isAliased(
const T* alias )
const noexcept {
5216 return vector_.isAliased( alias );
5249 template<
typename VT1
5253 class Subvector< SVecSVecCrossExpr<VT1,VT2,TF>,
unaligned, TF, true, CSAs... >
5254 :
public View< DenseVector< Subvector< SVecSVecCrossExpr<VT1,VT2,TF>, unaligned, TF, true, CSAs... >, TF > >
5255 ,
private SubvectorData<CSAs...>
5259 using CPE = SVecSVecCrossExpr<VT1,VT2,TF>;
5260 using RT = ResultType_t<CPE>;
5261 using DataType = SubvectorData<CSAs...>;
5267 using This = Subvector<CPE,
unaligned,TF,
true,CSAs...>;
5269 using BaseType = DenseVector<This,TF>;
5270 using ViewedType = CPE;
5272 using TransposeType = TransposeType_t<ResultType>;
5273 using ElementType = ElementType_t<CPE>;
5274 using ReturnType = ReturnType_t<CPE>;
5275 using CompositeType =
const ResultType;
5280 static constexpr
bool simdEnabled =
false;
5283 static constexpr
bool smpAssignable =
false;
5286 static constexpr
bool compileTimeArgs = DataType::compileTimeArgs;
5296 template<
typename... RSAs >
5297 explicit inline Subvector(
const CPE& vector, RSAs... args )
5298 : DataType( args... )
5299 , vector_ ( vector )
5302 if( offset() +
size() > vector.size() ) {
5318 inline ReturnType operator[](
size_t index )
const {
5320 return vector_[offset()+index];
5331 inline ReturnType at(
size_t index )
const {
5332 if( index >=
size() ) {
5335 return (*
this)[index];
5340 using DataType::offset;
5349 inline CPE operand() const noexcept {
5360 template<
typename T >
5361 inline bool canAlias(
const T* alias )
const noexcept {
5362 return vector_.canAlias( alias );
5372 template<
typename T >
5373 inline bool isAliased(
const T* alias )
const {
5374 return vector_.isAliased( alias );
AlignmentFlag
Alignment flag for (un-)aligned vectors and matrices.Via these flags it is possible to specify subvec...
Definition: AlignmentFlag.h:62
Constraint on the data type.
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Constraint on the data type.
Header file for auxiliary alias declarations.
Header file for the blaze::checked and blaze::unchecked instances.
auto operator-=(DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & >
Subtraction assignment operator for the subtraction of a dense matrix and a scalar value ( ).
Definition: DenseMatrix.h:432
#define BLAZE_USER_ASSERT(expr, msg)
Run time assertion macro for user checks.In case of an invalid run time expression,...
Definition: Assert.h:117
Header file for the alignment flag values.
size_t capacity(const Matrix< MT, SO > &matrix) noexcept
Returns the maximum capacity of the matrix.
Definition: Matrix.h:546
Header file for basic type definitions.
constexpr const DenseIterator< Type, AF > operator-(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:750
MT::ElementType * data(DenseMatrix< MT, SO > &dm) noexcept
Low-level data access to the dense matrix elements.
Definition: DenseMatrix.h:170
Header file for the View base class.
constexpr bool IsSIMDCombinable_v
Auxiliary variable template for the IsSIMDCombinable type trait.The IsSIMDCombinable_v variable templ...
Definition: IsSIMDCombinable.h:137
#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:81
constexpr bool operator<(const NegativeAccuracy< A > &lhs, const T &rhs)
Less-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:332
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > loadu(const T *address) noexcept
Loads a vector of 1-byte integral values.
Definition: Loadu.h:76
MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:372
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:595
Header file for the DenseVector base class.
constexpr bool IsReference_v
Auxiliary variable template for the IsReference type trait.The IsReference_v variable template provid...
Definition: IsReference.h:95
size_t nonZeros(const Matrix< MT, SO > &matrix)
Returns the total number of non-zero elements in the matrix.
Definition: Matrix.h:584
Header file for the Computation base class.
Header file for the reset shim.
constexpr bool HasSIMDAdd_v
Auxiliary variable template for the HasSIMDAdd type trait.The HasSIMDAdd_v variable template provides...
Definition: HasSIMDAdd.h:187
#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:81
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > storeu(T1 *address, const SIMDi8< T2 > &value) noexcept
Unaligned store of a vector of 1-byte integral values.
Definition: Storeu.h:75
Header file for the extended initializer_list functionality.
System settings for performance optimizations.
MT::ConstIterator cend(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:482
MT::ConstIterator cbegin(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:416
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.The ElementType_t alias declaration provide...
Definition: Aliases.h:170
auto smpDivAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > >
Default implementation of the SMP division assignment of a vector to a dense vector.
Definition: DenseVector.h:220
size_t spacing(const DenseMatrix< MT, SO > &dm) noexcept
Returns the spacing between the beginning of two rows/columns.
Definition: DenseMatrix.h:253
Constraint on the data type.
typename EnableIf< Condition, T >::Type EnableIf_t
Auxiliary type for the EnableIf class template.The EnableIf_t alias declaration provides a convenient...
Definition: EnableIf.h:138
constexpr bool IsContiguous_v
Auxiliary variable template for the IsContiguous type trait.The IsContiguous_v variable template prov...
Definition: IsContiguous.h:144
Header file for the DisableIf class template.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
Header file for the If class template.
Header file for the implementation of a vector representation of an initializer list.
decltype(auto) operator *(const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:9091
constexpr bool HasSIMDSub_v
Auxiliary variable template for the HasSIMDSub type trait.The HasSIMDSub_v variable template provides...
Definition: HasSIMDSub.h:187
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the HasSIMDAdd type trait.
constexpr bool operator>(const NegativeAccuracy< A > &lhs, const T &rhs)
Greater-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:370
constexpr bool operator>=(const NegativeAccuracy< A > &, const T &rhs)
Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:446
Header file for the implementation of the Subvector base template.
auto operator+=(DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & >
Addition assignment operator for the addition of a dense matrix and a scalar value ( ).
Definition: DenseMatrix.h:370
Header file for the implementation of the SubvectorData class template.
constexpr bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:253
Header file for the subvector trait.
Header file for all SIMD functionality.
constexpr bool Contains_v
Auxiliary variable template for the Contains type trait.The Contains_v variable template provides a c...
Definition: Contains.h:138
Constraint on the data type.
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > storea(T1 *address, const SIMDi8< T2 > &value) noexcept
Aligned store of a vector of 1-byte integral values.
Definition: Storea.h:78
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECTORIZABLE_TYPE(T)
Constraint on the data type.In case the given data type T is not a vectorizable data type,...
Definition: Vectorizable.h:61
Constraint on the data type.
Header file for the exception macros of the math module.
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:438
constexpr bool HasSIMDDiv_v
Auxiliary variable template for the HasSIMDDiv type trait.The HasSIMDDiv_v variable template provides...
Definition: HasSIMDDiv.h:171
constexpr bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:293
Constraint on the data type.
typename SubvectorTrait< VT, CSAs... >::Type SubvectorTrait_t
Auxiliary alias declaration for the SubvectorTrait type trait.The SubvectorTrait_t alias declaration ...
Definition: SubvectorTrait.h:171
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:615
Header file for the CrossExpr base class.
Flag for aligned vectors and matrices.
Definition: AlignmentFlag.h:65
auto operator/=(DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & >
Division assignment operator for the division of a dense matrix by a scalar value ( ).
Definition: DenseMatrix.h:558
Header file for the IsSIMDCombinable type trait.
Header file for the IsSparseVector type trait.
Header file for the HasSIMDMult type trait.
Header file for the IsConst type trait.
Header file for run time assertion macros.
Header file for the cross product trait.
auto smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:131
Header file for the Unique class template.
Header file for the IsContiguous type trait.
Check< false > Unchecked
Type of the blaze::unchecked instance.blaze::Unchecked is the type of the blaze::unchecked instance,...
Definition: Check.h:96
Header file for the cache size of the target architecture.
Header file for all forward declarations for expression class templates.
Header file for the isDefault shim.
constexpr size_t size(const Matrix< MT, SO > &matrix) noexcept
Returns the total number of elements of the matrix.
Definition: Matrix.h:530
auto smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:100
Header file for the HasSIMDSub type trait.
constexpr bool operator<=(const NegativeAccuracy< A > &, const T &rhs)
Less-or-equal-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:408
Header file for the HasMutableDataAccess type trait.
#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:81
constexpr const DenseIterator< Type, AF > operator+(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:718
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > loada(const T *address) noexcept
Loads a vector of 1-byte integral values.
Definition: Loada.h:79
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > stream(T1 *address, const SIMDi8< T2 > &value) noexcept
Aligned, non-temporal store of a vector of 1-byte integral values.
Definition: Stream.h:74
BLAZE_ALWAYS_INLINE bool checkAlignment(const T *address)
Checks the alignment of the given address.
Definition: AlignmentCheck.h:68
#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:61
#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....
Definition: Subvector.h:81
Macro for CUDA compatibility.
Header file for the HasSIMDDiv type trait.
Flag for unaligned vectors and matrices.
Definition: AlignmentFlag.h:64
auto smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:162
constexpr bool HasSIMDMult_v
Auxiliary variable template for the HasSIMDMult type trait.The HasSIMDMult_v variable template provid...
Definition: HasSIMDMult.h:188
Header file for the alignment check function.
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:264
auto operator *=(DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & >
Multiplication assignment operator for the multiplication of a dense matrix and a scalar value ( ).
Definition: DenseMatrix.h:494
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:635
#define BLAZE_DEVICE_CALLABLE
Conditional macro that sets host and device attributes when compiled with CUDA.
Definition: HostDevice.h:94
typename DisableIf< Condition, T >::Type DisableIf_t
Auxiliary type for the DisableIf class template.The DisableIf_t alias declaration provides a convenie...
Definition: DisableIf.h:138
Header file for the IsRestricted type trait.
System settings for the inline keywords.
#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:63
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression,...
Definition: Assert.h:101
auto smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > >
Default implementation of the SMP multiplication assignment of a vector to a dense vector.
Definition: DenseVector.h:191
Header file for the clear shim.
Header file for the IsExpression type trait class.