Add BFloat16

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

@@ -4379,6 +4379,9 @@
   <data name="NotSupported_EmitDebugInfo" xml:space="preserve">
     <value>Emitting debug info is not supported for this member.</value>
   </data>
+  <data name="Arg_MustBeBFloat16" xml:space="preserve">
+    <value>Object must be of type BFloat16.</value>
+  </data>
   <data name="NotSupported_ReferenceEnumOrPrimitiveTypeRequired" xml:space="preserve">
     <value>The specified type must be a reference type, a primitive type, or an enum type.</value>
   </data>

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

@@ -603,6 +603,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/BitConverter.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -947,6 +948,10 @@ public static bool ToBoolean(ReadOnlySpan<byte> value)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Half Int16BitsToHalf(short value) => new Half((ushort)(value));
 
+        internal static short BFloat16BitsToInt16(BFloat16 value) => (short)value._value;
+
+        internal static BFloat16 Int16BitsToBFloat16(short value) => new BFloat16((ushort)(value));
+
         /// <summary>
         /// Converts the specified double-precision floating point number to a 64-bit unsigned integer.
         /// </summary>
@@ -1000,5 +1005,9 @@ public static bool ToBoolean(ReadOnlySpan<byte> value)
         [CLSCompliant(false)]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Half UInt16BitsToHalf(ushort value) => new Half(value);
+
+        internal static ushort BFloat16BitsToUInt16(BFloat16 value) => value._value;
+
+        internal static BFloat16 UInt16BitsToBFloat16(ushort value) => new BFloat16(value);
     }
 }

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

