NumberTraits.h

 
#pragma once
 
#if defined(NumberTraits_RECURSES)
#error Recursive header files inclusion detected in NumberTraits.h
#else // defined(NumberTraits_RECURSES)
#define NumberTraits_RECURSES
 
#if !defined NumberTraits_h
#define NumberTraits_h
 
// Inclusions
#include <type_traits>
#include <limits>
 
#include <boost/call_traits.hpp>
 
#include "DGtal/base/Common.h"
 
namespace DGtal
{
  enum BoundEnum  {BOUNDED = 0, UNBOUNDED = 1, BOUND_UNKNOWN = 2};
 
  enum SignEnum   {SIGNED = 0, UNSIGNED = 1, SIGN_UNKNOWN = 2};
 
 
// template class NumberTraits and NumberTraitsImpl
 
  template <typename T, typename Enable = void>
  struct NumberTraitsImpl
  {
    // ----------------------- Associated types ------------------------------
    typedef TagUnknown IsBounded;   
    typedef TagUnknown IsUnsigned;  
    typedef TagUnknown IsSigned;    
    typedef TagUnknown IsIntegral;  
    typedef TagFalse IsSpecialized; 
    typedef T SignedVersion;        
    typedef T UnsignedVersion;      
    typedef T ReturnType;           
 
    typedef typename boost::call_traits<T>::param_type ParamType;
 
 
    static const T ZERO = T(0);
 
    static const T ONE  = T(1);
 
    static ReturnType zero();
 
    static ReturnType one();
 
    static ReturnType min();
 
    static ReturnType max();
 
    static unsigned int digits();
 
    static BoundEnum isBounded();
 
    static SignEnum isSigned();
 
    static DGtal::int64_t castToInt64_t(const T & aT)
    {
      return static_cast<DGtal::int64_t>(aT);
    }
    
    static inline constexpr
    DGtal::uint64_t castToUInt64_t(const T & aT) noexcept
    {
      return static_cast<DGtal::uint64_t>(aT);
    }
 
    static double castToDouble(const T & aT)
    {
      return static_cast<double>(aT);
    }
    static bool even( ParamType aT )
    {
      return ( aT & ONE ) == ZERO;
    }
 
    static bool odd( ParamType aT )
    {
      return ( aT & ONE ) != ZERO;
    }
 
  }; // end of class NumberTraitsImpl
 
  // Definition of the static attributes in order to allow ODR-usage.
  template <typename T, typename Enable> const T NumberTraitsImpl<T, Enable>::ZERO;
  template <typename T, typename Enable> const T NumberTraitsImpl<T, Enable>::ONE;
 
  // Some custom structs to factorize the code.
  namespace details
  {
 
    template <bool Value>
    struct BoolToTag
    {
      using type = DGtal::TagTrue;
    };
 
    template <>
    struct BoolToTag<false>
    {
      using type = DGtal::TagFalse;
    };
 
    template <typename T>
    struct NumberTraitsImplFundamental
    {
    private:
      using NL = std::numeric_limits<T>; 
 
    public:
      // ----------------------- Associated types ------------------------------
      using IsBounded     = typename BoolToTag<NL::is_bounded>::type; 
      using IsUnsigned    = typename BoolToTag<!NL::is_signed>::type; 
      using IsSigned      = typename BoolToTag<NL::is_signed>::type;  
      using IsIntegral    = typename BoolToTag<NL::is_integer>::type; 
      using IsSpecialized = TagTrue;  
 
      using ReturnType  = T;  
 
      using ParamType   = typename boost::call_traits<T>::param_type;
 
      static constexpr T ZERO = T(0);
 
      static constexpr T ONE  = T(1);
 
      static inline constexpr
      ReturnType zero() noexcept
      {
        return ZERO;
      }
 
      static inline constexpr
      ReturnType one() noexcept
      {
        return ONE;
      }
 
      static inline constexpr
      ReturnType min() noexcept
      {
        return NL::min();
      }
 
      static inline constexpr
      ReturnType max() noexcept
      {
        return NL::max();
      }
 
      static inline constexpr
      unsigned int digits() noexcept
      {
        return static_cast<unsigned int>(NL::digits);
      }
 
      static inline constexpr
      BoundEnum isBounded() noexcept
      {
        return NL::is_bounded ? BOUNDED : UNBOUNDED;
      }
 
      static inline constexpr
      SignEnum isSigned() noexcept
      {
        return NL::is_signed ? SIGNED : UNSIGNED;
      }
 
      static inline constexpr
      DGtal::int64_t castToInt64_t(const T & aT) noexcept
      {
        return static_cast<DGtal::int64_t>(aT);
      }
      
      static inline constexpr
      DGtal::uint64_t castToUInt64_t(const T & aT) noexcept
      {
        return static_cast<DGtal::uint64_t>(aT);
      }
 
      static inline constexpr
      double castToDouble(const T & aT) noexcept
      {
        return static_cast<double>(aT);
      }
 
      static inline constexpr
      bool even( ParamType aT ) noexcept
      {
        return ( aT & ONE ) == ZERO;
      }
 
