numeric_limits.hpp

Go to the documentation of this file.

 
/*****************************************************************************
** Ifdefs
*****************************************************************************/
 
#ifndef ECL_TYPE_TRAITS_NUMERIC_LIMITS_HPP_
#define ECL_TYPE_TRAITS_NUMERIC_LIMITS_HPP_
 
/*****************************************************************************
** Includes
*****************************************************************************/
 
#include <limits>
#include <climits>
#include <ecl/config/portable_types.hpp>
#include "macros.hpp"
 
/*****************************************************************************
** Namespaces
*****************************************************************************/
 
namespace ecl {
 
/*****************************************************************************
** Parent Template
*****************************************************************************/
template <typename T>
class ecl_type_traits_PUBLIC numeric_limits : public std::numeric_limits<T> {
public:
        numeric_limits() {}
private:
};
 
/*****************************************************************************
** Specialisations
*****************************************************************************/
template <>
class ecl_type_traits_PUBLIC numeric_limits<char> : public std::numeric_limits<char> {
public:
        static const char one = 1;
        static const uint16 bits = ECL_SIZE_OF_CHAR*8;
        static const uint16 bytes = ECL_SIZE_OF_CHAR;
        static const char minimum = CHAR_MIN;
        static const char maximum = CHAR_MAX;
 
        typedef float Precision;
        static const Precision dummy_precision;
};
 
template <>
class ecl_type_traits_PUBLIC numeric_limits<unsigned char> : public std::numeric_limits<unsigned char> {
public:
        static const unsigned char one = 1U;
        static const uint16 bits = ECL_SIZE_OF_CHAR*8;
        static const uint16 bytes = ECL_SIZE_OF_CHAR;
        static const unsigned char minimum = 0U;
        static const unsigned char maximum = UCHAR_MAX;
 
        typedef float Precision;
        static const Precision dummy_precision;
};
 
template <>
class ecl_type_traits_PUBLIC numeric_limits<short> : public std::numeric_limits<short> {
public:
        static const short one = 1;
        static const uint16 bits = ECL_SIZE_OF_SHORT*8;
        static const uint16 bytes = ECL_SIZE_OF_SHORT;
        static const short minimum = SHRT_MIN;
        static const short maximum = SHRT_MAX;
 
        typedef float Precision;
        static const Precision dummy_precision;
};
 
template <>
class ecl_type_traits_PUBLIC numeric_limits<unsigned short> : public std::numeric_limits<unsigned short> {
public:
        static const unsigned short one = 1U;
        static const uint16 bits = ECL_SIZE_OF_SHORT*8;
        static const uint16 bytes = ECL_SIZE_OF_SHORT;
        static const unsigned short minimum = 0U;
        static const unsigned short maximum = USHRT_MAX;
 
        typedef float Precision;
        static const Precision dummy_precision;
};
 
template <>
class ecl_type_traits_PUBLIC numeric_limits<int> : public std::numeric_limits<int> {
public:
        static const int one = 1;
        static const uint16 bits = ECL_SIZE_OF_INT*8;
        static const uint16 bytes = ECL_SIZE_OF_INT;
        static const int minimum = INT_MIN;
        static const int maximum = INT_MAX;
 
        typedef float Precision;
        static const Precision dummy_precision;
};
 
template <>
class ecl_type_traits_PUBLIC numeric_limits<unsigned int> : public std::numeric_limits<unsigned int> {
public:
        static const unsigned int one = 1U;
        static const uint16 bits = ECL_SIZE_OF_INT*8;
        static const uint16 bytes = ECL_SIZE_OF_INT;
        static const unsigned int minimum = 0U;
        static const unsigned int maximum = UINT_MAX;
 
        typedef float Precision;
        static const Precision dummy_precision;
};
 
 
template <>
class ecl_type_traits_PUBLIC numeric_limits<long> : public std::numeric_limits<long> {
public:
        static const long one = 1L;
        static const uint16 bits = ECL_SIZE_OF_LONG*8;
        static const uint16 bytes = ECL_SIZE_OF_LONG;
        static const long minimum = LONG_MIN;
        static const long maximum = LONG_MAX;
 
        typedef float Precision;
        static const Precision dummy_precision;
};
 
template <>
class ecl_type_traits_PUBLIC numeric_limits<unsigned long> : public std::numeric_limits<unsigned long> {
public:
        static const unsigned long one = 1UL;
        static const uint16 bits = ECL_SIZE_OF_LONG*8;
        static const uint16 bytes = ECL_SIZE_OF_LONG;
        static const unsigned long minimum = 0UL;
        static const unsigned long maximum = ULONG_MAX;
 
        typedef float Precision;
        static const Precision dummy_precision;
};
 
template <>
class ecl_type_traits_PUBLIC numeric_limits<long long> : public std::numeric_limits<long long> {
public:
        static const long long one = 1LL;
        static const uint16 bits = ECL_SIZE_OF_LONG_LONG*8;
        static const uint16 bytes = ECL_SIZE_OF_LONG_LONG;
        static const long long minimum = LLONG_MIN;
        static const long long maximum = LLONG_MAX;
 
        typedef float Precision;
        static const Precision dummy_precision;
};
 
template <>
class ecl_type_traits_PUBLIC numeric_limits<unsigned long long> : public std::numeric_limits<unsigned long long> {
public:
        static const unsigned long long one = 1ULL;
        static const uint16 bits = ECL_SIZE_OF_LONG_LONG*8;
        static const uint16 bytes = ECL_SIZE_OF_LONG_LONG;
        static const unsigned long long minimum = 0ULL;
        static const unsigned long long maximum = ULLONG_MAX;
 
        typedef float Precision;
        static const Precision dummy_precision;
};
 
template <>
class ecl_type_traits_PUBLIC numeric_limits<float> : public std::numeric_limits<float> {
public:
        static const uint16 bits = ECL_SIZE_OF_FLOAT*8;
        static const uint16 bytes = ECL_SIZE_OF_FLOAT;
 
        typedef float Precision; 
        static const float dummy_precision; 
        static const float minimum;
        static const float maximum;
};
 
template <>
class ecl_type_traits_PUBLIC numeric_limits<double> : public std::numeric_limits<double> {
public:
        static const uint16 bits = ECL_SIZE_OF_DOUBLE*8;
        static const uint16 bytes = ECL_SIZE_OF_DOUBLE;
 
        typedef double Precision; 
        static const double dummy_precision; 
        static const double minimum;
        static const double maximum;
};
 
template <>
class ecl_type_traits_PUBLIC numeric_limits<long double> : public std::numeric_limits<long double> {
public:
        static const uint16 bits = ECL_SIZE_OF_LONG_DOUBLE*8;
        static const uint16 bytes = ECL_SIZE_OF_LONG_DOUBLE;
 
        typedef long double Precision; 
        static const long double dummy_precision; 
        static const long double minimum;
        static const long double maximum;
};
 
 
} // namespace ecl
 
#endif /* ECL_TYPE_TRAITS_NUMERIC_LIMITS_HPP_ */