Go to the first, previous, next, last section, table of contents.


Low-Level Arithmetic Functions

This chapter contains information about functions for doing basic arithmetic operations, such as splitting a float into its integer and fractional parts. These functions are declared in the header file `math.h'.

"Not a Number" Values

The IEEE floating point format used by most modern computers supports values that are "not a number". These values are called NaNs. "Not a number" values result from certain operations which have no meaningful numeric result, such as zero divided by zero or infinity divided by infinity.

One noteworthy property of NaNs is that they are not equal to themselves. Thus, x == x can be 0 if the value of x is a NaN. You can use this to test whether a value is a NaN or not: if it is not equal to itself, then it is a NaN. But the recommended way to test for a NaN is with the isnan function (see section Predicates on Floats).

Almost any arithmetic operation in which one argument is a NaN returns a NaN.

Macro: double NAN
An expression representing a value which is "not a number". This macro is a GNU extension, available only on machines that support "not a number" values--that is to say, on all machines that support IEEE floating point.

You can use `#ifdef NAN' to test whether the machine supports NaNs. (Of course, you must arrange for GNU extensions to be visible, such as by defining _GNU_SOURCE, and then you must include `math.h'.)

Predicates on Floats

This section describes some miscellaneous test functions on doubles. Prototypes for these functions appear in `math.h'. These are BSD functions, and thus are available if you define _BSD_SOURCE or _GNU_SOURCE.

Function: int isinf (double x)
This function returns -1 if x represents negative infinity, 1 if x represents positive infinity, and 0 otherwise.

Function: int isnan (double x)
This function returns a nonzero value if x is a "not a number" value, and zero otherwise. (You can just as well use x != x to get the same result).

Function: int finite (double x)
This function returns a nonzero value if x is finite or a "not a number" value, and zero otherwise.

Function: double infnan (int error)
This function is provided for compatibility with BSD. The other mathematical functions use infnan to decide what to return on occasion of an error. Its argument is an error code, EDOM or ERANGE; infnan returns a suitable value to indicate this with. -ERANGE is also acceptable as an argument, and corresponds to -HUGE_VAL as a value.

In the BSD library, on certain machines, infnan raises a fatal signal in all cases. The GNU library does not do likewise, because that does not fit the ANSI C specification.

Portability Note: The functions listed in this section are BSD extensions.

Absolute Value

These functions are provided for obtaining the absolute value (or magnitude) of a number. The absolute value of a real number x is x is x is positive, -x if x is negative. For a complex number z, whose real part is x and whose imaginary part is y, the absolute value is sqrt (x*x + y*y).

Prototypes for abs and labs are in `stdlib.h'; fabs and cabs are declared in `math.h'.

Function: int abs (int number)
This function returns the absolute value of number.

Most computers use a two's complement integer representation, in which the absolute value of INT_MIN (the smallest possible int) cannot be represented; thus, abs (INT_MIN) is not defined.

Function: long int labs (long int number)
This is similar to abs, except that both the argument and result are of type long int rather than int.

Function: double fabs (double number)
This function returns the absolute value of the floating-point number number.

Function: double cabs (struct { double real, imag; } z)
The cabs function returns the absolute value of the complex number z, whose real part is z.real and whose imaginary part is z.imag. (See also the function hypot in section Exponentiation and Logarithms.) The value is:

sqrt (z.real*z.real + z.imag*z.imag)

Normalization Functions

The functions described in this section are primarily provided as a way to efficiently perform certain low-level manipulations on floating point numbers that are represented internally using a binary radix; see section Floating Point Representation Concepts. These functions are required to have equivalent behavior even if the representation does not use a radix of 2, but of course they are unlikely to be particularly efficient in those cases.

