GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-07-20 11:54:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

port VectorwiseOp and Swap to the novel mechanisms, and various cleanning

Browse Source
This commit is contained in:
Gael Guennebaud 2010-01-04 19:00:16 +01:00
parent fcc3be5dce
commit 8eab9fb87e
7 changed files with 88 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
Eigen/src/Array/ArrayBase.h
View File

@ -35,17 +35,17 @@ template<typename ExpressionType> class MatrixWrapper;
* *
* An array is similar to a dense vector or matrix. While matrices are mathematical * An array is similar to a dense vector or matrix. While matrices are mathematical
* objects with well defined linear algebra operators, an array is just a collection * objects with well defined linear algebra operators, an array is just a collection
* of scalar values arranged in a one or two dimensionnal fashion. The main consequence, * of scalar values arranged in a one or two dimensionnal fashion. As the main consequence,
* is that all operations applied to an array are performed coefficient wise. Furthermore, * all operations applied to an array are performed coefficient wise. Furthermore,
* arays support scalar math functions of the c++ standard library, and convenient * arrays support scalar math functions of the c++ standard library (e.g., std::sin(x)), and convenient
* constructors allowing to easily write generic code working for both scalar values * constructors allowing to easily write generic code working for both scalar values
* and arrays. * and arrays.
* *
* This class is the base that is inherited by all array expression types. * This class is the base that is inherited by all array expression types.
* *
* \param Derived is the derived type, e.g. an array type, or an expression, etc. * \param Derived is the derived type, e.g., an array or an expression type.
* *
* \sa class ArrayBase * \sa class MatrixBase
*/ */
template<typename Derived> class ArrayBase template<typename Derived> class ArrayBase
: public DenseBase<Derived> : public DenseBase<Derived>
@ -60,8 +60,6 @@ template<typename Derived> class ArrayBase
using ei_special_scalar_op_base<Derived,typename ei_traits<Derived>::Scalar, using ei_special_scalar_op_base<Derived,typename ei_traits<Derived>::Scalar,
typename NumTraits<typename ei_traits<Derived>::Scalar>::Real>::operator*; typename NumTraits<typename ei_traits<Derived>::Scalar>::Real>::operator*;
class InnerIterator;
typedef typename ei_traits<Derived>::Scalar Scalar; typedef typename ei_traits<Derived>::Scalar Scalar;
typedef typename ei_packet_traits<Scalar>::type PacketScalar; typedef typename ei_packet_traits<Scalar>::type PacketScalar;
@ -126,11 +124,6 @@ template<typename Derived> class ArrayBase
# endif # endif
#undef EIGEN_CURRENT_STORAGE_BASE_CLASS #undef EIGEN_CURRENT_STORAGE_BASE_CLASS
/** Copies \a other into *this. \returns a reference to *this. */
// template<typename OtherDerived>
// Derived& operator=(const ArrayBase<OtherDerived>& other);
/** Special case of the template operator=, in order to prevent the compiler /** Special case of the template operator=, in order to prevent the compiler
* from generating a default operator= (issue hit with g++ 4.1) * from generating a default operator= (issue hit with g++ 4.1)
*/ */
@ -139,14 +132,6 @@ template<typename Derived> class ArrayBase
return ei_assign_selector<Derived,Derived>::run(derived(), other.derived()); return ei_assign_selector<Derived,Derived>::run(derived(), other.derived());
} }
#ifndef EIGEN_PARSED_BY_DOXYGEN
/** Copies \a other into *this without evaluating other. \returns a reference to *this. */
// template<typename OtherDerived>
// Derived& lazyAssign(const ArrayBase<OtherDerived>& other);
// template<typename OtherDerived>
// Derived& lazyAssign(const MatrixBase<OtherDerived>& other);
#endif // not EIGEN_PARSED_BY_DOXYGEN
Derived& operator+=(const Scalar& scalar) Derived& operator+=(const Scalar& scalar)
{ return *this = derived() + scalar; } { return *this = derived() + scalar; }
Derived& operator-=(const Scalar& scalar) Derived& operator-=(const Scalar& scalar)
@ -168,45 +153,15 @@ template<typename Derived> class ArrayBase
inline bool operator!=(const ArrayBase<OtherDerived>& other) const inline bool operator!=(const ArrayBase<OtherDerived>& other) const
{ return cwiseNotEqual(other).all(); } { return cwiseNotEqual(other).all(); }
/** \returns the matrix or vector obtained by evaluating this expression.
*
* Notice that in the case of a plain matrix or vector (not an expression) this function just returns
* a const reference, in order to avoid a useless copy.
*/
// EIGEN_STRONG_INLINE const typename ei_eval<Derived>::type eval() const
// { return typename ei_eval<Derived>::type(derived()); }
// template<typename OtherDerived>
// void swap(ArrayBase<OtherDerived> EIGEN_REF_TO_TEMPORARY other);
// const VectorwiseOp<Derived,Horizontal> rowwise() const;
// VectorwiseOp<Derived,Horizontal> rowwise();
// const VectorwiseOp<Derived,Vertical> colwise() const;
// VectorwiseOp<Derived,Vertical> colwise();
public: public:
MatrixWrapper<Derived> asMatrix() { return derived(); } MatrixWrapper<Derived> asMatrix() { return derived(); }
const MatrixWrapper<Derived> asMatrix() const { return derived(); } const MatrixWrapper<Derived> asMatrix() const { return derived(); }
template<typename Dest> // template<typename Dest>
inline void evalTo(Dest& dst) const { dst = asMatrix(); } // inline void evalTo(Dest& dst) const { dst = asMatrix(); }
protected: protected:
/** Default constructor. Do nothing. */ ArrayBase() : Base() {}
ArrayBase()
{
/* Just checks for self-consistency of the flags.
* Only do it when debugging Eigen, as this borders on paranoiac and could slow compilation down
*/
#ifdef EIGEN_INTERNAL_DEBUGGING
EIGEN_STATIC_ASSERT(ei_are_flags_consistent<Flags>::ret,
INVALID_MATRIXBASE_TEMPLATE_PARAMETERS)
#endif
}
private: private:
explicit ArrayBase(int); explicit ArrayBase(int);

