NAME    [Toc]    [Back]

       copysign,  finite, fp_class, isnan, nextafter, unordered -
       Related miscellaneous IEEE arithmetic functions.

SYNOPSIS    [Toc]    [Back]

       #include <math.h>

       double copysign(
               double x,
               double y ); float copysignf(
               float x,
               float y ); long double copysignl(
               long double x,
               long double y ); int finite(
               double x ); int finitef(
               float x ); int finitel(
               long double x ); int fp_class(
               double x ); int fp_classf(
               float x ); int fp_classl(
               long double x ); int isnan(
               double x ); int isnanf(
               float x ); int isnanl(
               long double x ); double nextafter(
               double x,
               double y ); float nextafterf(
               float x,
               float y ); long double nextafterl(
               long double x,
               long double y ); int unordered(
               double x,
               double y ); int unorderedf(
               float x,
               float y ); int unorderedl(
               long double x,
               long double y );

LIBRARY    [Toc]    [Back]

       Math Library (libm)

STANDARDS    [Toc]    [Back]

       Interfaces documented on this reference  page  conform  to
       industry standards as follows:

       isnan():  XPG4

       nextafter():  XPG4-UNIX

       Refer to the standards(5) reference page for more information
 about industry standards and associated tags.

DESCRIPTION    [Toc]    [Back]

       The copysign(),  copysignf(),  and  copysignl()  functions
       return  x with the same sign as y. IEEE 754 requires copysign(x,NaN),
  copysignf(x,NaN)  and  copysignl(x,NaN)   to
       return +x or -x.

       The  finite(),  finitef(),  and finitel() functions return
       the integer value 1 (True) or 0 (False).   The  finite(x),
       finitef(x),    and  finitel(x)  functions  return  1  when
       -infinity < x< +infinity. They return 0 when |x| =  infinity
 or x is a NaN.

       The  fp_class(),  fp_classf(),  and  fp_classl() functions
       determine the class of an IEEE floating-point value.  They
       return  one  of the constants in the file <fp_class.h> and
       never cause an exception, even for signaling  NaNs.  These
       routines  implement  the  recommended function class(x) in
       the appendix of the  IEEE  754-1985  standard  for  binary
       floating-point  arithmetic.  The constants in <fp_class.h>
       refer to the following classes of values:

       ---------------------------------------------
       Constant        Class
       ---------------------------------------------
       FP_SNAN         Signaling NaN (Not-a-Number)
       FP_QNAN         Quiet NaN (Not-a-Number)
       FP_POS_INF      +infinity
       FP_NEG_INF      -infinity
       FP_POS_NORM     Positive normalized
       FP_NEG_NORM     Negative normalized
       FP_POS_DENORM   Positive denormalized
       FP_NEG_DENORM   Negative denormalized
       FP_POS_ZERO     +0.0 (positive zero)
       FP_NEG_ZERO     -0.0 (negative zero)
       ---------------------------------------------

       The isnan(), isnanf(), and isnanl() functions  return  the
       value  1  (True)  if  x  is  NaN  (the IEEE floating point
       reserved not-a-number value); otherwise,  it  returns  the
       value 0 (False).

       The  nextafter(), nextafterf(), and nextafterl() functions
       return the next machine-representable number from x in the
       direction of y.

       The  unordered(), unorderedf(), and unorderedl() functions
       return the value 1 (True) if either x or y or  both  is  a
       NaN; otherwise, it returns the value 0 (False).

SEE ALSO    [Toc]    [Back]

       drem(3),   logb(3),   scalb(3),   rint(3),   sqrt(3),  and
       ANSI/IEEE Std 754-1985, IEEE Standard for Binary FloatingPoint
 Arithmetic



                                                ieee_functions(3)