Non-Confidential | PDF version | ARM DUI0475M | ||

| ||||

Home > Floating-point Support > IEEE 754 arithmetic > Sample single precision floating-point values for IEEE 754 arithmetic |

Sample `float`

bit patterns, together with their mathematical values.

**Table 3-9 Sample single-precision floating-point values**

Float value | S | Exp | Frac | Mathematical value |
---|---|---|---|---|

`0x3F800000` |
`0` |
`0x7F` |
`000...000` |
`1.0` |

`0xBF800000` |
`1` |
`0x7F` |
`000...000` |
`-1.0` |

`0x3F800001` ^{a} |
`0` |
`0x7F` |
`000...001` |
`1.000 000 119` |

`0x3F400000` |
`0` |
`0x7E` |
`100...000` |
`0.75` |

`0x00800000` ^{b} |
`0` |
`0x01` |
`000...000` |
`1.18*10` |

`0x00000001` ^{c} |
`0` |
`0x00` |
`000...001` |
`1.40*10` |

`0x7F7FFFFF` ^{d} |
`0` |
`0xFE` |
`111...111` |
`3.40*10` |

`0x7F800000` |
`0` |
`0xFF` |
`000...000` |
Plus infinity |

`0xFF800000` |
`1` |
`0xFF` |
`000...000` |
Minus infinity |

`0x00000000` ^{e} |
`0` |
`0x00` |
`000...000` |
`0.0` |

`0x7F800001` |
`0` |
`0xFF` |
`000...001` |
Signaling NaN |

`0x7FC00000` ^{f} |
`0` |
`0xFF` |
`100...000` |
Quiet NaN |

The smallest representable number that can be seen
to be greater than 1.0. The amount that it differs from 1.0 is known
as the machine epsilon. This is 0.000 000 119
in `float`

, and 0.000 000 000 000 000 222 in `double`

.
The machine epsilon gives a rough idea of the number of significant
figures the format can keep track of. `float`

can
do six or seven places. `double`

can do fifteen
or sixteen.

The smallest value that can be represented as a normalized number in each format. Numbers smaller than this can be stored as denormals, but are not held with as much precision.

The smallest positive number that can be distinguished from zero. This is the absolute lower limit of the format.

The largest finite number that can be stored. Attempting to increase this number by addition or multiplication causes overflow and generates infinity (in general).

Zero. Strictly speaking, they show plus zero. Zero
with a sign bit of 1, minus zero, is treated differently by some
operations, although the comparison operations (for example `==`

and `!=`

)
report that the two types of zero are equal.

There are two types of NaNs, signaling NaNs and
quiet NaNs. Quiet NaNs have a 1 in the first bit of `Frac`

, and signaling
NaNs have a zero there. The difference is that signaling NaNs cause
an exception when used, whereas quiet NaNs do not.