Add BFloat16

src/libraries/System.Private.CoreLib/src/Resources/Strings.resx

@@ -4322,4 +4322,7 @@
   <data name="NotSupported_EmitDebugInfo" xml:space="preserve">
     <value>Emitting debug info is not supported for this member.</value>
   </data>
-</root>
+  <data name="Arg_MustBeBFloat16" xml:space="preserve">
+    <value>Object must be of type BFloat16.</value>
+  </data>
+</root>

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -589,6 +589,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Number.Grisu3.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Number.NumberToFloatingPointBits.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Number.Parsing.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\BFloat16.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\BitOperations.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\Matrix3x2.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\Matrix3x2.Impl.cs" />

src/libraries/System.Private.CoreLib/src/System/Half.cs

@@ -738,8 +738,8 @@ public static explicit operator Half(float value)
             const uint SingleBiasedExponentMask = float.BiasedExponentMask;
             // Exponent displacement #2
             const uint Exponent13 = 0x0680_0000u;
-            // Maximum value that is not Infinity in Half
-            const float MaxHalfValueBelowInfinity = 65520.0f;
+            // The value above Half.MaxValue
+            const float HalfAboveMaxValue = 65520.0f;
             // Mask for exponent bits in Half
             const uint ExponentMask = BiasedExponentMask;
             uint bitValue = BitConverter.SingleToUInt32Bits(value);
@@ -750,7 +750,7 @@ public static explicit operator Half(float value)
             // Clear sign bit
             value = float.Abs(value);
             // Rectify values that are Infinity in Half. (float.Min now emits vminps instruction if one of two arguments is a constant)
-            value = float.Min(MaxHalfValueBelowInfinity, value);
+            value = float.Min(HalfAboveMaxValue, value);
             // Rectify lower exponent
             uint exponentOffset0 = BitConverter.SingleToUInt32Bits(float.Max(value, BitConverter.UInt32BitsToSingle(MinExp)));
             // Extract exponent
@@ -1362,7 +1362,7 @@ int IFloatingPoint<Half>.GetExponentShortestBitLength()
         int IFloatingPoint<Half>.GetSignificandByteCount() => sizeof(ushort);
 
         /// <inheritdoc cref="IFloatingPoint{TSelf}.GetSignificandBitLength()" />
-        int IFloatingPoint<Half>.GetSignificandBitLength() => 11;
+        int IFloatingPoint<Half>.GetSignificandBitLength() => SignificandLength;
 
         /// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteExponentBigEndian(Span{byte}, out int)" />
         bool IFloatingPoint<Half>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten)
