Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

665 lines (592 sloc) 18.519 kb
/* Copyright (C) 2006 Garrett A. Kajmowicz
This file is part of the uClibc++ Library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <climits>
#ifndef __STD_HEADER_LIMITS
#define __STD_HEADER_LIMITS 1
// Yeah, yeah we know
//#warning limits header is nowhere complete or accurate
#pragma GCC visibility push(default)
namespace std{
enum float_round_style{
round_indeterminate =-1,
round_toward_zero = 0,
round_to_nearest = 1,
round_toward_infinity = 2,
round_toward_neg_infinity = 3
};
template <int bitsize> struct __bits_to_base_10{
static const int size = -1;
};
template <> struct __bits_to_base_10<7>{
static const int size = 2;
};
template <> struct __bits_to_base_10<8>{
static const int size = 2;
};
template <> struct __bits_to_base_10<9>{
static const int size = 2;
};
template <> struct __bits_to_base_10<10>{
static const int size = 3;
};
template <> struct __bits_to_base_10<15>{
static const int size = 4;
};
template <> struct __bits_to_base_10<16>{
static const int size = 4;
};
template <> struct __bits_to_base_10<17>{
static const int size = 5;
};
template <> struct __bits_to_base_10<18>{
static const int size = 5;
};
template <> struct __bits_to_base_10<31>{
static const int size = 9;
};
template <> struct __bits_to_base_10<32>{
static const int size = 9;
};
template <> struct __bits_to_base_10<35>{
static const int size = 10;
};
template <> struct __bits_to_base_10<36>{
static const int size = 10;
};
template <> struct __bits_to_base_10<63>{
static const int size = 18;
};
template <> struct __bits_to_base_10<64>{
static const int size = 19;
};
template <> struct __bits_to_base_10<71>{
static const int size = 21;
};
template <> struct __bits_to_base_10<72>{
static const int size = 21;
};
template <> struct __bits_to_base_10<79>{
static const int size = 23;
};
template <> struct __bits_to_base_10<80>{
static const int size = 24;
};
template <> struct __bits_to_base_10<127>{
static const int size = 38;
};
template <> struct __bits_to_base_10<128>{
static const int size = 38;
};
template <class T> class numeric_limits {
public:
// General -- meaningful for all specializations.
static const bool is_specialized = false;
static T min();
static T max();
static const int radix;
static const int digits;
static const int digits10;
static const bool is_signed;
static const bool is_integer;
static const bool is_exact;
static const bool traps;
static const bool is_modulo;
static const bool is_bounded;
// Floating point specific.
static T epsilon();
static T round_error();
static const int min_exponent10;
static const int max_exponent10;
static const int min_exponent;
static const int max_exponent;
static const bool has_infinity;
static const bool has_quiet_NaN;
static const bool has_signaling_NaN;
static const bool is_iec559;
static const bool has_denorm;
static const bool tinyness_before;
static const float_round_style round_style;
static T denorm_min();
static T infinity();
static T quiet_NaN();
static T signaling_NaN();
};
template <> class numeric_limits<bool> {
public:
typedef bool T;
// General -- meaningful for all specializations.
static const bool is_specialized = true;
static T min(){
return false;
}
static T max(){
return true;
}
static const int radix = 2;
static const int digits = 1;
static const int digits10 = 0;
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
static const bool traps = false;
static const bool is_modulo = false;
static const bool is_bounded = true;
// Floating point specific.
static T epsilon(){
return 0;
}
static T round_error(){
return 0;
}
static const int min_exponent10 = 0;
static const int max_exponent10 = 0;
static const int min_exponent = 0;
static const int max_exponent = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const bool is_iec559 = false;
static const bool has_denorm = false;
static const bool tinyness_before = false;
static const float_round_style round_style = round_indeterminate;
static T denorm_min();
static T infinity();
static T quiet_NaN();
static T signaling_NaN();
};
template <> class numeric_limits<unsigned char> {
public:
typedef unsigned char T;
// General -- meaningful for all specializations.
static const bool is_specialized = true;
static T min(){
return 0;
}
static T max(){
return UCHAR_MAX;
}
static const int radix = 2;
static const int digits = CHAR_BIT;
static const int digits10 = __bits_to_base_10<digits>::size;
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
static const bool traps = false;
static const bool is_modulo = true;
static const bool is_bounded = true;
// Floating point specific.
static T epsilon(){
return 0;
}
static T round_error(){
return 0;
}
static const int min_exponent10 = 0;
static const int max_exponent10 = 0;
static const int min_exponent = 0;
static const int max_exponent = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const bool is_iec559 = false;
static const bool has_denorm = false;
static const bool tinyness_before = false;
static const float_round_style round_style = round_indeterminate;
static T denorm_min();
static T infinity();
static T quiet_NaN();
static T signaling_NaN();
};
template <> class numeric_limits<signed char> {
public:
typedef signed char T;
// General -- meaningful for all specializations.
static const bool is_specialized = true;
static T min(){
return SCHAR_MIN;
}
static T max(){
return SCHAR_MAX;
}
static const int radix = 2;
static const int digits = CHAR_BIT - 1;
static const int digits10 = __bits_to_base_10<digits>::size;
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
static const bool traps = false;
static const bool is_modulo = true;
static const bool is_bounded = true;
// Floating point specific.
static T epsilon(){
return 0;
}
static T round_error(){
return 0;
}
static const int min_exponent10 = 0;
static const int max_exponent10 = 0;
static const int min_exponent = 0;
static const int max_exponent = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const bool is_iec559 = false;
static const bool has_denorm = false;
static const bool tinyness_before = false;
static const float_round_style round_style = round_indeterminate;
static T denorm_min();
static T infinity();
static T quiet_NaN();
static T signaling_NaN();
};
template <> class numeric_limits<char> {
public:
typedef char T;
// General -- meaningful for all specializations.
static const bool is_specialized = true;
static T min(){
return CHAR_MIN;
}
static T max(){
return CHAR_MAX;
}
static const int radix = 2;
static const int digits = (CHAR_MIN != 0) ? CHAR_BIT - 1 : CHAR_BIT;
static const int digits10 = __bits_to_base_10<digits>::size;
static const bool is_signed = (CHAR_MIN != 0);
static const bool is_integer = true;
static const bool is_exact = true;
static const bool traps = false;
static const bool is_modulo = true;
static const bool is_bounded = true;
// Floating point specific.
static T epsilon(){
return 0;
}
static T round_error(){
return 0;
}
static const int min_exponent10 = 0;
static const int max_exponent10 = 0;
static const int min_exponent = 0;
static const int max_exponent = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const bool is_iec559 = false;
static const bool has_denorm = false;
static const bool tinyness_before = false;
static const float_round_style round_style = round_indeterminate;
static T denorm_min();
static T infinity();
static T quiet_NaN();
static T signaling_NaN();
};
template <> class numeric_limits<unsigned short> {
public:
typedef unsigned short T;
// General -- meaningful for all specializations.
static const bool is_specialized = true;
static T min(){
return 0;
}
static T max(){
return USHRT_MAX;
}
static const int radix = 2;
static const int digits = CHAR_BIT * sizeof(T);
static const int digits10 = __bits_to_base_10<digits>::size;
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
static const bool traps = false;
static const bool is_modulo = true;
static const bool is_bounded = true;
// Floating point specific.
static T epsilon(){
return 0;
}
static T round_error(){
return 0;
}
static const int min_exponent10 = 0;
static const int max_exponent10 = 0;
static const int min_exponent = 0;
static const int max_exponent = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const bool is_iec559 = false;
static const bool has_denorm = false;
static const bool tinyness_before = false;
static const float_round_style round_style = round_indeterminate;
static T denorm_min();
static T infinity();
static T quiet_NaN();
static T signaling_NaN();
};
template <> class numeric_limits<signed short> {
public:
typedef signed short T;
// General -- meaningful for all specializations.
static const bool is_specialized = true;
static T min(){
return SHRT_MIN;
}
static T max(){
return SHRT_MAX;
}
static const int radix = 2;
static const int digits = CHAR_BIT * sizeof(T);
static const int digits10 = __bits_to_base_10<digits>::size;
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
static const bool traps = false;
static const bool is_modulo = true;
static const bool is_bounded = true;
// Floating point specific.
static T epsilon(){
return 0;
}
static T round_error(){
return 0;
}
static const int min_exponent10 = 0;
static const int max_exponent10 = 0;
static const int min_exponent = 0;
static const int max_exponent = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const bool is_iec559 = false;
static const bool has_denorm = false;
static const bool tinyness_before = false;
static const float_round_style round_style = round_indeterminate;
static T denorm_min();
static T infinity();
static T quiet_NaN();
static T signaling_NaN();
};
template <> class numeric_limits<unsigned int> {
public:
typedef unsigned int T;
// General -- meaningful for all specializations.
static const bool is_specialized = true;
static T min(){
return 0;
}
static T max(){
return UINT_MAX;
}
static const int radix = 2;
static const int digits = CHAR_BIT * sizeof(T);
static const int digits10 = __bits_to_base_10<digits>::size;
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
static const bool traps = false;
static const bool is_modulo = true;
static const bool is_bounded = true;
// Floating point specific.
static T epsilon(){
return 0;
}
static T round_error(){
return 0;
}
static const int min_exponent10 = 0;
static const int max_exponent10 = 0;
static const int min_exponent = 0;
static const int max_exponent = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const bool is_iec559 = false;
static const bool has_denorm = false;
static const bool tinyness_before = false;
static const float_round_style round_style = round_indeterminate;
static T denorm_min();
static T infinity();
static T quiet_NaN();
static T signaling_NaN();
};
template <> class numeric_limits<signed int> {
public:
typedef signed int T;
// General -- meaningful for all specializations.
static const bool is_specialized = true;
static T min(){
return INT_MIN;
}
static T max(){
return INT_MAX;
}
static const int radix = 2;
static const int digits = CHAR_BIT * sizeof(T);
static const int digits10 = __bits_to_base_10<digits>::size;
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
static const bool traps = false;
static const bool is_modulo = true;
static const bool is_bounded = true;
// Floating point specific.
static T epsilon(){
return 0;
}
static T round_error(){
return 0;
}
static const int min_exponent10 = 0;
static const int max_exponent10 = 0;
static const int min_exponent = 0;
static const int max_exponent = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const bool is_iec559 = false;
static const bool has_denorm = false;
static const bool tinyness_before = false;
static const float_round_style round_style = round_indeterminate;
static T denorm_min();
static T infinity();
static T quiet_NaN();
static T signaling_NaN();
};
template <> class numeric_limits<unsigned long int> {
public:
typedef unsigned long int T;
// General -- meaningful for all specializations.
static const bool is_specialized = true;
static T min(){
return 0;
}
static T max(){
return ULONG_MAX;
}
static const int radix = 2;
static const int digits = CHAR_BIT * sizeof(T);
static const int digits10 = __bits_to_base_10<digits>::size;
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
static const bool traps = false;
static const bool is_modulo = true;
static const bool is_bounded = true;
// Floating point specific.
static T epsilon(){
return 0;
}
static T round_error(){
return 0;
}
static const int min_exponent10 = 0;
static const int max_exponent10 = 0;
static const int min_exponent = 0;
static const int max_exponent = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const bool is_iec559 = false;
static const bool has_denorm = false;
static const bool tinyness_before = false;
static const float_round_style round_style = round_indeterminate;
static T denorm_min();
static T infinity();
static T quiet_NaN();
static T signaling_NaN();
};
template <> class numeric_limits<signed long int> {
public:
typedef signed long int T;
// General -- meaningful for all specializations.
static const bool is_specialized = true;
static T min(){
return LONG_MIN;
}
static T max(){
return LONG_MAX;
}
static const int radix = 2;
static const int digits = CHAR_BIT * sizeof(T);
static const int digits10 = __bits_to_base_10<digits>::size;
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
static const bool traps = false;
static const bool is_modulo = true;
static const bool is_bounded = true;
// Floating point specific.
static T epsilon(){
return 0;
}
static T round_error(){
return 0;
}
static const int min_exponent10 = 0;
static const int max_exponent10 = 0;
static const int min_exponent = 0;
static const int max_exponent = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const bool is_iec559 = false;
static const bool has_denorm = false;
static const bool tinyness_before = false;
static const float_round_style round_style = round_indeterminate;
static T denorm_min();
static T infinity();
static T quiet_NaN();
static T signaling_NaN();
};
template <> class numeric_limits<double> {
public:
typedef double numeric_type;
static const bool is_specialized = true;
static numeric_type min () { return __DBL_MIN__; }
static numeric_type max () { return __DBL_MAX__; }
static const int radix = __FLT_RADIX__;
static const int digits = __DBL_MANT_DIG__;
static const int digits10 = __DBL_DIG__;
static const bool is_signed = true;
static const bool is_integer = false;
static const bool is_exact = false;
static const bool traps = false; // this is a guess
static const bool is_modulo = false;
static const bool is_bounded = true;
// Floating point specific.
static numeric_type epsilon () { return __DBL_EPSILON__; }
static numeric_type round_error () { return 0.5; }
static const int min_exponent10 = -1; //How do I properly get this?
static const int max_exponent10 = -1; //How do I properly get this?
static const int min_exponent = -1; //How do I properly get this?
static const int max_exponent = -1; //How do I properly get this?
static const bool has_infinity = false; //I don't know, so until I can find out, I'm saying no
static const bool has_quiet_NaN = false; //I don't know, so until I can find out, I'm saying no
static const bool has_signaling_NaN = false; //I don't know, so until I can find out, I'm saying no
static const bool has_denorm = false; //I don't know, so until I can find out, I'm saying no
static const bool is_iec559 = false; //I don't know, so until I can find out, I'm saying no
static const bool tinyness_before = false; // more questions
static const float_round_style round_style = round_to_nearest; // more questions
static numeric_type denorm_min () { return -1; } //How do I properly get this?
static numeric_type infinity () { return -1; } //How do I properly get this?
static numeric_type quiet_NaN () { return -1; } //How do I properly get this?
static numeric_type signaling_NaN () { return -1; } //How do I properly get this?
};
}
#pragma GCC visibility pop
#endif
Jump to Line
Something went wrong with that request. Please try again.