URL
https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me
[/] [openrisc/] [trunk/] [gnu-src/] [newlib-1.18.0/] [newlib/] [libm/] [common/] [s_isnan.c] - Rev 262
Go to most recent revision | Compare with Previous | Blame | View Log
/* @(#)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 */
Go to most recent revision | Compare with Previous | Blame | View Log