@@ -2341,7 +2341,7 @@ public static bool TryParse(ReadOnlySpan<byte> utf8Text, NumberStyles style, IFo
         static int IBinaryFloatParseAndFormatInfo<Half>.NumberBufferLength => Number.HalfNumberBufferLength;
 
         static ulong IBinaryFloatParseAndFormatInfo<Half>.ZeroBits => 0;
-        static ulong IBinaryFloatParseAndFormatInfo<Half>.InfinityBits => 0x7C00;
+        static ulong IBinaryFloatParseAndFormatInfo<Half>.InfinityBits => PositiveInfinityBits;
 
         static ulong IBinaryFloatParseAndFormatInfo<Half>.NormalMantissaMask => (1UL << SignificandLength) - 1;
         static ulong IBinaryFloatParseAndFormatInfo<Half>.DenormalMantissaMask => TrailingSignificandMask;
@@ -2353,15 +2353,15 @@ public static bool TryParse(ReadOnlySpan<byte> utf8Text, NumberStyles style, IFo
         static int IBinaryFloatParseAndFormatInfo<Half>.MaxDecimalExponent => 5;
 
         static int IBinaryFloatParseAndFormatInfo<Half>.ExponentBias => ExponentBias;
-        static ushort IBinaryFloatParseAndFormatInfo<Half>.ExponentBits => 5;
+        static ushort IBinaryFloatParseAndFormatInfo<Half>.ExponentBits => BiasedExponentLength;
 
         static int IBinaryFloatParseAndFormatInfo<Half>.OverflowDecimalExponent => (MaxExponent + (2 * SignificandLength)) / 3;
-        static int IBinaryFloatParseAndFormatInfo<Half>.InfinityExponent => 0x1F;
+        static int IBinaryFloatParseAndFormatInfo<Half>.InfinityExponent => MaxBiasedExponent;
 
         static ushort IBinaryFloatParseAndFormatInfo<Half>.NormalMantissaBits => SignificandLength;
         static ushort IBinaryFloatParseAndFormatInfo<Half>.DenormalMantissaBits => TrailingSignificandLength;
 
-        static int IBinaryFloatParseAndFormatInfo<Half>.MinFastFloatDecimalExponent => -8;
+        static int IBinaryFloatParseAndFormatInfo<Half>.MinFastFloatDecimalExponent => -26;
         static int IBinaryFloatParseAndFormatInfo<Half>.MaxFastFloatDecimalExponent => 4;
 
         static int IBinaryFloatParseAndFormatInfo<Half>.MinExponentRoundToEven => -21;

src/libraries/System.Private.CoreLib/src/System/Number.Grisu3.cs

@@ -16,7 +16,7 @@ internal static partial class Number
         // The general idea behind Grisu3 is to leverage additional bits and cached powers of ten to generate the correct digits.
         // The algorithm is imprecise for some numbers. Fortunately, the algorithm itself can determine this scenario and gives us
         // a result indicating success or failure. We must fallback to a different algorithm for the failing scenario.
-        internal static class Grisu3
+        internal static partial class Grisu3
         {
             private const int CachedPowersDecimalExponentDistance = 8;
             private const int CachedPowersMinDecimalExponent = -348;

src/libraries/System.Private.CoreLib/src/System/Number.Parsing.cs

@@ -50,6 +50,9 @@ internal interface IBinaryIntegerParseAndFormatInfo<TSelf> : IBinaryInteger<TSel
     internal interface IBinaryFloatParseAndFormatInfo<TSelf> : IBinaryFloatingPointIeee754<TSelf>, IMinMaxValue<TSelf>
         where TSelf : unmanaged, IBinaryFloatParseAndFormatInfo<TSelf>
     {
+        /// <remarks>
+        /// Ceiling(Log10(5^(Abs(MinBinaryExponent) - 1))) + NormalMantissaBits + 1 + 1
+        /// </remarks>
         static abstract int NumberBufferLength { get; }
 
         static abstract ulong ZeroBits { get; }
@@ -61,7 +64,14 @@ internal interface IBinaryFloatParseAndFormatInfo<TSelf> : IBinaryFloatingPointI
         static abstract int MinBinaryExponent { get; }
         static abstract int MaxBinaryExponent { get; }
 
+        /// <remarks>
+        /// Floor(Log10(Epsilon))
+        /// </remarks>
         static abstract int MinDecimalExponent { get; }
+
+        /// <remarks>
+        /// Ceiling(Log10(MaxValue))
+        /// </remarks>
         static abstract int MaxDecimalExponent { get; }
 
         static abstract int ExponentBias { get; }
@@ -73,29 +83,53 @@ internal interface IBinaryFloatParseAndFormatInfo<TSelf> : IBinaryFloatingPointI
         static abstract ushort NormalMantissaBits { get; }
         static abstract ushort DenormalMantissaBits { get; }
 
+        /// <remarks>
+        /// Ceiling(Log10(2^(MinBinaryExponent - 1 - DenormalMantissaBits - 64)))
+        /// </remarks>
         static abstract int MinFastFloatDecimalExponent { get; }
+
+        /// <remarks>
+        /// MaxDecimalExponent - 1
+        /// </remarks>
         static abstract int MaxFastFloatDecimalExponent { get; }
 
+        /// <remarks>
+        /// -Floor(Log5(2^(64 - NormalMantissaBits)))
+        /// </remarks>
         static abstract int MinExponentRoundToEven { get; }
+
+        /// <remarks>
+        /// Floor(Log5(2^(NormalMantissaBits + 1)))
+        /// </remarks>
         static abstract int MaxExponentRoundToEven { get; }
 
+        /// <summary>
+        /// Max(n) when 10^n can be precisely represented
+        /// </summary>
         static abstract int MaxExponentFastPath { get; }
         static abstract ulong MaxMantissaFastPath { get; }
 
         static abstract TSelf BitsToFloat(ulong bits);
 
         static abstract ulong FloatToBits(TSelf value);
 
-        // Maximum number of digits required to guarantee that any given floating point
-        // number can roundtrip. Some numbers may require less, but none will require more.
+        /// <summary>
+        /// Maximum number of digits required to guarantee that any given floating point
+        /// number can roundtrip. Some numbers may require less, but none will require more.
+        /// </summary>
+        /// <remarks>
+        /// Ceiling(Log10(2^NormalMantissaBits)) + 1
+        /// </remarks>
         static abstract int MaxRoundTripDigits { get; }
 
-        // SinglePrecisionCustomFormat and DoublePrecisionCustomFormat are used to ensure that
-        // custom format strings return the same string as in previous releases when the format
-        // would return x digits or less (where x is the value of the corresponding constant).
-        // In order to support more digits, we would need to update ParseFormatSpecifier to pre-parse
-        // the format and determine exactly how many digits are being requested and whether they
-        // represent "significant digits" or "digits after the decimal point".
+        /// <summary>
+        /// MaxPrecisionCustomFormat is used to ensure that
+        /// custom format strings return the same string as in previous releases when the format
+        /// would return x digits or less (where x is the value of the corresponding constant).
+        /// In order to support more digits, we would need to update ParseFormatSpecifier to pre-parse
+        /// the format and determine exactly how many digits are being requested and whether they
+        /// represent "significant digits" or "digits after the decimal point".
+        /// </summary>
         static abstract int MaxPrecisionCustomFormat { get; }
     }