| // computing infinity and NaN's |
| |
| /*************************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the License); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| * |
| * Copyright 1999-2007 Rogue Wave Software, Inc. |
| * |
| **************************************************************************/ |
| |
| #include <stdio.h> // for printf() |
| #include <string.h> // for memset() |
| |
| #include "config.h" |
| #include "float_defs.h" // for FLT_MIN, DBL_MIN, LDBL_MIN |
| |
| /*************************************************************************** |
| * |
| * IEEE 754 specifies the following formats: |
| * |
| * K+1 exponent bits: 1 - 2^K < k < 2^K |
| * N significant bits: -2^N < n < 2^N |
| * |
| * +-----------+-----+-----+-----+ |
| * | FORMAT |BYTES|K + 1| N| |
| * +===========+=====+=====+=====+ |
| * | float| 4| 8| 24| |
| * +-----------+-----+-----+-----+ |
| * | double| 8| 11| 53| |
| * +-----------+-----+-----+-----+ |
| * |long double|>= 10|>= 15|>= 64| |
| * +-----------+-----+-----+-----+ |
| * | quad| 16| 15| 113| |
| * +-----------+-----+-----+-----+ |
| * |
| * +-----------+----+----------------+-------+-------------------+ |
| * |NUMBER TYPE|SIGN|K+1 bit EXPONENT|Nth BIT|N-1 bit SIGNIFICAND| |
| * +===========+====+================+=======+===================+ |
| * | NaN(s)| ? |binary 111...111| 1 | binary 1xxx...xxx | |
| * +-----------+----+----------------+-------+-------------------+ |
| * | SNaN(s)| ? |binary 111...111| 1 |nonzero 0xxx...xxx | |
| * +-----------+----+----------------+-------+-------------------+ |
| * | INF(s)| +/-|binary 111...111| 1 | 0 | |
| * +-----------+----+-------------- --+-------+-------------------+ |
| * | Normals| +/-| k - 1 + 2^K| 1 |n-2^(N-1) < 2^(N-1)| |
| * +-----------+----+----------------+-------+-------------------+ |
| * | Subnormals| +/-| 0| 0 | 0 < n < 2^(N-1)| |
| * +-----------+----+----------------+-------+-------------------+ |
| * | Zeros| +/-| 0| 0 | 0 | |
| * +-----------+----+----------------+-------+-------------------+ |
| * |
| **************************************************************************/ |
| |
| |
| // determine whether the architecture is little-endian or big-endian |
| enum endian { big_endian, little_endian }; |
| |
| static const int endian_test = 1; |
| |
| static const union { |
| const int *pi; |
| const char *pb; |
| } u = { &endian_test }; |
| |
| // adding zero below to work around an edg 2.44 bug (the compiler |
| // can't explicitly convert a bool expression to an enumeration) |
| static const endian e = endian (0 + !!*u.pb); |
| |
| /**************************************************************************/ |
| |
| // print out `size' bytes starting at data prefixed by `text' |
| static void print (const char *text, const void *data, unsigned size) |
| { |
| printf ("%s { ", text); |
| |
| const unsigned char *p = (const unsigned char*)data; |
| |
| for (unsigned i = 0; i != size; ++i) { |
| if (p[i]) |
| printf ("'\\x%x'", p[i]); |
| else |
| printf ("%d", p[i]); |
| if (i < size - 1) |
| printf (", "); |
| } |
| |
| printf (" }\n"); |
| } |
| |
| /**************************************************************************/ |
| |
| union flt_bits |
| { |
| char bits [sizeof (float)]; |
| float val; |
| |
| flt_bits () { memset (bits, 0, sizeof (bits)); } |
| }; |
| |
| static float flt_zero () |
| { |
| static float val = 0.0f; |
| |
| return val; |
| } |
| |
| static flt_bits flt_infinity () |
| { |
| flt_bits val; |
| |
| #ifdef _RWSTD_NO_DBL_TRAPS |
| |
| val.val = 1.0f / flt_zero (); |
| |
| // may need to negate to get a correct result |
| // i86 FP expressions appear to return a negative infinity |
| if (val.val < flt_zero ()) |
| val.val = -val.val; |
| |
| #else // if !defined (_RWSTD_NO_DBL_TRAPS) |
| |
| // floating point arithmetic traps |
| |
| // assume IEEE 754 floating point format |
| |
| if (e == big_endian) { |
| val.bits [0] = '\x7f'; |
| val.bits [1] = '\x80'; |
| val.bits [2] = '\0'; |
| val.bits [3] = '\0'; |
| } |
| else { |
| val.bits [0] = '\0'; |
| val.bits [1] = '\0'; |
| val.bits [2] = '\x80'; |
| val.bits [3] = '\x7f'; |
| } |
| |
| #endif // _RWSTD_NO_DBL_TRAPS |
| |
| return val; |
| } |
| |
| static flt_bits flt_qnan () |
| { |
| flt_bits val; |
| |
| #ifdef _RWSTD_NO_DBL_TRAPS |
| |
| val.val = flt_zero (); |
| |
| val.val /= flt_zero (); |
| |
| // val.val can be +qnan or -qnan |
| // clear sign bit |
| if (e == big_endian) { |
| val.bits [0] &= '\x7f'; |
| } |
| else { |
| val.bits [sizeof (val.val) - 1] &= '\x7f'; |
| } |
| |
| #else // if !defined (_RWSTD_NO_DBL_TRAPS) |
| |
| // floating point arithmetic traps |
| |
| // assume IEEE 754 floating point format |
| |
| if (e == big_endian) { |
| val.bits [0] = '\x7f'; |
| val.bits [1] = '\xc0'; |
| val.bits [2] = '\0'; |
| val.bits [3] = '\0'; |
| } |
| else { |
| val.bits [0] = '\0'; |
| val.bits [1] = '\0'; |
| val.bits [2] = '\xc0'; |
| val.bits [3] = '\x7f'; |
| } |
| |
| #endif // _RWSTD_NO_DBL_TRAPS |
| |
| return val; |
| } |
| |
| static flt_bits flt_snan () |
| { |
| flt_bits val; |
| |
| #ifdef _RWSTD_NO_DBL_TRAPS |
| |
| val = flt_infinity (); |
| |
| # if !defined (__hpux) |
| |
| // convert infinity into a signaling NAN (toggle any bit in signifcand) |
| if (e == little_endian) { |
| if (0.0f != val.val) |
| val.bits [0] |= 1; |
| } |
| else { |
| if (0.0f != val.val) |
| val.bits [sizeof (val.val) - 1] |= 1; |
| } |
| |
| # else // if defined (__hpux) |
| |
| // QNAN and SNAN on HP-UX are reversed... |
| |
| if (e == little_endian) { |
| if (0.0f != val.val) |
| val.bits [1] = '\xc0'; |
| } |
| else { |
| if (0.0f != val.val) |
| val.bits [sizeof val.val - 2] = '\xc0'; |
| } |
| |
| # endif // __hpux |
| |
| #else // if !defined (_RWSTD_NO_DBL_TRAPS) |
| |
| // floating point arithmetic traps |
| |
| // assume IEEE 754 floating point format |
| |
| if (e == big_endian) { |
| val.bits [0] = '\x7f'; |
| val.bits [1] = '\x80'; |
| val.bits [2] = '\0'; |
| val.bits [3] = '\x01'; |
| } |
| else { |
| val.bits [0] = '\x01'; |
| val.bits [1] = '\0'; |
| val.bits [2] = '\x80'; |
| val.bits [3] = '\x7f'; |
| } |
| |
| #endif // _RWSTD_NO_DBL_TRAPS |
| |
| return val; |
| } |
| |
| static flt_bits flt_denorm_min () |
| { |
| flt_bits val; |
| |
| #ifdef _RWSTD_NO_DBL_TRAPS |
| |
| // compute denorm min |
| for (volatile float tmp = 1.0f; tmp; tmp /= 2.0f) |
| val.val = tmp; |
| |
| if (FLT_MIN <= val.val) |
| val.val = 0.0f; |
| |
| #else |
| |
| // assume IEEE 754 floating point format |
| |
| if (e == big_endian) { |
| val.bits [0] = '\0'; |
| val.bits [1] = '\0'; |
| val.bits [2] = '\0'; |
| val.bits [3] = '\x01'; |
| } |
| else { |
| val.bits [0] = '\x01'; |
| val.bits [1] = '\0'; |
| val.bits [2] = '\0'; |
| val.bits [3] = '\0'; |
| } |
| |
| #endif // _RWSTD_NO_DBL_TRAPS |
| |
| return val; |
| } |
| |
| /**************************************************************************/ |
| |
| union dbl_bits |
| { |
| char bits [sizeof (double)]; |
| double val; |
| |
| dbl_bits () { memset (bits, 0, sizeof (bits)); } |
| }; |
| |
| static float dbl_zero () |
| { |
| static double val = 0.0; |
| |
| return val; |
| } |
| |
| static dbl_bits dbl_infinity () |
| { |
| dbl_bits val; |
| |
| #ifdef _RWSTD_NO_DBL_TRAPS |
| |
| val.val = 1.0 / dbl_zero (); |
| |
| // may need to negate to get a correct result |
| // i86 FP expressions appear to return a negative infinity |
| if (val.val < dbl_zero ()) |
| val.val = -val.val; |
| |
| #else // if !defined (_RWSTD_NO_DBL_TRAPS) |
| |
| // floating point arithmetic traps |
| |
| // assume IEEE 754 floating point format |
| |
| if (e == big_endian) { |
| val.bits [0] = '\x7f'; |
| val.bits [1] = '\xf0'; |
| val.bits [2] = '\0'; |
| val.bits [3] = '\0'; |
| val.bits [4] = '\0'; |
| val.bits [5] = '\0'; |
| val.bits [6] = '\0'; |
| val.bits [7] = '\0'; |
| } |
| else { |
| val.bits [0] = '\0'; |
| val.bits [1] = '\0'; |
| val.bits [2] = '\0'; |
| val.bits [3] = '\0'; |
| val.bits [4] = '\0'; |
| val.bits [5] = '\0'; |
| val.bits [6] = '\xf0'; |
| val.bits [7] = '\x7f'; |
| } |
| |
| #endif // _RWSTD_NO_DBL_TRAPS |
| |
| return val; |
| } |
| |
| static dbl_bits dbl_qnan () |
| { |
| dbl_bits val; |
| |
| #ifdef _RWSTD_NO_DBL_TRAPS |
| |
| val.val = dbl_zero (); |
| |
| val.val /= dbl_zero (); |
| |
| // val.val can be +qnan or -qnan |
| // clear sign bit |
| if (e == big_endian) { |
| val.bits [0] &= '\x7f'; |
| } |
| else { |
| val.bits [sizeof (val.val) - 1] &= '\x7f'; |
| } |
| |
| #else // if !defined (_RWSTD_NO_DBL_TRAPS) |
| |
| // floating point arithmetic traps |
| |
| // assume IEEE 754 floating point format |
| |
| if (e == big_endian) { |
| val.bits [0] = '\x7f'; |
| val.bits [1] = '\xf8'; |
| val.bits [2] = '\0'; |
| val.bits [3] = '\0'; |
| val.bits [4] = '\0'; |
| val.bits [5] = '\0'; |
| val.bits [6] = '\0'; |
| val.bits [7] = '\0'; |
| } |
| else { |
| val.bits [0] = '\0'; |
| val.bits [1] = '\0'; |
| val.bits [2] = '\0'; |
| val.bits [3] = '\0'; |
| val.bits [4] = '\0'; |
| val.bits [5] = '\0'; |
| val.bits [6] = '\xf8'; |
| val.bits [7] = '\x7f'; |
| } |
| |
| #endif // _RWSTD_NO_DBL_TRAPS |
| |
| return val; |
| } |
| |
| static dbl_bits dbl_snan () |
| { |
| dbl_bits val; |
| |
| #ifdef _RWSTD_NO_DBL_TRAPS |
| |
| val = dbl_infinity (); |
| |
| # if !defined (__hpux) |
| |
| // convert infinity into a signaling NAN (toggle any bit in signifcand) |
| if (e == little_endian) { |
| if (0.0 != val.val) |
| val.bits [0] |= 1; |
| } |
| else { |
| if (0.0 != val.val) |
| val.bits [sizeof val.val - 1] |= 1; |
| } |
| |
| # else // if defined (__hpux) |
| |
| // QNAN and SNAN on HP-UX are reversed... |
| |
| if (e == little_endian) { |
| if (0.0 != val.val) |
| val.bits [1] = '\xf8'; |
| } |
| else { |
| if (0.0 != val.val) |
| val.bits [sizeof val.val - 2] = '\xf8'; |
| } |
| |
| # endif // __hpux |
| |
| #else // if !defined (_RWSTD_NO_DBL_TRAPS) |
| |
| // floating point arithmetic traps |
| |
| // assume IEEE 754 floating point format |
| |
| if (e == big_endian) { |
| val.bits [0] = '\x7f'; |
| val.bits [1] = '\xf0'; |
| val.bits [2] = '\0'; |
| val.bits [3] = '\0'; |
| val.bits [4] = '\0'; |
| val.bits [5] = '\0'; |
| val.bits [6] = '\0'; |
| val.bits [7] = '\x01'; |
| } |
| else { |
| val.bits [0] = '\x01'; |
| val.bits [1] = '\0'; |
| val.bits [2] = '\0'; |
| val.bits [3] = '\0'; |
| val.bits [4] = '\0'; |
| val.bits [5] = '\0'; |
| val.bits [6] = '\xf0'; |
| val.bits [7] = '\x7f'; |
| } |
| |
| #endif // _RWSTD_NO_DBL_TRAPS |
| |
| return val; |
| } |
| |
| static dbl_bits dbl_denorm_min () |
| { |
| dbl_bits val; |
| |
| #ifdef _RWSTD_NO_DBL_TRAPS |
| |
| // compute denorm min |
| for (volatile double tmp = 1.0; tmp; tmp /= 2.0) |
| val.val = tmp; |
| |
| if (DBL_MIN <= val.val) |
| val.val = 0.0; |
| |
| #else |
| |
| // assume IEEE 754 floating point format |
| |
| if (e == big_endian) { |
| val.bits [0] = '\0'; |
| val.bits [1] = '\0'; |
| val.bits [2] = '\0'; |
| val.bits [3] = '\0'; |
| val.bits [4] = '\0'; |
| val.bits [5] = '\0'; |
| val.bits [6] = '\0'; |
| val.bits [7] = '\x01'; |
| } |
| else { |
| val.bits [0] = '\x01'; |
| val.bits [1] = '\0'; |
| val.bits [2] = '\0'; |
| val.bits [3] = '\0'; |
| val.bits [4] = '\0'; |
| val.bits [5] = '\0'; |
| val.bits [6] = '\0'; |
| val.bits [7] = '\0'; |
| } |
| |
| #endif // _RWSTD_NO_DBL_TRAPS |
| |
| return val; |
| } |
| |
| /**************************************************************************/ |
| |
| #ifndef _RWSTD_NO_LONG_DOUBLE |
| |
| union ldbl_bits |
| { |
| char bits [sizeof (long double)]; |
| long double val; |
| |
| ldbl_bits () { memset (bits, 0, sizeof (bits)); } |
| }; |
| |
| static long double ldbl_zero () |
| { |
| static long double val = 0.0L; |
| |
| return val; |
| } |
| |
| static ldbl_bits ldbl_infinity () |
| { |
| ldbl_bits val; |
| |
| #ifdef _RWSTD_NO_DBL_TRAPS |
| |
| val.val = 1.0L / ldbl_zero (); |
| |
| // may need to negate to get a correct result |
| // i86 FP expressions appear to return a negative infinity |
| if (val.val < ldbl_zero ()) |
| val.val = -val.val; |
| |
| #else // if !defined (_RWSTD_NO_DBL_TRAPS) |
| |
| // floating point arithmetic traps |
| |
| // assume IEEE 754 floating point format |
| |
| if (e == big_endian) { |
| val.bits [ 0] = '\x7f'; |
| val.bits [ 1] = '\xff'; |
| val.bits [ 2] = '\0'; |
| val.bits [ 3] = '\0'; |
| val.bits [ 4] = '\0'; |
| val.bits [ 5] = '\0'; |
| val.bits [ 6] = '\0'; |
| val.bits [ 7] = '\0'; |
| val.bits [ 8] = '\0'; |
| val.bits [ 9] = '\0'; |
| val.bits [10] = '\0'; |
| val.bits [11] = '\0'; |
| val.bits [12] = '\0'; |
| val.bits [13] = '\0'; |
| val.bits [14] = '\0'; |
| val.bits [15] = '\0'; |
| } |
| else { |
| val.bits [ 0] = '\0'; |
| val.bits [ 1] = '\0'; |
| val.bits [ 2] = '\0'; |
| val.bits [ 3] = '\0'; |
| val.bits [ 4] = '\0'; |
| val.bits [ 5] = '\0'; |
| val.bits [ 6] = '\0'; |
| val.bits [ 7] = '\0'; |
| val.bits [ 8] = '\0'; |
| val.bits [ 9] = '\0'; |
| val.bits [10] = '\0'; |
| val.bits [11] = '\0'; |
| val.bits [12] = '\0'; |
| val.bits [13] = '\0'; |
| val.bits [14] = '\xff'; |
| val.bits [15] = '\x7f'; |
| } |
| |
| #endif // _RWSTD_NO_DBL_TRAPS |
| |
| return val; |
| } |
| |
| static ldbl_bits ldbl_qnan () |
| { |
| ldbl_bits val; |
| |
| #ifdef _RWSTD_NO_DBL_TRAPS |
| |
| val.val = ldbl_zero (); |
| |
| val.val /= ldbl_zero (); |
| |
| // val.val can be +qnan or -qnan |
| // clear sign bit |
| if (e == big_endian) { |
| val.bits [0] &= '\x7f'; |
| } |
| else { |
| unsigned inx = sizeof (val.val) - 1; |
| // skip the trailing zero's |
| while (!val.bits [inx]) --inx; |
| val.bits [inx] &= '\x7f'; |
| } |
| |
| #else // if !defined (_RWSTD_NO_DBL_TRAPS) |
| |
| // floating point arithmetic traps |
| |
| // assume IEEE 754 floating point format |
| |
| if (e == big_endian) { |
| val.bits [ 0] = '\x7f'; |
| val.bits [ 1] = '\xff'; |
| val.bits [ 2] = '\x80'; |
| val.bits [ 3] = '\0'; |
| val.bits [ 4] = '\0'; |
| val.bits [ 5] = '\0'; |
| val.bits [ 6] = '\0'; |
| val.bits [ 7] = '\0'; |
| val.bits [ 8] = '\0'; |
| val.bits [ 9] = '\0'; |
| val.bits [10] = '\0'; |
| val.bits [11] = '\0'; |
| val.bits [12] = '\0'; |
| val.bits [13] = '\0'; |
| val.bits [14] = '\0'; |
| val.bits [15] = '\0'; |
| } |
| else { |
| val.bits [ 0] = '\0'; |
| val.bits [ 1] = '\0'; |
| val.bits [ 2] = '\0'; |
| val.bits [ 3] = '\0'; |
| val.bits [ 4] = '\0'; |
| val.bits [ 5] = '\0'; |
| val.bits [ 6] = '\0'; |
| val.bits [ 7] = '\0'; |
| val.bits [ 8] = '\0'; |
| val.bits [ 9] = '\0'; |
| val.bits [10] = '\0'; |
| val.bits [11] = '\0'; |
| val.bits [12] = '\0'; |
| val.bits [13] = '\x80'; |
| val.bits [14] = '\xff'; |
| val.bits [15] = '\x7f'; |
| } |
| |
| #endif // _RWSTD_NO_DBL_TRAPS |
| |
| return val; |
| } |
| |
| static ldbl_bits ldbl_snan () |
| { |
| ldbl_bits val; |
| |
| #ifdef _RWSTD_NO_DBL_TRAPS |
| |
| val = ldbl_infinity (); |
| |
| # if !defined (__hpux) |
| |
| // convert infinity into a signaling NAN (toggle any bit in signifcand) |
| if (e == little_endian) { |
| if (0.0L != val.val) |
| val.bits [0] |= 1; |
| } |
| else { |
| if (0.0L != val.val) |
| val.bits [sizeof val.val - 1] |= 1; |
| } |
| |
| # else // if defined (__hpux) |
| |
| // QNAN and SNAN on HP-UX are reversed... |
| if (e == little_endian) { |
| if (0.0L != val.val) |
| val.bits [2] = '\x80'; |
| } |
| else { |
| if (0.0L != val.val) |
| val.bits [sizeof val.val - 3] = '\x80'; |
| } |
| |
| # endif // __hpux |
| |
| #else // if !defined (_RWSTD_NO_DBL_TRAPS) |
| |
| // floating point arithmetic traps |
| |
| // assume IEEE 754 floating point format |
| |
| if (e == big_endian) { |
| val.bits [ 0] = '\x7f'; |
| val.bits [ 1] = '\xff'; |
| val.bits [ 2] = '\0'; |
| val.bits [ 3] = '\0'; |
| val.bits [ 4] = '\0'; |
| val.bits [ 5] = '\0'; |
| val.bits [ 6] = '\0'; |
| val.bits [ 7] = '\0'; |
| val.bits [ 8] = '\0'; |
| val.bits [ 9] = '\0'; |
| val.bits [10] = '\0'; |
| val.bits [11] = '\0'; |
| val.bits [12] = '\0'; |
| val.bits [13] = '\0'; |
| val.bits [14] = '\0'; |
| val.bits [15] = '\x01'; |
| } |
| else { |
| val.bits [ 0] = '\x01'; |
| val.bits [ 1] = '\0'; |
| val.bits [ 2] = '\0'; |
| val.bits [ 3] = '\0'; |
| val.bits [ 4] = '\0'; |
| val.bits [ 5] = '\0'; |
| val.bits [ 6] = '\0'; |
| val.bits [ 7] = '\0'; |
| val.bits [ 8] = '\0'; |
| val.bits [ 9] = '\0'; |
| val.bits [10] = '\0'; |
| val.bits [11] = '\0'; |
| val.bits [12] = '\0'; |
| val.bits [13] = '\0'; |
| val.bits [14] = '\xff'; |
| val.bits [15] = '\x7f'; |
| } |
| |
| #endif // _RWSTD_NO_DBL_TRAPS |
| |
| return val; |
| } |
| |
| static ldbl_bits ldbl_denorm_min () |
| { |
| ldbl_bits val; |
| |
| #ifdef _RWSTD_NO_DBL_TRAPS |
| |
| // compute denorm min |
| for (volatile long double tmp = 1.0L; tmp; tmp /= 2.0L) |
| val.val = tmp; |
| |
| if (DBL_MIN < val.val) |
| val.val = DBL_MIN; |
| |
| #else |
| |
| // assume IEEE 754 floating point format |
| |
| if (e == big_endian) { |
| val.bits [ 0] = '\0'; |
| val.bits [ 1] = '\0'; |
| val.bits [ 2] = '\0'; |
| val.bits [ 3] = '\0'; |
| val.bits [ 4] = '\0'; |
| val.bits [ 5] = '\0'; |
| val.bits [ 6] = '\0'; |
| val.bits [ 7] = '\0'; |
| val.bits [ 8] = '\0'; |
| val.bits [ 9] = '\0'; |
| val.bits [10] = '\0'; |
| val.bits [11] = '\0'; |
| val.bits [12] = '\0'; |
| val.bits [13] = '\0'; |
| val.bits [14] = '\0'; |
| val.bits [15] = '\x01'; |
| } |
| else { |
| val.bits [ 0] = '\x01'; |
| val.bits [ 1] = '\0'; |
| val.bits [ 2] = '\0'; |
| val.bits [ 3] = '\0'; |
| val.bits [ 4] = '\0'; |
| val.bits [ 5] = '\0'; |
| val.bits [ 6] = '\0'; |
| val.bits [ 7] = '\0'; |
| val.bits [ 8] = '\0'; |
| val.bits [ 9] = '\0'; |
| val.bits [10] = '\0'; |
| val.bits [11] = '\0'; |
| val.bits [12] = '\0'; |
| val.bits [13] = '\0'; |
| val.bits [14] = '\0'; |
| val.bits [15] = '\0'; |
| } |
| |
| #endif // _RWSTD_NO_DBL_TRAPS |
| |
| return val; |
| } |
| |
| #endif // _RWSTD_NO_LONG_DOUBLE |
| |
| /**************************************************************************/ |
| |
| int main () |
| { |
| const flt_bits f_inf = flt_infinity (); |
| const flt_bits f_qnan = flt_qnan (); |
| const flt_bits f_snan = flt_snan (); |
| const flt_bits f_den = flt_denorm_min (); |
| |
| const dbl_bits d_inf = dbl_infinity (); |
| const dbl_bits d_qnan = dbl_qnan (); |
| const dbl_bits d_snan = dbl_snan (); |
| const dbl_bits d_den = dbl_denorm_min (); |
| |
| #ifndef _RWSTD_NO_LONG_DOUBLE |
| |
| const ldbl_bits l_inf = ldbl_infinity (); |
| const ldbl_bits l_qnan = ldbl_qnan (); |
| const ldbl_bits l_snan = ldbl_snan (); |
| const ldbl_bits l_den = ldbl_denorm_min (); |
| |
| #endif // _RWSTD_NO_LONG_DOUBLE |
| |
| |
| #ifdef _RWSTD_NO_DBL_TRAPS |
| |
| printf ("// computed infinities and NANs for a %s endian architecture\n", |
| e == big_endian ? "big" : "little"); |
| |
| const int flt_has_denorm = 0.0f != f_den.val; |
| const int dbl_has_denorm = 0.0 != d_den.val; |
| |
| # ifndef _RWSTD_NO_LONG_DOUBLE |
| |
| const int ldbl_has_denorm = 0.0L != l_den.val; |
| |
| # endif // _RWSTD_NO_LONG_DOUBLE |
| |
| #else // if !defined (_RWSTD_NO_DBL_TRAPS) |
| |
| printf ("// IEEE 754 infinities and NANs for a %s endian architecture\n" |
| "// (values not computed due to floating exception trapping)\n", |
| e == big_endian ? "big" : "little"); |
| |
| const int flt_has_denorm = 1; |
| const int dbl_has_denorm = 1; |
| const int ldbl_has_denorm = 1; |
| |
| #endif // _RWSTD_NO_DBL_TRAPS |
| |
| print ("#define _RWSTD_FLT_INF_BITS ", &f_inf, sizeof f_inf); |
| print ("#define _RWSTD_FLT_QNAN_BITS ", &f_qnan, sizeof f_qnan); |
| print ("#define _RWSTD_FLT_SNAN_BITS ", &f_snan, sizeof f_snan); |
| print ("#define _RWSTD_FLT_DENORM_MIN_BITS ", &f_den, sizeof f_den); |
| |
| printf ("#define _RWSTD_FLT_HAS_DENORM %d\n", flt_has_denorm); |
| |
| print ("#define _RWSTD_DBL_INF_BITS ", &d_inf, sizeof d_inf); |
| print ("#define _RWSTD_DBL_QNAN_BITS ", &d_qnan, sizeof d_qnan); |
| print ("#define _RWSTD_DBL_SNAN_BITS ", &d_snan, sizeof d_snan); |
| print ("#define _RWSTD_DBL_DENORM_MIN_BITS ", &d_den, sizeof d_den); |
| |
| printf ("#define _RWSTD_DBL_HAS_DENORM %d\n", dbl_has_denorm); |
| |
| #ifndef _RWSTD_NO_LONG_DOUBLE |
| |
| print ("#define _RWSTD_LDBL_INF_BITS ", &l_inf, sizeof l_inf); |
| print ("#define _RWSTD_LDBL_QNAN_BITS ", &l_qnan, sizeof l_qnan); |
| print ("#define _RWSTD_LDBL_SNAN_BITS ", &l_snan, sizeof l_snan); |
| print ("#define _RWSTD_LDBL_DENORM_MIN_BITS ", &l_den, sizeof l_den); |
| |
| printf ("#define _RWSTD_LDBL_HAS_DENORM %d\n", ldbl_has_denorm); |
| |
| #endif // _RWSTD_NO_LONG_DOUBLE |
| |
| return 0; |
| } |
