C
Qt Quick Ultralite Automotive Cluster Demo
#ifndef ETL_STL_ALTERNATE_LIMITS_INCLUDED
#define ETL_STL_ALTERNATE_LIMITS_INCLUDED
#include "../../platform.h"
#include "../../type_traits.h"
#include "../../char_traits.h"
#include "../../integral_limits.h"
#include <limits.h>
#include <stdint.h>
#include <float.h>
#define ETL_LOG2(x) (((x) * 301) / 1000)
#if defined(ETL_IN_UNIT_TEST)
#if !defined(ETLSTD)
#define ETLSTD etlstd
#endif
namespace etlstd
#else
#if !defined(ETLSTD)
#define ETLSTD std
#endif
namespace std
#endif
{
template<class T> class numeric_limits;
enum float_round_style
{
round_indeterminate = -1,
round_toward_zero = 0,
round_to_nearest = 1,
round_toward_infinity = 2,
round_toward_neg_infinity = 3,
};
enum float_denorm_style
{
denorm_indeterminate = -1,
denorm_absent = 0,
denorm_present = 1
};
template <typename T>
class etl_integral_type
{
public:
static const bool is_specialized;
static const int max_digits10;
static const bool is_integer;
static const bool is_exact;
static const int radix;
static ETL_CONSTEXPR T epsilon() { return 0; }
static ETL_CONSTEXPR T round_error() { return 0; }
static const int digits;
static const int digits10;
static const bool is_signed;
static const int min_exponent;
static const int min_exponent10;
static const int max_exponent;
static const int max_exponent10;
static const bool has_infinity;
static const bool has_quiet_NaN;
static const bool has_signaling_NaN;
static const float_denorm_style has_denorm;
static const bool has_denorm_loss;
static ETL_CONSTEXPR T infinity() { return 0; }
static ETL_CONSTEXPR T quiet_NaN() { return 0; }
static ETL_CONSTEXPR T signaling_NaN() { return 0; }
static ETL_CONSTEXPR T denorm_min() { return 0; }
static const bool is_iec559;
static const bool is_bounded;
static const bool is_modulo;
static const bool traps;
static const bool tinyness_before;
static const float_round_style round_style;
};
template <typename T> const bool etl_integral_type<T>::is_specialized = true;
template <typename T> const int etl_integral_type<T>::digits = (CHAR_BIT * sizeof(T)) - (etl::is_signed<T>::value ? 1 : 0);
template <typename T> const int etl_integral_type<T>::digits10 = ETL_LOG2(digits);
template <typename T> const int etl_integral_type<T>::max_digits10 = 0;
template <typename T> const bool etl_integral_type<T>::is_signed = etl::is_signed<T>::value;
template <typename T> const bool etl_integral_type<T>::is_integer = true;
template <typename T> const bool etl_integral_type<T>::is_exact = true;
template <typename T> const int etl_integral_type<T>::radix = 2;
template <typename T> const int etl_integral_type<T>::min_exponent = 0;
template <typename T> const int etl_integral_type<T>::min_exponent10 = 0;
template <typename T> const int etl_integral_type<T>::max_exponent = 0;
template <typename T> const int etl_integral_type<T>::max_exponent10 = 0;
template <typename T> const bool etl_integral_type<T>::has_infinity = false;
template <typename T> const bool etl_integral_type<T>::has_quiet_NaN = false;
template <typename T> const bool etl_integral_type<T>::has_signaling_NaN = false;
template <typename T> const float_denorm_style etl_integral_type<T>::has_denorm = denorm_absent;
template <typename T> const bool etl_integral_type<T>::has_denorm_loss = false;
template <typename T> const bool etl_integral_type<T>::is_iec559 = false;
template <typename T> const bool etl_integral_type<T>::is_bounded = true;
template <typename T> const bool etl_integral_type<T>::is_modulo = etl::is_unsigned<T>::value;
template <typename T> const bool etl_integral_type<T>::traps = false;
template <typename T> const bool etl_integral_type<T>::tinyness_before = false;
template <typename T> const float_round_style etl_integral_type<T>::round_style = round_toward_zero;
template <typename T>
class etl_floating_point_type
{
public:
static const bool is_specialized;
static const bool is_signed;
static const bool is_integer;
static const bool is_exact;
static const int radix;
static const bool has_infinity;
static const bool has_quiet_NaN;
static const bool has_signaling_NaN;
static const float_denorm_style has_denorm;
static const bool has_denorm_loss;
static const bool is_iec559;
static const bool is_bounded;
static const bool is_modulo;
static ETL_CONSTEXPR T round_error() { return T(0.5); }
static ETL_CONSTEXPR T infinity() { return 0; }
static ETL_CONSTEXPR T quiet_NaN() { return 0; }
static ETL_CONSTEXPR T signaling_NaN() { return 0; }
static const bool traps;
static const bool tinyness_before;
static const float_round_style round_style;
};
template <typename T> const bool etl_floating_point_type<T>::is_specialized = true;
template <typename T> const bool etl_floating_point_type<T>::is_signed = true;
template <typename T> const bool etl_floating_point_type<T>::is_integer = false;
template <typename T> const bool etl_floating_point_type<T>::is_exact = false;
template <typename T> const int etl_floating_point_type<T>::radix = 2;
template <typename T> const bool etl_floating_point_type<T>::has_infinity = false;
template <typename T> const bool etl_floating_point_type<T>::has_quiet_NaN = false;
template <typename T> const bool etl_floating_point_type<T>::has_signaling_NaN = false;
template <typename T> const float_denorm_style etl_floating_point_type<T>::has_denorm = denorm_present;
template <typename T> const bool etl_floating_point_type<T>::has_denorm_loss = true;
template <typename T> const bool etl_floating_point_type<T>::is_iec559 = true;
template <typename T> const bool etl_floating_point_type<T>::is_bounded = true;
template <typename T> const bool etl_floating_point_type<T>::is_modulo = false;
template <typename T> const bool etl_floating_point_type<T>::traps = false;
template <typename T> const bool etl_floating_point_type<T>::tinyness_before = true;
template <typename T> const float_round_style etl_floating_point_type<T>::round_style = round_to_nearest;
template<class T>
class numeric_limits;
template<>
class numeric_limits<bool>
{
public:
static const bool is_specialized;
static ETL_CONSTEXPR bool min() { return false; }
static ETL_CONSTEXPR bool max() { return true; }
static ETL_CONSTEXPR bool lowest() { return false; }
static const int digits;
static const int digits10;
static const int max_digits10;
static const bool is_signed;
static const bool is_integer;
static const bool is_exact;
static const int radix;
static const bool epsilon() { return 0; }
static const bool round_error() { return 0; }
static const int min_exponent;
static const int min_exponent10;
static const int max_exponent;
static const int max_exponent10;
static const bool has_infinity;
static const bool has_quiet_NaN;
static const bool has_signaling_NaN;
static const float_denorm_style has_denorm;
static const bool has_denorm_loss;
static ETL_CONSTEXPR bool infinity() { return 0; }
static ETL_CONSTEXPR bool quiet_NaN() { return 0; }
static ETL_CONSTEXPR bool signaling_NaN() { return 0; }
static ETL_CONSTEXPR bool denorm_min() { return 0; }
static const bool is_iec559;
static const bool is_bounded;
static const bool is_modulo;
static const bool traps;
static const bool tinyness_before;
static const float_round_style round_style;
};
const bool numeric_limits<bool>::is_specialized = true;
const int numeric_limits<bool>::digits = 1;
const int numeric_limits<bool>::digits10 = 0;
const int numeric_limits<bool>::max_digits10 = 0;
const bool numeric_limits<bool>::is_signed = false;
const bool numeric_limits<bool>::is_integer = true;
const bool numeric_limits<bool>::is_exact = true;
const int numeric_limits<bool>::radix = 2;
const int numeric_limits<bool>::min_exponent = 0;
const int numeric_limits<bool>::min_exponent10 = 0;
const int numeric_limits<bool>::max_exponent = 0;
const int numeric_limits<bool>::max_exponent10 = 0;
const bool numeric_limits<bool>::has_infinity = false;
const bool numeric_limits<bool>::has_quiet_NaN = false;
const bool numeric_limits<bool>::has_signaling_NaN = false;
const float_denorm_style numeric_limits<bool>::has_denorm = denorm_absent;
const bool numeric_limits<bool>::has_denorm_loss = false;
const bool numeric_limits<bool>::is_iec559 = false;
const bool numeric_limits<bool>::is_bounded = true;
const bool numeric_limits<bool>::is_modulo = false;
const bool numeric_limits<bool>::traps = false;
const bool numeric_limits<bool>::tinyness_before = false;
const float_round_style numeric_limits<bool>::round_style = round_toward_zero;
template<>
class numeric_limits<char> : public etl_integral_type<char>
{
public:
static ETL_CONSTEXPR char min() { return CHAR_MIN; }
static ETL_CONSTEXPR char max() { return CHAR_MAX; }
static ETL_CONSTEXPR char lowest() { return CHAR_MIN; }
};
template<>
class numeric_limits<unsigned char> : public etl_integral_type<unsigned char>
{
public:
static ETL_CONSTEXPR unsigned char min() { return 0; }
static ETL_CONSTEXPR unsigned char max() { return UCHAR_MAX; }
static ETL_CONSTEXPR unsigned char lowest() { return 0; }
};
template<>
class numeric_limits<signed char> : public etl_integral_type<signed char>
{
public:
static ETL_CONSTEXPR signed char min() { return SCHAR_MIN; }
static ETL_CONSTEXPR signed char max() { return SCHAR_MAX; }
static ETL_CONSTEXPR signed char lowest() { return SCHAR_MIN; }
};
template<>
class numeric_limits<char16_t> : public etl_integral_type<char16_t>
{
public:
static ETL_CONSTEXPR char16_t min() { return 0; }
static ETL_CONSTEXPR char16_t max() { return UINT_LEAST16_MAX; }
static ETL_CONSTEXPR char16_t lowest() { return 0; }
};
template<>
class numeric_limits<char32_t> : public etl_integral_type<char32_t>
{
public:
static ETL_CONSTEXPR char32_t min() { return 0; }
static ETL_CONSTEXPR char32_t max() { return UINT_LEAST32_MAX; }
static ETL_CONSTEXPR char32_t lowest() { return 0; }
};
template<>
class numeric_limits<wchar_t> : public etl_integral_type<wchar_t>
{
public:
static ETL_CONSTEXPR wchar_t min() { return WCHAR_MIN; }
static ETL_CONSTEXPR wchar_t max() { return WCHAR_MAX; }
static ETL_CONSTEXPR wchar_t lowest() { return WCHAR_MIN; }
};
template<>
class numeric_limits<short> : public etl_integral_type<short>
{
public:
static ETL_CONSTEXPR short min() { return SHRT_MIN; }
static ETL_CONSTEXPR short max() { return SHRT_MAX; }
static ETL_CONSTEXPR short lowest() { return SHRT_MIN; }
};
template<>
class numeric_limits<unsigned short> : public etl_integral_type<unsigned short>
{
public:
static ETL_CONSTEXPR unsigned short min() { return 0; }
static ETL_CONSTEXPR unsigned short max() { return USHRT_MAX; }
static ETL_CONSTEXPR unsigned short lowest() { return 0; }
};
template<>
class numeric_limits<int> : public etl_integral_type<int>
{
public:
static ETL_CONSTEXPR int min() { return INT_MIN; }
static ETL_CONSTEXPR int max() { return INT_MAX; }
static ETL_CONSTEXPR int lowest() { return INT_MIN; }
};
template<>
class numeric_limits<unsigned int> : public etl_integral_type<unsigned int>
{
public:
static ETL_CONSTEXPR unsigned int min() { return 0; }
static ETL_CONSTEXPR unsigned int max() { return UINT_MAX; }
static ETL_CONSTEXPR unsigned int lowest() { return 0; }
};
template<>
class numeric_limits<long> : public etl_integral_type<long>
{
public:
static ETL_CONSTEXPR long min() { return LONG_MIN; }
static ETL_CONSTEXPR long max() { return LONG_MAX; }
static ETL_CONSTEXPR long lowest() { return LONG_MIN; }
};
template<>
class numeric_limits<unsigned long> : public etl_integral_type<unsigned long>
{
public:
static ETL_CONSTEXPR unsigned long min() { return 0; }
static ETL_CONSTEXPR unsigned long max() { return ULONG_MAX; }
static ETL_CONSTEXPR unsigned long lowest() { return 0; }
};
template<>
class numeric_limits<long long> : public etl_integral_type<long long>
{
public:
static ETL_CONSTEXPR long long min() { return LLONG_MIN; }
static ETL_CONSTEXPR long long max() { return LLONG_MAX; }
static ETL_CONSTEXPR long long lowest() { return LLONG_MIN; }
};
template<>
class numeric_limits<unsigned long long> : public etl_integral_type<unsigned long long>
{
public:
static ETL_CONSTEXPR unsigned long long min() { return 0; }
static ETL_CONSTEXPR unsigned long long max() { return ULLONG_MAX; }
static ETL_CONSTEXPR unsigned long long lowest() { return 0; }
};
template<>
class numeric_limits<float> : public etl_floating_point_type<float>
{
public:
static ETL_CONSTEXPR float min() { return FLT_MIN; }
static ETL_CONSTEXPR float max() { return FLT_MAX; }
static ETL_CONSTEXPR float lowest() { return -FLT_MAX; }
static ETL_CONSTEXPR float epsilon() { return FLT_EPSILON; }
static ETL_CONSTEXPR float denorm_min() { return FLT_MIN; }
static const int digits;
static const int digits10;
static const int max_digits10;
static const int min_exponent;
static const int min_exponent10;
static const int max_exponent;
static const int max_exponent10;
};
const int numeric_limits<float>::digits = FLT_MANT_DIG;
const int numeric_limits<float>::max_digits10 = ETL_LOG2(FLT_MANT_DIG) + 2;
const int numeric_limits<float>::digits10 = FLT_DIG;
const int numeric_limits<float>::min_exponent = FLT_MIN_EXP;
const int numeric_limits<float>::min_exponent10 = FLT_MIN_10_EXP;
const int numeric_limits<float>::max_exponent = FLT_MAX_EXP;
const int numeric_limits<float>::max_exponent10 = FLT_MAX_10_EXP;
template<>
class numeric_limits<double> : public etl_floating_point_type<double>
{
public:
static ETL_CONSTEXPR double min() { return DBL_MIN; }
static ETL_CONSTEXPR double max() { return DBL_MAX; }
static ETL_CONSTEXPR double lowest() { return -DBL_MAX; }
static ETL_CONSTEXPR double epsilon() { return DBL_EPSILON; }
static ETL_CONSTEXPR double denorm_min() { return DBL_MIN; }
static const int digits;
static const int digits10;
static const int max_digits10;
static const int min_exponent;
static const int min_exponent10;
static const int max_exponent;
static const int max_exponent10;
};
const int numeric_limits<double>::digits = DBL_MANT_DIG;
const int numeric_limits<double>::max_digits10 = ETL_LOG2(DBL_MANT_DIG) + 2;
const int numeric_limits<double>::digits10 = DBL_DIG;
const int numeric_limits<double>::min_exponent = DBL_MIN_EXP;
const int numeric_limits<double>::min_exponent10 = DBL_MIN_10_EXP;
const int numeric_limits<double>::max_exponent = DBL_MAX_EXP;
const int numeric_limits<double>::max_exponent10 = DBL_MAX_10_EXP;
template<>
class numeric_limits<long double> : public etl_floating_point_type<long double>
{
public:
static ETL_CONSTEXPR long double min() { return LDBL_MIN; }
static ETL_CONSTEXPR long double max() { return LDBL_MAX; }
static ETL_CONSTEXPR long double lowest() { return -LDBL_MAX; }
static ETL_CONSTEXPR long double epsilon() { return LDBL_EPSILON; }
static ETL_CONSTEXPR long double denorm_min() { return LDBL_MIN; }
static const int digits;
static const int digits10;
static const int max_digits10;
static const int min_exponent;
static const int min_exponent10;
static const int max_exponent;
static const int max_exponent10;
};
const int numeric_limits<long double>::digits = LDBL_MANT_DIG;
const int numeric_limits<long double>::max_digits10 = ETL_LOG2(LDBL_MANT_DIG) + 2;
const int numeric_limits<long double>::digits10 = LDBL_DIG;
const int numeric_limits<long double>::min_exponent = LDBL_MIN_EXP;
const int numeric_limits<long double>::min_exponent10 = LDBL_MIN_10_EXP;
const int numeric_limits<long double>::max_exponent = LDBL_MAX_EXP;
const int numeric_limits<long double>::max_exponent10 = LDBL_MAX_10_EXP;
}
#endif