68
Eigen/src/Array/VectorwiseOp.h
View File

@ -119,7 +119,7 @@ class PartialReduxExpr : ei_no_assignment_operator,
template<typename Scalar, int Size> struct Cost \ template<typename Scalar, int Size> struct Cost \
{ enum { value = COST }; }; \ { enum { value = COST }; }; \
template<typename Derived> \ template<typename Derived> \
inline ResultType operator()(const MatrixBase<Derived>& mat) const \ inline ResultType operator()(const DenseBase<Derived>& mat) const \
{ return mat.MEMBER(); } \ { return mat.MEMBER(); } \
} }
@ -148,7 +148,7 @@ struct ei_member_redux {
{ enum { value = (Size-1) * ei_functor_traits<BinaryOp>::Cost }; }; { enum { value = (Size-1) * ei_functor_traits<BinaryOp>::Cost }; };
ei_member_redux(const BinaryOp func) : m_functor(func) {} ei_member_redux(const BinaryOp func) : m_functor(func) {}
template<typename Derived> template<typename Derived>
inline result_type operator()(const MatrixBase<Derived>& mat) const inline result_type operator()(const DenseBase<Derived>& mat) const
{ return mat.redux(m_functor); } { return mat.redux(m_functor); }
const BinaryOp m_functor; const BinaryOp m_functor;
}; };
@ -163,13 +163,13 @@ struct ei_member_redux {
* \param Direction indicates the direction of the redux (Vertical or Horizontal) * \param Direction indicates the direction of the redux (Vertical or Horizontal)
* *
* This class represents a pseudo expression with partial reduction features. * This class represents a pseudo expression with partial reduction features.
* It is the return type of MatrixBase::colwise() and MatrixBase::rowwise() * It is the return type of DenseBase::colwise() and DenseBase::rowwise()
* and most of the time this is the only way it is used. * and most of the time this is the only way it is used.
* *
* Example: \include MatrixBase_colwise.cpp * Example: \include MatrixBase_colwise.cpp
* Output: \verbinclude MatrixBase_colwise.out * Output: \verbinclude MatrixBase_colwise.out
* *
* \sa MatrixBase::colwise(), MatrixBase::rowwise(), class PartialReduxExpr * \sa DenseBase::colwise(), DenseBase::rowwise(), class PartialReduxExpr
*/ */
template<typename ExpressionType, int Direction> class VectorwiseOp template<typename ExpressionType, int Direction> class VectorwiseOp
{ {
@ -227,7 +227,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* Replicates a vector to match the size of \c *this */ * Replicates a vector to match the size of \c *this */
template<typename OtherDerived> template<typename OtherDerived>
typename ExtendedType<OtherDerived>::Type typename ExtendedType<OtherDerived>::Type
extendedTo(const MatrixBase<OtherDerived>& other) const extendedTo(const DenseBase<OtherDerived>& other) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived); EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived);
return typename ExtendedType<OtherDerived>::Type return typename ExtendedType<OtherDerived>::Type
@ -248,7 +248,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* The template parameter \a BinaryOp is the type of the functor * The template parameter \a BinaryOp is the type of the functor
* of the custom redux operator. Note that func must be an associative operator. * of the custom redux operator. Note that func must be an associative operator.
* *
* \sa class VectorwiseOp, MatrixBase::colwise(), MatrixBase::rowwise() * \sa class VectorwiseOp, DenseBase::colwise(), DenseBase::rowwise()
*/ */
template<typename BinaryOp> template<typename BinaryOp>
const typename ReduxReturnType<BinaryOp>::Type const typename ReduxReturnType<BinaryOp>::Type
@ -261,7 +261,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* Example: \include PartialRedux_minCoeff.cpp * Example: \include PartialRedux_minCoeff.cpp
* Output: \verbinclude PartialRedux_minCoeff.out * Output: \verbinclude PartialRedux_minCoeff.out
* *
* \sa MatrixBase::minCoeff() */ * \sa DenseBase::minCoeff() */
const typename ReturnType<ei_member_minCoeff>::Type minCoeff() const const typename ReturnType<ei_member_minCoeff>::Type minCoeff() const
{ return _expression(); } { return _expression(); }
@ -271,7 +271,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* Example: \include PartialRedux_maxCoeff.cpp * Example: \include PartialRedux_maxCoeff.cpp
* Output: \verbinclude PartialRedux_maxCoeff.out * Output: \verbinclude PartialRedux_maxCoeff.out
* *
* \sa MatrixBase::maxCoeff() */ * \sa DenseBase::maxCoeff() */
const typename ReturnType<ei_member_maxCoeff>::Type maxCoeff() const const typename ReturnType<ei_member_maxCoeff>::Type maxCoeff() const
{ return _expression(); } { return _expression(); }
@ -281,7 +281,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* Example: \include PartialRedux_squaredNorm.cpp * Example: \include PartialRedux_squaredNorm.cpp
* Output: \verbinclude PartialRedux_squaredNorm.out * Output: \verbinclude PartialRedux_squaredNorm.out
* *
* \sa MatrixBase::squaredNorm() */ * \sa DenseBase::squaredNorm() */
const typename ReturnType<ei_member_squaredNorm>::Type squaredNorm() const const typename ReturnType<ei_member_squaredNorm>::Type squaredNorm() const
{ return _expression(); } { return _expression(); }
@ -291,7 +291,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* Example: \include PartialRedux_norm.cpp * Example: \include PartialRedux_norm.cpp
* Output: \verbinclude PartialRedux_norm.out * Output: \verbinclude PartialRedux_norm.out
* *
* \sa MatrixBase::norm() */ * \sa DenseBase::norm() */
const typename ReturnType<ei_member_norm>::Type norm() const const typename ReturnType<ei_member_norm>::Type norm() const
{ return _expression(); } { return _expression(); }
@ -300,7 +300,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* of each column (or row) of the referenced expression, using * of each column (or row) of the referenced expression, using
* blue's algorithm. * blue's algorithm.
* *
* \sa MatrixBase::blueNorm() */ * \sa DenseBase::blueNorm() */
const typename ReturnType<ei_member_blueNorm>::Type blueNorm() const const typename ReturnType<ei_member_blueNorm>::Type blueNorm() const
{ return _expression(); } { return _expression(); }
@ -309,7 +309,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* of each column (or row) of the referenced expression, avoiding * of each column (or row) of the referenced expression, avoiding
* underflow and overflow. * underflow and overflow.
* *
* \sa MatrixBase::stableNorm() */ * \sa DenseBase::stableNorm() */
const typename ReturnType<ei_member_stableNorm>::Type stableNorm() const const typename ReturnType<ei_member_stableNorm>::Type stableNorm() const
{ return _expression(); } { return _expression(); }
@ -318,7 +318,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* of each column (or row) of the referenced expression, avoiding * of each column (or row) of the referenced expression, avoiding
* underflow and overflow using a concatenation of hypot() calls. * underflow and overflow using a concatenation of hypot() calls.
* *
* \sa MatrixBase::hypotNorm() */ * \sa DenseBase::hypotNorm() */
const typename ReturnType<ei_member_hypotNorm>::Type hypotNorm() const const typename ReturnType<ei_member_hypotNorm>::Type hypotNorm() const
{ return _expression(); } { return _expression(); }
@ -328,28 +328,28 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* Example: \include PartialRedux_sum.cpp * Example: \include PartialRedux_sum.cpp
* Output: \verbinclude PartialRedux_sum.out * Output: \verbinclude PartialRedux_sum.out
* *
* \sa MatrixBase::sum() */ * \sa DenseBase::sum() */
const typename ReturnType<ei_member_sum>::Type sum() const const typename ReturnType<ei_member_sum>::Type sum() const
{ return _expression(); } { return _expression(); }
/** \returns a row (or column) vector expression of the mean /** \returns a row (or column) vector expression of the mean
* of each column (or row) of the referenced expression. * of each column (or row) of the referenced expression.
* *
* \sa MatrixBase::mean() */ * \sa DenseBase::mean() */
const typename ReturnType<ei_member_mean>::Type mean() const const typename ReturnType<ei_member_mean>::Type mean() const
{ return _expression(); } { return _expression(); }
/** \returns a row (or column) vector expression representing /** \returns a row (or column) vector expression representing
* whether \b all coefficients of each respective column (or row) are \c true. * whether \b all coefficients of each respective column (or row) are \c true.
* *
* \sa MatrixBase::all() */ * \sa DenseBase::all() */
const typename ReturnType<ei_member_all>::Type all() const const typename ReturnType<ei_member_all>::Type all() const
{ return _expression(); } { return _expression(); }
/** \returns a row (or column) vector expression representing /** \returns a row (or column) vector expression representing
* whether \b at \b least one coefficient of each respective column (or row) is \c true. * whether \b at \b least one coefficient of each respective column (or row) is \c true.
* *
* \sa MatrixBase::any() */ * \sa DenseBase::any() */
const typename ReturnType<ei_member_any>::Type any() const const typename ReturnType<ei_member_any>::Type any() const
{ return _expression(); } { return _expression(); }
@ -359,7 +359,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* Example: \include PartialRedux_count.cpp * Example: \include PartialRedux_count.cpp
* Output: \verbinclude PartialRedux_count.out * Output: \verbinclude PartialRedux_count.out
* *
* \sa MatrixBase::count() */ * \sa DenseBase::count() */
const PartialReduxExpr<ExpressionType, ei_member_count<int>, Direction> count() const const PartialReduxExpr<ExpressionType, ei_member_count<int>, Direction> count() const
{ return _expression(); } { return _expression(); }
@ -369,7 +369,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* Example: \include PartialRedux_prod.cpp * Example: \include PartialRedux_prod.cpp
* Output: \verbinclude PartialRedux_prod.out * Output: \verbinclude PartialRedux_prod.out
* *
* \sa MatrixBase::prod() */ * \sa DenseBase::prod() */
const typename ReturnType<ei_member_prod>::Type prod() const const typename ReturnType<ei_member_prod>::Type prod() const
{ return _expression(); } { return _expression(); }
@ -380,7 +380,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* Example: \include PartialRedux_reverse.cpp * Example: \include PartialRedux_reverse.cpp
* Output: \verbinclude PartialRedux_reverse.out * Output: \verbinclude PartialRedux_reverse.out
* *
* \sa MatrixBase::reverse() */ * \sa DenseBase::reverse() */
const Reverse<ExpressionType, Direction> reverse() const const Reverse<ExpressionType, Direction> reverse() const
{ return Reverse<ExpressionType, Direction>( _expression() ); } { return Reverse<ExpressionType, Direction>( _expression() ); }
@ -393,7 +393,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
* Example: \include DirectionWise_replicate.cpp * Example: \include DirectionWise_replicate.cpp
* Output: \verbinclude DirectionWise_replicate.out * Output: \verbinclude DirectionWise_replicate.out
* *
* \sa VectorwiseOp::replicate(int), MatrixBase::replicate(), class Replicate * \sa VectorwiseOp::replicate(int), DenseBase::replicate(), class Replicate
*/ */
// NOTE implemented here because of sunstudio's compilation errors // NOTE implemented here because of sunstudio's compilation errors
template<int Factor> const Replicate<ExpressionType,(IsVertical?Factor:1),(IsHorizontal?Factor:1)> template<int Factor> const Replicate<ExpressionType,(IsVertical?Factor:1),(IsHorizontal?Factor:1)>
@ -407,7 +407,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
/** Copies the vector \a other to each subvector of \c *this */ /** Copies the vector \a other to each subvector of \c *this */
template<typename OtherDerived> template<typename OtherDerived>
ExpressionType& operator=(const MatrixBase<OtherDerived>& other) ExpressionType& operator=(const DenseBase<OtherDerived>& other)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
//ei_assert((m_matrix.isNull()) == (other.isNull())); FIXME //ei_assert((m_matrix.isNull()) == (other.isNull())); FIXME
@ -418,21 +418,21 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
/** Adds the vector \a other to each subvector of \c *this */ /** Adds the vector \a other to each subvector of \c *this */
template<typename OtherDerived> template<typename OtherDerived>
ExpressionType& operator+=(const MatrixBase<OtherDerived>& other) ExpressionType& operator+=(const DenseBase<OtherDerived>& other)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
for(int j=0; j<subVectors(); ++j) for(int j=0; j<subVectors(); ++j)
subVector(j) += other; subVector(j) += other.derived();
return const_cast<ExpressionType&>(m_matrix); return const_cast<ExpressionType&>(m_matrix);
} }
/** Substracts the vector \a other to each subvector of \c *this */ /** Substracts the vector \a other to each subvector of \c *this */
template<typename OtherDerived> template<typename OtherDerived>
ExpressionType& operator-=(const MatrixBase<OtherDerived>& other) ExpressionType& operator-=(const DenseBase<OtherDerived>& other)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
for(int j=0; j<subVectors(); ++j) for(int j=0; j<subVectors(); ++j)
subVector(j) -= other; subVector(j) -= other.derived();
return const_cast<ExpressionType&>(m_matrix); return const_cast<ExpressionType&>(m_matrix);
} }
@ -441,10 +441,10 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
CwiseBinaryOp<ei_scalar_sum_op<Scalar>, CwiseBinaryOp<ei_scalar_sum_op<Scalar>,
ExpressionType, ExpressionType,
typename ExtendedType<OtherDerived>::Type> typename ExtendedType<OtherDerived>::Type>
operator+(const MatrixBase<OtherDerived>& other) const operator+(const DenseBase<OtherDerived>& other) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived); EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived);
return m_matrix + extendedTo(other); return m_matrix + extendedTo(other.derived());
} }
/** Returns the expression of the difference between each subvector of \c *this and the vector \a other */ /** Returns the expression of the difference between each subvector of \c *this and the vector \a other */
@ -452,10 +452,10 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
CwiseBinaryOp<ei_scalar_difference_op<Scalar>, CwiseBinaryOp<ei_scalar_difference_op<Scalar>,
ExpressionType, ExpressionType,
typename ExtendedType<OtherDerived>::Type> typename ExtendedType<OtherDerived>::Type>
operator-(const MatrixBase<OtherDerived>& other) const operator-(const DenseBase<OtherDerived>& other) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived); EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived);
return m_matrix - extendedTo(other); return m_matrix - extendedTo(other.derived());
} }
/////////// Geometry module /////////// /////////// Geometry module ///////////
@ -505,7 +505,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
*/ */
template<typename Derived> template<typename Derived>
inline const VectorwiseOp<Derived,Vertical> inline const VectorwiseOp<Derived,Vertical>
MatrixBase<Derived>::colwise() const DenseBase<Derived>::colwise() const
{ {
return derived(); return derived();
} }
@ -518,7 +518,7 @@ MatrixBase<Derived>::colwise() const
*/ */
template<typename Derived> template<typename Derived>
inline VectorwiseOp<Derived,Vertical> inline VectorwiseOp<Derived,Vertical>
MatrixBase<Derived>::colwise() DenseBase<Derived>::colwise()
{ {
return derived(); return derived();
} }
@ -534,7 +534,7 @@ MatrixBase<Derived>::colwise()
*/ */
template<typename Derived> template<typename Derived>
inline const VectorwiseOp<Derived,Horizontal> inline const VectorwiseOp<Derived,Horizontal>
MatrixBase<Derived>::rowwise() const DenseBase<Derived>::rowwise() const
{ {
return derived(); return derived();
} }
@ -547,7 +547,7 @@ MatrixBase<Derived>::rowwise() const
*/ */
template<typename Derived> template<typename Derived>
inline VectorwiseOp<Derived,Horizontal> inline VectorwiseOp<Derived,Horizontal>
MatrixBase<Derived>::rowwise() DenseBase<Derived>::rowwise()
{ {
return derived(); return derived();
} }

