devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Cleaning pass on evaluators: remove the useless and error prone evaluator<>::type indirection.

Browse Source
This commit is contained in:
Gael Guennebaud
2015-09-02 21:38:40 +02:00
parent cda55ab245
commit 92b9f0e102
29 changed files with 92 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Eigen/src/Core/AssignEvaluator.h
View File

@@ -647,8 +647,8 @@ EIGEN_DEVICE_FUNC void call_dense_assignment_loop(const DstXprType& dst, const S
{
eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
DstEvaluatorType dstEvaluator(dst);
SrcEvaluatorType srcEvaluator(src);

4
Eigen/src/Core/BooleanRedux.h
View File

@@ -80,7 +80,7 @@ struct any_unroller<Derived, Dynamic>
template<typename Derived>
inline bool DenseBase<Derived>::all() const
{
typedef typename internal::evaluator<Derived>::type Evaluator;
typedef internal::evaluator<Derived> Evaluator;
enum {
unroll = SizeAtCompileTime != Dynamic
&& Evaluator::CoeffReadCost != Dynamic
@@ -106,7 +106,7 @@ inline bool DenseBase<Derived>::all() const
template<typename Derived>
inline bool DenseBase<Derived>::any() const
{
typedef typename internal::evaluator<Derived>::type Evaluator;
typedef internal::evaluator<Derived> Evaluator;
enum {
unroll = SizeAtCompileTime != Dynamic
&& Evaluator::CoeffReadCost != Dynamic

25
Eigen/src/Core/CoreEvaluators.h
View File

@@ -59,11 +59,6 @@ template< typename T,
template<typename T>
struct evaluator_traits_base
{
// TODO check whether these two indirections are really needed.
// Basically, if nobody overwrite type and nestedType, then, they can be dropped
// typedef evaluator<T> type;
// typedef evaluator<T> nestedType;
// by default, get evaluator kind and shape from storage
typedef typename storage_kind_to_evaluator_kind<typename traits<T>::StorageKind>::Kind Kind;
typedef typename storage_kind_to_shape<typename traits<T>::StorageKind>::Shape Shape;
@@ -90,25 +85,26 @@ struct evaluator : public unary_evaluator<T>
// TODO: Think about const-correctness
template<typename T>
struct evaluator<const T>
: evaluator<T>
{ };
{
typedef evaluator<const T> nestedType;
explicit evaluator(const T& xpr) : evaluator<T>(xpr) {}
};
// ---------- base class for all writable evaluators ----------
// ---------- base class for all evaluators ----------
// TODO this class does not seem to be necessary anymore
template<typename ExpressionType>
struct evaluator_base
{
// typedef typename evaluator_traits<ExpressionType>::type type;
// typedef typename evaluator_traits<ExpressionType>::nestedType nestedType;
typedef evaluator<ExpressionType> type;
// TODO Check whether nestedType is really needed:
// As long as evaluator are non-copyable, there is no reason to make it different.
typedef evaluator<ExpressionType> nestedType;
// FIXME is it really usefull?
typedef typename traits<ExpressionType>::StorageIndex StorageIndex;
// TODO that's not very nice to have to propagate all these traits. They are currently only needed to handle outer,inner indices.
typedef traits<ExpressionType> ExpressionTraits;
@@ -1332,13 +1328,12 @@ class EvalToTemp
template<typename ArgType>
struct evaluator<EvalToTemp<ArgType> >
: public evaluator<typename ArgType::PlainObject>::type
: public evaluator<typename ArgType::PlainObject>
{
typedef EvalToTemp<ArgType> XprType;
typedef typename ArgType::PlainObject PlainObject;
typedef typename evaluator<PlainObject>::type Base;
typedef evaluator<PlainObject> Base;
typedef evaluator type;
typedef evaluator nestedType;
EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)

6
Eigen/src/Core/CoreIterators.h
View File

@@ -34,7 +34,7 @@ class InnerIterator
{
protected:
typedef internal::inner_iterator_selector<XprType, typename internal::evaluator_traits<XprType>::Kind> IteratorType;
typedef typename internal::evaluator<XprType>::type EvaluatorType;
typedef internal::evaluator<XprType> EvaluatorType;
typedef typename internal::traits<XprType>::Scalar Scalar;
public:
/** Construct an iterator over the \a outerId -th row or column of \a xpr */
@@ -74,7 +74,7 @@ template<typename XprType>
class inner_iterator_selector<XprType, IndexBased>
{
protected:
typedef typename evaluator<XprType>::type EvaluatorType;
typedef evaluator<XprType> EvaluatorType;
typedef typename traits<XprType>::Scalar Scalar;
enum { IsRowMajor = (XprType::Flags&RowMajorBit)==RowMajorBit };
@@ -112,7 +112,7 @@ class inner_iterator_selector<XprType, IteratorBased>
{
protected:
typedef typename evaluator<XprType>::InnerIterator Base;
typedef typename evaluator<XprType>::type EvaluatorType;
typedef evaluator<XprType> EvaluatorType;
public:
EIGEN_STRONG_INLINE inner_iterator_selector(const EvaluatorType &eval, const Index &outerId, const Index &/*innerSize*/)

12
Eigen/src/Core/DenseCoeffsBase.h
View File

@@ -97,7 +97,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
{
eigen_internal_assert(row >= 0 && row < rows()
&& col >= 0 && col < cols());
return typename internal::evaluator<Derived>::type(derived()).coeff(row,col);
return internal::evaluator<Derived>(derived()).coeff(row,col);
}
EIGEN_DEVICE_FUNC
@@ -139,7 +139,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
coeff(Index index) const
{
eigen_internal_assert(index >= 0 && index < size());
return typename internal::evaluator<Derived>::type(derived()).coeff(index);
return internal::evaluator<Derived>(derived()).coeff(index);
}
@@ -218,7 +218,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
{
typedef typename internal::packet_traits<Scalar>::type DefaultPacketType;
eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols());
return typename internal::evaluator<Derived>::type(derived()).template packet<LoadMode,DefaultPacketType>(row,col);
return internal::evaluator<Derived>(derived()).template packet<LoadMode,DefaultPacketType>(row,col);
}
@@ -245,7 +245,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
{
typedef typename internal::packet_traits<Scalar>::type DefaultPacketType;
eigen_internal_assert(index >= 0 && index < size());
return typename internal::evaluator<Derived>::type(derived()).template packet<LoadMode,DefaultPacketType>(index);
return internal::evaluator<Derived>(derived()).template packet<LoadMode,DefaultPacketType>(index);
}
protected:
@@ -325,7 +325,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived,
{
eigen_internal_assert(row >= 0 && row < rows()
&& col >= 0 && col < cols());
return typename internal::evaluator<Derived>::type(derived()).coeffRef(row,col);
return internal::evaluator<Derived>(derived()).coeffRef(row,col);
}
EIGEN_DEVICE_FUNC
@@ -371,7 +371,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived,
coeffRef(Index index)
{
eigen_internal_assert(index >= 0 && index < size());
return typename internal::evaluator<Derived>::type(derived()).coeffRef(index);
return internal::evaluator<Derived>(derived()).coeffRef(index);
}
/** \returns a reference to the coefficient at given index.

5
Eigen/src/Core/Inverse.h
View File

@@ -100,13 +100,12 @@ namespace internal {
*/
template<typename ArgType>
struct unary_evaluator<Inverse<ArgType> >
: public evaluator<typename Inverse<ArgType>::PlainObject>::type
: public evaluator<typename Inverse<ArgType>::PlainObject>
{
typedef Inverse<ArgType> InverseType;
typedef typename InverseType::PlainObject PlainObject;
typedef typename evaluator<PlainObject>::type Base;
typedef evaluator<PlainObject> Base;
typedef evaluator<InverseType> type;
typedef evaluator<InverseType> nestedType;
enum { Flags = Base::Flags | EvalBeforeNestingBit };

6
Eigen/src/Core/Product.h
View File

@@ -165,7 +165,7 @@ public:
operator const Scalar() const
{
return typename internal::evaluator<ProductXpr>::type(derived()).coeff(0,0);
return internal::evaluator<ProductXpr>(derived()).coeff(0,0);
}
};
@@ -203,7 +203,7 @@ class ProductImpl<Lhs,Rhs,Option,Dense>
EIGEN_STATIC_ASSERT(EnableCoeff, THIS_METHOD_IS_ONLY_FOR_INNER_OR_LAZY_PRODUCTS);
eigen_assert( (Option==LazyProduct) || (this->rows() == 1 && this->cols() == 1) );
return typename internal::evaluator<Derived>::type(derived()).coeff(row,col);
return internal::evaluator<Derived>(derived()).coeff(row,col);
}
EIGEN_DEVICE_FUNC Scalar coeff(Index i) const
@@ -211,7 +211,7 @@ class ProductImpl<Lhs,Rhs,Option,Dense>
EIGEN_STATIC_ASSERT(EnableCoeff, THIS_METHOD_IS_ONLY_FOR_INNER_OR_LAZY_PRODUCTS);
eigen_assert( (Option==LazyProduct) || (this->rows() == 1 && this->cols() == 1) );
return typename internal::evaluator<Derived>::type(derived()).coeff(i);
return internal::evaluator<Derived>(derived()).coeff(i);
}

15
Eigen/src/Core/ProductEvaluators.h
View File

@@ -32,7 +32,6 @@ struct evaluator<Product<Lhs, Rhs, Options> >
typedef Product<Lhs, Rhs, Options> XprType;
typedef product_evaluator<XprType> Base;
typedef evaluator type;
typedef evaluator nestedType;
EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
@@ -47,7 +46,6 @@ struct evaluator<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const Produ
typedef CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const Product<Lhs, Rhs, DefaultProduct> > XprType;
typedef evaluator<Product<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>,const Lhs>, Rhs, DefaultProduct> > Base;
typedef evaluator type;
typedef evaluator nestedType;
EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
@@ -63,7 +61,6 @@ struct evaluator<Diagonal<const Product<Lhs, Rhs, DefaultProduct>, DiagIndex> >
typedef Diagonal<const Product<Lhs, Rhs, DefaultProduct>, DiagIndex> XprType;
typedef evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex> > Base;
typedef evaluator type;
typedef evaluator nestedType;
EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
@@ -102,11 +99,11 @@ struct evaluator_traits<Product<Lhs, Rhs, AliasFreeProduct> >
template<typename Lhs, typename Rhs, int Options, int ProductTag, typename LhsShape, typename RhsShape>
struct product_evaluator<Product<Lhs, Rhs, Options>, ProductTag, LhsShape, RhsShape, typename traits<Lhs>::Scalar, typename traits<Rhs>::Scalar,
EnableIf<(Options==DefaultProduct || Options==AliasFreeProduct)> >
: public evaluator<typename Product<Lhs, Rhs, Options>::PlainObject>::type
: public evaluator<typename Product<Lhs, Rhs, Options>::PlainObject>
{
typedef Product<Lhs, Rhs, Options> XprType;
typedef typename XprType::PlainObject PlainObject;
typedef typename evaluator<PlainObject>::type Base;
typedef evaluator<PlainObject> Base;
enum {
Flags = Base::Flags | EvalBeforeNestingBit
};
@@ -221,7 +218,7 @@ struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,InnerProduct>
template<typename Dst, typename Lhs, typename Rhs, typename Func>
EIGEN_DONT_INLINE void outer_product_selector_run(Dst& dst, const Lhs &lhs, const Rhs &rhs, const Func& func, const false_type&)
{
typename evaluator<Rhs>::type rhsEval(rhs);
evaluator<Rhs> rhsEval(rhs);
// FIXME make sure lhs is sequentially stored
// FIXME not very good if rhs is real and lhs complex while alpha is real too
// FIXME we should probably build an evaluator for dst
@@ -234,7 +231,7 @@ EIGEN_DONT_INLINE void outer_product_selector_run(Dst& dst, const Lhs &lhs, cons
template<typename Dst, typename Lhs, typename Rhs, typename Func>
EIGEN_DONT_INLINE void outer_product_selector_run(Dst& dst, const Lhs &lhs, const Rhs &rhs, const Func& func, const true_type&)
{
typename evaluator<Lhs>::type lhsEval(lhs);
evaluator<Lhs> lhsEval(lhs);
// FIXME make sure rhs is sequentially stored
// FIXME not very good if lhs is real and rhs complex while alpha is real too
// FIXME we should probably build an evaluator for dst
@@ -406,8 +403,8 @@ struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, DenseShape,
typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
typedef typename evaluator<LhsNestedCleaned>::type LhsEtorType;
typedef typename evaluator<RhsNestedCleaned>::type RhsEtorType;
typedef evaluator<LhsNestedCleaned> LhsEtorType;
typedef evaluator<RhsNestedCleaned> RhsEtorType;
enum {
RowsAtCompileTime = LhsNestedCleaned::RowsAtCompileTime,

5
Eigen/src/Core/ReturnByValue.h
View File

@@ -94,13 +94,12 @@ namespace internal {
template<typename Derived>
struct evaluator<ReturnByValue<Derived> >
: public evaluator<typename internal::traits<Derived>::ReturnType>::type
: public evaluator<typename internal::traits<Derived>::ReturnType>
{
typedef ReturnByValue<Derived> XprType;
typedef typename internal::traits<Derived>::ReturnType PlainObject;
typedef typename evaluator<PlainObject>::type Base;
typedef evaluator<PlainObject> Base;
typedef evaluator type;
typedef evaluator nestedType;
EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)

5
Eigen/src/Core/Solve.h
View File

@@ -113,13 +113,12 @@ namespace internal {
// Evaluator of Solve -> eval into a temporary
template<typename Decomposition, typename RhsType>
struct evaluator<Solve<Decomposition,RhsType> >
: public evaluator<typename Solve<Decomposition,RhsType>::PlainObject>::type
: public evaluator<typename Solve<Decomposition,RhsType>::PlainObject>
{
typedef Solve<Decomposition,RhsType> SolveType;
typedef typename SolveType::PlainObject PlainObject;
typedef typename evaluator<PlainObject>::type Base;
typedef evaluator<PlainObject> Base;
typedef evaluator type;
typedef evaluator nestedType;
EIGEN_DEVICE_FUNC explicit evaluator(const SolveType& solve)

5
Eigen/src/Core/TriangularMatrix.h
View File

@@ -664,7 +664,6 @@ struct unary_evaluator<TriangularView<MatrixType,Mode>, IndexBased>
{
typedef TriangularView<MatrixType,Mode> XprType;
typedef evaluator<typename internal::remove_all<MatrixType>::type> Base;
typedef evaluator<XprType> type;
unary_evaluator(const XprType &xpr) : Base(xpr.nestedExpression()) {}
};
@@ -734,8 +733,8 @@ EIGEN_DEVICE_FUNC void call_triangular_assignment_loop(const DstXprType& dst, co
{
eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
DstEvaluatorType dstEvaluator(dst);
SrcEvaluatorType srcEvaluator(src);