testNumberTraits.cpp

 
#include <limits>
 
#include "DGtal/base/BasicTypes.h"
#include "DGtal/kernel/NumberTraits.h"
 
#include "DGtalCatch.h"
 
template <typename T>
struct IntegralCstToTag
{
  using type = DGtal::TagUnknown;
};
 
template <>
struct IntegralCstToTag<std::true_type>
{
  using type = DGtal::TagTrue;
};
 
template <>
struct IntegralCstToTag<std::false_type>
{
  using type = DGtal::TagFalse;
};
 
template <bool V>
struct ValueToTag
{
  using type = DGtal::TagUnknown;
};
 
template <>
struct ValueToTag<true>
{
  using type = DGtal::TagTrue;
};
 
template <>
struct ValueToTag<false>
{
  using type = DGtal::TagFalse;
};
 
#define REQUIRE_SAME_TAG(a, b)    REQUIRE( (std::is_same<a, typename IntegralCstToTag<b>::type>::value) )
#define REQUIRE_SAME_VALUE(a, b)  REQUIRE( (std::is_same<a, typename ValueToTag<b>::type>::value) )
#define REQUIRE_SAME_TYPE(a, b)   REQUIRE( (std::is_same<a, b>::value) )
 
template <typename T>
void checkParamRef(T const&)
{
}
 
template <typename T>
void checkFundamentalType()
{
  using NT = typename DGtal::NumberTraits<T>;
  using NL = typename std::numeric_limits<T>;
 
  REQUIRE_SAME_VALUE( typename NT::IsBounded,  NL::is_bounded );
  REQUIRE_SAME_VALUE( typename NT::IsSigned, NL::is_signed );
  REQUIRE_SAME_VALUE( typename NT::IsUnsigned, ! NL::is_signed );
  REQUIRE_SAME_VALUE( typename NT::IsIntegral, NL::is_integer );
  REQUIRE_SAME_VALUE( typename NT::IsSpecialized, true );
  REQUIRE_SAME_TYPE( typename NT::ReturnType, T );
  REQUIRE_SAME_TYPE( typename std::decay<typename NT::ParamType>::type, T );
 
  REQUIRE( NT::ZERO == T(0) );
  REQUIRE( NT::ONE  == T(1) );
 
  REQUIRE( NT::zero() == T(0) );
  REQUIRE( NT::one()  == T(1) );
 
  REQUIRE( NT::min() == NL::min() );
  REQUIRE( NT::max() == NL::max() );
  REQUIRE( NT::digits() == NL::digits );
  REQUIRE( NT::isBounded() == (NL::is_bounded ? DGtal::BOUNDED : DGtal::UNBOUNDED) );
  REQUIRE( NT::isSigned() == (NL::is_signed ? DGtal::SIGNED : DGtal::UNSIGNED) );
 
  REQUIRE( NT::castToInt64_t(T(3.25)) == 3 );
  REQUIRE( NT::castToDouble(T(3.25)) == (NL::is_integer ? 3. : 3.25) );
 
  checkParamRef(NT::ZERO);
  checkParamRef(NT::ONE);
}
 
template <typename T>
void checkFundamentalIntegerType()
{
  checkFundamentalType<T>();
 
  using NT = typename DGtal::NumberTraits<T>;
 
  REQUIRE_SAME_TYPE( typename NT::SignedVersion, typename std::make_signed<T>::type );
  REQUIRE_SAME_TYPE( typename NT::UnsignedVersion, typename std::make_unsigned<T>::type );
 
  REQUIRE( NT::even(T(42)) == true );
  REQUIRE( NT::even(T(43)) == false );
  REQUIRE( NT::odd(T(42)) == false );
  REQUIRE( NT::odd(T(43)) == true );
}
 
template <typename T>
void checkFundamentalFloatType()
{
  checkFundamentalType<T>();
}
 
#define TEST_TYPE_TRAITS( test, a )         TEST_CASE( #a ) { test<a>(); }
#define TEST_FUNDAMENTAL_INTEGER_TYPE( a )  TEST_TYPE_TRAITS( checkFundamentalIntegerType, a )
#define TEST_FUNDAMENTAL_FLOAT_TYPE( a )    TEST_TYPE_TRAITS( checkFundamentalFloatType, a )
 
TEST_FUNDAMENTAL_INTEGER_TYPE(   signed char )
TEST_FUNDAMENTAL_INTEGER_TYPE( unsigned char )
TEST_FUNDAMENTAL_INTEGER_TYPE(   signed short )
TEST_FUNDAMENTAL_INTEGER_TYPE( unsigned short )
TEST_FUNDAMENTAL_INTEGER_TYPE(   signed int )
TEST_FUNDAMENTAL_INTEGER_TYPE( unsigned int )
TEST_FUNDAMENTAL_INTEGER_TYPE(   signed long int )
TEST_FUNDAMENTAL_INTEGER_TYPE( unsigned long int )
TEST_FUNDAMENTAL_INTEGER_TYPE(   signed long long int )
TEST_FUNDAMENTAL_INTEGER_TYPE( unsigned long long int )
 
TEST_FUNDAMENTAL_INTEGER_TYPE(  int8_t )
TEST_FUNDAMENTAL_INTEGER_TYPE( uint8_t )
TEST_FUNDAMENTAL_INTEGER_TYPE(  int16_t )
TEST_FUNDAMENTAL_INTEGER_TYPE( uint16_t )
TEST_FUNDAMENTAL_INTEGER_TYPE(  int32_t )
TEST_FUNDAMENTAL_INTEGER_TYPE( uint32_t )
TEST_FUNDAMENTAL_INTEGER_TYPE(  int64_t )
TEST_FUNDAMENTAL_INTEGER_TYPE( uint64_t )
 
TEST_FUNDAMENTAL_FLOAT_TYPE( float )
TEST_FUNDAMENTAL_FLOAT_TYPE( double )
TEST_FUNDAMENTAL_FLOAT_TYPE( long double )
 
#ifdef WITH_BIGINTEGER
 
TEST_CASE( "BigInteger" )
{
  using T = DGtal::BigInteger;
  using NT = typename DGtal::NumberTraits<T>;
 
  REQUIRE_SAME_VALUE( typename NT::IsBounded,     false );
  REQUIRE_SAME_VALUE( typename NT::IsSigned,      true );
  REQUIRE_SAME_VALUE( typename NT::IsUnsigned,    true );
  REQUIRE_SAME_VALUE( typename NT::IsIntegral,    true );
  REQUIRE_SAME_VALUE( typename NT::IsSpecialized, true );
 
  REQUIRE_SAME_TYPE( typename NT::ReturnType, T );
  REQUIRE_SAME_TYPE( typename std::decay<NT::ParamType>::type, T );
 
  REQUIRE( NT::zero() == T(0) );
  REQUIRE( NT::one() == T(1) );
 
  REQUIRE( NT::even(T(42)) == true );
  REQUIRE( NT::even(T(43)) == false );
  REQUIRE( NT::odd(T(42)) == false );
  REQUIRE( NT::odd(T(43)) == true );
 
  REQUIRE( NT::isBounded() == DGtal::UNBOUNDED );
  REQUIRE( NT::isSigned() == DGtal::SIGNED );
 
  REQUIRE( NT::castToInt64_t(T(3.25)) == 3 );
  REQUIRE( NT::castToDouble(T(3.25)) == 3. );
 
  checkParamRef(NT::ZERO);
  checkParamRef(NT::ONE);
}
 
#endif