Subversion Repositories openrisc

/* @(#)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 */