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

Exploit fixed values in seq and reverse with C++98 compatibility

Browse Source
This commit is contained in:
Gael Guennebaud
2017-01-19 19:57:32 +01:00
parent 7691723e34
commit 54f3fbee24
3 changed files with 76 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Eigen/src/Core/util/IndexedViewHelper.h
View File

@@ -60,7 +60,7 @@ static const auto end = last+1;
#else
// Using a FixedExpr<1> expression is important here to make sure the compiler
// can fully optimize the computation starting indices with zero overhead.
static const Symbolic::AddExpr<Symbolic::SymbolExpr<internal::symbolic_last_tag>,Symbolic::FixedExpr<1> > end(last+fix<1>());
static const Symbolic::AddExpr<Symbolic::SymbolExpr<internal::symbolic_last_tag>,Symbolic::ValueExpr<Eigen::internal::fix_t<1> > > end(last+fix<1>());
#endif
} // end namespace placeholders

80
Eigen/src/Core/util/SymbolicIndex.h
View File

@@ -46,23 +46,24 @@ template<typename Arg1,typename Arg2> class AddExpr;
template<typename Arg1,typename Arg2> class ProductExpr;
template<typename Arg1,typename Arg2> class QuotientExpr;
// A simple wrapper around an Index to provide the eval method.
// A simple wrapper around an integral value to provide the eval method.
// We could also use a free-function symbolic_eval...
template<typename IndexType=Index>
class ValueExpr {
public:
ValueExpr(Index val) : m_value(val) {}
ValueExpr(IndexType val) : m_value(val) {}
template<typename T>
Index eval_impl(const T&) const { return m_value; }
IndexType eval_impl(const T&) const { return m_value; }
protected:
Index m_value;
IndexType m_value;
};
// Simple wrapper around a compile-time value,
// Specialization for compile-time value,
// It is similar to ValueExpr(N) but this version helps the compiler to generate better code.
template<int N>
class FixedExpr {
class ValueExpr<internal::fix_t<N> > {
public:
FixedExpr() {}
ValueExpr() {}
template<typename T>
Index eval_impl(const T&) const { return N; }
};
@@ -94,50 +95,49 @@ public:
NegateExpr<Derived> operator-() const { return NegateExpr<Derived>(derived()); }
AddExpr<Derived,ValueExpr> operator+(Index b) const
{ return AddExpr<Derived,ValueExpr >(derived(), b); }
AddExpr<Derived,ValueExpr> operator-(Index a) const
{ return AddExpr<Derived,ValueExpr >(derived(), -a); }
ProductExpr<Derived,ValueExpr> operator*(Index a) const
{ return ProductExpr<Derived,ValueExpr>(derived(),a); }
QuotientExpr<Derived,ValueExpr> operator/(Index a) const
{ return QuotientExpr<Derived,ValueExpr>(derived(),a); }
friend AddExpr<Derived,ValueExpr> operator+(Index a, const BaseExpr& b)
{ return AddExpr<Derived,ValueExpr>(b.derived(), a); }
friend AddExpr<NegateExpr<Derived>,ValueExpr> operator-(Index a, const BaseExpr& b)
{ return AddExpr<NegateExpr<Derived>,ValueExpr>(-b.derived(), a); }
friend ProductExpr<ValueExpr,Derived> operator*(Index a, const BaseExpr& b)
{ return ProductExpr<ValueExpr,Derived>(a,b.derived()); }
friend QuotientExpr<ValueExpr,Derived> operator/(Index a, const BaseExpr& b)
{ return QuotientExpr<ValueExpr,Derived>(a,b.derived()); }
AddExpr<Derived,ValueExpr<> > operator+(Index b) const
{ return AddExpr<Derived,ValueExpr<> >(derived(), b); }
AddExpr<Derived,ValueExpr<> > operator-(Index a) const
{ return AddExpr<Derived,ValueExpr<> >(derived(), -a); }
ProductExpr<Derived,ValueExpr<> > operator*(Index a) const
{ return ProductExpr<Derived,ValueExpr<> >(derived(),a); }
QuotientExpr<Derived,ValueExpr<> > operator/(Index a) const
{ return QuotientExpr<Derived,ValueExpr<> >(derived(),a); }
friend AddExpr<Derived,ValueExpr<> > operator+(Index a, const BaseExpr& b)
{ return AddExpr<Derived,ValueExpr<> >(b.derived(), a); }
friend AddExpr<NegateExpr<Derived>,ValueExpr<> > operator-(Index a, const BaseExpr& b)
{ return AddExpr<NegateExpr<Derived>,ValueExpr<> >(-b.derived(), a); }
friend ProductExpr<ValueExpr<>,Derived> operator*(Index a, const BaseExpr& b)
{ return ProductExpr<ValueExpr<>,Derived>(a,b.derived()); }
friend QuotientExpr<ValueExpr<>,Derived> operator/(Index a, const BaseExpr& b)
{ return QuotientExpr<ValueExpr<>,Derived>(a,b.derived()); }
template<int N>
AddExpr<Derived,FixedExpr<N> > operator+(internal::fix_t<N>) const
{ return AddExpr<Derived,FixedExpr<N> >(derived(), FixedExpr<N>()); }
AddExpr<Derived,ValueExpr<internal::fix_t<N> > > operator+(internal::fix_t<N>) const
{ return AddExpr<Derived,ValueExpr<internal::fix_t<N> > >(derived(), ValueExpr<internal::fix_t<N> >()); }
template<int N>
AddExpr<Derived,FixedExpr<N> > operator-(internal::fix_t<N>) const
{ return AddExpr<Derived,FixedExpr<-N> >(derived(), FixedExpr<-N>()); }
AddExpr<Derived,ValueExpr<internal::fix_t<N> > > operator-(internal::fix_t<N>) const
{ return AddExpr<Derived,ValueExpr<internal::fix_t<-N> > >(derived(), ValueExpr<internal::fix_t<-N> >()); }
template<int N>
ProductExpr<Derived,FixedExpr<N> > operator*(internal::fix_t<N>) const
{ return ProductExpr<Derived,FixedExpr<N> >(derived(),FixedExpr<N>()); }
ProductExpr<Derived,ValueExpr<internal::fix_t<N> > > operator*(internal::fix_t<N>) const
{ return ProductExpr<Derived,ValueExpr<internal::fix_t<N> > >(derived(),ValueExpr<internal::fix_t<N> >()); }
template<int N>
QuotientExpr<Derived,FixedExpr<N> > operator/(internal::fix_t<N>) const
{ return QuotientExpr<Derived,FixedExpr<N> >(derived(),FixedExpr<N>()); }
QuotientExpr<Derived,ValueExpr<internal::fix_t<N> > > operator/(internal::fix_t<N>) const
{ return QuotientExpr<Derived,ValueExpr<internal::fix_t<N> > >(derived(),ValueExpr<internal::fix_t<N> >()); }
template<int N>
friend AddExpr<Derived,FixedExpr<N> > operator+(internal::fix_t<N>, const BaseExpr& b)
{ return AddExpr<Derived,FixedExpr<N> >(b.derived(), FixedExpr<N>()); }
friend AddExpr<Derived,ValueExpr<internal::fix_t<N> > > operator+(internal::fix_t<N>, const BaseExpr& b)
{ return AddExpr<Derived,ValueExpr<internal::fix_t<N> > >(b.derived(), ValueExpr<internal::fix_t<N> >()); }
template<int N>
friend AddExpr<NegateExpr<Derived>,FixedExpr<N> > operator-(internal::fix_t<N>, const BaseExpr& b)
{ return AddExpr<NegateExpr<Derived>,FixedExpr<N> >(-b.derived(), FixedExpr<N>()); }
friend AddExpr<NegateExpr<Derived>,ValueExpr<internal::fix_t<N> > > operator-(internal::fix_t<N>, const BaseExpr& b)
{ return AddExpr<NegateExpr<Derived>,ValueExpr<internal::fix_t<N> > >(-b.derived(), ValueExpr<internal::fix_t<N> >()); }
template<int N>
friend ProductExpr<FixedExpr<N>,Derived> operator*(internal::fix_t<N>, const BaseExpr& b)
{ return ProductExpr<FixedExpr<N>,Derived>(FixedExpr<N>(),b.derived()); }
friend ProductExpr<ValueExpr<internal::fix_t<N> >,Derived> operator*(internal::fix_t<N>, const BaseExpr& b)
{ return ProductExpr<ValueExpr<internal::fix_t<N> >,Derived>(ValueExpr<internal::fix_t<N> >(),b.derived()); }
template<int N>
friend QuotientExpr<FixedExpr<N>,Derived> operator/(internal::fix_t<N>, const BaseExpr& b)
{ return QuotientExpr<FixedExpr<N> ,Derived>(FixedExpr<N>(),b.derived()); }
friend QuotientExpr<ValueExpr<internal::fix_t<N> >,Derived> operator/(internal::fix_t<N>, const BaseExpr& b)
{ return QuotientExpr<ValueExpr<internal::fix_t<N> > ,Derived>(ValueExpr<internal::fix_t<N> >(),b.derived()); }
template<typename OtherDerived>