Small Float Formats: Difference between revisions
(→Low-bitdepth floats: formatting fix.) |
(→Numeric limits and precision: Clarifying the meaning of "decimal") |
||
(21 intermediate revisions by 2 users not shown) | |||
Line 1: | Line 1: | ||
'''Small Float Formats''' | '''Small Float Formats''', are floating-point values that use less than the standard 32-bits of precision. An example of these are 16-bit half-floats. This article details how these are encoded and used. | ||
== IEEE float review == | == IEEE float review == | ||
Line 7: | Line 7: | ||
The IEEE 754 specification defines a floating-point encoding format that breaks a floating-point number into 3 parts: a sign bit, a ''mantissa'', and an ''exponent''. | The IEEE 754 specification defines a floating-point encoding format that breaks a floating-point number into 3 parts: a sign bit, a ''mantissa'', and an ''exponent''. | ||
The mantissa is an unsigned binary number (the sign of the number is in the sign bit) with some particular bitdepth. For 32-bit floats, this depth is 23 bits. The absolute value of the mantissa, when converting it into an actual number, is the mantissa divided by 2 | The mantissa is an unsigned binary number (the sign of the number is in the sign bit) with some particular bitdepth. For 32-bit floats, this depth is 23 bits. The absolute value of the mantissa, when converting it into an actual number, is the mantissa divided by 2<sup>bitdepth</sup>. | ||
The exponent has special handling. This is again an unsigned binary number with a particular bitdepth. A ''bias'' value is based on the | The exponent has special handling. This is again an unsigned binary number with a particular bitdepth. A ''bias'' value is based on the exponent's bitdepth: it is (2<sup>bitdepth - 1</sup>) - 1. For example, 32-bit floats have an exponent bitdepth of 8, so they have a bias of 127 (2<sup>7</sup> - 1). The bias is applied to the absolute value of the exponent depending on the exponent's value. | ||
The actual interpretation of the number depends on the value of the exponent. The exponent can be one of the following: | The actual interpretation of the number depends on the value of the exponent. The exponent can be one of the following: | ||
* 0: The resulting number is the mantissa directly multiplied by 2 | * 0: The resulting number is the mantissa's absolute value directly multiplied by 2<sup>bias - 1</sup>. If the mantissa is also zero, you get 0.0. In floating-point numbers, you can have positive and negative 0, thanks to the sign bit. | ||
* (0, 2 | * (0, 2<sup>bitdepth</sup> - 1): The resulting number is: (1.0 + mantissa) * 2<sup>exponent - bias</sup>. Note the addition of 1.0 to the mantissa in this case. This allows the mantissa to effectively gain one bit of extra precision. | ||
* 2 | * 2<sup>bitdepth</sup> - 1: This will either be infinity or NaN based on the mantissa. A zero mantissa gives infinity, while any other number gives NaN. OpenGL's internal processes will produce undefined results when given Inf or NaN, but they will not crash. | ||
The result of the above is negated if the sign bit is set. | The result of the above is negated if the sign bit is set. | ||
Line 57: | Line 57: | ||
<nowiki>**</nowiki> Used only in RGB9_E5 textures. | <nowiki>**</nowiki> Used only in RGB9_E5 textures. | ||
=== Half floats === | === Half floats === | ||
Line 63: | Line 62: | ||
32-bit floats are often called "single-precision" floats, and 64-bit floats are often called "double-precision" floats. 16-bit floats therefore are called "half-precision" floats, or just "half floats". | 32-bit floats are often called "single-precision" floats, and 64-bit floats are often called "double-precision" floats. 16-bit floats therefore are called "half-precision" floats, or just "half floats". | ||
OpenGL supports the use of half floats in [[Image Formats]], but it also allows them to be used as | OpenGL supports the use of half floats in [[Image Formats]], but it also allows them to be used as [[Vertex Attribute]]s by [[Vertex Format Type|setting the format component type]] to {{enum|GL_HALF_FLOAT}}. | ||
=== R11F_G11F_B10F === | === R11F_G11F_B10F === | ||
The 11 and 10 bit floats are used exclusively for the GL_R11F_G11F_B10F image format. They have no sign bit, as they're generally used to represent image data in floating-point format. | The 11 and 10 bit floats are used exclusively for the {{enum|GL_R11F_G11F_B10F}} image format. They have no sign bit, as they're generally used to represent image data in floating-point format. And negative colors is (usually) not a concept that makes sense. With {{require|4.4|vertex_type_10f_11f_11f_rev}}, this kind of data can be passed as [[Vertex Format Type|vertex data]]. | ||
=== RGB9_E5 === | === RGB9_E5 === | ||
The 14-bit float format is exclusively used in the GL_RGB9_E5 image format. These have no sign bit, as they're generally used to represent image data. They have individual mantissa bits, but share a single exponent for all 3 values. | The 14-bit float format is exclusively used in the {{enum|GL_RGB9_E5}} image format. These have no sign bit, as they're generally used to represent image data. They have individual mantissa bits, but share a single exponent for all 3 values. | ||
=== Numeric limits and precision === | |||
Floating point values have limits and precision. It is important to remember the numeric precision of small float values: | |||
{| class="wikitable" border="1" | |||
|- | |||
! Floating Point Bitdepth | |||
! Largest value | |||
! Smallest value<sup>1</sup> | |||
! Decimal digits of precision<sup>2</sup> | |||
|- | |||
| 32-bit Float | |||
| 3.4028237 × 10<sup>38</sup> | |||
| 1.175494 × 10<sup>-38</sup> | |||
| 7.22 | |||
|- | |||
| 16-bit Float | |||
| 6.55 × 10<sup>4</sup> | |||
| 6.10 × 10<sup>-5</sup> | |||
| 3.31 | |||
|- | |||
| 14-bit Float | |||
| 6.55 × 10<sup>4</sup> | |||
| 6.10 × 10<sup>-5</sup> | |||
| 3.01 <!-- log(2^(9 + 1)) --> | |||
|- | |||
| 11-bit Float | |||
| 6.50 × 10<sup>4</sup> | |||
| 6.10 × 10<sup>-5</sup> | |||
| 2.1 <!-- log(2^(6 + 1)) --> | |||
|- | |||
| 10-bit Float | |||
| 6.50 × 10<sup>4</sup> | |||
| 6.10 × 10<sup>-5</sup> | |||
| 1.8 <!-- log(2^(5 + 1)) --> | |||
|- | |||
|} | |||
<sup>1</sup> Smallest in this case meaning the value most near zero, ignoring [http://en.wikipedia.org/wiki/Denormal_number denormalization]. | |||
<sup>2</sup> "Decimal" here meaning in decimal numerals as opposed to binary numerals. This is not the number of digits past the decimal; it's the number of digits of precision you get in the mantissa. | |||
Take note of the number of decimal digits of precision each format offers. All of the small floats use the same exponent precision (5-bits), so they all cover approximately the same range of values. What matters is how many digits of precision you get for the mantissa. | |||
When you add floats together, you get the precision of the one with the greatest exponent. So if the smaller number cannot be represented with the size of the larger exponent, then the addition does nothing. It is possible therefore for X+Y == X, depending on the relative sizes of X and Y. | |||
Note that once you get the data into the shader, you always get the full 32-bits of floating-point precision. These formats matter when reading from or writing to external memory, such as from textures, FBO writes, or vertex attribute reads. | |||
[[Category:General OpenGL]] | [[Category:General OpenGL]] |
Latest revision as of 18:36, 19 July 2019
Small Float Formats, are floating-point values that use less than the standard 32-bits of precision. An example of these are 16-bit half-floats. This article details how these are encoded and used.
IEEE float review
We start with a quick review on how 32-bit floating-point numbers are encoded; detailed information can be found on Wikipedia.
The IEEE 754 specification defines a floating-point encoding format that breaks a floating-point number into 3 parts: a sign bit, a mantissa, and an exponent.
The mantissa is an unsigned binary number (the sign of the number is in the sign bit) with some particular bitdepth. For 32-bit floats, this depth is 23 bits. The absolute value of the mantissa, when converting it into an actual number, is the mantissa divided by 2^{bitdepth}.
The exponent has special handling. This is again an unsigned binary number with a particular bitdepth. A bias value is based on the exponent's bitdepth: it is (2^{bitdepth - 1}) - 1. For example, 32-bit floats have an exponent bitdepth of 8, so they have a bias of 127 (2^{7} - 1). The bias is applied to the absolute value of the exponent depending on the exponent's value.
The actual interpretation of the number depends on the value of the exponent. The exponent can be one of the following:
- 0: The resulting number is the mantissa's absolute value directly multiplied by 2^{bias - 1}. If the mantissa is also zero, you get 0.0. In floating-point numbers, you can have positive and negative 0, thanks to the sign bit.
- (0, 2^{bitdepth} - 1): The resulting number is: (1.0 + mantissa) * 2^{exponent - bias}. Note the addition of 1.0 to the mantissa in this case. This allows the mantissa to effectively gain one bit of extra precision.
- 2^{bitdepth} - 1: This will either be infinity or NaN based on the mantissa. A zero mantissa gives infinity, while any other number gives NaN. OpenGL's internal processes will produce undefined results when given Inf or NaN, but they will not crash.
The result of the above is negated if the sign bit is set.
This process works for floating-point numbers of any bitdepth.
Low-bitdepth floats
OpenGL supports a number of low bitdpeth floating-point formats. These are:
Overall bitdepth | Sign bitdepth | Mantissa bitdepth | Exponent bitdepth |
---|---|---|---|
16 | 1 | 10 | 5 |
14** | 0* | 9 | 5 |
11 | 0* | 6 | 5 |
10 | 0 | 5 | 5 |
* No sign bits mean that the value is always positive.
** Used only in RGB9_E5 textures.
Half floats
32-bit floats are often called "single-precision" floats, and 64-bit floats are often called "double-precision" floats. 16-bit floats therefore are called "half-precision" floats, or just "half floats".
OpenGL supports the use of half floats in Image Formats, but it also allows them to be used as Vertex Attributes by setting the format component type to GL_HALF_FLOAT.
R11F_G11F_B10F
The 11 and 10 bit floats are used exclusively for the GL_R11F_G11F_B10F image format. They have no sign bit, as they're generally used to represent image data in floating-point format. And negative colors is (usually) not a concept that makes sense. With OpenGL 4.4 or ARB_vertex_type_10f_11f_11f_rev, this kind of data can be passed as vertex data.
RGB9_E5
The 14-bit float format is exclusively used in the GL_RGB9_E5 image format. These have no sign bit, as they're generally used to represent image data. They have individual mantissa bits, but share a single exponent for all 3 values.
Numeric limits and precision
Floating point values have limits and precision. It is important to remember the numeric precision of small float values:
Floating Point Bitdepth | Largest value | Smallest value^{1} | Decimal digits of precision^{2} |
---|---|---|---|
32-bit Float | 3.4028237 × 10^{38} | 1.175494 × 10^{-38} | 7.22 |
16-bit Float | 6.55 × 10^{4} | 6.10 × 10^{-5} | 3.31 |
14-bit Float | 6.55 × 10^{4} | 6.10 × 10^{-5} | 3.01 |
11-bit Float | 6.50 × 10^{4} | 6.10 × 10^{-5} | 2.1 |
10-bit Float | 6.50 × 10^{4} | 6.10 × 10^{-5} | 1.8 |
^{1} Smallest in this case meaning the value most near zero, ignoring denormalization.
^{2} "Decimal" here meaning in decimal numerals as opposed to binary numerals. This is not the number of digits past the decimal; it's the number of digits of precision you get in the mantissa.
Take note of the number of decimal digits of precision each format offers. All of the small floats use the same exponent precision (5-bits), so they all cover approximately the same range of values. What matters is how many digits of precision you get for the mantissa.
When you add floats together, you get the precision of the one with the greatest exponent. So if the smaller number cannot be represented with the size of the larger exponent, then the addition does nothing. It is possible therefore for X+Y == X, depending on the relative sizes of X and Y.
Note that once you get the data into the shader, you always get the full 32-bits of floating-point precision. These formats matter when reading from or writing to external memory, such as from textures, FBO writes, or vertex attribute reads.