0,0 → 1,206 |
|
/* @(#)s_isnan.c 5.1 93/09/24 */ |
/* |
* ==================================================== |
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. |
* |
* Developed at SunPro, a Sun Microsystems, Inc. business. |
* Permission to use, copy, modify, and distribute this |
* software is freely granted, provided that this notice |
* is preserved. |
* ==================================================== |
*/ |
|
/* |
FUNCTION |
<<fpclassify>>, <<isfinite>>, <<isinf>>, <<isnan>>, and <<isnormal>>--floating-point classification macros; <<finite>>, <<finitef>>, <<isinf>>, <<isinff>>, <<isnan>>, <<isnanf>>--test for exceptional numbers |
|
@c C99 (start |
INDEX |
fpclassify |
INDEX |
isfinite |
INDEX |
isinf |
INDEX |
isnan |
INDEX |
isnormal |
@c C99 end) |
@c SUSv2 (start |
INDEX |
isnan |
INDEX |
isinf |
INDEX |
finite |
|
INDEX |
isnanf |
INDEX |
isinff |
INDEX |
finitef |
@c SUSv2 end) |
|
ANSI_SYNOPSIS |
[C99 standard macros:] |
#include <math.h> |
int fpclassify(real-floating <[x]>); |
int isfinite(real-floating <[x]>); |
int isinf(real-floating <[x]>); |
int isnan(real-floating <[x]>); |
int isnormal(real-floating <[x]>); |
|
[Archaic SUSv2 functions:] |
#include <ieeefp.h> |
int isnan(double <[arg]>); |
int isinf(double <[arg]>); |
int finite(double <[arg]>); |
int isnanf(float <[arg]>); |
int isinff(float <[arg]>); |
int finitef(float <[arg]>); |
|
DESCRIPTION |
<<fpclassify>>, <<isfinite>>, <<isinf>>, <<isnan>>, and <<isnormal>> are macros |
defined for use in classifying floating-point numbers. This is a help because |
of special "values" like NaN and infinities. In the synopses shown, |
"real-floating" indicates that the argument is an expression of real floating |
type. These function-like macros are C99 and POSIX-compliant, and should be |
used instead of the now-archaic SUSv2 functions. |
|
The <<fpclassify>> macro classifies its argument value as NaN, infinite, normal, |
subnormal, zero, or into another implementation-defined category. First, an |
argument represented in a format wider than its semantic type is converted to |
its semantic type. Then classification is based on the type of the argument. |
The <<fpclassify>> macro returns the value of the number classification macro |
appropriate to the value of its argument: |
|
o+ |
o FP_INFINITE |
<[x]> is either plus or minus infinity; |
o FP_NAN |
<[x]> is "Not A Number" (plus or minus); |
o FP_NORMAL |
<[x]> is a "normal" number (i.e. is none of the other special forms); |
o FP_SUBNORMAL |
<[x]> is too small be stored as a regular normalized number (i.e. loss of precision is likely); or |
o FP_ZERO |
<[x]> is 0 (either plus or minus). |
o- |
|
The "<<is>>" set of macros provide a useful set of shorthand ways for |
classifying floating-point numbers, providing the following equivalent |
relations: |
|
o+ |
o <<isfinite>>(<[x]>) |
returns non-zero if <[x]> is finite. (It is equivalent to |
(<<fpclassify>>(<[x]>) != FP_INFINITE && <<fpclassify>>(<[x]>) != FP_NAN).) |
|
o <<isinf>>(<[x]>) |
returns non-zero if <[x]> is infinite. (It is equivalent to |
(<<fpclassify>>(<[x]>) == FP_INFINITE).) |
|
o <<isnan>>(<[x]>) |
returns non-zero if <[x]> is NaN. (It is equivalent to |
(<<fpclassify>>(<[x]>) == FP_NAN).) |
|
o <<isnormal>>(<[x]>) |
returns non-zero if <[x]> is normal. (It is equivalent to |
(<<fpclassify>>(<[x]>) == FP_NORMAL).) |
o- |
|
The archaic SUSv2 functions provide information on the floating-point |
argument supplied. |
|
There are five major number formats ("exponent" referring to the |
biased exponent in the binary-encoded number): |
o+ |
o zero |
A number which contains all zero bits, excluding the sign bit. |
o subnormal |
A number with a zero exponent but a nonzero fraction. |
o normal |
A number with an exponent and a fraction. |
o infinity |
A number with an all 1's exponent and a zero fraction. |
o NAN |
A number with an all 1's exponent and a nonzero fraction. |
|
o- |
|
<<isnan>> returns 1 if the argument is a nan. <<isinf>> |
returns 1 if the argument is infinity. <<finite>> returns 1 if the |
argument is zero, subnormal or normal. |
|
The <<isnanf>>, <<isinff>> and <<finitef>> functions perform the same |
operations as their <<isnan>>, <<isinf>> and <<finite>> |
counterparts, but on single-precision floating-point numbers. |
|
It should be noted that the C99 standard dictates that <<isnan>> |
and <<isinf>> are macros that operate on multiple types of |
floating-point. The SUSv2 standard declares <<isnan>> as |
a function taking double. Newlib has decided to declare |
them both as macros in math.h and as functions in ieeefp.h to |
maintain backward compatibility. |
|
RETURNS |
@comment Formatting note: "$@" forces a new line |
The fpclassify macro returns the value corresponding to the appropriate FP_ macro.@* |
The isfinite macro returns nonzero if <[x]> is finite, else 0.@* |
The isinf macro returns nonzero if <[x]> is infinite, else 0.@* |
The isnan macro returns nonzero if <[x]> is an NaN, else 0.@* |
The isnormal macro returns nonzero if <[x]> has a normal value, else 0. |
|
PORTABILITY |
math.h macros are C99, POSIX. |
|
ieeefp.h funtions are outdated and should be avoided. |
|
QUICKREF |
isnan - pure |
QUICKREF |
isinf - pure |
QUICKREF |
finite - pure |
QUICKREF |
isnan - pure |
QUICKREF |
isinf - pure |
QUICKREF |
finite - pure |
*/ |
|
/* |
* isnan(x) returns 1 is x is nan, else 0; |
* no branching! |
* |
* The C99 standard dictates that isnan is a macro taking |
* multiple floating-point types while the SUSv2 standard |
* notes it is a function taking a double argument. Newlib |
* has chosen to implement it as a macro in <math.h> and |
* declare it as a function in <ieeefp.h>. |
*/ |
|
#include "fdlibm.h" |
#include <ieeefp.h> |
|
#ifndef _DOUBLE_IS_32BITS |
|
#ifdef __STDC__ |
int isnan(double x) |
#else |
int isnan(x) |
double x; |
#endif |
{ |
__int32_t hx,lx; |
EXTRACT_WORDS(hx,lx,x); |
hx &= 0x7fffffff; |
hx |= (__uint32_t)(lx|(-lx))>>31; |
hx = 0x7ff00000 - hx; |
return (int)(((__uint32_t)(hx))>>31); |
} |
|
#endif /* _DOUBLE_IS_32BITS */ |