mirror of
https://gitee.com/mirrors_PX4/PX4-Autopilot.git
synced 2026-07-04 08:10:34 +08:00
patacongo
23e8d5321a
git-svn-id: http://svn.code.sf.net/p/nuttx/code/trunk@5300 42af7a65-404d-4744-a932-0658087f49c3
821 lines
19 KiB
Plaintext
821 lines
19 KiB
Plaintext
/* 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
|
|
|
|
#warning limits header is nowhere complete or accurate
|
|
|
|
#pragma GCC visibility push(default)
|
|
|
|
extern "C++"
|
|
{
|
|
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?
|
|
};
|
|
|
|
} // namespace
|
|
} // extern "C++"
|
|
|
|
#pragma GCC visibility pop
|
|
|
|
#endif
|