Clarify IEEE 754 compliance for floating-point types and decimal

docs/csharp/language-reference/builtin-types/floating-point-numeric-types.md

@@ -44,6 +44,8 @@ System.Double b = 12.3;
 
 The default value of each floating-point type is zero, `0`. Each of the floating-point types has the `MinValue` and `MaxValue` constants that provide the minimum and maximum finite value of that type. The `float` and `double` types also provide constants that represent not-a-number and infinity values. For example, the `double` type provides the following constants: <xref:System.Double.NaN?displayProperty=nameWithType>, <xref:System.Double.NegativeInfinity?displayProperty=nameWithType>, and <xref:System.Double.PositiveInfinity?displayProperty=nameWithType>.
 
+The `float` and `double` types conform to the IEEE 754 specification for binary floating-point arithmetic (`binary32` and `binary64`, respectively). The `decimal` type is not an IEEE 754 floating-point format (such as `decimal128`); it does not support NaN or infinity values, and represents numbers using a 96-bit integer mantissa scaled by a power of 10.
+
 The `decimal` type is appropriate when the required degree of precision is determined by the number of digits to the right of the decimal point. Such numbers are commonly used in financial applications, for currency amounts (for example, $1.00), interest rates (for example, 2.625%), and so forth. Even numbers that are precise to only one decimal digit are handled more accurately by the `decimal` type: 0.1, for example, can be exactly represented by a `decimal` instance, while there's no `double` or `float` instance that exactly represents 0.1. Because of this difference in numeric types, unexpected rounding errors can occur in arithmetic calculations when you use `double` or `float` for decimal data. You can use `double` instead of `decimal` when optimizing performance is more important than ensuring accuracy. However, any difference in performance goes unnoticed by all but the most calculation-intensive applications. Another possible reason to avoid `decimal` is to minimize storage requirements. For example, [ML.NET](../../../machine-learning/mldotnet-api.md) uses `float` because the difference between 4 bytes and 16 bytes adds up for very large data sets. For more information, see <xref:System.Decimal?displayProperty=nameWithType>.
 
 You can mix [integral](integral-numeric-types.md) types and the `float` and `double` types in an expression. In this case, integral types are implicitly converted to one of the floating-point types and, if necessary, the `float` type is implicitly converted to `double`. The expression is evaluated as follows: