22 #ifndef _BLAZE_MATH_VIEWS_SPARSECOLUMN_H_
23 #define _BLAZE_MATH_VIEWS_SPARSECOLUMN_H_
332 template<
typename MT
333 ,
bool SO = IsColumnMajorMatrix<MT>::value >
334 class SparseColumn :
public SparseVector< SparseColumn<MT,SO>, false >
346 enum { useConst = IsConst<MT>::value };
374 explicit inline SparseColumn( MT& matrix,
size_t index );
407 template<
typename Other >
409 operator*=( Other rhs );
411 template<
typename Other >
413 operator/=( Other rhs );
420 inline size_t size()
const;
425 inline void erase (
size_t index );
429 inline void reserve(
size_t n );
430 template<
typename Other >
inline SparseColumn& scale ( Other scalar );
444 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
445 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
497 template<
typename MT
503 if(
matrix_.columns() <= index )
504 throw std::invalid_argument(
"Invalid column access index" );
523 template<
typename MT
528 return matrix_(index,col_);
539 template<
typename MT
544 return const_cast<const MT&
>( matrix_ )(index,col_);
556 template<
typename MT
560 return matrix_.begin( col_ );
572 template<
typename MT
576 return matrix_.begin( col_ );
588 template<
typename MT
592 return matrix_.begin( col_ );
604 template<
typename MT
608 return matrix_.end( col_ );
620 template<
typename MT
624 return matrix_.end( col_ );
636 template<
typename MT
640 return matrix_.end( col_ );
663 template<
typename MT
669 if(
this == &rhs || ( &matrix_ == &rhs.matrix_ && col_ == rhs.col_ ) )
672 if( size() != rhs.size() )
673 throw std::invalid_argument(
"Column sizes do not match" );
675 if( rhs.canAlias( &matrix_ ) ) {
677 matrix_.reset ( col_ );
678 matrix_.reserve( col_, tmp.nonZeros() );
682 matrix_.reset ( col_ );
683 matrix_.reserve( col_, rhs.nonZeros() );
702 template<
typename MT
704 template<
typename VT >
709 if( size() != (~rhs).size() )
710 throw std::invalid_argument(
"Vector sizes do not match" );
712 if( (~rhs).canAlias( &matrix_ ) ) {
713 const typename VT::ResultType tmp( ~rhs );
714 matrix_.reset( col_ );
718 matrix_.reset( col_ );
737 template<
typename MT
739 template<
typename VT >
744 if( size() != (~rhs).size() )
745 throw std::invalid_argument(
"Vector sizes do not match" );
747 if( (~rhs).canAlias( &matrix_ ) ) {
748 const typename VT::ResultType tmp( ~rhs );
749 matrix_.reset ( col_ );
750 matrix_.reserve( col_, tmp.nonZeros() );
754 matrix_.reset ( col_ );
755 matrix_.reserve( col_, (~rhs).nonZeros() );
774 template<
typename MT
776 template<
typename VT >
781 if( (~rhs).size() != size() )
782 throw std::invalid_argument(
"Vector sizes do not match" );
801 template<
typename MT
803 template<
typename VT >
808 if( (~rhs).size() != size() )
809 throw std::invalid_argument(
"Vector sizes do not match" );
829 template<
typename MT
831 template<
typename VT >
834 if( (~rhs).size() != size() )
835 throw std::invalid_argument(
"Vector sizes do not match" );
842 const MultType tmp( *
this * (~rhs) );
843 matrix_.reset( col_ );
862 template<
typename MT
864 template<
typename Other >
868 for(
Iterator element=begin(); element!=end(); ++element )
869 element->value() *= rhs;
887 template<
typename MT
889 template<
typename Other >
901 const Tmp tmp( Tmp(1)/static_cast<Tmp>( rhs ) );
902 for(
Iterator element=begin(); element!=end(); ++element )
903 element->value() *= tmp;
906 for(
Iterator element=begin(); element!=end(); ++element )
907 element->value() /= rhs;
928 template<
typename MT
932 return matrix_.rows();
942 template<
typename MT
946 return matrix_.capacity( col_ );
959 template<
typename MT
963 return matrix_.nonZeros( col_ );
973 template<
typename MT
977 matrix_.reset( col_ );
994 template<
typename MT
999 return matrix_.insert( index, col_, value )->value();
1012 template<
typename MT
1016 matrix_.erase( index, col_ );
1029 template<
typename MT
1033 return matrix_.erase( col_, pos );
1051 template<
typename MT
1055 return matrix_.find( index, col_ );
1073 template<
typename MT
1077 return matrix_.find( index, col_ );
1091 template<
typename MT
1095 matrix_.reserve( col_, n );
1106 template<
typename MT
1108 template<
typename Other >
1111 for(
Iterator element=begin(); element!=end(); ++element )
1112 element->value() *= scalar;
1126 template<
typename MT
1133 size_t nonzeros( 2UL*capacity()+1UL );
1134 nonzeros =
max( nonzeros, 7UL );
1135 nonzeros =
min( nonzeros, size() );
1176 template<
typename MT
1180 matrix_.append( index, col_, value, check );
1203 template<
typename MT
1205 template<
typename Other >
1208 return static_cast<const void*
>( &matrix_ ) == static_cast<const void*>( alias );
1223 template<
typename MT
1225 template<
typename Other >
1228 return static_cast<const void*
>( &matrix_ ) == static_cast<const void*>( alias );
1244 template<
typename MT
1246 template<
typename VT >
1251 size_t nonzeros( 0UL );
1253 for(
size_t i=0UL; i<size(); ++i )
1255 if( matrix_.nonZeros( col_ ) == matrix_.capacity( col_ ) )
1256 matrix_.reserve( col_, extendCapacity() );
1258 matrix_.append( i, col_, (~rhs)[i],
true );
1275 template<
typename MT
1277 template<
typename VT >
1282 for(
typename VT::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element ) {
1283 matrix_.append( element->index(), col_, element->value() );
1300 template<
typename MT
1302 template<
typename VT >
1313 const AddType tmp( *
this + (~rhs) );
1314 matrix_.reset( col_ );
1331 template<
typename MT
1333 template<
typename VT >
1344 const AddType tmp( *
this + (~rhs) );
1345 matrix_.reset ( col_ );
1346 matrix_.reserve( col_, tmp.nonZeros() );
1363 template<
typename MT
1365 template<
typename VT >
1376 const SubType tmp( *
this - (~rhs) );
1377 matrix_.reset( col_ );
1394 template<
typename MT
1396 template<
typename VT >
1407 const SubType tmp( *
this - (~rhs) );
1408 matrix_.reset ( col_ );
1409 matrix_.reserve( col_, tmp.nonZeros() );
1435 template<
typename MT >
1453 typedef SparseColumn<MT,false>
This;
1454 typedef typename ColumnTrait<MT>::Type
ResultType;
1464 typedef typename SelectType< useConst, ConstReference, typename MT::Reference >::Type
Reference;
1470 template<
typename MatrixType
1471 ,
typename IteratorType >
1482 enum { returnConst = IsConst<MatrixType>::value };
1487 typedef typename SelectType< returnConst, const ElementType&, ElementType& >::Type ReferenceType;
1496 inline ColumnElement( IteratorType pos,
size_t row )
1508 template<
typename T >
inline ColumnElement&
operator=(
const T& v ) {
1520 template<
typename T >
inline ColumnElement& operator+=(
const T& v ) {
1532 template<
typename T >
inline ColumnElement& operator-=(
const T& v ) {
1544 template<
typename T >
inline ColumnElement& operator*=(
const T& v ) {
1556 template<
typename T >
inline ColumnElement& operator/=(
const T& v ) {
1567 inline const ColumnElement* operator->()
const {
1577 inline ReferenceType value()
const {
1578 return pos_->value();
1587 inline size_t index()
const {
1603 template<
typename MatrixType
1604 ,
typename IteratorType >
1605 class ColumnIterator
1615 enum { returnConst = IsConst<MatrixType>::value };
1620 typedef std::forward_iterator_tag IteratorCategory;
1621 typedef ColumnElement<MatrixType,IteratorType> ValueType;
1622 typedef ValueType PointerType;
1623 typedef ValueType ReferenceType;
1624 typedef ptrdiff_t DifferenceType;
1627 typedef IteratorCategory iterator_category;
1628 typedef ValueType value_type;
1629 typedef PointerType pointer;
1630 typedef ReferenceType reference;
1631 typedef DifferenceType difference_type;
1634 typedef typename SelectType< returnConst, ReturnType, ElementType& >::Type Value;
1644 inline ColumnIterator( MatrixType& matrix,
size_t row,
size_t column )
1650 for( ; row_<
matrix_.rows(); ++row_ ) {
1651 pos_ =
matrix_.find( row_, column_ );
1652 if( pos_ !=
matrix_.end( row_ ) )
break;
1665 inline ColumnIterator( MatrixType& matrix,
size_t row,
size_t column, IteratorType pos )
1680 template<
typename MatrixType2,
typename IteratorType2 >
1681 inline ColumnIterator(
const ColumnIterator<MatrixType2,IteratorType2>& it )
1684 , column_( it.column_ )
1694 inline ColumnIterator& operator++() {
1696 for( ; row_<
matrix_.rows(); ++row_ ) {
1697 pos_ =
matrix_.find( row_, column_ );
1698 if( pos_ !=
matrix_.end( row_ ) )
break;
1710 inline const ColumnIterator operator++(
int ) {
1711 const ColumnIterator tmp( *
this );
1722 inline ReferenceType
operator*()
const {
1723 return ReferenceType( pos_, row_ );
1732 inline PointerType operator->()
const {
1733 return PointerType( pos_, row_ );
1743 template<
typename MatrixType2,
typename IteratorType2 >
1744 inline bool operator==(
const ColumnIterator<MatrixType2,IteratorType2>& rhs )
const {
1745 return ( &
matrix_ == &rhs.matrix_ ) && ( row_ == rhs.row_ ) && ( column_ == rhs.column_ );
1755 template<
typename MatrixType2,
typename IteratorType2 >
1756 inline bool operator!=(
const ColumnIterator<MatrixType2,IteratorType2>& rhs )
const {
1757 return !( *
this == rhs );
1767 inline DifferenceType
operator-(
const ColumnIterator& rhs )
const {
1768 size_t counter( 0UL );
1769 for(
size_t i=rhs.row_; i<row_; ++i ) {
1787 template<
typename MatrixType2,
typename IteratorType2 >
friend class ColumnIterator;
1788 template<
typename MT2,
bool SO2 >
friend class SparseColumn;
1796 typedef ColumnIterator<const MT,typename MT::ConstIterator>
ConstIterator;
1799 typedef typename SelectType< useConst, ConstIterator, ColumnIterator<MT,typename MT::Iterator> >::Type
Iterator;
1805 explicit inline SparseColumn( MT& matrix,
size_t index );
1833 template<
typename VT >
inline SparseColumn& operator+=(
const Vector<VT,false>& rhs );
1834 template<
typename VT >
inline SparseColumn& operator-=(
const Vector<VT,false>& rhs );
1835 template<
typename VT >
inline SparseColumn& operator*=(
const Vector<VT,false>& rhs );
1837 template<
typename Other >
1838 inline typename EnableIf< IsNumeric<Other>,
SparseColumn >::Type&
1839 operator*=( Other rhs );
1841 template<
typename Other >
1842 inline typename EnableIf< IsNumeric<Other>,
SparseColumn >::Type&
1843 operator/=( Other rhs );
1850 inline size_t size()
const;
1853 inline void reset();
1855 inline void erase (
size_t index );
1859 inline void reserve(
size_t n );
1860 template<
typename Other >
inline SparseColumn& scale ( Other scalar );
1874 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
1875 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
1876 template<
typename VT >
inline void assign (
const DenseVector <VT,false>& rhs );
1877 template<
typename VT >
inline void assign (
const SparseVector<VT,false>& rhs );
1878 template<
typename VT >
inline void addAssign(
const Vector<VT,false>& rhs );
1879 template<
typename VT >
inline void subAssign(
const Vector<VT,false>& rhs );
1920 template<
typename MT >
1925 if(
matrix_.columns() <= index )
1926 throw std::invalid_argument(
"Invalid column access index" );
1947 template<
typename MT >
1951 return matrix_(index,col_);
1964 template<
typename MT >
1968 return const_cast<const MT&
>( matrix_ )(index,col_);
1982 template<
typename MT >
1985 return Iterator( matrix_, 0UL, col_ );
1999 template<
typename MT >
2002 return ConstIterator( matrix_, 0UL, col_ );
2016 template<
typename MT >
2019 return ConstIterator( matrix_, 0UL, col_ );
2033 template<
typename MT >
2036 return Iterator( matrix_, size(), col_ );
2050 template<
typename MT >
2053 return ConstIterator( matrix_, size(), col_ );
2067 template<
typename MT >
2070 return ConstIterator( matrix_, size(), col_ );
2095 template<
typename MT >
2100 if(
this == &rhs || ( &matrix_ == &rhs.matrix_ && col_ == rhs.col_ ) )
2103 if( size() != rhs.size() )
2104 throw std::invalid_argument(
"Column sizes do not match" );
2106 if( rhs.canAlias( &matrix_ ) ) {
2107 const ResultType tmp( rhs );
2131 template<
typename MT >
2132 template<
typename VT >
2137 if( size() != (~rhs).size() )
2138 throw std::invalid_argument(
"Vector sizes do not match" );
2140 const typename VT::CompositeType tmp( ~rhs );
2160 template<
typename MT >
2161 template<
typename VT >
2162 inline SparseColumn<MT,false>& SparseColumn<MT,false>::operator+=(
const Vector<VT,false>& rhs )
2166 if( (~rhs).size() != size() )
2167 throw std::invalid_argument(
"Vector sizes do not match" );
2188 template<
typename MT >
2189 template<
typename VT >
2190 inline SparseColumn<MT,false>& SparseColumn<MT,false>::operator-=(
const Vector<VT,false>& rhs )
2194 if( (~rhs).size() != size() )
2195 throw std::invalid_argument(
"Vector sizes do not match" );
2217 template<
typename MT >
2218 template<
typename VT >
2219 inline SparseColumn<MT,false>& SparseColumn<MT,false>::operator*=(
const Vector<VT,false>& rhs )
2221 if( (~rhs).size() != size() )
2222 throw std::invalid_argument(
"Vector sizes do not match" );
2224 typedef typename MultTrait<This,typename VT::ResultType>::Type MultType;
2229 const MultType tmp( *
this * (~rhs) );
2250 template<
typename MT >
2251 template<
typename Other >
2252 inline typename EnableIf< IsNumeric<Other>, SparseColumn<MT,false> >::Type&
2253 SparseColumn<MT,false>::operator*=( Other rhs )
2255 for( Iterator element=begin(); element!=end(); ++element )
2256 element->value() *= rhs;
2276 template<
typename MT >
2277 template<
typename Other >
2278 inline typename EnableIf< IsNumeric<Other>, SparseColumn<MT,false> >::Type&
2279 SparseColumn<MT,false>::operator/=( Other rhs )
2283 typedef typename DivTrait<ElementType,Other>::Type DT;
2284 typedef typename If< IsNumeric<DT>, DT, Other >::Type Tmp;
2288 if( IsNumeric<DT>::value && IsFloatingPoint<DT>::value ) {
2289 const Tmp tmp( Tmp(1)/static_cast<Tmp>( rhs ) );
2290 for( Iterator element=begin(); element!=end(); ++element )
2291 element->value() *= tmp;
2294 for( Iterator element=begin(); element!=end(); ++element )
2295 element->value() /= rhs;
2318 template<
typename MT >
2321 return matrix_.rows();
2333 template<
typename MT >
2336 return matrix_.rows();
2351 template<
typename MT >
2354 size_t counter( 0UL );
2355 for( ConstIterator element=begin(); element!=end(); ++element ) {
2370 template<
typename MT >
2373 for(
size_t i=0UL; i<size(); ++i ) {
2374 matrix_.erase( i, col_ );
2394 template<
typename MT >
2395 inline typename SparseColumn<MT,false>::ElementType&
2398 return matrix_.insert( index, col_, value )->value();
2413 template<
typename MT >
2416 matrix_.erase( index, col_ );
2431 template<
typename MT >
2434 const size_t row( pos.row_ );
2439 matrix_.erase( row, pos.pos_ );
2440 return Iterator( matrix_, row+1UL, col_ );
2460 template<
typename MT >
2463 const typename MT::Iterator pos( matrix_.find( index, col_ ) );
2465 if( pos != matrix_.end( index ) )
2466 return Iterator( matrix_, index, col_, pos );
2488 template<
typename MT >
2491 const typename MT::ConstIterator pos( matrix_.find( index, col_ ) );
2493 if( pos != matrix_.end( index ) )
2494 return ConstIterator( matrix_, index, col_, pos );
2512 template<
typename MT >
2528 template<
typename MT >
2529 template<
typename Other >
2530 inline SparseColumn<MT,false>& SparseColumn<MT,false>::scale( Other scalar )
2532 for( Iterator element=begin(); element!=end(); ++element )
2533 element->value() *= scalar;
2573 template<
typename MT >
2576 matrix_.insert( index, col_, value );
2601 template<
typename MT >
2602 template<
typename Other >
2605 return static_cast<const void*
>( &matrix_ ) == static_cast<const void*>( alias );
2618 template<
typename MT >
2619 template<
typename Other >
2622 return static_cast<const void*
>( &matrix_ ) == static_cast<const void*>( alias );
2640 template<
typename MT >
2641 template<
typename VT >
2646 for(
size_t i=0UL; i<(~rhs).size(); ++i ) {
2647 matrix_(i,col_) = (~rhs)[i];
2666 template<
typename MT >
2667 template<
typename VT >
2674 for(
typename VT::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element ) {
2675 for( ; i<element->index(); ++i )
2676 matrix_.erase( i, col_ );
2677 matrix_(i++,col_) = element->value();
2679 for( ; i<size(); ++i ) {
2680 matrix_.erase( i, col_ );
2699 template<
typename MT >
2700 template<
typename VT >
2703 typedef typename AddTrait<This,typename VT::ResultType>::Type AddType;
2710 const AddType tmp( *
this + (~rhs) );
2729 template<
typename MT >
2730 template<
typename VT >
2733 typedef typename SubTrait<This,typename VT::ResultType>::Type SubType;
2740 const SubType tmp( *
this - (~rhs) );
2762 template<
typename MT,
bool SO >
2763 inline void reset( SparseColumn<MT,SO>& column );
2765 template<
typename MT,
bool SO >
2766 inline void clear( SparseColumn<MT,SO>& column );
2768 template<
typename MT,
bool SO >
2769 inline bool isnan(
const SparseColumn<MT,SO>& column );
2771 template<
typename MT,
bool SO >
2772 inline bool isDefault(
const SparseColumn<MT,SO>& column );
2784 template<
typename MT
2800 template<
typename MT
2825 template<
typename MT
2831 const ConstIterator end( column.end() );
2832 for( ConstIterator element=column.begin(); element!=end; ++element ) {
2833 if(
isnan( element->value() ) )
return true;
2858 template<
typename MT
2864 const ConstIterator end( column.end() );
2865 for( ConstIterator element=column.begin(); element!=end; ++element )
2866 if( !
isDefault( element->value() ) )
return false;
2899 template<
typename MT
2901 inline typename DisableIf< IsExpression<MT>, SparseColumn<MT> >::Type
2930 template<
typename MT
2932 inline typename DisableIf< IsExpression<MT>, SparseColumn<const MT> >::Type
2962 template<
typename MT
2964 inline typename EnableIf< IsMatMatAddExpr<MT>,
typename ColumnExprTrait<MT>::Type >::Type
2965 column(
const SparseMatrix<MT,SO>& dm,
size_t index )
2969 return column( (~dm).leftOperand(), index ) +
column( (~dm).rightOperand(), index );
2987 template<
typename MT
2989 inline typename EnableIf< IsMatMatSubExpr<MT>,
typename ColumnExprTrait<MT>::Type >::Type
2990 column(
const SparseMatrix<MT,SO>& dm,
size_t index )
2994 return column( (~dm).leftOperand(), index ) -
column( (~dm).rightOperand(), index );
3012 template<
typename MT
3014 inline typename EnableIf< IsMatMatMultExpr<MT>,
typename ColumnExprTrait<MT>::Type >::Type
3015 column(
const SparseMatrix<MT,SO>& dm,
size_t index )
3019 return (~dm).leftOperand() *
column( (~dm).rightOperand(), index );
3037 template<
typename MT
3039 inline typename EnableIf< IsVecTVecMultExpr<MT>,
typename ColumnExprTrait<MT>::Type >::Type
3040 column(
const SparseMatrix<MT,SO>& dm,
size_t index )
3044 return (~dm).leftOperand() * (~dm).rightOperand()[index];
3062 template<
typename MT
3064 inline typename EnableIf< IsMatScalarMultExpr<MT>,
typename ColumnExprTrait<MT>::Type >::Type
3065 column(
const SparseMatrix<MT,SO>& dm,
size_t index )
3069 return column( (~dm).leftOperand(), index ) * (~dm).rightOperand();
3087 template<
typename MT
3089 inline typename EnableIf< IsMatScalarDivExpr<MT>,
typename ColumnExprTrait<MT>::Type >::Type
3090 column(
const SparseMatrix<MT,SO>& dm,
size_t index )
3094 return column( (~dm).leftOperand(), index ) / (~dm).rightOperand();
3112 template<
typename MT
3114 inline typename EnableIf< IsMatAbsExpr<MT>,
typename ColumnExprTrait<MT>::Type >::Type
3115 column(
const SparseMatrix<MT,SO>& dm,
size_t index )
3119 return abs(
column( (~dm).operand(), index ) );
3137 template<
typename MT
3139 inline typename EnableIf< IsMatEvalExpr<MT>,
typename ColumnExprTrait<MT>::Type >::Type
3140 column(
const SparseMatrix<MT,SO>& dm,
size_t index )
3144 return eval(
column( (~dm).operand(), index ) );
3162 template<
typename MT
3164 inline typename EnableIf< IsMatTransExpr<MT>,
typename ColumnExprTrait<MT>::Type >::Type
3165 column(
const SparseMatrix<MT,SO>& dm,
size_t index )
3169 return trans(
row( (~dm).operand(), index ) );
3185 template<
typename T1,
bool SO,
typename T2,
size_t N >
3186 struct AddTrait< SparseColumn<T1,SO>, StaticVector<T2,N,false> >
3188 typedef typename AddTrait< typename SparseColumn<T1,SO>::ResultType,
3189 StaticVector<T2,N,false> >::Type Type;
3192 template<
typename T1,
size_t N,
typename T2,
bool SO >
3193 struct AddTrait< StaticVector<T1,N,false>, SparseColumn<T2,SO> >
3195 typedef typename AddTrait< StaticVector<T1,N,false>,
3196 typename SparseColumn<T2,SO>::ResultType >::Type Type;
3199 template<
typename T1,
bool SO,
typename T2 >
3200 struct AddTrait< SparseColumn<T1,SO>, DynamicVector<T2,false> >
3202 typedef typename AddTrait< typename SparseColumn<T1,SO>::ResultType,
3203 DynamicVector<T2,false> >::Type Type;
3206 template<
typename T1,
typename T2,
bool SO >
3207 struct AddTrait< DynamicVector<T1,false>, SparseColumn<T2,SO> >
3209 typedef typename AddTrait< DynamicVector<T1,false>,
3210 typename SparseColumn<T2,SO>::ResultType >::Type Type;
3213 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3214 struct AddTrait< SparseColumn<T1,SO1>, DenseColumn<T2,SO2> >
3216 typedef typename AddTrait< typename SparseColumn<T1,SO1>::ResultType,
3217 typename DenseColumn <T2,SO2>::ResultType >::Type Type;
3220 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3221 struct AddTrait< DenseColumn<T1,SO1>, SparseColumn<T2,SO2> >
3223 typedef typename AddTrait< typename DenseColumn <T1,SO1>::ResultType,
3224 typename SparseColumn<T2,SO2>::ResultType >::Type Type;
3227 template<
typename T1,
bool SO,
typename T2 >
3228 struct AddTrait< SparseColumn<T1,SO>, CompressedVector<T2,false> >
3230 typedef typename AddTrait< typename SparseColumn<T1,SO>::ResultType,
3231 CompressedVector<T2,false> >::Type Type;
3234 template<
typename T1,
typename T2,
bool SO >
3235 struct AddTrait< CompressedVector<T1,false>, SparseColumn<T2,SO> >
3237 typedef typename AddTrait< CompressedVector<T1,false>,
3238 typename SparseColumn<T2,SO>::ResultType >::Type Type;
3241 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3242 struct AddTrait< SparseColumn<T1,SO1>, SparseColumn<T2,SO2> >
3244 typedef typename AddTrait< typename SparseColumn<T1,SO1>::ResultType,
3245 typename SparseColumn<T2,SO2>::ResultType >::Type Type;
3261 template<
typename T1,
bool SO,
typename T2,
size_t N >
3262 struct SubTrait< SparseColumn<T1,SO>, StaticVector<T2,N,false> >
3264 typedef typename SubTrait< typename SparseColumn<T1,SO>::ResultType,
3265 StaticVector<T2,N,false> >::Type Type;
3268 template<
typename T1,
size_t N,
typename T2,
bool SO >
3269 struct SubTrait< StaticVector<T1,N,false>, SparseColumn<T2,SO> >
3271 typedef typename SubTrait< StaticVector<T1,N,false>,
3272 typename SparseColumn<T2,SO>::ResultType >::Type Type;
3275 template<
typename T1,
bool SO,
typename T2 >
3276 struct SubTrait< SparseColumn<T1,SO>, DynamicVector<T2,false> >
3278 typedef typename SubTrait< typename SparseColumn<T1,SO>::ResultType,
3279 DynamicVector<T2,false> >::Type Type;
3282 template<
typename T1,
typename T2,
bool SO >
3283 struct SubTrait< DynamicVector<T1,false>, SparseColumn<T2,SO> >
3285 typedef typename SubTrait< DynamicVector<T1,false>,
3286 typename SparseColumn<T2,SO>::ResultType >::Type Type;
3289 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3290 struct SubTrait< SparseColumn<T1,SO1>, DenseColumn<T2,SO2> >
3292 typedef typename SubTrait< typename SparseColumn<T1,SO1>::ResultType,
3293 typename DenseColumn <T2,SO2>::ResultType >::Type Type;
3296 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3297 struct SubTrait< DenseColumn<T1,SO1>, SparseColumn<T2,SO2> >
3299 typedef typename SubTrait< typename DenseColumn <T1,SO1>::ResultType,
3300 typename SparseColumn<T2,SO2>::ResultType >::Type Type;
3303 template<
typename T1,
bool SO,
typename T2 >
3304 struct SubTrait< SparseColumn<T1,SO>, CompressedVector<T2,false> >
3306 typedef typename SubTrait< typename SparseColumn<T1,SO>::ResultType,
3307 CompressedVector<T2,false> >::Type Type;
3310 template<
typename T1,
typename T2,
bool SO >
3311 struct SubTrait< CompressedVector<T1,false>, SparseColumn<T2,SO> >
3313 typedef typename SubTrait< CompressedVector<T1,false>,
3314 typename SparseColumn<T2,SO>::ResultType >::Type Type;
3317 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3318 struct SubTrait< SparseColumn<T1,SO1>, SparseColumn<T2,SO2> >
3320 typedef typename SubTrait< typename SparseColumn<T1,SO1>::ResultType,
3321 typename SparseColumn<T2,SO2>::ResultType >::Type Type;
3337 template<
typename T1,
bool SO,
typename T2 >
3338 struct MultTrait< SparseColumn<T1,SO>, T2 >
3340 typedef typename MultTrait< typename SparseColumn<T1,SO>::ResultType, T2 >::Type Type;
3344 template<
typename T1,
typename T2,
bool SO >
3345 struct MultTrait< T1, SparseColumn<T2,SO> >
3347 typedef typename MultTrait< T1, typename SparseColumn<T2,SO>::ResultType >::Type Type;
3351 template<
typename T1,
bool SO,
typename T2,
size_t N,
bool TF >
3352 struct MultTrait< SparseColumn<T1,SO>, StaticVector<T2,N,TF> >
3354 typedef typename MultTrait< typename SparseColumn<T1,SO>::ResultType,
3355 StaticVector<T2,N,TF> >::Type Type;
3358 template<
typename T1,
size_t N,
bool TF,
typename T2,
bool SO >
3359 struct MultTrait< StaticVector<T1,N,TF>, SparseColumn<T2,SO> >
3361 typedef typename MultTrait< StaticVector<T1,N,TF>,
3362 typename SparseColumn<T2,SO>::ResultType >::Type Type;
3365 template<
typename T1,
bool SO,
typename T2,
bool TF >
3366 struct MultTrait< SparseColumn<T1,SO>, DynamicVector<T2,TF> >
3368 typedef typename MultTrait< typename SparseColumn<T1,SO>::ResultType,
3369 DynamicVector<T2,TF> >::Type Type;
3372 template<
typename T1,
bool TF,
typename T2,
bool SO >
3373 struct MultTrait< DynamicVector<T1,TF>, SparseColumn<T2,SO> >
3375 typedef typename MultTrait< DynamicVector<T1,TF>,
3376 typename SparseColumn<T2,SO>::ResultType >::Type Type;
3379 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3380 struct MultTrait< SparseColumn<T1,SO1>, DenseColumn<T2,SO2> >
3382 typedef typename MultTrait< typename SparseColumn<T1,SO1>::ResultType,
3383 typename DenseColumn <T2,SO2>::ResultType >::Type Type;
3386 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3387 struct MultTrait< DenseColumn<T1,SO1>, SparseColumn<T2,SO2> >
3389 typedef typename MultTrait< typename DenseColumn <T1,SO1>::ResultType,
3390 typename SparseColumn<T2,SO2>::ResultType >::Type Type;
3393 template<
typename T1,
bool SO,
typename T2,
bool TF >
3394 struct MultTrait< SparseColumn<T1,SO>, CompressedVector<T2,TF> >
3396 typedef typename MultTrait< typename SparseColumn<T1,SO>::ResultType,
3397 CompressedVector<T2,TF> >::Type Type;
3400 template<
typename T1,
bool TF,
typename T2,
bool SO >
3401 struct MultTrait< CompressedVector<T1,TF>, SparseColumn<T2,SO> >
3403 typedef typename MultTrait< CompressedVector<T1,TF>,
3404 typename SparseColumn<T2,SO>::ResultType >::Type Type;
3407 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3408 struct MultTrait< SparseColumn<T1,SO1>, SparseColumn<T2,SO2> >
3410 typedef typename MultTrait< typename SparseColumn<T1,SO1>::ResultType,
3411 typename SparseColumn<T2,SO2>::ResultType >::Type Type;
3414 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
3415 struct MultTrait< StaticMatrix<T1,M,N,SO1>, SparseColumn<T2,SO2> >
3417 typedef typename MultTrait< StaticMatrix<T1,M,N,SO1>,
3418 typename SparseColumn<T2,SO2>::ResultType >::Type Type;
3421 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3422 struct MultTrait< DynamicMatrix<T1,SO1>, SparseColumn<T2,SO2> >
3424 typedef typename MultTrait< DynamicMatrix<T1,SO1>,
3425 typename SparseColumn<T2,SO2>::ResultType >::Type Type;
3428 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
3429 struct MultTrait< CompressedMatrix<T1,SO1>, SparseColumn<T2,SO2> >
3431 typedef typename MultTrait< CompressedMatrix<T1,SO1>,
3432 typename SparseColumn<T2,SO2>::ResultType >::Type Type;
3448 template<
typename T1,
bool SO,
typename T2 >
3449 struct DivTrait< SparseColumn<T1,SO>, T2 >
3451 typedef typename DivTrait< typename SparseColumn<T1,SO>::ResultType, T2 >::Type Type;