41
Eigen/src/Core/DenseBase.h
View File

@ -30,16 +30,17 @@
* *
* \brief Base class for all dense matrices, vectors, and arrays * \brief Base class for all dense matrices, vectors, and arrays
* *
* This class is the base that is inherited by all dense objects (matrix, vector, arrays, and expression * This class is the base that is inherited by all dense objects (matrix, vector, arrays,
* types). The common Eigen API for dense object is contained in this class. * and related expression types). The common Eigen API for dense objects is contained in this class.
* *
* \param Derived is the derived type, e.g. a matrix type, or an expression, etc. * \param Derived is the derived type, e.g., a matrix type or an expression.
*/ */
template<typename Derived> class DenseBase template<typename Derived> class DenseBase
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
// : public AnyMatrixBase<Derived>
: public ei_special_scalar_op_base<Derived,typename ei_traits<Derived>::Scalar, : public ei_special_scalar_op_base<Derived,typename ei_traits<Derived>::Scalar,
typename NumTraits<typename ei_traits<Derived>::Scalar>::Real> typename NumTraits<typename ei_traits<Derived>::Scalar>::Real>
#else
: public AnyMatrixBase<Derived>
#endif // not EIGEN_PARSED_BY_DOXYGEN #endif // not EIGEN_PARSED_BY_DOXYGEN
{ {
public: public:
@ -266,11 +267,6 @@ template<typename Derived> class DenseBase
template<int StoreMode> template<int StoreMode>
void writePacket(int index, const PacketScalar& x); void writePacket(int index, const PacketScalar& x);
template<typename OtherDerived>
Derived& operator+=(const DenseBase<OtherDerived>& other);
template<typename OtherDerived>
Derived& operator-=(const DenseBase<OtherDerived>& other);
Eigen::Transpose<Derived> transpose(); Eigen::Transpose<Derived> transpose();
const Eigen::Transpose<Derived> transpose() const; const Eigen::Transpose<Derived> transpose() const;
void transposeInPlace(); void transposeInPlace();
@ -385,31 +381,8 @@ template<typename Derived> class DenseBase
bool isZero(RealScalar prec = dummy_precision<Scalar>()) const; bool isZero(RealScalar prec = dummy_precision<Scalar>()) const;
bool isOnes(RealScalar prec = dummy_precision<Scalar>()) const; bool isOnes(RealScalar prec = dummy_precision<Scalar>()) const;
// FIXME inline Derived& operator*=(const Scalar& other);
EIGEN_STRONG_INLINE Derived& operator*=(const Scalar& other) inline Derived& operator/=(const Scalar& other);
{
SelfCwiseBinaryOp<ei_scalar_product_op<Scalar>, Derived> tmp(derived());
typedef typename Derived::PlainMatrixType PlainMatrixType;
tmp = PlainMatrixType::Constant(rows(),cols(),other);
return derived();
}
EIGEN_STRONG_INLINE Derived& operator/=(const Scalar& other)
{
SelfCwiseBinaryOp<typename ei_meta_if<NumTraits<Scalar>::HasFloatingPoint,ei_scalar_product_op<Scalar>,ei_scalar_quotient_op<Scalar> >::ret, Derived> tmp(derived());
typedef typename Derived::PlainMatrixType PlainMatrixType;
tmp = PlainMatrixType::Constant(rows(),cols(), NumTraits<Scalar>::HasFloatingPoint ? Scalar(1)/other : other);
return derived();
}
// FIXME
// template<typename OtherDerived>
// inline bool operator==(const DenseBase<OtherDerived>& other) const
// { return cwiseEqual(other).all(); }
//
// template<typename OtherDerived>
// inline bool operator!=(const DenseBase<OtherDerived>& other) const
// { return cwiseNotEqual(other).all(); }
/** \returns the matrix or vector obtained by evaluating this expression. /** \returns the matrix or vector obtained by evaluating this expression.
* *

53
Eigen/src/Core/MatrixBase.h
View File

@ -30,9 +30,9 @@
* *
* \brief Base class for all dense matrices, vectors, and expressions * \brief Base class for all dense matrices, vectors, and expressions
* *
* This class is the base that is inherited by all matrix, vector, and expression * This class is the base that is inherited by all matrix, vector, and related expression
* types. Most of the Eigen API is contained in this class. Other important classes for * types. Most of the Eigen API is contained in this class, and its base classes. Other important
* the Eigen API are Matrix, Cwise, and VectorwiseOp. * classes for the Eigen API are Matrix, and VectorwiseOp.
* *
* Note that some methods are defined in the \ref Array_Module array module. * Note that some methods are defined in the \ref Array_Module array module.
* *
@ -61,10 +61,6 @@ template<typename Derived> class MatrixBase
/** Construct the base class type for the derived class OtherDerived */ /** Construct the base class type for the derived class OtherDerived */
template <typename OtherDerived> struct MakeBase { typedef MatrixBase<OtherDerived> Type; }; template <typename OtherDerived> struct MakeBase { typedef MatrixBase<OtherDerived> Type; };
// using DenseBase<Derived>::operator*;
class InnerIterator;
typedef typename ei_traits<Derived>::Scalar Scalar; typedef typename ei_traits<Derived>::Scalar Scalar;
typedef typename ei_packet_traits<Scalar>::type PacketScalar; typedef typename ei_packet_traits<Scalar>::type PacketScalar;
@ -89,6 +85,7 @@ template<typename Derived> class MatrixBase
using Base::coeff; using Base::coeff;
using Base::coeffRef; using Base::coeffRef;
using Base::lazyAssign; using Base::lazyAssign;
using Base::eval;
using Base::operator=; using Base::operator=;
using Base::operator+=; using Base::operator+=;
using Base::operator-=; using Base::operator-=;
@ -96,6 +93,8 @@ template<typename Derived> class MatrixBase
using Base::operator/=; using Base::operator/=;
typedef typename Base::CoeffReturnType CoeffReturnType; typedef typename Base::CoeffReturnType CoeffReturnType;
typedef typename Base::RowXpr RowXpr;
typedef typename Base::ColXpr ColXpr;
#endif // not EIGEN_PARSED_BY_DOXYGEN #endif // not EIGEN_PARSED_BY_DOXYGEN
@ -132,13 +131,6 @@ template<typename Derived> class MatrixBase
ei_traits<Derived>::MaxRowsAtCompileTime, ei_traits<Derived>::MaxRowsAtCompileTime,
ei_traits<Derived>::MaxColsAtCompileTime ei_traits<Derived>::MaxColsAtCompileTime
> PlainMatrixType; > PlainMatrixType;
/** \internal the column-major plain matrix type corresponding to this expression. Note that is not necessarily
* exactly the return type of eval(): in the case of plain matrices, the return type of eval() is a const
* reference to a matrix, not a matrix!
* The only difference from PlainMatrixType is that PlainMatrixType_ColMajor is guaranteed to be column-major.
*/
// typedef typename ei_plain_matrix_type<Derived>::type PlainMatrixType_ColMajor;
/** \internal Represents a matrix with all coefficients equal to one another*/ /** \internal Represents a matrix with all coefficients equal to one another*/
typedef CwiseNullaryOp<ei_scalar_constant_op<Scalar>,Derived> ConstantReturnType; typedef CwiseNullaryOp<ei_scalar_constant_op<Scalar>,Derived> ConstantReturnType;
@ -149,10 +141,6 @@ template<typename Derived> class MatrixBase
>::ret AdjointReturnType; >::ret AdjointReturnType;
/** \internal the return type of MatrixBase::eigenvalues() */ /** \internal the return type of MatrixBase::eigenvalues() */
typedef Matrix<typename NumTraits<typename ei_traits<Derived>::Scalar>::Real, ei_traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType; typedef Matrix<typename NumTraits<typename ei_traits<Derived>::Scalar>::Real, ei_traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType;
/** \internal expression tyepe of a column */
typedef Block<Derived, ei_traits<Derived>::RowsAtCompileTime, 1> ColXpr;
/** \internal expression tyepe of a column */
typedef Block<Derived, 1, ei_traits<Derived>::ColsAtCompileTime> RowXpr;
/** \internal the return type of identity */ /** \internal the return type of identity */
typedef CwiseNullaryOp<ei_scalar_identity_op<Scalar>,Derived> IdentityReturnType; typedef CwiseNullaryOp<ei_scalar_identity_op<Scalar>,Derived> IdentityReturnType;
/** \internal the return type of unit vectors */ /** \internal the return type of unit vectors */
@ -286,18 +274,6 @@ template<typename Derived> class MatrixBase
inline bool operator!=(const MatrixBase<OtherDerived>& other) const inline bool operator!=(const MatrixBase<OtherDerived>& other) const
{ return cwiseNotEqual(other).all(); } { return cwiseNotEqual(other).all(); }
/** \returns the matrix or vector obtained by evaluating this expression.
*
* Notice that in the case of a plain matrix or vector (not an expression) this function just returns
* a const reference, in order to avoid a useless copy.
*/
EIGEN_STRONG_INLINE const typename ei_eval<Derived>::type eval() const
{ return typename ei_eval<Derived>::type(derived()); }
template<typename OtherDerived>
void swap(MatrixBase<OtherDerived> EIGEN_REF_TO_TEMPORARY other);
NoAlias<Derived,Eigen::MatrixBase > noalias(); NoAlias<Derived,Eigen::MatrixBase > noalias();
inline const NestByValue<Derived> nestByValue() const; inline const NestByValue<Derived> nestByValue() const;
@ -311,11 +287,6 @@ template<typename Derived> class MatrixBase
/////////// Array module /////////// /////////// Array module ///////////
const VectorwiseOp<Derived,Horizontal> rowwise() const;
VectorwiseOp<Derived,Horizontal> rowwise();
const VectorwiseOp<Derived,Vertical> colwise() const;
VectorwiseOp<Derived,Vertical> colwise();
template<int p> RealScalar lpNorm() const; template<int p> RealScalar lpNorm() const;
ArrayWrapper<Derived> array() { return derived(); } ArrayWrapper<Derived> array() { return derived(); }
@ -435,17 +406,7 @@ template<typename Derived> class MatrixBase
#endif #endif
protected: protected:
/** Default constructor. Do nothing. */ MatrixBase() : Base() {}
MatrixBase()
{
/* Just checks for self-consistency of the flags.
* Only do it when debugging Eigen, as this borders on paranoiac and could slow compilation down
*/
#ifdef EIGEN_INTERNAL_DEBUGGING
EIGEN_STATIC_ASSERT(ei_are_flags_consistent<Flags>::ret,
INVALID_MATRIXBASE_TEMPLATE_PARAMETERS)
#endif
}
private: private:
explicit MatrixBase(int); explicit MatrixBase(int);

27
Eigen/src/Core/SelfCwiseBinaryOp.h
View File

@ -30,12 +30,18 @@
* \internal * \internal
* *
* \brief Internal helper class for optimizing operators like +=, -= * \brief Internal helper class for optimizing operators like +=, -=
*
* This is a pseudo expression class re-implementing the copyCoeff/copyPacket
* method to directly performs a +=/-= operations in an optimal way. In particular,
* this allows to make sure that the input/output data are loaded only once using
* aligned packet loads.
*
* \sa class SwapWrapper for a similar trick.
*/ */
template<typename BinaryOp, typename MatrixType> template<typename BinaryOp, typename MatrixType>
struct ei_traits<SelfCwiseBinaryOp<BinaryOp,MatrixType> > : ei_traits<MatrixType> {}; struct ei_traits<SelfCwiseBinaryOp<BinaryOp,MatrixType> > : ei_traits<MatrixType> {};
template<typename BinaryOp, typename MatrixType> class SelfCwiseBinaryOp template<typename BinaryOp, typename MatrixType> class SelfCwiseBinaryOp
//: public MatrixBase<SelfCwiseBinaryOp<BinaryOp,MatrixType> >
: public MatrixType::template MakeBase< SelfCwiseBinaryOp<BinaryOp, MatrixType> >::Type : public MatrixType::template MakeBase< SelfCwiseBinaryOp<BinaryOp, MatrixType> >::Type
{ {
public: public:
@ -43,7 +49,6 @@ template<typename BinaryOp, typename MatrixType> class SelfCwiseBinaryOp
typedef typename MatrixType::template MakeBase< SelfCwiseBinaryOp<BinaryOp, MatrixType> >::Type Base; typedef typename MatrixType::template MakeBase< SelfCwiseBinaryOp<BinaryOp, MatrixType> >::Type Base;
_EIGEN_DENSE_PUBLIC_INTERFACE(SelfCwiseBinaryOp) _EIGEN_DENSE_PUBLIC_INTERFACE(SelfCwiseBinaryOp)
// EIGEN_GENERIC_PUBLIC_INTERFACE(SelfCwiseBinaryOp)
typedef typename ei_packet_traits<Scalar>::type Packet; typedef typename ei_packet_traits<Scalar>::type Packet;
using Base::operator=; using Base::operator=;
@ -114,4 +119,22 @@ template<typename BinaryOp, typename MatrixType> class SelfCwiseBinaryOp
SelfCwiseBinaryOp& operator=(const SelfCwiseBinaryOp&); SelfCwiseBinaryOp& operator=(const SelfCwiseBinaryOp&);
}; };
template<typename Derived>
inline Derived& DenseBase<Derived>::operator*=(const Scalar& other)
{
SelfCwiseBinaryOp<ei_scalar_product_op<Scalar>, Derived> tmp(derived());
typedef typename Derived::PlainMatrixType PlainMatrixType;
tmp = PlainMatrixType::Constant(rows(),cols(),other);
return derived();
}
template<typename Derived>
inline Derived& DenseBase<Derived>::operator/=(const Scalar& other)
{
SelfCwiseBinaryOp<typename ei_meta_if<NumTraits<Scalar>::HasFloatingPoint,ei_scalar_product_op<Scalar>,ei_scalar_quotient_op<Scalar> >::ret, Derived> tmp(derived());
typedef typename Derived::PlainMatrixType PlainMatrixType;
tmp = PlainMatrixType::Constant(rows(),cols(), NumTraits<Scalar>::HasFloatingPoint ? Scalar(1)/other : other);
return derived();
}
#endif // EIGEN_SELFCWISEBINARYOP_H #endif // EIGEN_SELFCWISEBINARYOP_H

7
Eigen/src/Core/Swap.h
View File

@ -35,11 +35,12 @@ template<typename ExpressionType>
struct ei_traits<SwapWrapper<ExpressionType> > : ei_traits<ExpressionType> {}; struct ei_traits<SwapWrapper<ExpressionType> > : ei_traits<ExpressionType> {};
template<typename ExpressionType> class SwapWrapper template<typename ExpressionType> class SwapWrapper
: public MatrixBase<SwapWrapper<ExpressionType> > : public ExpressionType::template MakeBase<SwapWrapper<ExpressionType> >::Type
{ {
public: public:
EIGEN_GENERIC_PUBLIC_INTERFACE(SwapWrapper) typedef typename ExpressionType::template MakeBase<SwapWrapper<ExpressionType> >::Type Base;
_EIGEN_DENSE_PUBLIC_INTERFACE(SwapWrapper)
typedef typename ei_packet_traits<Scalar>::type Packet; typedef typename ei_packet_traits<Scalar>::type Packet;
inline SwapWrapper(ExpressionType& xpr) : m_expression(xpr) {} inline SwapWrapper(ExpressionType& xpr) : m_expression(xpr) {}
@ -117,7 +118,7 @@ template<typename ExpressionType> class SwapWrapper
*/ */
template<typename Derived> template<typename Derived>
template<typename OtherDerived> template<typename OtherDerived>
void MatrixBase<Derived>::swap(MatrixBase<OtherDerived> EIGEN_REF_TO_TEMPORARY other) void DenseBase<Derived>::swap(DenseBase<OtherDerived> EIGEN_REF_TO_TEMPORARY other)
{ {
(SwapWrapper<Derived>(derived())).lazyAssign(other); (SwapWrapper<Derived>(derived())).lazyAssign(other);
} }

4
Eigen/src/Sparse/CoreIterators.h
View File

@ -1,7 +1,7 @@
// This file is part of Eigen, a lightweight C++ template library // This file is part of Eigen, a lightweight C++ template library
// for linear algebra. // for linear algebra.
// //
// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr> // Copyright (C) 2008-2010 Gael Guennebaud <g.gael@free.fr>
// //
// Eigen is free software; you can redistribute it and/or // Eigen is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -35,7 +35,7 @@
*/ */
// generic version for dense matrix and expressions // generic version for dense matrix and expressions
template<typename Derived> class MatrixBase<Derived>::InnerIterator template<typename Derived> class DenseBase<Derived>::InnerIterator
{ {
typedef typename Derived::Scalar Scalar; typedef typename Derived::Scalar Scalar;
enum { IsRowMajor = (Derived::Flags&RowMajorBit)==RowMajorBit }; enum { IsRowMajor = (Derived::Flags&RowMajorBit)==RowMajorBit };