All these functions are declared in `math.h'.

Function: double frexp (double value, int *exponent)
The frexp function is used to split the number value into a normalized fraction and an exponent.

If the argument value is not zero, the return value is value times a power of two, and is always in the range 1/2 (inclusive) to 1 (exclusive). The corresponding exponent is stored in *exponent; the return value multiplied by 2 raised to this exponent equals the original number value.

For example, frexp (12.8, &exponent) returns 0.8 and stores 4 in exponent.

If value is zero, then the return value is zero and zero is stored in *exponent.

Function: double ldexp (double value, int exponent)
This function returns the result of multiplying the floating-point number value by 2 raised to the power exponent. (It can be used to reassemble floating-point numbers that were taken apart by frexp.)

For example, ldexp (0.8, 4) returns 12.8.

The following functions which come from BSD provide facilities equivalent to those of ldexp and frexp:

Function: double scalb (double value, int exponent)
The scalb function is the BSD name for ldexp.

Function: double logb (double x)
This BSD function returns the integer part of the base-2 logarithm of x, an integer value represented in type double. This is the highest integer power of 2 contained in x. The sign of x is ignored. For example, logb (3.5) is 1.0 and logb (4.0) is 2.0.

When 2 raised to this power is divided into x, it gives a quotient between 1 (inclusive) and 2 (exclusive).

If x is zero, the value is minus infinity (if the machine supports such a value), or else a very small number. If x is infinity, the value is infinity.

The value returned by logb is one less than the value that frexp would store into *exponent.

Function: double copysign (double value, double sign)
The copysign function returns a value whose absolute value is the same as that of value, and whose sign matches that of sign. This is a BSD function.

Rounding and Remainder Functions

The functions listed here perform operations such as rounding, truncation, and remainder in division of floating point numbers. Some of these functions convert floating point numbers to integer values. They are all declared in `math.h'.

You can also convert floating-point numbers to integers simply by casting them to int. This discards the fractional part, effectively rounding towards zero. However, this only works if the result can actually be represented as an int---for very large numbers, this is impossible. The functions listed here return the result as a double instead to get around this problem.

Function: double ceil (double x)
The ceil function rounds x upwards to the nearest integer, returning that value as a double. Thus, ceil (1.5) is 2.0.

Function: double floor (double x)
The ceil function rounds x downwards to the nearest integer, returning that value as a double. Thus, floor (1.5) is 1.0 and floor (-1.5) is -2.0.

Function: double rint (double x)
This function rounds x to an integer value according to the current rounding mode. See section Floating Point Parameters, for information about the various rounding modes. The default rounding mode is to round to the nearest integer; some machines support other modes, but round-to-nearest is always used unless you explicit select another.

Function: double modf (double value, double *integer-part)
This function breaks the argument value into an integer part and a fractional part (between -1 and 1, exclusive). Their sum equals value. Each of the parts has the same sign as value, so the rounding of the integer part is towards zero.

modf stores the integer part in *integer-part, and returns the fractional part. For example, modf (2.5, &intpart) returns 0.5 and stores 2.0 into intpart.

Function: double fmod (double numerator, double denominator)
This function computes the remainder from the division of numerator by denominator. Specifically, the return value is numerator - n * denominator, where n is the quotient of numerator divided by denominator, rounded towards zero to an integer. Thus, fmod (6.5, 2.3) returns 1.9, which is 6.5 minus 4.6.

The result has the same sign as the numerator and has magnitude less than the magnitude of the denominator.

If denominator is zero, fmod fails and sets errno to EDOM.

Function: double drem (double numerator, double denominator)
The function drem is like fmod except that it rounds the internal quotient n to the nearest integer instead of towards zero to an integer. For example, drem (6.5, 2.3) returns -0.4, which is 6.5 minus 6.9.

The absolute value of the result is less than or equal to half the absolute value of the denominator. The difference between fmod (numerator, denominator) and drem (numerator, denominator) is always either denominator, minus denominator, or zero.

If denominator is zero, drem fails and sets errno to EDOM.

Integer Division

This section describes functions for performing integer division. These functions are redundant in the GNU C library, since in GNU C the `/' operator always rounds towards zero. But in other C implementations, `/' may round differently with negative arguments. div and ldiv are useful because they specify how to round the quotient: towards zero. The remainder has the same sign as the numerator.

These functions are specified to return a result r such that the value r.quot*denominator + r.rem equals numerator.

