diff options
Diffstat (limited to 'src/Eigen/src/Core/ArithmeticSequence.h')
| -rw-r--r-- | src/Eigen/src/Core/ArithmeticSequence.h | 413 |
1 files changed, 0 insertions, 413 deletions
diff --git a/src/Eigen/src/Core/ArithmeticSequence.h b/src/Eigen/src/Core/ArithmeticSequence.h deleted file mode 100644 index b6200fa..0000000 --- a/src/Eigen/src/Core/ArithmeticSequence.h +++ /dev/null @@ -1,413 +0,0 @@ -// This file is part of Eigen, a lightweight C++ template library -// for linear algebra. -// -// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr> -// -// This Source Code Form is subject to the terms of the Mozilla -// Public License v. 2.0. If a copy of the MPL was not distributed -// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. - -#ifndef EIGEN_ARITHMETIC_SEQUENCE_H -#define EIGEN_ARITHMETIC_SEQUENCE_H - -namespace Eigen { - -namespace internal { - -#if (!EIGEN_HAS_CXX11) || !((!EIGEN_COMP_GNUC) || EIGEN_COMP_GNUC>=48) -template<typename T> struct aseq_negate {}; - -template<> struct aseq_negate<Index> { - typedef Index type; -}; - -template<int N> struct aseq_negate<FixedInt<N> > { - typedef FixedInt<-N> type; -}; - -// Compilation error in the following case: -template<> struct aseq_negate<FixedInt<DynamicIndex> > {}; - -template<typename FirstType,typename SizeType,typename IncrType, - bool FirstIsSymbolic=symbolic::is_symbolic<FirstType>::value, - bool SizeIsSymbolic =symbolic::is_symbolic<SizeType>::value> -struct aseq_reverse_first_type { - typedef Index type; -}; - -template<typename FirstType,typename SizeType,typename IncrType> -struct aseq_reverse_first_type<FirstType,SizeType,IncrType,true,true> { - typedef symbolic::AddExpr<FirstType, - symbolic::ProductExpr<symbolic::AddExpr<SizeType,symbolic::ValueExpr<FixedInt<-1> > >, - symbolic::ValueExpr<IncrType> > - > type; -}; - -template<typename SizeType,typename IncrType,typename EnableIf = void> -struct aseq_reverse_first_type_aux { - typedef Index type; -}; - -template<typename SizeType,typename IncrType> -struct aseq_reverse_first_type_aux<SizeType,IncrType,typename internal::enable_if<bool((SizeType::value+IncrType::value)|0x1)>::type> { - typedef FixedInt<(SizeType::value-1)*IncrType::value> type; -}; - -template<typename FirstType,typename SizeType,typename IncrType> -struct aseq_reverse_first_type<FirstType,SizeType,IncrType,true,false> { - typedef typename aseq_reverse_first_type_aux<SizeType,IncrType>::type Aux; - typedef symbolic::AddExpr<FirstType,symbolic::ValueExpr<Aux> > type; -}; - -template<typename FirstType,typename SizeType,typename IncrType> -struct aseq_reverse_first_type<FirstType,SizeType,IncrType,false,true> { - typedef symbolic::AddExpr<symbolic::ProductExpr<symbolic::AddExpr<SizeType,symbolic::ValueExpr<FixedInt<-1> > >, - symbolic::ValueExpr<IncrType> >, - symbolic::ValueExpr<> > type; -}; -#endif - -// Helper to cleanup the type of the increment: -template<typename T> struct cleanup_seq_incr { - typedef typename cleanup_index_type<T,DynamicIndex>::type type; -}; - -} - -//-------------------------------------------------------------------------------- -// seq(first,last,incr) and seqN(first,size,incr) -//-------------------------------------------------------------------------------- - -template<typename FirstType=Index,typename SizeType=Index,typename IncrType=internal::FixedInt<1> > -class ArithmeticSequence; - -template<typename FirstType,typename SizeType,typename IncrType> -ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type, - typename internal::cleanup_index_type<SizeType>::type, - typename internal::cleanup_seq_incr<IncrType>::type > -seqN(FirstType first, SizeType size, IncrType incr); - -/** \class ArithmeticSequence - * \ingroup Core_Module - * - * This class represents an arithmetic progression \f$ a_0, a_1, a_2, ..., a_{n-1}\f$ defined by - * its \em first value \f$ a_0 \f$, its \em size (aka length) \em n, and the \em increment (aka stride) - * that is equal to \f$ a_{i+1}-a_{i}\f$ for any \em i. - * - * It is internally used as the return type of the Eigen::seq and Eigen::seqN functions, and as the input arguments - * of DenseBase::operator()(const RowIndices&, const ColIndices&), and most of the time this is the - * only way it is used. - * - * \tparam FirstType type of the first element, usually an Index, - * but internally it can be a symbolic expression - * \tparam SizeType type representing the size of the sequence, usually an Index - * or a compile time integral constant. Internally, it can also be a symbolic expression - * \tparam IncrType type of the increment, can be a runtime Index, or a compile time integral constant (default is compile-time 1) - * - * \sa Eigen::seq, Eigen::seqN, DenseBase::operator()(const RowIndices&, const ColIndices&), class IndexedView - */ -template<typename FirstType,typename SizeType,typename IncrType> -class ArithmeticSequence -{ -public: - ArithmeticSequence(FirstType first, SizeType size) : m_first(first), m_size(size) {} - ArithmeticSequence(FirstType first, SizeType size, IncrType incr) : m_first(first), m_size(size), m_incr(incr) {} - - enum { - SizeAtCompileTime = internal::get_fixed_value<SizeType>::value, - IncrAtCompileTime = internal::get_fixed_value<IncrType,DynamicIndex>::value - }; - - /** \returns the size, i.e., number of elements, of the sequence */ - Index size() const { return m_size; } - - /** \returns the first element \f$ a_0 \f$ in the sequence */ - Index first() const { return m_first; } - - /** \returns the value \f$ a_i \f$ at index \a i in the sequence. */ - Index operator[](Index i) const { return m_first + i * m_incr; } - - const FirstType& firstObject() const { return m_first; } - const SizeType& sizeObject() const { return m_size; } - const IncrType& incrObject() const { return m_incr; } - -protected: - FirstType m_first; - SizeType m_size; - IncrType m_incr; - -public: - -#if EIGEN_HAS_CXX11 && ((!EIGEN_COMP_GNUC) || EIGEN_COMP_GNUC>=48) - auto reverse() const -> decltype(Eigen::seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr)) { - return seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr); - } -#else -protected: - typedef typename internal::aseq_negate<IncrType>::type ReverseIncrType; - typedef typename internal::aseq_reverse_first_type<FirstType,SizeType,IncrType>::type ReverseFirstType; -public: - ArithmeticSequence<ReverseFirstType,SizeType,ReverseIncrType> - reverse() const { - return seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr); - } -#endif -}; - -/** \returns an ArithmeticSequence starting at \a first, of length \a size, and increment \a incr - * - * \sa seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType) */ -template<typename FirstType,typename SizeType,typename IncrType> -ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type,typename internal::cleanup_seq_incr<IncrType>::type > -seqN(FirstType first, SizeType size, IncrType incr) { - return ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type,typename internal::cleanup_seq_incr<IncrType>::type>(first,size,incr); -} - -/** \returns an ArithmeticSequence starting at \a first, of length \a size, and unit increment - * - * \sa seqN(FirstType,SizeType,IncrType), seq(FirstType,LastType) */ -template<typename FirstType,typename SizeType> -ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type > -seqN(FirstType first, SizeType size) { - return ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type>(first,size); -} - -#ifdef EIGEN_PARSED_BY_DOXYGEN - -/** \returns an ArithmeticSequence starting at \a f, up (or down) to \a l, and with positive (or negative) increment \a incr - * - * It is essentially an alias to: - * \code - * seqN(f, (l-f+incr)/incr, incr); - * \endcode - * - * \sa seqN(FirstType,SizeType,IncrType), seq(FirstType,LastType) - */ -template<typename FirstType,typename LastType, typename IncrType> -auto seq(FirstType f, LastType l, IncrType incr); - -/** \returns an ArithmeticSequence starting at \a f, up (or down) to \a l, and unit increment - * - * It is essentially an alias to: - * \code - * seqN(f,l-f+1); - * \endcode - * - * \sa seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType) - */ -template<typename FirstType,typename LastType> -auto seq(FirstType f, LastType l); - -#else // EIGEN_PARSED_BY_DOXYGEN - -#if EIGEN_HAS_CXX11 -template<typename FirstType,typename LastType> -auto seq(FirstType f, LastType l) -> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f), - ( typename internal::cleanup_index_type<LastType>::type(l) - - typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>()))) -{ - return seqN(typename internal::cleanup_index_type<FirstType>::type(f), - (typename internal::cleanup_index_type<LastType>::type(l) - -typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>())); -} - -template<typename FirstType,typename LastType, typename IncrType> -auto seq(FirstType f, LastType l, IncrType incr) - -> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f), - ( typename internal::cleanup_index_type<LastType>::type(l) - - typename internal::cleanup_index_type<FirstType>::type(f)+typename internal::cleanup_seq_incr<IncrType>::type(incr) - ) / typename internal::cleanup_seq_incr<IncrType>::type(incr), - typename internal::cleanup_seq_incr<IncrType>::type(incr))) -{ - typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType; - return seqN(typename internal::cleanup_index_type<FirstType>::type(f), - ( typename internal::cleanup_index_type<LastType>::type(l) - -typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr)) / CleanedIncrType(incr), - CleanedIncrType(incr)); -} - -#else // EIGEN_HAS_CXX11 - -template<typename FirstType,typename LastType> -typename internal::enable_if<!(symbolic::is_symbolic<FirstType>::value || symbolic::is_symbolic<LastType>::value), - ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,Index> >::type -seq(FirstType f, LastType l) -{ - return seqN(typename internal::cleanup_index_type<FirstType>::type(f), - Index((typename internal::cleanup_index_type<LastType>::type(l)-typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>()))); -} - -template<typename FirstTypeDerived,typename LastType> -typename internal::enable_if<!symbolic::is_symbolic<LastType>::value, - ArithmeticSequence<FirstTypeDerived, symbolic::AddExpr<symbolic::AddExpr<symbolic::NegateExpr<FirstTypeDerived>,symbolic::ValueExpr<> >, - symbolic::ValueExpr<internal::FixedInt<1> > > > >::type -seq(const symbolic::BaseExpr<FirstTypeDerived> &f, LastType l) -{ - return seqN(f.derived(),(typename internal::cleanup_index_type<LastType>::type(l)-f.derived()+fix<1>())); -} - -template<typename FirstType,typename LastTypeDerived> -typename internal::enable_if<!symbolic::is_symbolic<FirstType>::value, - ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type, - symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::ValueExpr<> >, - symbolic::ValueExpr<internal::FixedInt<1> > > > >::type -seq(FirstType f, const symbolic::BaseExpr<LastTypeDerived> &l) -{ - return seqN(typename internal::cleanup_index_type<FirstType>::type(f),(l.derived()-typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>())); -} - -template<typename FirstTypeDerived,typename LastTypeDerived> -ArithmeticSequence<FirstTypeDerived, - symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::NegateExpr<FirstTypeDerived> >,symbolic::ValueExpr<internal::FixedInt<1> > > > -seq(const symbolic::BaseExpr<FirstTypeDerived> &f, const symbolic::BaseExpr<LastTypeDerived> &l) -{ - return seqN(f.derived(),(l.derived()-f.derived()+fix<1>())); -} - - -template<typename FirstType,typename LastType, typename IncrType> -typename internal::enable_if<!(symbolic::is_symbolic<FirstType>::value || symbolic::is_symbolic<LastType>::value), - ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,Index,typename internal::cleanup_seq_incr<IncrType>::type> >::type -seq(FirstType f, LastType l, IncrType incr) -{ - typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType; - return seqN(typename internal::cleanup_index_type<FirstType>::type(f), - Index((typename internal::cleanup_index_type<LastType>::type(l)-typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr))/CleanedIncrType(incr)), incr); -} - -template<typename FirstTypeDerived,typename LastType, typename IncrType> -typename internal::enable_if<!symbolic::is_symbolic<LastType>::value, - ArithmeticSequence<FirstTypeDerived, - symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<symbolic::NegateExpr<FirstTypeDerived>, - symbolic::ValueExpr<> >, - symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >, - symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >, - typename internal::cleanup_seq_incr<IncrType>::type> >::type -seq(const symbolic::BaseExpr<FirstTypeDerived> &f, LastType l, IncrType incr) -{ - typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType; - return seqN(f.derived(),(typename internal::cleanup_index_type<LastType>::type(l)-f.derived()+CleanedIncrType(incr))/CleanedIncrType(incr), incr); -} - -template<typename FirstType,typename LastTypeDerived, typename IncrType> -typename internal::enable_if<!symbolic::is_symbolic<FirstType>::value, - ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type, - symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::ValueExpr<> >, - symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >, - symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >, - typename internal::cleanup_seq_incr<IncrType>::type> >::type -seq(FirstType f, const symbolic::BaseExpr<LastTypeDerived> &l, IncrType incr) -{ - typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType; - return seqN(typename internal::cleanup_index_type<FirstType>::type(f), - (l.derived()-typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr))/CleanedIncrType(incr), incr); -} - -template<typename FirstTypeDerived,typename LastTypeDerived, typename IncrType> -ArithmeticSequence<FirstTypeDerived, - symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived, - symbolic::NegateExpr<FirstTypeDerived> >, - symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >, - symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >, - typename internal::cleanup_seq_incr<IncrType>::type> -seq(const symbolic::BaseExpr<FirstTypeDerived> &f, const symbolic::BaseExpr<LastTypeDerived> &l, IncrType incr) -{ - typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType; - return seqN(f.derived(),(l.derived()-f.derived()+CleanedIncrType(incr))/CleanedIncrType(incr), incr); -} -#endif // EIGEN_HAS_CXX11 - -#endif // EIGEN_PARSED_BY_DOXYGEN - - -#if EIGEN_HAS_CXX11 || defined(EIGEN_PARSED_BY_DOXYGEN) -/** \cpp11 - * \returns a symbolic ArithmeticSequence representing the last \a size elements with increment \a incr. - * - * It is a shortcut for: \code seqN(last-(size-fix<1>)*incr, size, incr) \endcode - * - * \sa lastN(SizeType), seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType) */ -template<typename SizeType,typename IncrType> -auto lastN(SizeType size, IncrType incr) --> decltype(seqN(Eigen::last-(size-fix<1>())*incr, size, incr)) -{ - return seqN(Eigen::last-(size-fix<1>())*incr, size, incr); -} - -/** \cpp11 - * \returns a symbolic ArithmeticSequence representing the last \a size elements with a unit increment. - * - * It is a shortcut for: \code seq(last+fix<1>-size, last) \endcode - * - * \sa lastN(SizeType,IncrType, seqN(FirstType,SizeType), seq(FirstType,LastType) */ -template<typename SizeType> -auto lastN(SizeType size) --> decltype(seqN(Eigen::last+fix<1>()-size, size)) -{ - return seqN(Eigen::last+fix<1>()-size, size); -} -#endif - -namespace internal { - -// Convert a symbolic span into a usable one (i.e., remove last/end "keywords") -template<typename T> -struct make_size_type { - typedef typename internal::conditional<symbolic::is_symbolic<T>::value, Index, T>::type type; -}; - -template<typename FirstType,typename SizeType,typename IncrType,int XprSize> -struct IndexedViewCompatibleType<ArithmeticSequence<FirstType,SizeType,IncrType>, XprSize> { - typedef ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType> type; -}; - -template<typename FirstType,typename SizeType,typename IncrType> -ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType> -makeIndexedViewCompatible(const ArithmeticSequence<FirstType,SizeType,IncrType>& ids, Index size,SpecializedType) { - return ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType>( - eval_expr_given_size(ids.firstObject(),size),eval_expr_given_size(ids.sizeObject(),size),ids.incrObject()); -} - -template<typename FirstType,typename SizeType,typename IncrType> -struct get_compile_time_incr<ArithmeticSequence<FirstType,SizeType,IncrType> > { - enum { value = get_fixed_value<IncrType,DynamicIndex>::value }; -}; - -} // end namespace internal - -/** \namespace Eigen::indexing - * \ingroup Core_Module - * - * The sole purpose of this namespace is to be able to import all functions - * and symbols that are expected to be used within operator() for indexing - * and slicing. If you already imported the whole Eigen namespace: - * \code using namespace Eigen; \endcode - * then you are already all set. Otherwise, if you don't want/cannot import - * the whole Eigen namespace, the following line: - * \code using namespace Eigen::indexing; \endcode - * is equivalent to: - * \code - using Eigen::all; - using Eigen::seq; - using Eigen::seqN; - using Eigen::lastN; // c++11 only - using Eigen::last; - using Eigen::lastp1; - using Eigen::fix; - \endcode - */ -namespace indexing { - using Eigen::all; - using Eigen::seq; - using Eigen::seqN; - #if EIGEN_HAS_CXX11 - using Eigen::lastN; - #endif - using Eigen::last; - using Eigen::lastp1; - using Eigen::fix; -} - -} // end namespace Eigen - -#endif // EIGEN_ARITHMETIC_SEQUENCE_H |