IntegralConstant.h

Go to the documentation of this file.

// 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_INTEGRAL_CONSTANT_H
#define EIGEN_INTEGRAL_CONSTANT_H
 
#include "../InternalHeaderCheck.h"
 
namespace Eigen {
 
namespace internal {
 
template<int N> class FixedInt;
template<int N> class VariableAndFixedInt;
 
template<int N> class FixedInt
{
public:
  static const int value = N;
  EIGEN_CONSTEXPR operator int() const { return value; }
  
  EIGEN_CONSTEXPR
  FixedInt() = default;
  
  EIGEN_CONSTEXPR
  FixedInt(std::integral_constant<int,N>) {}
  
  EIGEN_CONSTEXPR
  FixedInt( VariableAndFixedInt<N> other) {
    #ifndef EIGEN_INTERNAL_DEBUGGING
    EIGEN_UNUSED_VARIABLE(other);
    #endif
    eigen_internal_assert(int(other)==N);
  }
 
  EIGEN_CONSTEXPR
  FixedInt<-N> operator-() const { return FixedInt<-N>(); }
  
  template<int M>
  EIGEN_CONSTEXPR
  FixedInt<N+M> operator+( FixedInt<M>) const { return FixedInt<N+M>(); }
  
  template<int M>
  EIGEN_CONSTEXPR
  FixedInt<N-M> operator-( FixedInt<M>) const { return FixedInt<N-M>(); }
  
  template<int M>
  EIGEN_CONSTEXPR
  FixedInt<N*M> operator*( FixedInt<M>) const { return FixedInt<N*M>(); }
  
  template<int M>
  EIGEN_CONSTEXPR
  FixedInt<N/M> operator/( FixedInt<M>) const { return FixedInt<N/M>(); }
  
  template<int M>
  EIGEN_CONSTEXPR
  FixedInt<N%M> operator%( FixedInt<M>) const { return FixedInt<N%M>(); }
  
  template<int M>
  EIGEN_CONSTEXPR
  FixedInt<N|M> operator|( FixedInt<M>) const { return FixedInt<N|M>(); }
  
  template<int M>
  EIGEN_CONSTEXPR
  FixedInt<N&M> operator&( FixedInt<M>) const { return FixedInt<N&M>(); }
 
  // Needed in C++14 to allow fix<N>():
  EIGEN_CONSTEXPR FixedInt operator() () const { return *this; }
 
  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