@@ -906,6 +906,12 @@ static bool INumberBase<byte>.TryConvertToChecked<TOther>(byte value, [MaybeNull
                 result = (TOther)(object)actualResult;
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualResult = value;
+                result = (TOther)(object)actualResult;
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualResult = value;
@@ -980,6 +986,12 @@ static bool INumberBase<byte>.TryConvertToSaturating<TOther>(byte value, [MaybeN
                 result = (TOther)(object)actualResult;
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualResult = value;
+                result = (TOther)(object)actualResult;
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualResult = value;
@@ -1054,6 +1066,12 @@ static bool INumberBase<byte>.TryConvertToTruncating<TOther>(byte value, [MaybeN
                 result = (TOther)(object)actualResult;
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualResult = value;
+                result = (TOther)(object)actualResult;
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualResult = value;

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

@@ -1661,6 +1661,12 @@ static bool INumberBase<decimal>.TryConvertToChecked<TOther>(decimal value, [May
                 result = (TOther)(object)actualResult;
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualResult = checked((BFloat16)value);
+                result = (TOther)(object)actualResult;
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualResult = checked((short)value);
@@ -1749,6 +1755,12 @@ private static bool TryConvertTo<TOther>(decimal value, [MaybeNullWhen(false)] o
                 result = (TOther)(object)actualResult;
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualResult = (BFloat16)value;
+                result = (TOther)(object)actualResult;
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualResult = (value >= short.MaxValue) ? short.MaxValue :

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

@@ -162,6 +162,8 @@ internal static ulong ExtractTrailingSignificandFromBits(ulong bits)
             return bits & TrailingSignificandMask;
         }
 
+        internal static double CreateDouble(bool sign, ushort exp, ulong sig) => BitConverter.UInt64BitsToDouble(((sign ? 1UL : 0UL) << double.SignShift) + ((ulong)exp << double.BiasedExponentShift) + sig);
+
         /// <summary>Determines whether the specified value is finite (zero, subnormal, or normal).</summary>
         /// <remarks>This effectively checks the value is not NaN and not infinite.</remarks>
         [NonVersionable]
@@ -1245,6 +1247,12 @@ private static bool TryConvertFrom<TOther>(TOther value, out double result)
                 result = (double)actualValue;
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualValue = (BFloat16)(object)value;
+                result = (double)actualValue;
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualValue = (short)(object)value;

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 maximum infinitely precise value that will round down to 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
@@ -1015,7 +1015,7 @@ public static explicit operator double(Half value)
                 exp -= 1;
             }
 
-            return CreateDouble(sign, (ushort)(exp + 0x3F0), (ulong)sig << 42);
+            return double.CreateDouble(sign, (ushort)(exp + 0x3F0), (ulong)sig << 42);
         }
 
         /// <summary>Explicitly converts a half-precision floating-point value to its nearest representable <see cref="float" /> value.</summary>
@@ -1177,10 +1177,6 @@ private static double CreateDoubleNaN(bool sign, ulong significand)
             return BitConverter.UInt64BitsToDouble(signInt | NaNBits | sigInt);
         }
 
-        private static float CreateSingle(bool sign, byte exp, uint sig) => BitConverter.UInt32BitsToSingle(((sign ? 1U : 0U) << float.SignShift) + ((uint)exp << float.BiasedExponentShift) + sig);
-
-        private static double CreateDouble(bool sign, ushort exp, ulong sig) => BitConverter.UInt64BitsToDouble(((sign ? 1UL : 0UL) << double.SignShift) + ((ulong)exp << double.BiasedExponentShift) + sig);
-
         #endregion
 
         //
@@ -1360,7 +1356,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)
@@ -2339,7 +2335,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;
@@ -2351,15 +2347,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/Int128.cs

@@ -1522,6 +1522,12 @@ private static bool TryConvertFromChecked<TOther>(TOther value, out Int128 resul
                 result = checked((Int128)actualValue);
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualValue = (BFloat16)(object)value;
+                result = checked((Int128)actualValue);
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualValue = (short)(object)value;
@@ -1594,6 +1600,13 @@ private static bool TryConvertFromSaturating<TOther>(TOther value, out Int128 re
                 result = (Int128)actualValue;
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualValue = (BFloat16)(object)value;
+                result = (actualValue >= BitConverter.UInt16BitsToBFloat16(0x7F00)) /* (BFloat16)MaxValue */ ? MaxValue :
+                         (actualValue <= BitConverter.UInt16BitsToBFloat16(0xFF00)) /* (BFloat16)MinValue */ ? MinValue : (Int128)actualValue;
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualValue = (short)(object)value;
@@ -1666,6 +1679,13 @@ private static bool TryConvertFromTruncating<TOther>(TOther value, out Int128 re
                 result = (Int128)actualValue;
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualValue = (BFloat16)(object)value;
+                result = (actualValue >= BitConverter.UInt16BitsToBFloat16(0x7F00)) ? MaxValue :
+                         (actualValue <= BitConverter.UInt16BitsToBFloat16(0xFF00)) ? MinValue : (Int128)actualValue;
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualValue = (short)(object)value;

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

@@ -898,6 +898,12 @@ private static bool TryConvertFromChecked<TOther>(TOther value, out short result
                 result = checked((short)actualValue);
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualValue = (BFloat16)(object)value;
+                result = checked((short)actualValue);
+                return true;
+            }
             else if (typeof(TOther) == typeof(int))
             {
                 int actualValue = (int)(object)value;
@@ -968,8 +974,15 @@ private static bool TryConvertFromSaturating<TOther>(TOther value, out short res
             else if (typeof(TOther) == typeof(Half))
             {
                 Half actualValue = (Half)(object)value;
-                result = (actualValue >= BitConverter.UInt16BitsToHalf(0x7800)) ? MaxValue :
-                         (actualValue <= BitConverter.UInt16BitsToHalf(0xF800)) ? MinValue : (short)actualValue;
+                result = (actualValue >= BitConverter.UInt16BitsToHalf(0x7800)) /* (Half)MaxValue */ ? MaxValue :
+                         (actualValue <= BitConverter.UInt16BitsToHalf(0xF800)) /* (Half)MinValue */ ? MinValue : (short)actualValue;
+                return true;
+            }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualValue = (BFloat16)(object)value;
+                result = (actualValue >= BitConverter.UInt16BitsToBFloat16(0x4700)) /* (BFloat16)MaxValue */ ? MaxValue :
+                         (actualValue <= BitConverter.UInt16BitsToBFloat16(0xB700)) /* (BFloat16)MinValue */ ? MinValue : (short)actualValue;
                 return true;
             }
             else if (typeof(TOther) == typeof(int))
@@ -1051,6 +1064,13 @@ private static bool TryConvertFromTruncating<TOther>(TOther value, out short res
                          (actualValue <= BitConverter.UInt16BitsToHalf(0xF800)) ? MinValue : (short)actualValue;
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualValue = (BFloat16)(object)value;
+                result = (actualValue >= BitConverter.UInt16BitsToBFloat16(0x4700)) ? MaxValue :
+                         (actualValue <= BitConverter.UInt16BitsToBFloat16(0xB700)) ? MinValue : (short)actualValue;
+                return true;
+            }
             else if (typeof(TOther) == typeof(int))
             {
                 int actualValue = (int)(object)value;

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

@@ -939,6 +939,12 @@ private static bool TryConvertFromChecked<TOther>(TOther value, out int result)
                 result = checked((int)actualValue);
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualValue = (BFloat16)(object)value;
+                result = checked((int)actualValue);
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualValue = (short)(object)value;
@@ -1021,6 +1027,13 @@ private static bool TryConvertFromSaturating<TOther>(TOther value, out int resul
 #endif
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualValue = (BFloat16)(object)value;
+                result = (actualValue >= BitConverter.UInt16BitsToBFloat16(0x4F00)) /* (BFloat16)MaxValue */ ? MaxValue :
+                         (actualValue <= BitConverter.UInt16BitsToBFloat16(0xBF00)) /* (BFloat16)MinValue */ ? MinValue : (int)actualValue;
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualValue = (short)(object)value;
@@ -1111,6 +1124,13 @@ private static bool TryConvertFromTruncating<TOther>(TOther value, out int resul
 #endif
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualValue = (BFloat16)(object)value;
+                result = (actualValue >= BitConverter.UInt16BitsToBFloat16(0x4F00)) ? MaxValue :
+                         (actualValue <= BitConverter.UInt16BitsToBFloat16(0xBF00)) ? MinValue : (int)actualValue;
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualValue = (short)(object)value;

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

@@ -936,6 +936,12 @@ private static bool TryConvertFromChecked<TOther>(TOther value, out long result)
                 result = checked((long)actualValue);
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualValue = (BFloat16)(object)value;
+                result = checked((long)actualValue);
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualValue = (short)(object)value;
@@ -1018,6 +1024,13 @@ private static bool TryConvertFromSaturating<TOther>(TOther value, out long resu
 #endif
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualValue = (BFloat16)(object)value;
+                result = (actualValue >= BitConverter.UInt16BitsToBFloat16(0x5F00)) /* (BFloat16)MaxValue */ ? MaxValue :
+                         (actualValue <= BitConverter.UInt16BitsToBFloat16(0xCF00)) /* (BFloat16)MinValue */ ? MinValue : (long)actualValue;
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualValue = (short)(object)value;
@@ -1106,6 +1119,13 @@ private static bool TryConvertFromTruncating<TOther>(TOther value, out long resu
 #endif
                 return true;
             }
+            else if (typeof(TOther) == typeof(BFloat16))
+            {
+                BFloat16 actualValue = (BFloat16)(object)value;
+                result = (actualValue >= BitConverter.UInt16BitsToBFloat16(0x5F00)) ? MaxValue :
+                         (actualValue <= BitConverter.UInt16BitsToBFloat16(0xCF00)) ? MinValue : (long)actualValue;
+                return true;
+            }
             else if (typeof(TOther) == typeof(short))
             {
                 short actualValue = (short)(object)value;