| // 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 |
| |
| // IWYU pragma: private |
| #include "./InternalHeaderCheck.h" |
| |
| namespace Eigen { |
| |
| namespace internal { |
| |
| // Helper to cleanup the type of the increment: |
| template<typename T> struct cleanup_seq_incr { |
| typedef typename cleanup_index_type<T,DynamicIndex>::type type; |
| }; |
| |
| } // namespace internal |
| |
| //-------------------------------------------------------------------------------- |
| // 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: |
| 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); |
| } |
| }; |
| |
| /** \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 |
| |
| 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)); |
| } |
| |
| |
| #endif // EIGEN_PARSED_BY_DOXYGEN |
| |
| namespace placeholders { |
| |
| /** \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::placeholders::last-(size-fix<1>())*incr, size, incr)) |
| { |
| return seqN(Eigen::placeholders::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::placeholders::last+fix<1>()-size, size)) |
| { |
| return seqN(Eigen::placeholders::last+fix<1>()-size, size); |
| } |
| |
| } // namespace placeholders |
| |
| namespace internal { |
| |
| // Convert a symbolic span into a usable one (i.e., remove last/end "keywords") |
| template<typename T> |
| struct make_size_type { |
| typedef std::conditional_t<symbolic::is_symbolic<T>::value, Index, T> 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::fix; |
| using Eigen::seq; |
| using Eigen::seqN; |
| using Eigen::placeholders::all; |
| using Eigen::placeholders::last; |
| using Eigen::placeholders::lastN; // c++11 only |
| using Eigen::placeholders::lastp1; |
| \endcode |
| */ |
| namespace indexing { |
| using Eigen::fix; |
| using Eigen::seq; |
| using Eigen::seqN; |
| using Eigen::placeholders::all; |
| using Eigen::placeholders::last; |
| using Eigen::placeholders::lastN; |
| using Eigen::placeholders::lastp1; |
| } |
| |
| } // end namespace Eigen |
| |
| #endif // EIGEN_ARITHMETIC_SEQUENCE_H |