Decimal floating-point constants always include at least one digit, and at least a period . or an exponent (consisting of e or E, and followed by an optional sign, then at least one decimal digit). Without the period and the exponent, such a sequence would interpreted as an integer constant. The exponent multiplies the represented value by a power of 10. 0.0, 0. and .0 all represent zero. 1e3 represents 1000, 1.2e3 represents 1200, and 1.2e-3 represents 0·0012.

From C99, hexadecimal floating-point constants are permitted, prefixed by 0x or 0X, and use p or P to introduce the exponent, e.g., 0x1EFp+12. The exponent is required, to avoid the token being mistaken for an integer constant. It is always expressed in decimal, and multiplies the represented value by a power of 2.

Floating-point constants may be suffixed by f or F to give them the type float, while l or L gives them the type long double. Otherwise, FP constants are of type double.

Floating-point constants are always non-negative, and do not include a sign. -3.0 is a unary-expression formed from a sign - and a floating-point constant 3.0, but it is still a constant expression.

constant

floating-constant

floating-constant

decimal-floating-constant

hexadecimal-floating-constant

from C99

decimal-floating-constant

fractional-constant exponent-partopt floating-suffixopt

digit-sequence exponent-part floating-suffixopt

fractional-constant

digit-sequenceopt . digit-sequence

digit-sequence .

exponent-part

e signopt digit-sequence

E signopt digit-sequence

digit-sequence

digit

digit-sequence digit

digit

any of 0 1 2 3 4 5 6 7 8 9

hexadecimal-floating-constant

hexadecimal-prefix hexadecimal-fractional-constant binary-exponent-part floating-suffixopt

hexadecimal-prefix hexadecimal-digit-sequence binary-exponent-part floating-suffixopt

hexadecimal-fractional-constant

hexadecimal-digit-sequenceopt . hexadecimal-digit-sequence

hexadecimal-digit-sequence .

binary-exponent-part

p signopt digit-sequence

P signopt digit-sequence

hexadecimal-digit-sequence

hexadecimal-digit

hexadecimal-digit-sequence hexadecimal-digit

hexadecimal-digit

any of 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F

sign

+

-

floating-suffix

f

l

F

L

#include <math.h>
int isfinite(real-floating-type x);
int isinf(real-floating-type x);

#include <math.h>
int isnormal(real-floating-type x);

#include <math.h>
int isnan(real-floating-type x);

relational-expression

relational-expression < shift-expression

relational-expression > shift-expression

relational-expression <= shift-expression

relational-expression >= shift-expression

equality-expression

equality-expression == relational-expression

equality-expression != relational-expression

The operators <, >, <=, >=, == and != allow real floating-point values to be compared in the expected mathematical ways. == and != should be used with caution, however, as it can be extremely difficult for two computed floating-point expressions to yield exactly the same number. Instead, compare a value with a small range centered on the intended value, e.g., with fabs(val - target) < epsilon, or consider avoiding the circumstance altogether.

<math.h> also defines several macros for comparing two floating-point numbers that don't raise floating-point exceptions.

• isless(x, y) is equivalent to (x < y).
• isgreater(x, y) is equivalent to (x > y).
• islessequal(x, y) is equivalent to (x <= y).
• isgreaterequal(x, y) is equivalent to (x >= y).
• islessgreater(x, y) is equivalent to (x < y || x > y).

Also, the macro isunordered returns non-zero if either of its arguments are NaN.

#include <math.h>
float nextafterf(float x, float y);
double nextafter(double x, double y);
long double nextafterl(long double x, long double y);
float nexttowardf(float x, long double y);
double nexttoward(double x, long double y);
long double nexttowardl(long double x, long double y);

#include <tgmath.h>
real-floating-type nextafter(real-floating-type x, real-floating-type y);
real-floating-type nexttoward(real-floating-type x, long double y);

Real floating-point types can be incremented and decremented by the smallest amounts. The nextafter and nexttoward functions return the next representable value after x in the direction of y.

#include <math.h>
int fpclassify(real-floating-type x);

The macro fpclassify takes a value of any real floating-point type, and returns a code indicating what kind of value it is. FP_ZERO is returned if the value is positive or negative zero. FP_INFINITE is returned if the value is positive or negative infinity. FP_NAN is returned if the value is NaN. FP_SUBNORMAL is returned if the value is subnormal. FP_NORMAL is returned if the value is normalized. Other values may have defined meanings.

The macros isinf, isfinite, isnormal and isnan test for specific classifications.

float_t should be the most efficient real floating-point type that is at least as wide as float. double_t should be the most efficient floating-point type that is at least as wide as double. These are defined in <math.h>. FLT_EVAL_METHOD can indicate exactly what these types really are:

[: Need to say how operations involving two floats would be done using float_t, etc.]