IntegralConstant.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_INTEGRAL_CONSTANT_H
#define EIGEN_INTEGRAL_CONSTANT_H
 
// IWYU pragma: private
#include "../InternalHeaderCheck.h"
 
namespace Eigen {
 
namespace internal {
 
template <int N>
class FixedInt;
template <int N>
class VariableAndFixedInt;
 
template <int N>
class FixedInt {
 public:
  static constexpr int value = N;
  constexpr operator int() const { return N; }
 
  constexpr FixedInt() = default;
  constexpr FixedInt(std::integral_constant<int, N>) {}
 
  constexpr FixedInt(VariableAndFixedInt<N> other) {
#ifndef EIGEN_INTERNAL_DEBUGGING
    EIGEN_UNUSED_VARIABLE(other);
#endif
    eigen_internal_assert(int(other) == N);
  }
 
  constexpr FixedInt<-N> operator-() const { return FixedInt<-N>(); }
 
  template <int M>
  constexpr FixedInt<N + M> operator+(FixedInt<M>) const {
    return FixedInt<N + M>();
  }
 
  template <int M>
  constexpr FixedInt<N - M> operator-(FixedInt<M>) const {
    return FixedInt<N - M>();
  }
 
  template <int M>
  constexpr FixedInt<N * M> operator*(FixedInt<M>) const {
    return FixedInt<N * M>();
  }
 
  template <int M>
  constexpr FixedInt<N / M> operator/(FixedInt<M>) const {
    return FixedInt<N / M>();
  }
 
  template <int M>
  constexpr FixedInt<N % M> operator%(FixedInt<M>) const {
    return FixedInt<N % M>();
  }
 
  template <int M>
  constexpr FixedInt<N | M> operator|(FixedInt<M>) const {
    return FixedInt<N | M>();
  }
 
  template <int M>
  constexpr FixedInt<N & M> operator&(FixedInt<M>) const {
    return FixedInt<N & M>();
  }
 
  // Needed in C++14 to allow fix<N>():
  constexpr FixedInt operator()() const { return *this; }
 
  constexpr VariableAndFixedInt<N> operator()(int val) const { return VariableAndFixedInt<N>(val); }
};
 
template <int N>
class VariableAndFixedInt {
 public:
  static const int value = N;
  operator int() const { return m_value; }
  VariableAndFixedInt(int val) { m_value = val; }
 
 protected:
  int m_value;
};
 
template <typename T, int Default = Dynamic>
struct get_fixed_value {
  static const int value = Default;
};
 
template <int N, int Default>
struct get_fixed_value<FixedInt<N>, Default> {
  static const int value = N;
};
 
template <int N, int Default>
struct get_fixed_value<VariableAndFixedInt<N>, Default> {
  static const int value = N;
};
 
template <typename T, int N, int Default>
struct get_fixed_value<variable_if_dynamic<T, N>, Default> {
  static const int value = N;
};
 
template <typename T>
EIGEN_DEVICE_FUNC Index get_runtime_value(const T &x) {
  return x;
}
 
// Cleanup integer/FixedInt/VariableAndFixedInt/etc types:
 
// By default, no cleanup:
template <typename T, int DynamicKey = Dynamic, typename EnableIf = void>
struct cleanup_index_type {
  typedef T type;
};
 
// Convert any integral type (e.g., short, int, unsigned int, etc.) to Eigen::Index
template <typename T, int DynamicKey>
struct cleanup_index_type<T, DynamicKey, std::enable_if_t<internal::is_integral<T>::value>> {
  typedef Index type;
};
 
// If VariableAndFixedInt does not match DynamicKey, then we turn it to a pure compile-time value:
template <int N, int DynamicKey>
struct cleanup_index_type<VariableAndFixedInt<N>, DynamicKey> {
  typedef FixedInt<N> type;
};
// If VariableAndFixedInt matches DynamicKey, then we turn it to a pure runtime-value (aka Index):
template <int DynamicKey>
struct cleanup_index_type<VariableAndFixedInt<DynamicKey>, DynamicKey> {
  typedef Index type;
};
 
template <int N, int DynamicKey>
struct cleanup_index_type<std::integral_constant<int, N>, DynamicKey> {
  typedef FixedInt<N> type;
};
 
}  // end namespace internal
 
#ifndef EIGEN_PARSED_BY_DOXYGEN
 
template <int N>
constexpr internal::FixedInt<N> fix{};
 
#else  // EIGEN_PARSED_BY_DOXYGEN
 
template <int N>
static const auto fix();
 
template <int N>
static const auto fix(int val);
 
#endif  // EIGEN_PARSED_BY_DOXYGEN
 
}  // end namespace Eigen
 
#endif  // EIGEN_INTEGRAL_CONSTANT_H