# <float.h>

<head><title>&lt;float.h&gt;</title></head>

# `<float.h>`

* * *

Include the standard header **`<float.h>`**
to determine various properties of floating-point type representations.
The standard header `<float.h>` is available even in a
[freestanding implementation](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_lib_over.html#freestanding%20implementation).

You can test the values of any of the integer macros except
[`FLT_ROUNDS`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_float.html#FLT_ROUNDS) in an
[*if* directive](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_preproc.html#if%20directive).
(The macros expand to
[*#if* expressions](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_preproc.html#if%20expression).)
All other macros defined in this header expand to
[floating-point constant expressions](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_express.html#floating-point%20constant%20expression).

Some target environments can change
the rounding and error-reporting properties of floating-point type
representations while the program is running.

    #define FLT_RADIX <#if expression >= 2>
    #define FLT_ROUNDS <integer rvalue>
    #define FLT_EVAL_METHOD <#if expression> [added with C99]
    #define DECIMAL_DIG <#if expression> >= 10 [added with C99]
    
    #define DBL_DIG <#if expression >= 10>
    #define DBL_EPSILON <double constant <= 10^(-9)>
    #define DBL_MANT_DIG <#if expression>
    #define DBL_MAX <double constant >= 10^37>
    #define DBL_MAX_10_EXP <#if expression >= 37>
    #define DBL_MAX_EXP <#if expression>
    #define DBL_MIN <double constant <= 10^(-37)>
    #define DBL_MIN_10_EXP <#if expression <= -37>
    #define DBL_MIN_EXP <#if expression>
    
    #define FLT_DIG <#if expression >= 6>
    #define FLT_EPSILON <float constant <= 10^(-5)>
    #define FLT_MANT_DIG <#if expression>
    #define FLT_MAX <float constant >= 10^37>
    #define FLT_MAX_10_EXP <#if expression >= 37>
    #define FLT_MAX_EXP <#if expression>
    #define FLT_MIN <float constant <= 10^(-37)>
    #define FLT_MIN_10_EXP <#if expression <= -37>
    #define FLT_MIN_EXP <#if expression>
    
    #define LDBL_DIG <#if expression >= 10>
    #define LDBL_EPSILON <long double constant <= 10^(-9)>
    #define LDBL_MANT_DIG <#if expression>
    #define LDBL_MAX <long double constant >= 10^37>
    #define LDBL_MAX_10_EXP <#if expression >= 37>
    #define LDBL_MAX_EXP <#if expression>
    #define LDBL_MIN <long double constant <= 10^(-37)>
    #define LDBL_MIN_10_EXP <#if expression <= -37>
    #define LDBL_MIN_EXP <#if expression>Copy to clipboard

## `DBL_DIG`

    #define DBL_DIG <#if expression >= 10>Copy to clipboard

The macro yields the precision in decimal digits for
type *double.*

## `DBL_EPSILON`

    #define DBL_EPSILON <double constant <= 10^(-9)>Copy to clipboard

The macro yields the smallest *X* of type *double*
such that 1.0 + *X* != 1.0.

## `DBL_MANT_DIG`

    #define DBL_MANT_DIG <#if expression>Copy to clipboard

The macro yields the number of mantissa digits, base
[`FLT_RADIX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_float.html#FLT_RADIX),
for type *double.*

## `DBL_MAX`

    #define DBL_MAX <double constant >= 10^37>Copy to clipboard

The macro yields the largest finite representable value
of type *double.*

## `DBL_MAX_10_EXP`

    #define DBL_MAX_10_EXP <#if expression >= 37>Copy to clipboard

The macro yields the maximum integer *X,* such that
10^*X* is a finite representable value of type *double.*

## `DBL_MAX_EXP`

    #define DBL_MAX_EXP <#if expression>Copy to clipboard

The macro yields the maximum integer *X,* such that
[`FLT_RADIX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_float.html#FLT_RADIX)^(*X* - 1)
is a finite representable value of type *double.*

## `DBL_MIN`

    #define DBL_MIN <double constant <= 10^(-37)>Copy to clipboard

The macro yields the smallest normalized, finite representable
value of type *double.*

## `DBL_MIN_10_EXP`

    #define DBL_MIN_10_EXP <#if expression <= -37>Copy to clipboard

The macro yields the minimum integer *X* such that
10^*X* is a normalized, finite representable value
of type *double.*

## `DBL_MIN_EXP`

    #define DBL_MIN_EXP <#if expression>Copy to clipboard

The macro yields the minimum integer *X* such that
[`FLT_RADIX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_float.html#FLT_RADIX)^(*X* - 1)
is a normalized, finite representable value of type *double.*

## `DECIMAL_DIG`

    #define DECIMAL_DIG <#if expression >= 10> [added with C99]Copy to clipboard

The macro yields the minimum number of decimal digits needed to represent
all the significant digits for type *long double.*

## `FLT_DIG`

    #define FLT_DIG <#if expression >= 6>Copy to clipboard

The macro yields the precision in decimal digits
for type *float.*

## `FLT_EPSILON`

    #define FLT_EPSILON <float constant <= 10^(-5)>Copy to clipboard

The macro yields the smallest *X* of type *float*
such that 1.0 + *X* != 1.0.

## `FLT_EVAL_METHOD`

    #define FLT_EVAL_METHOD <#if expression> [added with C99]Copy to clipboard

The macro yields a value that describes the evaluation
mode for floating-point operations. The values are:

- -1 if the mode is indeterminate
- 0 if no promotions occur
- 1 if *float* values promote to *double*
- 2 if *float* and *double* values promote to *long double*

An implementation can define additional negative values for this macro.

## `FLT_MANT_DIG`

    #define FLT_MANT_DIG <#if expression>Copy to clipboard

The macro yields the number of mantissa digits, base
[`FLT_RADIX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_float.html#FLT_RADIX),
for type *float.*

## `FLT_MAX`

    #define FLT_MAX <float constant >= 10^37>Copy to clipboard

The macro yields the largest finite representable value
of type *float.*

## `FLT_MAX_10_EXP`

    #define FLT_MAX_10_EXP <#if expression >= 37>Copy to clipboard

The macro yields the maximum integer *X,* such that 10^*X*
is a finite representable value of type *float.*

## `FLT_MAX_EXP`

    #define FLT_MAX_EXP <#if expression>Copy to clipboard

The macro yields the maximum integer *X,* such that
[`FLT_RADIX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_float.html#FLT_RADIX)^(*X* - 1)
is a finite representable value of type *float.*

## `FLT_MIN`

    #define FLT_MIN <float constant <= 10^(-37)>Copy to clipboard

The macro yields the smallest normalized, finite representable
value of type *float.*

## `FLT_MIN_10_EXP`

    #define FLT_MIN_10_EXP <#if expression <= -37>Copy to clipboard

The macro yields the minimum integer *X,* such that 10^*X*
is a normalized, finite representable value of type *float.*

## `FLT_MIN_EXP`

    #define FLT_MIN_EXP <#if expression>Copy to clipboard

The macro yields the minimum integer *X,* such that
[`FLT_RADIX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_float.html#FLT_RADIX)^(*X* - 1)
is a normalized, finite representable value of type *float.*

## `FLT_RADIX`

    #define FLT_RADIX <#if expression >= 2>Copy to clipboard

The macro yields the radix of all floating-point representations.

## `FLT_ROUNDS`

    #define FLT_ROUNDS <integer rvalue>Copy to clipboard

The macro yields a value that describes the current rounding
mode for floating-point operations. Note that the target environment
can change the rounding mode while the program executes. How it does
so, however, is not specified. The values are:

- -1 if the mode is indeterminate
- 0 if rounding is toward zero
- 1 if rounding is to nearest representable value
- 2 if rounding is toward positive infinity
- 3 if rounding is toward negative infinity

An implementation can define additional values for this macro.

## `LDBL_DIG`

    #define LDBL_DIG <#if expression >= 10>Copy to clipboard

The macro yields the precision in decimal digits for type *longdouble.*

## `LDBL_EPSILON`

    #define LDBL_EPSILON <long double constant <= 10^(-9)>Copy to clipboard

The macro yields the smallest *X* of type *long double*
such that 1.0 + *X* != 1.0.

## `LDBL_MANT_DIG`

    #define LDBL_MANT_DIG <#if expression>Copy to clipboard

The macro yields the number of mantissa digits, base
[`FLT_RADIX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_float.html#FLT_RADIX),
for type *long double.*

## `LDBL_MAX`

    #define LDBL_MAX <long double constant >= 10^37>Copy to clipboard

The macro yields the largest finite representable value of type
*long double.*

## `LDBL_MAX_10_EXP`

    #define LDBL_MAX_10_EXP <#if expression >= 37>Copy to clipboard

The macro yields the maximum integer *X,* such that
10^*X* is a finite representable value of type *long double.*

## `LDBL_MAX_EXP`

    #define LDBL_MAX_EXP <#if expression>Copy to clipboard

The macro yields the maximum integer *X,* such that
[`FLT_RADIX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_float.html#FLT_RADIX)^(*X* - 1)
is a finite representable value of type *long double.*

## `LDBL_MIN`

    #define LDBL_MIN <long double constant <= 10^(-37)>Copy to clipboard

The macro yields the smallest normalized, finite representable
value of type *long double.*

## `LDBL_MIN_10_EXP`

    #define LDBL_MIN_10_EXP <#if expression <= -37>Copy to clipboard

The macro yields the minimum integer *X,* such that
10^*X* is a normalized, finite representable value
of type *long double.*

## `LDBL_MIN_EXP`

    #define LDBL_MIN_EXP <#if expression>Copy to clipboard

The macro yields the minimum integer *X,* such that
[`FLT_RADIX`](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_float.html#FLT_RADIX)^(*X* - 1)
is a normalized, finite representable value of type *long double.*

* * *

See also the
**[Table of Contents](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_index.html#Table%20of%20Contents)** and the
**[Index](https://docs.qualcomm.com/doc/80-N3040-23/topic/_c_index.html)**.

*[Copyright](https://docs.qualcomm.com/doc/80-N3040-23/topic/c_crit_pjp.html) © 1992-2006by P.J. Plauger and Jim Brodie. All rights reserved.*

<!--V5.01:1566-->

Last Published: Oct 06, 2026

Previous Topic
 
<fenv.h></fenv.h> Next Topic

<inttypes.h></inttypes.h>