nan(2) [plan9 man page]

NAN(2)								System Calls Manual							    NAN(2)

NAME

       NaN, Inf, isNaN, isInf - not-a-number and infinity functions

SYNOPSIS

       #include <u.h>
       #include <libc.h>

       double NaN(void)

       long   Inf(int)

       int    isNaN(double)

       int    isInf(double, int)

DESCRIPTION

       The  IEEE  floating point standard defines values called `not-a-number' and positive and negative `infinity'.  These values can be produced
       by such things as overflow and division by zero.  Also, the library functions sometimes return them when  the  arguments  are  not  in  the
       domain, or the result is out of range.

       NaN returns a double that is not-a-number.  IsNaN returns true if its argument is not-a-number.

       Inf(i)  returns	positive infinity if i is greater than or equal to zero, else negative infinity.  IsInf returns true if its first argument
       is infinity with the same sign as the second argument.

SOURCE

       /sys/src/libc/$objtype/nan.c

																	    NAN(2)

ieee(3m)																  ieee(3m)

Name
       copysign, drem, finite, logb, scalb - copysign, remainder, exponent manipulations

Syntax
       #include <math.h>

       double copysign(x,y)
       double x,y;

       double drem(x,y)
       double x,y;

       int finite(x)
       double x;

       double logb(x)
       double x;

       double scalb(x,n)
       double x;
       int n;

Description
       These functions are required, or recommended by the IEEE standard 754 for floating-point arithmetic.

       The function returns x with its sign changed to y's.

       The function returns the remainder r := x - n*y where n is the integer nearest the exact value of x/y.  Additionally if |n-x/y|=1/2, then n
       is even.  Consequently the remainder is computed exactly and |r| <= |y|/2.  Note that is the exception (see Diagnostics).

       Finite(x) = 1 just when -infinity < x < +infinity,
		 = 0 otherwise (when |x| = infinity or x is NaN)

       The a signed integer converted to double-precision floating-point and so chosen that 1 <= |x|/2**n < 2 unless x = 0 or |x| = infinity or  x
       lies between 0 and the Underflow Threshold.

       Scalb(x,n) = x*(2**n) computed, for integer n, without first computing 2**N.

Diagnostics
       IEEE 754 defines drem(x,0) and drem(infinity,y) to be invalid operations that produce a NaN.

       IEEE 754 defines logb(+-infinity) = +infinity and logb(0) = -infinity, requires the latter to signal Division-by-Zero.

Restrictions
       IEEE 754 currently specifies that logb(denormalized no.) = logb(tiniest normalized no. > 0) but the consensus has changed to the specifica-
       tion in the new proposed IEEE standard p854, namely that logb(x) satisfy
	      1 <= scalb(|x|,-logb(x)) < Radix	 ... = 2 for IEEE 754
       for every x except 0, infinity and NaN.	Almost every program that assumes 754's specification will work correctly if  logb  follows  854's
       specification instead.

       IEEE 754 requires copysign(x,NaN) = +-x	but says nothing else about the sign of a NaN.

See Also
       floor(3M), fp_class(3), math(3M)

								       RISC								  ieee(3m)