# FP_NORMAL, FP_SUBNORMAL, FP_ZERO, FP_INFINITE, FP_NAN

> C++ Atlas: `cppatlas.com/w/c/numeric/math/FP_categories` | Source: https://en.cppreference.com/w/c/numeric/math/FP_categories | Domain: Numerics | Standards: C99

The FP_NORMAL, FP_SUBNORMAL, FP_ZERO, FP_INFINITE, FP_NAN macros each represent a distinct category of floating-point numbers.

## Official Specification Summary (cppreference)

```cpp
// 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

```c
#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:

```text
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
```

### References

- C17 standard (ISO/IEC 9899:2018):

  - 7.12/6 FP_NORMAL,... (p: 169-170)

- 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)

### See also

- [`fpclassify`](https://en.cppreference.com/w/c/numeric/math/fpclassify) (C99): classifies the given floating-point value (function macro)
- [C++ documentation for `FP_categories`](https://en.cppreference.com/w/cpp/numeric/math/FP_categories)

---
Attribution: content from https://en.cppreference.com/w/c/numeric/math/FP_categories (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.