22 #ifndef _BLAZE_MATH_VIEWS_SPARSEROW_H_
23 #define _BLAZE_MATH_VIEWS_SPARSEROW_H_
321 template<
typename MT
322 ,
bool SO = IsRowMajorMatrix<MT>::value >
323 class SparseRow :
public SparseVector< SparseRow<MT,SO>, true >
335 enum { useConst = IsConst<MT>::value };
363 explicit inline SparseRow( MT& matrix,
size_t index );
396 template<
typename Other >
398 operator*=( Other rhs );
400 template<
typename Other >
402 operator/=( Other rhs );
409 inline size_t size()
const;
414 inline void erase (
size_t index );
418 inline void reserve(
size_t n );
419 template<
typename Other >
inline SparseRow& scale ( Other scalar );
433 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
434 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
486 template<
typename MT
493 throw std::invalid_argument(
"Invalid row access index" );
512 template<
typename MT
517 return matrix_(row_,index);
528 template<
typename MT
533 return const_cast<const MT&
>( matrix_ )(row_,index);
545 template<
typename MT
549 return matrix_.begin( row_ );
561 template<
typename MT
565 return matrix_.begin( row_ );
577 template<
typename MT
581 return matrix_.begin( row_ );
593 template<
typename MT
597 return matrix_.end( row_ );
609 template<
typename MT
613 return matrix_.end( row_ );
625 template<
typename MT
629 return matrix_.end( row_ );
652 template<
typename MT
658 if(
this == &rhs || ( &matrix_ == &rhs.matrix_ && row_ == rhs.row_ ) )
661 if( size() != rhs.size() )
662 throw std::invalid_argument(
"Row sizes do not match" );
664 if( rhs.canAlias( &matrix_ ) ) {
666 matrix_.reset ( row_ );
667 matrix_.reserve( row_, tmp.nonZeros() );
671 matrix_.reset ( row_ );
672 matrix_.reserve( row_, rhs.nonZeros() );
691 template<
typename MT
693 template<
typename VT >
698 if( size() != (~rhs).size() )
699 throw std::invalid_argument(
"Vector sizes do not match" );
701 if( (~rhs).canAlias( &matrix_ ) ) {
702 const typename VT::ResultType tmp( ~rhs );
703 matrix_.reset( row_ );
707 matrix_.reset( row_ );
726 template<
typename MT
728 template<
typename VT >
733 if( size() != (~rhs).size() )
734 throw std::invalid_argument(
"Vector sizes do not match" );
736 if( (~rhs).canAlias( &matrix_ ) ) {
737 const typename VT::ResultType tmp( ~rhs );
738 matrix_.reset ( row_ );
739 matrix_.reserve( row_, tmp.nonZeros() );
743 matrix_.reset ( row_ );
744 matrix_.reserve( row_, (~rhs).nonZeros() );
763 template<
typename MT
765 template<
typename VT >
770 if( (~rhs).size() != size() )
771 throw std::invalid_argument(
"Vector sizes do not match" );
790 template<
typename MT
792 template<
typename VT >
797 if( (~rhs).size() != size() )
798 throw std::invalid_argument(
"Vector sizes do not match" );
818 template<
typename MT
820 template<
typename VT >
823 if( (~rhs).size() != size() )
824 throw std::invalid_argument(
"Vector sizes do not match" );
831 const MultType tmp( *
this * (~rhs) );
832 matrix_.reset( row_ );
851 template<
typename MT
853 template<
typename Other >
857 for(
Iterator element=begin(); element!=end(); ++element )
858 element->value() *= rhs;
876 template<
typename MT
878 template<
typename Other >
890 const Tmp tmp( Tmp(1)/static_cast<Tmp>( rhs ) );
891 for(
Iterator element=begin(); element!=end(); ++element )
892 element->value() *= tmp;
895 for(
Iterator element=begin(); element!=end(); ++element )
896 element->value() /= rhs;
917 template<
typename MT
921 return matrix_.columns();
931 template<
typename MT
935 return matrix_.capacity( row_ );
948 template<
typename MT
952 return matrix_.nonZeros( row_ );
962 template<
typename MT
966 matrix_.reset( row_ );
983 template<
typename MT
988 return matrix_.insert( row_, index, value )->value();
1001 template<
typename MT
1005 matrix_.erase( row_, index );
1018 template<
typename MT
1022 return matrix_.erase( row_, pos );
1040 template<
typename MT
1044 return matrix_.find( row_, index );
1062 template<
typename MT
1066 return matrix_.find( row_, index );
1080 template<
typename MT
1084 matrix_.reserve( row_, n );
1095 template<
typename MT
1097 template<
typename Other >
1100 for(
Iterator element=begin(); element!=end(); ++element )
1101 element->value() *= scalar;
1115 template<
typename MT
1122 size_t nonzeros( 2UL*capacity()+1UL );
1123 nonzeros =
max( nonzeros, 7UL );
1124 nonzeros =
min( nonzeros, size() );
1165 template<
typename MT
1169 matrix_.append( row_, index, value, check );
1192 template<
typename MT
1194 template<
typename Other >
1197 return static_cast<const void*
>( &matrix_ ) == static_cast<const void*>( alias );
1212 template<
typename MT
1214 template<
typename Other >
1217 return static_cast<const void*
>( &matrix_ ) == static_cast<const void*>( alias );
1233 template<
typename MT
1235 template<
typename VT >
1240 size_t nonzeros( 0UL );
1242 for(
size_t j=0UL; j<size(); ++j )
1244 if( matrix_.nonZeros( row_ ) == matrix_.capacity( row_ ) )
1245 matrix_.reserve( row_, extendCapacity() );
1247 matrix_.append( row_, j, (~rhs)[j],
true );
1264 template<
typename MT
1266 template<
typename VT >
1271 for(
typename VT::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element ) {
1272 matrix_.append( row_, element->index(), element->value() );
1289 template<
typename MT
1291 template<
typename VT >
1302 const AddType tmp( *
this + (~rhs) );
1303 matrix_.reset( row_ );
1320 template<
typename MT
1322 template<
typename VT >
1333 const AddType tmp( *
this + (~rhs) );
1334 matrix_.reset ( row_ );
1335 matrix_.reserve( row_, tmp.nonZeros() );
1352 template<
typename MT
1354 template<
typename VT >
1365 const SubType tmp( *
this - (~rhs) );
1366 matrix_.reset ( row_ );
1383 template<
typename MT
1385 template<
typename VT >
1396 const SubType tmp( *
this - (~rhs) );
1397 matrix_.reset ( row_ );
1398 matrix_.reserve( row_, tmp.nonZeros() );
1424 template<
typename MT >
1442 typedef SparseRow<MT,false>
This;
1443 typedef typename RowTrait<MT>::Type
ResultType;
1453 typedef typename SelectType< useConst, ConstReference, typename MT::Reference >::Type
Reference;
1459 template<
typename MatrixType
1460 ,
typename IteratorType >
1471 enum { returnConst = IsConst<MatrixType>::value };
1476 typedef typename SelectType< returnConst, const ElementType&, ElementType& >::Type ReferenceType;
1485 inline RowElement( IteratorType pos,
size_t column )
1497 template<
typename T >
inline RowElement&
operator=(
const T& v ) {
1509 template<
typename T >
inline RowElement& operator+=(
const T& v ) {
1521 template<
typename T >
inline RowElement& operator-=(
const T& v ) {
1533 template<
typename T >
inline RowElement& operator*=(
const T& v ) {
1545 template<
typename T >
inline RowElement& operator/=(
const T& v ) {
1556 inline const RowElement* operator->()
const {
1566 inline ReferenceType value()
const {
1567 return pos_->value();
1576 inline size_t index()
const {
1592 template<
typename MatrixType
1593 ,
typename IteratorType >
1604 enum { returnConst = IsConst<MatrixType>::value };
1609 typedef std::forward_iterator_tag IteratorCategory;
1610 typedef RowElement<MatrixType,IteratorType> ValueType;
1611 typedef ValueType PointerType;
1612 typedef ValueType ReferenceType;
1613 typedef ptrdiff_t DifferenceType;
1616 typedef IteratorCategory iterator_category;
1617 typedef ValueType value_type;
1618 typedef PointerType pointer;
1619 typedef ReferenceType reference;
1620 typedef DifferenceType difference_type;
1623 typedef typename SelectType< returnConst, ReturnType, ElementType& >::Type Value;
1633 inline RowIterator( MatrixType& matrix,
size_t row,
size_t column )
1639 for( ; column_<
matrix_.columns(); ++column_ ) {
1641 if( pos_ !=
matrix_.end( column_ ) )
break;
1654 inline RowIterator( MatrixType& matrix,
size_t row,
size_t column, IteratorType pos )
1669 template<
typename MatrixType2,
typename IteratorType2 >
1670 inline RowIterator(
const RowIterator<MatrixType2,IteratorType2>& it )
1673 , column_( it.column_ )
1683 inline RowIterator& operator++() {
1685 for( ; column_<
matrix_.columns(); ++column_ ) {
1687 if( pos_ !=
matrix_.end( column_ ) )
break;
1699 inline const RowIterator operator++(
int ) {
1700 const RowIterator tmp( *
this );
1711 inline ReferenceType
operator*()
const {
1712 return ReferenceType( pos_, column_ );
1721 inline PointerType operator->()
const {
1722 return PointerType( pos_, column_ );
1732 template<
typename MatrixType2,
typename IteratorType2 >
1733 inline bool operator==(
const RowIterator<MatrixType2,IteratorType2>& rhs )
const {
1734 return ( &
matrix_ == &rhs.matrix_ ) && (
row_ == rhs.row_ ) && ( column_ == rhs.column_ );
1744 template<
typename MatrixType2,
typename IteratorType2 >
1745 inline bool operator!=(
const RowIterator<MatrixType2,IteratorType2>& rhs )
const {
1746 return !( *
this == rhs );
1756 inline DifferenceType
operator-(
const RowIterator& rhs )
const {
1757 size_t counter( 0UL );
1758 for(
size_t j=rhs.column_; j<column_; ++j ) {
1776 template<
typename MatrixType2,
typename IteratorType2 >
friend class RowIterator;
1777 template<
typename MT2,
bool SO2 >
friend class SparseRow;
1785 typedef RowIterator<const MT,typename MT::ConstIterator>
ConstIterator;
1788 typedef typename SelectType< useConst, ConstIterator, RowIterator<MT,typename MT::Iterator> >::Type
Iterator;
1794 explicit inline SparseRow( MT& matrix,
size_t index );
1822 template<
typename VT >
inline SparseRow& operator+=(
const Vector<VT,true>& rhs );
1823 template<
typename VT >
inline SparseRow& operator-=(
const Vector<VT,true>& rhs );
1824 template<
typename VT >
inline SparseRow& operator*=(
const Vector<VT,true>& rhs );
1826 template<
typename Other >
1827 inline typename EnableIf< IsNumeric<Other>,
SparseRow >::Type&
1828 operator*=( Other rhs );
1830 template<
typename Other >
1831 inline typename EnableIf< IsNumeric<Other>,
SparseRow >::Type&
1832 operator/=( Other rhs );
1839 inline size_t size()
const;
1842 inline void reset();
1844 inline void erase (
size_t index );
1848 inline void reserve(
size_t n );
1849 template<
typename Other >
inline SparseRow& scale ( Other scalar );
1863 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
1864 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
1865 template<
typename VT >
inline void assign (
const DenseVector <VT,true>& rhs );
1866 template<
typename VT >
inline void assign (
const SparseVector<VT,true>& rhs );
1867 template<
typename VT >
inline void addAssign(
const Vector<VT,true>& rhs );
1868 template<
typename VT >
inline void subAssign(
const Vector<VT,true>& rhs );
1909 template<
typename MT >
1915 throw std::invalid_argument(
"Invalid row access index" );
1936 template<
typename MT >
1940 return matrix_(row_,index);
1953 template<
typename MT >
1957 return const_cast<const MT&
>( matrix_ )(row_,index);
1971 template<
typename MT >
1974 return Iterator( matrix_, row_, 0UL );
1988 template<
typename MT >
1991 return ConstIterator( matrix_, row_, 0UL );
2005 template<
typename MT >
2008 return ConstIterator( matrix_, row_, 0UL );
2022 template<
typename MT >
2025 return Iterator( matrix_, row_, size() );
2039 template<
typename MT >
2042 return ConstIterator( matrix_, row_, size() );
2056 template<
typename MT >
2059 return ConstIterator( matrix_, row_, size() );
2084 template<
typename MT >
2089 if(
this == &rhs || ( &matrix_ == &rhs.matrix_ && row_ == rhs.row_ ) )
2092 if( size() != rhs.size() )
2093 throw std::invalid_argument(
"Row sizes do not match" );
2095 if( rhs.canAlias( &matrix_ ) ) {
2096 const ResultType tmp( rhs );
2120 template<
typename MT >
2121 template<
typename VT >
2126 if( size() != (~rhs).size() )
2127 throw std::invalid_argument(
"Vector sizes do not match" );
2129 const typename VT::CompositeType tmp( ~rhs );
2149 template<
typename MT >
2150 template<
typename VT >
2151 inline SparseRow<MT,false>& SparseRow<MT,false>::operator+=(
const Vector<VT,true>& rhs )
2155 if( (~rhs).size() != size() )
2156 throw std::invalid_argument(
"Vector sizes do not match" );
2177 template<
typename MT >
2178 template<
typename VT >
2179 inline SparseRow<MT,false>& SparseRow<MT,false>::operator-=(
const Vector<VT,true>& rhs )
2183 if( (~rhs).size() != size() )
2184 throw std::invalid_argument(
"Vector sizes do not match" );
2206 template<
typename MT >
2207 template<
typename VT >
2208 inline SparseRow<MT,false>& SparseRow<MT,false>::operator*=(
const Vector<VT,true>& rhs )
2210 if( (~rhs).size() != size() )
2211 throw std::invalid_argument(
"Vector sizes do not match" );
2213 typedef typename MultTrait<This,typename VT::ResultType>::Type MultType;
2218 const MultType tmp( *
this * (~rhs) );
2239 template<
typename MT >
2240 template<
typename Other >
2241 inline typename EnableIf< IsNumeric<Other>, SparseRow<MT,false> >::Type&
2242 SparseRow<MT,false>::operator*=( Other rhs )
2244 for( Iterator element=begin(); element!=end(); ++element )
2245 element->value() *= rhs;
2265 template<
typename MT >
2266 template<
typename Other >
2267 inline typename EnableIf< IsNumeric<Other>, SparseRow<MT,false> >::Type&
2268 SparseRow<MT,false>::operator/=( Other rhs )
2272 typedef typename DivTrait<ElementType,Other>::Type DT;
2273 typedef typename If< IsNumeric<DT>, DT, Other >::Type Tmp;
2277 if( IsNumeric<DT>::value && IsFloatingPoint<DT>::value ) {
2278 const Tmp tmp( Tmp(1)/static_cast<Tmp>( rhs ) );
2279 for( Iterator element=begin(); element!=end(); ++element )
2280 element->value() *= tmp;
2283 for( Iterator element=begin(); element!=end(); ++element )
2284 element->value() /= rhs;
2307 template<
typename MT >
2310 return matrix_.columns();
2322 template<
typename MT >
2325 return matrix_.columns();
2340 template<
typename MT >
2343 size_t counter( 0UL );
2344 for( ConstIterator element=begin(); element!=end(); ++element ) {
2359 template<
typename MT >
2362 for(
size_t j=0UL; j<size(); ++j ) {
2363 matrix_.erase( row_, j );
2383 template<
typename MT >
2384 inline typename SparseRow<MT,false>::ElementType&
2387 return matrix_.insert( row_, index, value )->value();
2402 template<
typename MT >
2405 matrix_.erase( row_, index );
2420 template<
typename MT >
2423 const size_t column( pos.column_ );
2425 if( column == size() )
2428 matrix_.erase( column, pos.pos_ );
2429 return Iterator( matrix_, row_, column+1UL );
2449 template<
typename MT >
2452 const typename MT::Iterator pos( matrix_.find( row_, index ) );
2454 if( pos != matrix_.end( index ) )
2455 return Iterator( matrix_, row_, index, pos );
2477 template<
typename MT >
2480 const typename MT::ConstIterator pos( matrix_.find( row_, index ) );
2482 if( pos != matrix_.end( index ) )
2483 return ConstIterator( matrix_, row_, index, pos );
2501 template<
typename MT >
2517 template<
typename MT >
2518 template<
typename Other >
2519 inline SparseRow<MT,false>& SparseRow<MT,false>::scale( Other scalar )
2521 for( Iterator element=begin(); element!=end(); ++element )
2522 element->value() *= scalar;
2562 template<
typename MT >
2565 matrix_.insert( row_, index, value );
2590 template<
typename MT >
2591 template<
typename Other >
2594 return static_cast<const void*
>( &matrix_ ) == static_cast<const void*>( alias );
2607 template<
typename MT >
2608 template<
typename Other >
2611 return static_cast<const void*
>( &matrix_ ) == static_cast<const void*>( alias );
2629 template<
typename MT >
2630 template<
typename VT >
2635 for(
size_t j=0UL; j<(~rhs).size(); ++j ) {
2636 matrix_(row_,j) = (~rhs)[j];
2655 template<
typename MT >
2656 template<
typename VT >
2663 for(
typename VT::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element ) {
2664 for( ; j<element->index(); ++j )
2665 matrix_.erase( row_, j );
2666 matrix_(row_,j++) = element->value();
2668 for( ; j<size(); ++j ) {
2669 matrix_.erase( row_, j );
2688 template<
typename MT >
2689 template<
typename VT >
2692 typedef typename AddTrait<This,typename VT::ResultType>::Type AddType;
2699 const AddType tmp( *
this + (~rhs) );
2718 template<
typename MT >
2719 template<
typename VT >
2722 typedef typename SubTrait<This,typename VT::ResultType>::Type SubType;
2729 const SubType tmp( *
this - (~rhs) );
2751 template<
typename MT,
bool SO >
2752 inline void reset( SparseRow<MT,SO>& row );
2754 template<
typename MT,
bool SO >
2755 inline void clear( SparseRow<MT,SO>& row );
2757 template<
typename MT,
bool SO >
2758 inline bool isnan(
const SparseRow<MT,SO>& row );
2760 template<
typename MT,
bool SO >
2761 inline bool isDefault(
const SparseRow<MT,SO>& row );
2773 template<
typename MT
2789 template<
typename MT
2814 template<
typename MT
2820 const ConstIterator end( row.end() );
2821 for( ConstIterator element=row.begin(); element!=end; ++element ) {
2822 if(
isnan( element->value() ) )
return true;
2847 template<
typename MT
2853 const ConstIterator end( row.end() );
2854 for( ConstIterator element=row.begin(); element!=end; ++element )
2855 if( !
isDefault( element->value() ) )
return false;
2888 template<
typename MT
2918 template<
typename MT
2939 template<
typename T1,
bool SO,
typename T2,
size_t N >
2940 struct AddTrait< SparseRow<T1,SO>, StaticVector<T2,N,true> >
2942 typedef typename AddTrait< typename SparseRow<T1,SO>::ResultType,
2943 StaticVector<T2,N,true> >::Type Type;
2946 template<
typename T1,
size_t N,
typename T2,
bool SO >
2947 struct AddTrait< StaticVector<T1,N,true>, SparseRow<T2,SO> >
2949 typedef typename AddTrait< StaticVector<T1,N,true>,
2950 typename SparseRow<T2,SO>::ResultType >::Type Type;
2953 template<
typename T1,
bool SO,
typename T2 >
2954 struct AddTrait< SparseRow<T1,SO>, DynamicVector<T2,true> >
2956 typedef typename AddTrait< typename SparseRow<T1,SO>::ResultType,
2957 DynamicVector<T2,true> >::Type Type;
2960 template<
typename T1,
typename T2,
bool SO >
2961 struct AddTrait< DynamicVector<T1,true>, SparseRow<T2,SO> >
2963 typedef typename AddTrait< DynamicVector<T1,true>,
2964 typename SparseRow<T2,SO>::ResultType >::Type Type;
2967 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
2968 struct AddTrait< SparseRow<T1,SO1>, DenseRow<T2,SO2> >
2970 typedef typename AddTrait< typename SparseRow<T1,SO1>::ResultType,
2971 typename DenseRow <T2,SO2>::ResultType >::Type Type;
2974 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
2975 struct AddTrait< DenseRow<T1,SO1>, SparseRow<T2,SO2> >
2977 typedef typename AddTrait< typename DenseRow <T1,SO1>::ResultType,
2978 typename SparseRow<T2,SO2>::ResultType >::Type Type;
2981 template<
typename T1,
bool SO,
typename T2 >
2982 struct AddTrait< SparseRow<T1,SO>, CompressedVector<T2,true> >
2984 typedef typename AddTrait< typename SparseRow<T1,SO>::ResultType,
2985 CompressedVector<T2,true> >::Type Type;
2988 template<
typename T1,
typename T2,
bool SO >
2989 struct AddTrait< CompressedVector<T1,true>, SparseRow<T2,SO> >
2991 typedef typename AddTrait< CompressedVector<T1,true>,
2992 typename SparseRow<T2,SO>::ResultType >::Type Type;
2995 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
2996 struct AddTrait< SparseRow<T1,SO1>, SparseRow<T2,SO2> >
2998 typedef typename AddTrait< typename SparseRow<T1,SO1>::ResultType,
2999 typename SparseRow<T2,SO2>::ResultType >::Type Type;
3015 template<
typename T1,
bool SO,
typename T2,
size_t N >
3016 struct SubTrait< SparseRow<T1,SO>, StaticVector<T2,N,true> >
3018 typedef typename SubTrait< typename SparseRow<T1,SO>::ResultType,
3019 StaticVector<T2,N,true> >::Type Type;
3022 template<
typename T1,
size_t N,
typename T2,
bool SO >
3023 struct SubTrait< StaticVector<T1,N,true>, SparseRow<T2,SO> >
3025 typedef typename SubTrait< StaticVector<T1,N,true>,
3026 typename SparseRow<T2,SO>::ResultType >::Type Type;
3029 template<
typename T1,
bool SO,
typename T2 >
3030 struct SubTrait< SparseRow<T1,SO>, DynamicVector<T2,true> >
3032 typedef typename SubTrait< typename SparseRow<T1,SO>::ResultType,
3033 DynamicVector<T2,true> >::Type Type;
3036 template<
typename T1,
typename T2,
bool SO >
3037 struct SubTrait< DynamicVector<T1,true>, SparseRow<T2,SO> >
3039 typedef typename SubTrait< DynamicVector<T1,true>,
3040 typename SparseRow<T2,SO>::ResultType >::Type Type;
3043 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3044 struct SubTrait< SparseRow<T1,SO1>, DenseRow<T2,SO2> >
3046 typedef typename SubTrait< typename SparseRow<T1,SO1>::ResultType,
3047 typename DenseRow <T2,SO2>::ResultType >::Type Type;
3050 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3051 struct SubTrait< DenseRow<T1,SO1>, SparseRow<T2,SO2> >
3053 typedef typename SubTrait< typename DenseRow <T1,SO1>::ResultType,
3054 typename SparseRow<T2,SO2>::ResultType >::Type Type;
3057 template<
typename T1,
bool SO,
typename T2 >
3058 struct SubTrait< SparseRow<T1,SO>, CompressedVector<T2,true> >
3060 typedef typename SubTrait< typename SparseRow<T1,SO>::ResultType,
3061 CompressedVector<T2,true> >::Type Type;
3064 template<
typename T1,
typename T2,
bool SO >
3065 struct SubTrait< CompressedVector<T1,true>, SparseRow<T2,SO> >
3067 typedef typename SubTrait< CompressedVector<T1,true>,
3068 typename SparseRow<T2,SO>::ResultType >::Type Type;
3071 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3072 struct SubTrait< SparseRow<T1,SO1>, SparseRow<T2,SO2> >
3074 typedef typename SubTrait< typename SparseRow<T1,SO1>::ResultType,
3075 typename SparseRow<T2,SO2>::ResultType >::Type Type;
3091 template<
typename T1,
bool SO,
typename T2 >
3092 struct MultTrait< SparseRow<T1,SO>, T2 >
3094 typedef typename MultTrait< typename SparseRow<T1,SO>::ResultType, T2 >::Type Type;
3098 template<
typename T1,
typename T2,
bool SO >
3099 struct MultTrait< T1, SparseRow<T2,SO> >
3101 typedef typename MultTrait< T1, typename SparseRow<T2,SO>::ResultType >::Type Type;
3105 template<
typename T1,
bool SO,
typename T2,
size_t N,
bool TF >
3106 struct MultTrait< SparseRow<T1,SO>, StaticVector<T2,N,TF> >
3108 typedef typename MultTrait< typename SparseRow<T1,SO>::ResultType,
3109 StaticVector<T2,N,TF> >::Type Type;
3112 template<
typename T1,
size_t N,
bool TF,
typename T2,
bool SO >
3113 struct MultTrait< StaticVector<T1,N,TF>, SparseRow<T2,SO> >
3115 typedef typename MultTrait< StaticVector<T1,N,TF>,
3116 typename SparseRow<T2,SO>::ResultType >::Type Type;
3119 template<
typename T1,
bool SO,
typename T2,
bool TF >
3120 struct MultTrait< SparseRow<T1,SO>, DynamicVector<T2,TF> >
3122 typedef typename MultTrait< typename SparseRow<T1,SO>::ResultType,
3123 DynamicVector<T2,TF> >::Type Type;
3126 template<
typename T1,
bool TF,
typename T2,
bool SO >
3127 struct MultTrait< DynamicVector<T1,TF>, SparseRow<T2,SO> >
3129 typedef typename MultTrait< DynamicVector<T1,TF>,
3130 typename SparseRow<T2,SO>::ResultType >::Type Type;
3133 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3134 struct MultTrait< SparseRow<T1,SO1>, DenseRow<T2,SO2> >
3136 typedef typename MultTrait< typename SparseRow<T1,SO1>::ResultType,
3137 typename DenseRow <T2,SO2>::ResultType >::Type Type;
3140 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3141 struct MultTrait< DenseRow<T1,SO1>, SparseRow<T2,SO2> >
3143 typedef typename MultTrait< typename DenseRow <T1,SO1>::ResultType,
3144 typename SparseRow<T2,SO2>::ResultType >::Type Type;
3147 template<
typename T1,
bool SO,
typename T2,
bool TF >
3148 struct MultTrait< SparseRow<T1,SO>, CompressedVector<T2,TF> >
3150 typedef typename MultTrait< typename SparseRow<T1,SO>::ResultType,
3151 CompressedVector<T2,TF> >::Type Type;
3154 template<
typename T1,
bool TF,
typename T2,
bool SO >
3155 struct MultTrait< CompressedVector<T1,TF>, SparseRow<T2,SO> >
3157 typedef typename MultTrait< CompressedVector<T1,TF>,
3158 typename SparseRow<T2,SO>::ResultType >::Type Type;
3161 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3162 struct MultTrait< SparseRow<T1,SO1>, SparseRow<T2,SO2> >
3164 typedef typename MultTrait< typename SparseRow<T1,SO1>::ResultType,
3165 typename SparseRow<T2,SO2>::ResultType >::Type Type;
3168 template<
typename T1,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
3169 struct MultTrait< SparseRow<T1,SO1>, StaticMatrix<T2,M,N,SO2> >
3171 typedef typename MultTrait< typename SparseRow<T1,SO1>::ResultType,
3172 StaticMatrix<T2,M,N,SO2> >::Type Type;
3175 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3176 struct MultTrait< SparseRow<T1,SO1>, DynamicMatrix<T2,SO2> >
3178 typedef typename MultTrait< typename SparseRow<T1,SO1>::ResultType,
3179 DynamicMatrix<T2,SO2> >::Type Type;
3182 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3183 struct MultTrait< SparseRow<T1,SO1>, CompressedMatrix<T2,SO2> >
3185 typedef typename MultTrait< typename SparseRow<T1,SO1>::ResultType,
3186 CompressedMatrix<T2,SO2> >::Type Type;
3202 template<
typename T1,
bool SO,
typename T2 >
3203 struct DivTrait< SparseRow<T1,SO>, T2 >
3205 typedef typename DivTrait< typename SparseRow<T1,SO>::ResultType, T2 >::Type Type;