      static inline constexpr
      bool odd( ParamType aT ) noexcept
      {
        return ( aT & ONE ) != ZERO;
      }
 
    };
 
    // Definition of the static attributes in order to allow ODR-usage.
    template <typename T> constexpr T NumberTraitsImplFundamental<T>::ZERO;
    template <typename T> constexpr T NumberTraitsImplFundamental<T>::ONE;
 
  } // namespace details
 
  template <typename T>
  struct NumberTraitsImpl<T, typename std::enable_if<std::is_integral<T>::value>::type>
    : details::NumberTraitsImplFundamental<T>
  {
  private:
    using NTIF = typename details::NumberTraitsImplFundamental<T>;  
 
  public:
    using SignedVersion   = typename std::make_signed<T>::type;   
    using UnsignedVersion = typename std::make_unsigned<T>::type; 
 
    static inline constexpr
    bool even( typename NTIF::ParamType aT ) noexcept
    {
      return ( aT & NTIF::ONE ) == NTIF::ZERO;
    }
 
    static inline constexpr
    bool odd( typename NTIF::ParamType aT ) noexcept
    {
      return ( aT & NTIF::ONE ) != NTIF::ZERO;
    }
 
  }; // end of class NumberTraitsImpl
 
  template <typename T>
  struct NumberTraitsImpl<T, typename std::enable_if<std::is_floating_point<T>::value>::type>
    : details::NumberTraitsImplFundamental<T>
  {
    using SignedVersion   = T; 
    using UnsignedVersion = T; 
  }; // end of class NumberTraitsImpl
 
#ifdef WITH_BIGINTEGER
  template <typename Enable>
  struct NumberTraitsImpl<DGtal::BigInteger, Enable>
  {
    typedef TagTrue IsIntegral;     
    typedef TagFalse IsBounded;     
    typedef TagTrue IsUnsigned;     
    typedef TagTrue IsSigned;       
    typedef TagTrue IsSpecialized;  
 
    typedef DGtal::BigInteger SignedVersion;    
    typedef DGtal::BigInteger UnsignedVersion;  
    typedef DGtal::BigInteger ReturnType;       
 
    typedef typename boost::call_traits<BigInteger>::param_type ParamType;
 
    static const DGtal::BigInteger ZERO;
 
    static const DGtal::BigInteger ONE;
 
    static inline
    ReturnType zero() noexcept
    {
      return ZERO;
    }
 
    static inline
    ReturnType one() noexcept
    {
      return ONE;
    }
 
    static inline
    ReturnType min() noexcept
    {
      FATAL_ERROR_MSG(false, "UnBounded interger type does not support min() function");
      return ZERO;
    }
 
    static inline
    ReturnType max() noexcept
    {
      FATAL_ERROR_MSG(false, "UnBounded interger type does not support max() function");
      return ZERO;
    }
 
    static inline
    unsigned int digits() noexcept
    {
      FATAL_ERROR_MSG(false, "UnBounded interger type does not support digits() function");
      return 0;
    }
 
    static inline
    BoundEnum isBounded() noexcept
    {
      return UNBOUNDED;
    }
 
    static inline
    SignEnum isSigned() noexcept
    {
      return SIGNED;
    }
 
    static inline
    DGtal::int64_t castToInt64_t(const DGtal::BigInteger & aT) noexcept
    {
      return aT.get_si();
    }
 
    static inline
    DGtal::uint64_t castToUInt64_t(const DGtal::BigInteger & aT) noexcept
    {
      return aT.get_ui();
    }
 
    
    static inline
    double castToDouble(const DGtal::BigInteger & aT) noexcept
    {
      return aT.get_d();
    }
 
    static inline
    bool even( ParamType aT ) noexcept
    {
      return mpz_even_p( aT.get_mpz_t() );
    }
 
    static inline
    bool odd( ParamType aT ) noexcept
    {
      return mpz_odd_p( aT.get_mpz_t() );
    }
  }; // end of class NumberTraits<DGtal::BigInteger>.
 
  // Definition of the static attributes in order to allow ODR-usage.
  template <typename Enable> const DGtal::BigInteger NumberTraitsImpl<DGtal::BigInteger, Enable>::ZERO = 0;
  template <typename Enable> const DGtal::BigInteger NumberTraitsImpl<DGtal::BigInteger, Enable>::ONE  = 1;
#endif
 
  template <typename T>
  struct NumberTraits
    : NumberTraitsImpl<typename std::decay<T>::type>
  {
  };
 
  class Warning_promote_trait_not_specialized_for_this_case { };
 
  template<class A, class B>
  struct promote_trait
  {
    typedef Warning_promote_trait_not_specialized_for_this_case promote_t;
  };
 
  template<>
  struct promote_trait<int32_t, int64_t>
  {
    typedef int64_t promote_t;
  };
 
} // namespace DGtal
 
#endif // !defined NumberTraits_h
 
#undef NumberTraits_RECURSES
#endif // else defined(NumberTraits_RECURSES)