/C

# FP_NORMAL, FP_SUBNORMAL, FP_ZERO, FP_INFINITE, FP_NAN

Defined in header `<math.h>`
`#define FP_NORMAL    /*implementation defined*/`
(since C99)
`#define FP_SUBNORMAL /*implementation defined*/`
(since C99)
`#define FP_ZERO      /*implementation defined*/`
(since C99)
`#define FP_INFINITE  /*implementation defined*/`
(since C99)
`#define FP_NAN       /*implementation defined*/`
(since C99)

The `FP_NORMAL`, `FP_SUBNORMAL`, `FP_ZERO`, `FP_INFINITE`, `FP_NAN` macros each represent a distinct category of floating-point numbers. They all expand to an integer constant expression.

Constant Explanation
`FP_NORMAL` indicates that the value is normal, i.e. not an infinity, subnormal, not-a-number or zero
`FP_SUBNORMAL` indicates that the value is subnormal
`FP_ZERO` indicates that the value is positive or negative zero
`FP_INFINITE` indicates that the value is not representable by the underlying type (positive or negative infinity)
`FP_NAN` indicates that the value is not-a-number (NaN)

### Example

```#include <stdio.h>
#include <math.h>
#include <float.h>

const char *show_classification(double x) {
switch(fpclassify(x)) {
case FP_INFINITE:  return "Inf";
case FP_NAN:       return "NaN";
case FP_NORMAL:    return "normal";
case FP_SUBNORMAL: return "subnormal";
case FP_ZERO:      return "zero";
default:           return "unknown";
}
}
int main(void)
{
printf("1.0/0.0 is %s\n", show_classification(1/0.0));
printf("0.0/0.0 is %s\n", show_classification(0.0/0.0));
printf("DBL_MIN/2 is %s\n", show_classification(DBL_MIN/2));
printf("-0.0 is %s\n", show_classification(-0.0));
printf(" 1.0 is %s\n", show_classification(1.0));
}```

Output:

```1.0/0.0 is Inf
0.0/0.0 is NaN
DBL_MIN/2 is subnormal
-0.0 is zero
1.0 is normal```
• C11 standard (ISO/IEC 9899:2011):
• 7.12/6 FP_NORMAL, ... (p: 232)
• C99 standard (ISO/IEC 9899:1999):
• 7.12/6 FP_NORMAL, ... (p: 213)