ArithmeticSequence.h

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2017 Gael Guennebaud <[email protected]>
//
// 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);
 
template <typename FirstType, typename SizeType, typename IncrType>
class ArithmeticSequence {
 public:
  constexpr ArithmeticSequence() = default;
  constexpr ArithmeticSequence(FirstType first, SizeType size) : m_first(first), m_size(size) {}
  constexpr 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
  };
 
  constexpr Index size() const { return m_size; }
 
  constexpr Index first() const { return m_first; }
 
  constexpr Index operator[](Index i) const { return m_first + i * m_incr; }
 
  constexpr const FirstType& firstObject() const { return m_first; }
  constexpr const SizeType& sizeObject() const { return m_size; }
  constexpr const IncrType& incrObject() const { return m_incr; }
 
 protected:
  FirstType m_first;
  SizeType m_size;
  IncrType m_incr;
 
 public:
  constexpr 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);
  }
};
 
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);
}
 
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
 
template <typename FirstType, typename LastType, typename IncrType>
auto seq(FirstType f, LastType l, IncrType incr);
 
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 {
 
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);
}
 
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 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;
}  // namespace indexing
 
}  // end namespace Eigen
 
#endif  // EIGEN_ARITHMETIC_SEQUENCE_H