ArithmeticSequence.h

// 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/.
// SPDX-License-Identifier: 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 {
  using type = typename cleanup_index_type<T, DynamicIndex>::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 { 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) {
  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) {
  using CleanedIncrType = typename internal::cleanup_seq_incr<IncrType>::type;
  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) {
  return seqN(Eigen::placeholders::last - (size - fix<1>()) * incr, size, incr);
}

template <typename SizeType>
auto lastN(SizeType 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