00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifndef EIGEN_PARTIAL_REDUX_H
00027 #define EIGEN_PARTIAL_REDUX_H
00028
00029 namespace Eigen {
00030
00047 template< typename MatrixType, typename MemberOp, int Direction>
00048 class PartialReduxExpr;
00049
00050 namespace internal {
00051 template<typename MatrixType, typename MemberOp, int Direction>
00052 struct traits<PartialReduxExpr<MatrixType, MemberOp, Direction> >
00053 : traits<MatrixType>
00054 {
00055 typedef typename MemberOp::result_type Scalar;
00056 typedef typename traits<MatrixType>::StorageKind StorageKind;
00057 typedef typename traits<MatrixType>::XprKind XprKind;
00058 typedef typename MatrixType::Scalar InputScalar;
00059 typedef typename nested<MatrixType>::type MatrixTypeNested;
00060 typedef typename remove_all<MatrixTypeNested>::type _MatrixTypeNested;
00061 enum {
00062 RowsAtCompileTime = Direction==Vertical ? 1 : MatrixType::RowsAtCompileTime,
00063 ColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::ColsAtCompileTime,
00064 MaxRowsAtCompileTime = Direction==Vertical ? 1 : MatrixType::MaxRowsAtCompileTime,
00065 MaxColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::MaxColsAtCompileTime,
00066 Flags0 = (unsigned int)_MatrixTypeNested::Flags & HereditaryBits,
00067 Flags = (Flags0 & ~RowMajorBit) | (RowsAtCompileTime == 1 ? RowMajorBit : 0),
00068 TraversalSize = Direction==Vertical ? RowsAtCompileTime : ColsAtCompileTime
00069 };
00070 #if EIGEN_GNUC_AT_LEAST(3,4)
00071 typedef typename MemberOp::template Cost<InputScalar,int(TraversalSize)> CostOpType;
00072 #else
00073 typedef typename MemberOp::template Cost<InputScalar,TraversalSize> CostOpType;
00074 #endif
00075 enum {
00076 CoeffReadCost = TraversalSize * traits<_MatrixTypeNested>::CoeffReadCost + int(CostOpType::value)
00077 };
00078 };
00079 }
00080
00081 template< typename MatrixType, typename MemberOp, int Direction>
00082 class PartialReduxExpr : internal::no_assignment_operator,
00083 public internal::dense_xpr_base< PartialReduxExpr<MatrixType, MemberOp, Direction> >::type
00084 {
00085 public:
00086
00087 typedef typename internal::dense_xpr_base<PartialReduxExpr>::type Base;
00088 EIGEN_DENSE_PUBLIC_INTERFACE(PartialReduxExpr)
00089 typedef typename internal::traits<PartialReduxExpr>::MatrixTypeNested MatrixTypeNested;
00090 typedef typename internal::traits<PartialReduxExpr>::_MatrixTypeNested _MatrixTypeNested;
00091
00092 PartialReduxExpr(const MatrixType& mat, const MemberOp& func = MemberOp())
00093 : m_matrix(mat), m_functor(func) {}
00094
00095 Index rows() const { return (Direction==Vertical ? 1 : m_matrix.rows()); }
00096 Index cols() const { return (Direction==Horizontal ? 1 : m_matrix.cols()); }
00097
00098 EIGEN_STRONG_INLINE const Scalar coeff(Index i, Index j) const
00099 {
00100 if (Direction==Vertical)
00101 return m_functor(m_matrix.col(j));
00102 else
00103 return m_functor(m_matrix.row(i));
00104 }
00105
00106 const Scalar coeff(Index index) const
00107 {
00108 if (Direction==Vertical)
00109 return m_functor(m_matrix.col(index));
00110 else
00111 return m_functor(m_matrix.row(index));
00112 }
00113
00114 protected:
00115 MatrixTypeNested m_matrix;
00116 const MemberOp m_functor;
00117 };
00118
00119 #define EIGEN_MEMBER_FUNCTOR(MEMBER,COST) \
00120 template <typename ResultType> \
00121 struct member_##MEMBER { \
00122 EIGEN_EMPTY_STRUCT_CTOR(member_##MEMBER) \
00123 typedef ResultType result_type; \
00124 template<typename Scalar, int Size> struct Cost \
00125 { enum { value = COST }; }; \
00126 template<typename XprType> \
00127 EIGEN_STRONG_INLINE ResultType operator()(const XprType& mat) const \
00128 { return mat.MEMBER(); } \
00129 }
00130
00131 namespace internal {
00132
00133 EIGEN_MEMBER_FUNCTOR(squaredNorm, Size * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
00134 EIGEN_MEMBER_FUNCTOR(norm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
00135 EIGEN_MEMBER_FUNCTOR(stableNorm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
00136 EIGEN_MEMBER_FUNCTOR(blueNorm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
00137 EIGEN_MEMBER_FUNCTOR(hypotNorm, (Size-1) * functor_traits<scalar_hypot_op<Scalar> >::Cost );
00138 EIGEN_MEMBER_FUNCTOR(sum, (Size-1)*NumTraits<Scalar>::AddCost);
00139 EIGEN_MEMBER_FUNCTOR(mean, (Size-1)*NumTraits<Scalar>::AddCost + NumTraits<Scalar>::MulCost);
00140 EIGEN_MEMBER_FUNCTOR(minCoeff, (Size-1)*NumTraits<Scalar>::AddCost);
00141 EIGEN_MEMBER_FUNCTOR(maxCoeff, (Size-1)*NumTraits<Scalar>::AddCost);
00142 EIGEN_MEMBER_FUNCTOR(all, (Size-1)*NumTraits<Scalar>::AddCost);
00143 EIGEN_MEMBER_FUNCTOR(any, (Size-1)*NumTraits<Scalar>::AddCost);
00144 EIGEN_MEMBER_FUNCTOR(count, (Size-1)*NumTraits<Scalar>::AddCost);
00145 EIGEN_MEMBER_FUNCTOR(prod, (Size-1)*NumTraits<Scalar>::MulCost);
00146
00147
00148 template <typename BinaryOp, typename Scalar>
00149 struct member_redux {
00150 typedef typename result_of<
00151 BinaryOp(Scalar)
00152 >::type result_type;
00153 template<typename _Scalar, int Size> struct Cost
00154 { enum { value = (Size-1) * functor_traits<BinaryOp>::Cost }; };
00155 member_redux(const BinaryOp func) : m_functor(func) {}
00156 template<typename Derived>
00157 inline result_type operator()(const DenseBase<Derived>& mat) const
00158 { return mat.redux(m_functor); }
00159 const BinaryOp m_functor;
00160 };
00161 }
00162
00180 template<typename ExpressionType, int Direction> class VectorwiseOp
00181 {
00182 public:
00183
00184 typedef typename ExpressionType::Scalar Scalar;
00185 typedef typename ExpressionType::RealScalar RealScalar;
00186 typedef typename ExpressionType::Index Index;
00187 typedef typename internal::conditional<internal::must_nest_by_value<ExpressionType>::ret,
00188 ExpressionType, ExpressionType&>::type ExpressionTypeNested;
00189 typedef typename internal::remove_all<ExpressionTypeNested>::type ExpressionTypeNestedCleaned;
00190
00191 template<template<typename _Scalar> class Functor,
00192 typename Scalar=typename internal::traits<ExpressionType>::Scalar> struct ReturnType
00193 {
00194 typedef PartialReduxExpr<ExpressionType,
00195 Functor<Scalar>,
00196 Direction
00197 > Type;
00198 };
00199
00200 template<typename BinaryOp> struct ReduxReturnType
00201 {
00202 typedef PartialReduxExpr<ExpressionType,
00203 internal::member_redux<BinaryOp,typename internal::traits<ExpressionType>::Scalar>,
00204 Direction
00205 > Type;
00206 };
00207
00208 enum {
00209 IsVertical = (Direction==Vertical) ? 1 : 0,
00210 IsHorizontal = (Direction==Horizontal) ? 1 : 0
00211 };
00212
00213 protected:
00214
00217 typedef typename internal::conditional<Direction==Vertical,
00218 typename ExpressionType::ColXpr,
00219 typename ExpressionType::RowXpr>::type SubVector;
00220 SubVector subVector(Index i)
00221 {
00222 return SubVector(m_matrix.derived(),i);
00223 }
00224
00227 Index subVectors() const
00228 { return Direction==Vertical?m_matrix.cols():m_matrix.rows(); }
00229
00230 template<typename OtherDerived> struct ExtendedType {
00231 typedef Replicate<OtherDerived,
00232 Direction==Vertical ? 1 : ExpressionType::RowsAtCompileTime,
00233 Direction==Horizontal ? 1 : ExpressionType::ColsAtCompileTime> Type;
00234 };
00235
00238 template<typename OtherDerived>
00239 typename ExtendedType<OtherDerived>::Type
00240 extendedTo(const DenseBase<OtherDerived>& other) const
00241 {
00242 EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(Direction==Vertical, OtherDerived::MaxColsAtCompileTime==1),
00243 YOU_PASSED_A_ROW_VECTOR_BUT_A_COLUMN_VECTOR_WAS_EXPECTED)
00244 EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(Direction==Horizontal, OtherDerived::MaxRowsAtCompileTime==1),
00245 YOU_PASSED_A_COLUMN_VECTOR_BUT_A_ROW_VECTOR_WAS_EXPECTED)
00246 return typename ExtendedType<OtherDerived>::Type
00247 (other.derived(),
00248 Direction==Vertical ? 1 : m_matrix.rows(),
00249 Direction==Horizontal ? 1 : m_matrix.cols());
00250 }
00251
00252 public:
00253
00254 inline VectorwiseOp(ExpressionType& matrix) : m_matrix(matrix) {}
00255
00257 inline const ExpressionType& _expression() const { return m_matrix; }
00258
00266 template<typename BinaryOp>
00267 const typename ReduxReturnType<BinaryOp>::Type
00268 redux(const BinaryOp& func = BinaryOp()) const
00269 { return typename ReduxReturnType<BinaryOp>::Type(_expression(), func); }
00270
00278 const typename ReturnType<internal::member_minCoeff>::Type minCoeff() const
00279 { return _expression(); }
00280
00288 const typename ReturnType<internal::member_maxCoeff>::Type maxCoeff() const
00289 { return _expression(); }
00290
00298 const typename ReturnType<internal::member_squaredNorm,RealScalar>::Type squaredNorm() const
00299 { return _expression(); }
00300
00308 const typename ReturnType<internal::member_norm,RealScalar>::Type norm() const
00309 { return _expression(); }
00310
00311
00317 const typename ReturnType<internal::member_blueNorm,RealScalar>::Type blueNorm() const
00318 { return _expression(); }
00319
00320
00326 const typename ReturnType<internal::member_stableNorm,RealScalar>::Type stableNorm() const
00327 { return _expression(); }
00328
00329
00335 const typename ReturnType<internal::member_hypotNorm,RealScalar>::Type hypotNorm() const
00336 { return _expression(); }
00337
00345 const typename ReturnType<internal::member_sum>::Type sum() const
00346 { return _expression(); }
00347
00352 const typename ReturnType<internal::member_mean>::Type mean() const
00353 { return _expression(); }
00354
00359 const typename ReturnType<internal::member_all>::Type all() const
00360 { return _expression(); }
00361
00366 const typename ReturnType<internal::member_any>::Type any() const
00367 { return _expression(); }
00368
00376 const PartialReduxExpr<ExpressionType, internal::member_count<Index>, Direction> count() const
00377 { return _expression(); }
00378
00386 const typename ReturnType<internal::member_prod>::Type prod() const
00387 { return _expression(); }
00388
00389
00397 const Reverse<ExpressionType, Direction> reverse() const
00398 { return Reverse<ExpressionType, Direction>( _expression() ); }
00399
00400 typedef Replicate<ExpressionType,Direction==Vertical?Dynamic:1,Direction==Horizontal?Dynamic:1> ReplicateReturnType;
00401 const ReplicateReturnType replicate(Index factor) const;
00402
00411
00412 template<int Factor> const Replicate<ExpressionType,(IsVertical?Factor:1),(IsHorizontal?Factor:1)>
00413 replicate(Index factor = Factor) const
00414 {
00415 return Replicate<ExpressionType,Direction==Vertical?Factor:1,Direction==Horizontal?Factor:1>
00416 (_expression(),Direction==Vertical?factor:1,Direction==Horizontal?factor:1);
00417 }
00418
00420
00422 template<typename OtherDerived>
00423 ExpressionType& operator=(const DenseBase<OtherDerived>& other)
00424 {
00425 EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
00426 EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
00427
00428 return const_cast<ExpressionType&>(m_matrix = extendedTo(other.derived()));
00429 }
00430
00432 template<typename OtherDerived>
00433 ExpressionType& operator+=(const DenseBase<OtherDerived>& other)
00434 {
00435 EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
00436 EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
00437 return const_cast<ExpressionType&>(m_matrix += extendedTo(other.derived()));
00438 }
00439
00441 template<typename OtherDerived>
00442 ExpressionType& operator-=(const DenseBase<OtherDerived>& other)
00443 {
00444 EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
00445 EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
00446 return const_cast<ExpressionType&>(m_matrix -= extendedTo(other.derived()));
00447 }
00448
00450 template<typename OtherDerived>
00451 ExpressionType& operator*=(const DenseBase<OtherDerived>& other)
00452 {
00453 EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
00454 EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
00455 EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
00456 m_matrix *= extendedTo(other.derived());
00457 return const_cast<ExpressionType&>(m_matrix);
00458 }
00459
00461 template<typename OtherDerived>
00462 ExpressionType& operator/=(const DenseBase<OtherDerived>& other)
00463 {
00464 EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
00465 EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
00466 EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
00467 m_matrix /= extendedTo(other.derived());
00468 return const_cast<ExpressionType&>(m_matrix);
00469 }
00470
00472 template<typename OtherDerived> EIGEN_STRONG_INLINE
00473 CwiseBinaryOp<internal::scalar_sum_op<Scalar>,
00474 const ExpressionTypeNestedCleaned,
00475 const typename ExtendedType<OtherDerived>::Type>
00476 operator+(const DenseBase<OtherDerived>& other) const
00477 {
00478 EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
00479 EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
00480 return m_matrix + extendedTo(other.derived());
00481 }
00482
00484 template<typename OtherDerived>
00485 CwiseBinaryOp<internal::scalar_difference_op<Scalar>,
00486 const ExpressionTypeNestedCleaned,
00487 const typename ExtendedType<OtherDerived>::Type>
00488 operator-(const DenseBase<OtherDerived>& other) const
00489 {
00490 EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
00491 EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
00492 return m_matrix - extendedTo(other.derived());
00493 }
00494
00497 template<typename OtherDerived> EIGEN_STRONG_INLINE
00498 CwiseBinaryOp<internal::scalar_product_op<Scalar>,
00499 const ExpressionTypeNestedCleaned,
00500 const typename ExtendedType<OtherDerived>::Type>
00501 operator*(const DenseBase<OtherDerived>& other) const
00502 {
00503 EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
00504 EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
00505 EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
00506 return m_matrix * extendedTo(other.derived());
00507 }
00508
00511 template<typename OtherDerived>
00512 CwiseBinaryOp<internal::scalar_quotient_op<Scalar>,
00513 const ExpressionTypeNestedCleaned,
00514 const typename ExtendedType<OtherDerived>::Type>
00515 operator/(const DenseBase<OtherDerived>& other) const
00516 {
00517 EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
00518 EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
00519 EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
00520 return m_matrix / extendedTo(other.derived());
00521 }
00522
00524
00525 #if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS
00526 Homogeneous<ExpressionType,Direction> homogeneous() const;
00527 #endif
00528
00529 typedef typename ExpressionType::PlainObject CrossReturnType;
00530 template<typename OtherDerived>
00531 const CrossReturnType cross(const MatrixBase<OtherDerived>& other) const;
00532
00533 enum {
00534 HNormalized_Size = Direction==Vertical ? internal::traits<ExpressionType>::RowsAtCompileTime
00535 : internal::traits<ExpressionType>::ColsAtCompileTime,
00536 HNormalized_SizeMinusOne = HNormalized_Size==Dynamic ? Dynamic : HNormalized_Size-1
00537 };
00538 typedef Block<const ExpressionType,
00539 Direction==Vertical ? int(HNormalized_SizeMinusOne)
00540 : int(internal::traits<ExpressionType>::RowsAtCompileTime),
00541 Direction==Horizontal ? int(HNormalized_SizeMinusOne)
00542 : int(internal::traits<ExpressionType>::ColsAtCompileTime)>
00543 HNormalized_Block;
00544 typedef Block<const ExpressionType,
00545 Direction==Vertical ? 1 : int(internal::traits<ExpressionType>::RowsAtCompileTime),
00546 Direction==Horizontal ? 1 : int(internal::traits<ExpressionType>::ColsAtCompileTime)>
00547 HNormalized_Factors;
00548 typedef CwiseBinaryOp<internal::scalar_quotient_op<typename internal::traits<ExpressionType>::Scalar>,
00549 const HNormalized_Block,
00550 const Replicate<HNormalized_Factors,
00551 Direction==Vertical ? HNormalized_SizeMinusOne : 1,
00552 Direction==Horizontal ? HNormalized_SizeMinusOne : 1> >
00553 HNormalizedReturnType;
00554
00555 const HNormalizedReturnType hnormalized() const;
00556
00557 protected:
00558 ExpressionTypeNested m_matrix;
00559 };
00560
00568 template<typename Derived>
00569 inline const typename DenseBase<Derived>::ConstColwiseReturnType
00570 DenseBase<Derived>::colwise() const
00571 {
00572 return derived();
00573 }
00574
00579 template<typename Derived>
00580 inline typename DenseBase<Derived>::ColwiseReturnType
00581 DenseBase<Derived>::colwise()
00582 {
00583 return derived();
00584 }
00585
00593 template<typename Derived>
00594 inline const typename DenseBase<Derived>::ConstRowwiseReturnType
00595 DenseBase<Derived>::rowwise() const
00596 {
00597 return derived();
00598 }
00599
00604 template<typename Derived>
00605 inline typename DenseBase<Derived>::RowwiseReturnType
00606 DenseBase<Derived>::rowwise()
00607 {
00608 return derived();
00609 }
00610
00611 }
00612
00613 #endif // EIGEN_PARTIAL_REDUX_H