To use these facilities, you should include the header file `stdlib.h' in your program.

Data Type: div_t
This is a structure type used to hold the result returned by the div function. It has the following members:

int quot
The quotient from the division.
int rem
The remainder from the division.

Function: div_t div (int numerator, int denominator)
This function div computes the quotient and remainder from the division of numerator by denominator, returning the result in a structure of type div_t.

If the result cannot be represented (as in a division by zero), the behavior is undefined.

Here is an example, albeit not a very useful one.

div_t result;
result = div (20, -6);

Now result.quot is -3 and result.rem is 2.

Data Type: ldiv_t
This is a structure type used to hold the result returned by the ldiv function. It has the following members:

long int quot
The quotient from the division.
long int rem
The remainder from the division.

(This is identical to div_t except that the components are of type long int rather than int.)

Function: ldiv_t ldiv (long int numerator, long int denominator)
The ldiv function is similar to div, except that the arguments are of type long int and the result is returned as a structure of type ldiv.

Parsing of Numbers

This section describes functions for "reading" integer and floating-point numbers from a string. It may be more convenient in some cases to use sscanf or one of the related functions; see section Formatted Input. But often you can make a program more robust by finding the tokens in the string by hand, then converting the numbers one by one.

Parsing of Integers

These functions are declared in `stdlib.h'.

Function: long int strtol (const char *string, char **tailptr, int base)
The strtol ("string-to-long") function converts the initial part of string to a signed integer, which is returned as a value of type long int.

This function attempts to decompose string as follows:

If the string is empty, contains only whitespace, or does not contain an initial substring that has the expected syntax for an integer in the specified base, no conversion is performed. In this case, strtol returns a value of zero and the value stored in *tailptr is the value of string.

In a locale other than the standard "C" locale, this function may recognize additional implementation-dependent syntax.

If the string has valid syntax for an integer but the value is not representable because of overflow, strtol returns either LONG_MAX or LONG_MIN (see section Range of an Integer Type), as appropriate for the sign of the value. It also sets errno to ERANGE to indicate there was overflow.

There is an example at the end of this section.

Function: unsigned long int strtoul (const char *string, char **tailptr, int base)
The strtoul ("string-to-unsigned-long") function is like strtol except that it returns its value with type unsigned long int. The value returned in case of overflow is ULONG_MAX (see section Range of an Integer Type).

Function: long int atol (const char *string)
This function is similar to the strtol function with a base argument of 10, except that it need not detect overflow errors. The atol function is provided mostly for compatibility with existing code; using strtol is more robust.

Function: int atoi (const char *string)
This function is like atol, except that it returns an int value rather than long int. The atoi function is also considered obsolete; use strtol instead.

Here is a function which parses a string as a sequence of integers and returns the sum of them:

int
sum_ints_from_string (char *string)
{
  int sum = 0;

  while (1) {
    char *tail;
    int next;

    /* Skip whitespace by hand, to detect the end.  */
    while (isspace (*string)) string++;
    if (*string == 0)
      break;

    /* There is more nonwhitespace,  */
    /* so it ought to be another number.  */
    errno = 0;
    /* Parse it.  */
    next = strtol (string, &tail, 0);
    /* Add it in, if not overflow.  */
    if (errno)
      printf ("Overflow\n");
    else
      sum += next;
    /* Advance past it.  */
    string = tail;
  }

  return sum;
}

Parsing of Floats

These functions are declared in `stdlib.h'.

Function: double strtod (const char *string, char **tailptr)
The strtod ("string-to-double") function converts the initial part of string to a floating-point number, which is returned as a value of type double.

This function attempts to decompose string as follows:

If the string is empty, contains only whitespace, or does not contain an initial substring that has the expected syntax for a floating-point number, no conversion is performed. In this case, strtod returns a value of zero and the value returned in *tailptr is the value of string.

In a locale other than the standard "C" locale, this function may recognize additional locale-dependent syntax.

If the string has valid syntax for a floating-point number but the value is not representable because of overflow, strtod returns either positive or negative HUGE_VAL (see section Mathematics), depending on the sign of the value. Similarly, if the value is not representable because of underflow, strtod returns zero. It also sets errno to ERANGE if there was overflow or underflow.

Function: double atof (const char *string)
This function is similar to the strtod function, except that it need not detect overflow and underflow errors. The atof function is provided mostly for compatibility with existing code; using strtod is more robust.


Go to the first, previous, next, last section, table of contents.