From 11247731b00865d4f88fbb2a8056cea5368fd78f Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 16 Jan 2026 20:57:01 +0000 Subject: [PATCH 1/7] Initial plan From 147a9a94544631ffa4a830da81e0eb01049423bd Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 16 Jan 2026 21:05:30 +0000 Subject: [PATCH 2/7] Fix BFloat16 TryWriteSignificand methods and add tests - Changed bytesWritten from sizeof(uint) to sizeof(ushort) in TryWriteSignificandBigEndian - Changed bytesWritten from sizeof(uint) to sizeof(ushort) in TryWriteSignificandLittleEndian - Added comprehensive tests for both methods Co-authored-by: EgorBo <523221+EgorBo@users.noreply.github.com> --- .../src/System/Numerics/BFloat16.cs | 4 +- .../System/Numerics/BFloat16Tests.cs | 110 ++++++++++++++++++ 2 files changed, 112 insertions(+), 2 deletions(-) diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/BFloat16.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/BFloat16.cs index 7095ca0a3f10d8..bc55b8d6dd120e 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/BFloat16.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/BFloat16.cs @@ -1048,7 +1048,7 @@ bool IFloatingPoint.TryWriteSignificandBigEndian(Span destinatio { if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, Significand)) { - bytesWritten = sizeof(uint); + bytesWritten = sizeof(ushort); return true; } @@ -1061,7 +1061,7 @@ bool IFloatingPoint.TryWriteSignificandLittleEndian(Span destina { if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, Significand)) { - bytesWritten = sizeof(uint); + bytesWritten = sizeof(ushort); return true; } diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs index 041dccf8528618..f53987512c22dc 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs @@ -2271,6 +2271,116 @@ public static void RadiansToDegreesTest(BFloat16 value, BFloat16 expectedResult, AssertEqual(+expectedResult, BFloat16.RadiansToDegrees(+value), allowedVariance); } + [Fact] + public static void TryWriteSignificandBigEndianTest() + { + Span destination = stackalloc byte[2]; + int bytesWritten = 0; + + Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BFloat16.NegativeInfinity, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0x80 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BFloat16.MinValue, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0xFF }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian((BFloat16)(-1.0f), destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0x80 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(-BFloat16.Epsilon, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0x01 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BitConverter.UInt16BitsToBFloat16(0x8000), destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0x00 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BFloat16.NaN, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0xC0 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BitConverter.UInt16BitsToBFloat16(0x0000), destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0x00 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BFloat16.Epsilon, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0x01 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian((BFloat16)1.0f, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0x80 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BFloat16.MaxValue, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0xFF }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BFloat16.PositiveInfinity, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0x80 }, destination.ToArray()); + + Assert.False(FloatingPointHelper.TryWriteSignificandBigEndian(default, Span.Empty, out bytesWritten)); + Assert.Equal(0, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0x80 }, destination.ToArray()); + } + + [Fact] + public static void TryWriteSignificandLittleEndianTest() + { + Span destination = stackalloc byte[2]; + int bytesWritten = 0; + + Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BFloat16.NegativeInfinity, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x80, 0x00 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BFloat16.MinValue, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0xFF, 0x00 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian((BFloat16)(-1.0f), destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x80, 0x00 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(-BFloat16.Epsilon, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x01, 0x00 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BitConverter.UInt16BitsToBFloat16(0x8000), destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0x00 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BFloat16.NaN, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0xC0, 0x00 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BitConverter.UInt16BitsToBFloat16(0x0000), destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x00, 0x00 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BFloat16.Epsilon, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x01, 0x00 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian((BFloat16)1.0f, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x80, 0x00 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BFloat16.MaxValue, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0xFF, 0x00 }, destination.ToArray()); + + Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BFloat16.PositiveInfinity, destination, out bytesWritten)); + Assert.Equal(2, bytesWritten); + Assert.Equal(new byte[] { 0x80, 0x00 }, destination.ToArray()); + + Assert.False(FloatingPointHelper.TryWriteSignificandLittleEndian(default, Span.Empty, out bytesWritten)); + Assert.Equal(0, bytesWritten); + Assert.Equal(new byte[] { 0x80, 0x00 }, destination.ToArray()); + } + #region AssertExtentions static bool IsNegativeZero(BFloat16 value) { From 2d899b60ebe55004511c259fcb5c794e371569f7 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 16 Jan 2026 22:37:37 +0000 Subject: [PATCH 3/7] Refactor tests to use [Theory] with [InlineData] MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Converted TryWriteSignificandBigEndianTest to [Theory] with [InlineData] attributes - Converted TryWriteSignificandLittleEndianTest to [Theory] with [InlineData] attributes - Separated empty destination tests into dedicated [Fact] methods - Removed duplicate test cases (same significand for ±0.0 and ±Epsilon) Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com> --- .../System/Numerics/BFloat16Tests.cs | 142 ++++++------------ 1 file changed, 50 insertions(+), 92 deletions(-) diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs index f53987512c22dc..c7fe099848babe 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs @@ -2271,110 +2271,68 @@ public static void RadiansToDegreesTest(BFloat16 value, BFloat16 expectedResult, AssertEqual(+expectedResult, BFloat16.RadiansToDegrees(+value), allowedVariance); } - [Fact] - public static void TryWriteSignificandBigEndianTest() - { + [Theory] + [InlineData(float.NegativeInfinity, 2, new byte[] { 0x00, 0x80 })] + [InlineData(-3.40282347E+38f, 2, new byte[] { 0x00, 0xFF })] // MinValue + [InlineData(-1.0f, 2, new byte[] { 0x00, 0x80 })] + [InlineData(-1.1754944E-38f, 2, new byte[] { 0x00, 0x01 })] // -Epsilon + [InlineData(float.NaN, 2, new byte[] { 0x00, 0xC0 })] + [InlineData(0.0f, 2, new byte[] { 0x00, 0x00 })] // Zero + [InlineData(1.0f, 2, new byte[] { 0x00, 0x80 })] + [InlineData(3.40282347E+38f, 2, new byte[] { 0x00, 0xFF })] // MaxValue + [InlineData(float.PositiveInfinity, 2, new byte[] { 0x00, 0x80 })] + public static void TryWriteSignificandBigEndianTest(float floatValue, int expectedBytesWritten, byte[] expectedBytes) + { + BFloat16 value = (BFloat16)floatValue; Span destination = stackalloc byte[2]; - int bytesWritten = 0; - - Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BFloat16.NegativeInfinity, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0x80 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BFloat16.MinValue, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0xFF }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian((BFloat16)(-1.0f), destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0x80 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(-BFloat16.Epsilon, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0x01 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BitConverter.UInt16BitsToBFloat16(0x8000), destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0x00 }, destination.ToArray()); + int bytesWritten; - Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BFloat16.NaN, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0xC0 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BitConverter.UInt16BitsToBFloat16(0x0000), destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0x00 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BFloat16.Epsilon, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0x01 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian((BFloat16)1.0f, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0x80 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BFloat16.MaxValue, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0xFF }, destination.ToArray()); + Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(value, destination, out bytesWritten)); + Assert.Equal(expectedBytesWritten, bytesWritten); + Assert.Equal(expectedBytes, destination.ToArray()); + } - Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(BFloat16.PositiveInfinity, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0x80 }, destination.ToArray()); + [Fact] + public static void TryWriteSignificandBigEndianTest_EmptyDestination() + { + Span destination = stackalloc byte[2]; + destination[0] = 0x00; + destination[1] = 0x80; + int bytesWritten; Assert.False(FloatingPointHelper.TryWriteSignificandBigEndian(default, Span.Empty, out bytesWritten)); Assert.Equal(0, bytesWritten); Assert.Equal(new byte[] { 0x00, 0x80 }, destination.ToArray()); } - [Fact] - public static void TryWriteSignificandLittleEndianTest() - { + [Theory] + [InlineData(float.NegativeInfinity, 2, new byte[] { 0x80, 0x00 })] + [InlineData(-3.40282347E+38f, 2, new byte[] { 0xFF, 0x00 })] // MinValue + [InlineData(-1.0f, 2, new byte[] { 0x80, 0x00 })] + [InlineData(-1.1754944E-38f, 2, new byte[] { 0x01, 0x00 })] // -Epsilon + [InlineData(float.NaN, 2, new byte[] { 0xC0, 0x00 })] + [InlineData(0.0f, 2, new byte[] { 0x00, 0x00 })] // Zero + [InlineData(1.0f, 2, new byte[] { 0x80, 0x00 })] + [InlineData(3.40282347E+38f, 2, new byte[] { 0xFF, 0x00 })] // MaxValue + [InlineData(float.PositiveInfinity, 2, new byte[] { 0x80, 0x00 })] + public static void TryWriteSignificandLittleEndianTest(float floatValue, int expectedBytesWritten, byte[] expectedBytes) + { + BFloat16 value = (BFloat16)floatValue; Span destination = stackalloc byte[2]; - int bytesWritten = 0; - - Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BFloat16.NegativeInfinity, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x80, 0x00 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BFloat16.MinValue, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0xFF, 0x00 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian((BFloat16)(-1.0f), destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x80, 0x00 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(-BFloat16.Epsilon, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x01, 0x00 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BitConverter.UInt16BitsToBFloat16(0x8000), destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0x00 }, destination.ToArray()); + int bytesWritten; - Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BFloat16.NaN, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0xC0, 0x00 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BitConverter.UInt16BitsToBFloat16(0x0000), destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0x00 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BFloat16.Epsilon, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x01, 0x00 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian((BFloat16)1.0f, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x80, 0x00 }, destination.ToArray()); - - Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BFloat16.MaxValue, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0xFF, 0x00 }, destination.ToArray()); + Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(value, destination, out bytesWritten)); + Assert.Equal(expectedBytesWritten, bytesWritten); + Assert.Equal(expectedBytes, destination.ToArray()); + } - Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(BFloat16.PositiveInfinity, destination, out bytesWritten)); - Assert.Equal(2, bytesWritten); - Assert.Equal(new byte[] { 0x80, 0x00 }, destination.ToArray()); + [Fact] + public static void TryWriteSignificandLittleEndianTest_EmptyDestination() + { + Span destination = stackalloc byte[2]; + destination[0] = 0x80; + destination[1] = 0x00; + int bytesWritten; Assert.False(FloatingPointHelper.TryWriteSignificandLittleEndian(default, Span.Empty, out bytesWritten)); Assert.Equal(0, bytesWritten); From b44d1de6fa9b9f30ec1858825d2fbb8e4a0ba3d7 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Sat, 17 Jan 2026 00:45:34 +0000 Subject: [PATCH 4/7] Fix test data to use BFloat16 constants instead of float conversions - Changed from [InlineData] with float values to [MemberData] with BFloat16 values - Use BFloat16.MinValue/MaxValue instead of float.MinValue/MaxValue conversions - This ensures test data matches the actual BFloat16 representation - Fixes CI test failures where float-to-BFloat16 conversions produced different values Co-authored-by: EgorBo <523221+EgorBo@users.noreply.github.com> --- .../System/Numerics/BFloat16Tests.cs | 56 +++++++++++-------- 1 file changed, 32 insertions(+), 24 deletions(-) diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs index c7fe099848babe..26c666b85a90b9 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs @@ -2271,19 +2271,23 @@ public static void RadiansToDegreesTest(BFloat16 value, BFloat16 expectedResult, AssertEqual(+expectedResult, BFloat16.RadiansToDegrees(+value), allowedVariance); } + public static IEnumerable TryWriteSignificandBigEndianTest_TestData() + { + yield return new object[] { BFloat16.NegativeInfinity, 2, new byte[] { 0x00, 0x80 } }; + yield return new object[] { BFloat16.MinValue, 2, new byte[] { 0x00, 0xFF } }; + yield return new object[] { (BFloat16)(-1.0f), 2, new byte[] { 0x00, 0x80 } }; + yield return new object[] { -BFloat16.Epsilon, 2, new byte[] { 0x00, 0x01 } }; + yield return new object[] { BFloat16.NaN, 2, new byte[] { 0x00, 0xC0 } }; + yield return new object[] { (BFloat16)0.0f, 2, new byte[] { 0x00, 0x00 } }; + yield return new object[] { (BFloat16)1.0f, 2, new byte[] { 0x00, 0x80 } }; + yield return new object[] { BFloat16.MaxValue, 2, new byte[] { 0x00, 0xFF } }; + yield return new object[] { BFloat16.PositiveInfinity, 2, new byte[] { 0x00, 0x80 } }; + } + [Theory] - [InlineData(float.NegativeInfinity, 2, new byte[] { 0x00, 0x80 })] - [InlineData(-3.40282347E+38f, 2, new byte[] { 0x00, 0xFF })] // MinValue - [InlineData(-1.0f, 2, new byte[] { 0x00, 0x80 })] - [InlineData(-1.1754944E-38f, 2, new byte[] { 0x00, 0x01 })] // -Epsilon - [InlineData(float.NaN, 2, new byte[] { 0x00, 0xC0 })] - [InlineData(0.0f, 2, new byte[] { 0x00, 0x00 })] // Zero - [InlineData(1.0f, 2, new byte[] { 0x00, 0x80 })] - [InlineData(3.40282347E+38f, 2, new byte[] { 0x00, 0xFF })] // MaxValue - [InlineData(float.PositiveInfinity, 2, new byte[] { 0x00, 0x80 })] - public static void TryWriteSignificandBigEndianTest(float floatValue, int expectedBytesWritten, byte[] expectedBytes) - { - BFloat16 value = (BFloat16)floatValue; + [MemberData(nameof(TryWriteSignificandBigEndianTest_TestData))] + public static void TryWriteSignificandBigEndianTest(BFloat16 value, int expectedBytesWritten, byte[] expectedBytes) + { Span destination = stackalloc byte[2]; int bytesWritten; @@ -2305,19 +2309,23 @@ public static void TryWriteSignificandBigEndianTest_EmptyDestination() Assert.Equal(new byte[] { 0x00, 0x80 }, destination.ToArray()); } + public static IEnumerable TryWriteSignificandLittleEndianTest_TestData() + { + yield return new object[] { BFloat16.NegativeInfinity, 2, new byte[] { 0x80, 0x00 } }; + yield return new object[] { BFloat16.MinValue, 2, new byte[] { 0xFF, 0x00 } }; + yield return new object[] { (BFloat16)(-1.0f), 2, new byte[] { 0x80, 0x00 } }; + yield return new object[] { -BFloat16.Epsilon, 2, new byte[] { 0x01, 0x00 } }; + yield return new object[] { BFloat16.NaN, 2, new byte[] { 0xC0, 0x00 } }; + yield return new object[] { (BFloat16)0.0f, 2, new byte[] { 0x00, 0x00 } }; + yield return new object[] { (BFloat16)1.0f, 2, new byte[] { 0x80, 0x00 } }; + yield return new object[] { BFloat16.MaxValue, 2, new byte[] { 0xFF, 0x00 } }; + yield return new object[] { BFloat16.PositiveInfinity, 2, new byte[] { 0x80, 0x00 } }; + } + [Theory] - [InlineData(float.NegativeInfinity, 2, new byte[] { 0x80, 0x00 })] - [InlineData(-3.40282347E+38f, 2, new byte[] { 0xFF, 0x00 })] // MinValue - [InlineData(-1.0f, 2, new byte[] { 0x80, 0x00 })] - [InlineData(-1.1754944E-38f, 2, new byte[] { 0x01, 0x00 })] // -Epsilon - [InlineData(float.NaN, 2, new byte[] { 0xC0, 0x00 })] - [InlineData(0.0f, 2, new byte[] { 0x00, 0x00 })] // Zero - [InlineData(1.0f, 2, new byte[] { 0x80, 0x00 })] - [InlineData(3.40282347E+38f, 2, new byte[] { 0xFF, 0x00 })] // MaxValue - [InlineData(float.PositiveInfinity, 2, new byte[] { 0x80, 0x00 })] - public static void TryWriteSignificandLittleEndianTest(float floatValue, int expectedBytesWritten, byte[] expectedBytes) - { - BFloat16 value = (BFloat16)floatValue; + [MemberData(nameof(TryWriteSignificandLittleEndianTest_TestData))] + public static void TryWriteSignificandLittleEndianTest(BFloat16 value, int expectedBytesWritten, byte[] expectedBytes) + { Span destination = stackalloc byte[2]; int bytesWritten; From 062a536876d5b64631bcc1480f508354fd1cb9c6 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Sat, 17 Jan 2026 01:08:46 +0000 Subject: [PATCH 5/7] Use collection literal syntax for test data - Changed from yield return new object[] { ... } to collection literal [ ... ] syntax - Applied to both TryWriteSignificandBigEndianTest_TestData and TryWriteSignificandLittleEndianTest_TestData - Uses expression-bodied member syntax with => for cleaner code Co-authored-by: EgorBo <523221+EgorBo@users.noreply.github.com> --- .../System/Numerics/BFloat16Tests.cs | 48 +++++++++---------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs index 26c666b85a90b9..93e41d03adfc1f 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs @@ -2271,18 +2271,18 @@ public static void RadiansToDegreesTest(BFloat16 value, BFloat16 expectedResult, AssertEqual(+expectedResult, BFloat16.RadiansToDegrees(+value), allowedVariance); } - public static IEnumerable TryWriteSignificandBigEndianTest_TestData() - { - yield return new object[] { BFloat16.NegativeInfinity, 2, new byte[] { 0x00, 0x80 } }; - yield return new object[] { BFloat16.MinValue, 2, new byte[] { 0x00, 0xFF } }; - yield return new object[] { (BFloat16)(-1.0f), 2, new byte[] { 0x00, 0x80 } }; - yield return new object[] { -BFloat16.Epsilon, 2, new byte[] { 0x00, 0x01 } }; - yield return new object[] { BFloat16.NaN, 2, new byte[] { 0x00, 0xC0 } }; - yield return new object[] { (BFloat16)0.0f, 2, new byte[] { 0x00, 0x00 } }; - yield return new object[] { (BFloat16)1.0f, 2, new byte[] { 0x00, 0x80 } }; - yield return new object[] { BFloat16.MaxValue, 2, new byte[] { 0x00, 0xFF } }; - yield return new object[] { BFloat16.PositiveInfinity, 2, new byte[] { 0x00, 0x80 } }; - } + public static IEnumerable TryWriteSignificandBigEndianTest_TestData() => + [ + [BFloat16.NegativeInfinity, 2, new byte[] { 0x00, 0x80 }], + [BFloat16.MinValue, 2, new byte[] { 0x00, 0xFF }], + [(BFloat16)(-1.0f), 2, new byte[] { 0x00, 0x80 }], + [-BFloat16.Epsilon, 2, new byte[] { 0x00, 0x01 }], + [BFloat16.NaN, 2, new byte[] { 0x00, 0xC0 }], + [(BFloat16)0.0f, 2, new byte[] { 0x00, 0x00 }], + [(BFloat16)1.0f, 2, new byte[] { 0x00, 0x80 }], + [BFloat16.MaxValue, 2, new byte[] { 0x00, 0xFF }], + [BFloat16.PositiveInfinity, 2, new byte[] { 0x00, 0x80 }], + ]; [Theory] [MemberData(nameof(TryWriteSignificandBigEndianTest_TestData))] @@ -2309,18 +2309,18 @@ public static void TryWriteSignificandBigEndianTest_EmptyDestination() Assert.Equal(new byte[] { 0x00, 0x80 }, destination.ToArray()); } - public static IEnumerable TryWriteSignificandLittleEndianTest_TestData() - { - yield return new object[] { BFloat16.NegativeInfinity, 2, new byte[] { 0x80, 0x00 } }; - yield return new object[] { BFloat16.MinValue, 2, new byte[] { 0xFF, 0x00 } }; - yield return new object[] { (BFloat16)(-1.0f), 2, new byte[] { 0x80, 0x00 } }; - yield return new object[] { -BFloat16.Epsilon, 2, new byte[] { 0x01, 0x00 } }; - yield return new object[] { BFloat16.NaN, 2, new byte[] { 0xC0, 0x00 } }; - yield return new object[] { (BFloat16)0.0f, 2, new byte[] { 0x00, 0x00 } }; - yield return new object[] { (BFloat16)1.0f, 2, new byte[] { 0x80, 0x00 } }; - yield return new object[] { BFloat16.MaxValue, 2, new byte[] { 0xFF, 0x00 } }; - yield return new object[] { BFloat16.PositiveInfinity, 2, new byte[] { 0x80, 0x00 } }; - } + public static IEnumerable TryWriteSignificandLittleEndianTest_TestData() => + [ + [BFloat16.NegativeInfinity, 2, new byte[] { 0x80, 0x00 }], + [BFloat16.MinValue, 2, new byte[] { 0xFF, 0x00 }], + [(BFloat16)(-1.0f), 2, new byte[] { 0x80, 0x00 }], + [-BFloat16.Epsilon, 2, new byte[] { 0x01, 0x00 }], + [BFloat16.NaN, 2, new byte[] { 0xC0, 0x00 }], + [(BFloat16)0.0f, 2, new byte[] { 0x00, 0x00 }], + [(BFloat16)1.0f, 2, new byte[] { 0x80, 0x00 }], + [BFloat16.MaxValue, 2, new byte[] { 0xFF, 0x00 }], + [BFloat16.PositiveInfinity, 2, new byte[] { 0x80, 0x00 }], + ]; [Theory] [MemberData(nameof(TryWriteSignificandLittleEndianTest_TestData))] From 84166d8948af2fa327be9aa2d0f3bc54c585da24 Mon Sep 17 00:00:00 2001 From: Egor Bogatov Date: Sat, 17 Jan 2026 04:31:53 +0100 Subject: [PATCH 6/7] Update BFloat16Tests.cs --- .../System/Numerics/BFloat16Tests.cs | 28 ++++--------------- 1 file changed, 6 insertions(+), 22 deletions(-) diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs index 93e41d03adfc1f..86d314f8000789 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs @@ -2288,10 +2288,8 @@ public static IEnumerable TryWriteSignificandBigEndianTest_TestData() [MemberData(nameof(TryWriteSignificandBigEndianTest_TestData))] public static void TryWriteSignificandBigEndianTest(BFloat16 value, int expectedBytesWritten, byte[] expectedBytes) { - Span destination = stackalloc byte[2]; - int bytesWritten; - - Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(value, destination, out bytesWritten)); + Span destination = [0, 0]; + Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(value, destination, out int bytesWritten)); Assert.Equal(expectedBytesWritten, bytesWritten); Assert.Equal(expectedBytes, destination.ToArray()); } @@ -2299,14 +2297,8 @@ public static void TryWriteSignificandBigEndianTest(BFloat16 value, int expected [Fact] public static void TryWriteSignificandBigEndianTest_EmptyDestination() { - Span destination = stackalloc byte[2]; - destination[0] = 0x00; - destination[1] = 0x80; - int bytesWritten; - - Assert.False(FloatingPointHelper.TryWriteSignificandBigEndian(default, Span.Empty, out bytesWritten)); + Assert.False(FloatingPointHelper.TryWriteSignificandBigEndian(default, Span.Empty, out int bytesWritten)); Assert.Equal(0, bytesWritten); - Assert.Equal(new byte[] { 0x00, 0x80 }, destination.ToArray()); } public static IEnumerable TryWriteSignificandLittleEndianTest_TestData() => @@ -2326,10 +2318,8 @@ public static IEnumerable TryWriteSignificandLittleEndianTest_TestData [MemberData(nameof(TryWriteSignificandLittleEndianTest_TestData))] public static void TryWriteSignificandLittleEndianTest(BFloat16 value, int expectedBytesWritten, byte[] expectedBytes) { - Span destination = stackalloc byte[2]; - int bytesWritten; - - Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(value, destination, out bytesWritten)); + Span destination = [0, 0]; + Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(value, destination, out int bytesWritten)); Assert.Equal(expectedBytesWritten, bytesWritten); Assert.Equal(expectedBytes, destination.ToArray()); } @@ -2337,14 +2327,8 @@ public static void TryWriteSignificandLittleEndianTest(BFloat16 value, int expec [Fact] public static void TryWriteSignificandLittleEndianTest_EmptyDestination() { - Span destination = stackalloc byte[2]; - destination[0] = 0x80; - destination[1] = 0x00; - int bytesWritten; - - Assert.False(FloatingPointHelper.TryWriteSignificandLittleEndian(default, Span.Empty, out bytesWritten)); + Assert.False(FloatingPointHelper.TryWriteSignificandLittleEndian(default, Span.Empty, out int bytesWritten)); Assert.Equal(0, bytesWritten); - Assert.Equal(new byte[] { 0x80, 0x00 }, destination.ToArray()); } #region AssertExtentions From ca5fb3564f7cbdae73490434872de6c90a8d4c48 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Sat, 17 Jan 2026 23:57:57 +0000 Subject: [PATCH 7/7] Change BFloat16.Significand from ushort to byte - Changed Significand property from ushort to byte (BFloat16 has 8-bit significand) - Updated GetSignificandByteCount to return sizeof(byte) instead of sizeof(ushort) - Updated TryWriteSignificandBigEndian to write 1 byte directly (no endianness needed) - Updated TryWriteSignificandLittleEndian to write 1 byte directly (no endianness needed) - Updated test data to expect 1 byte written instead of 2 bytes - Updated test destination buffers from [0, 0] to [0] Co-authored-by: EgorBo <523221+EgorBo@users.noreply.github.com> --- .../src/System/Numerics/BFloat16.cs | 16 ++++---- .../System/Numerics/BFloat16Tests.cs | 40 +++++++++---------- 2 files changed, 29 insertions(+), 27 deletions(-) diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/BFloat16.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/BFloat16.cs index bc55b8d6dd120e..9cb4fb9e09da08 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/BFloat16.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/BFloat16.cs @@ -116,11 +116,11 @@ internal sbyte Exponent } } - internal ushort Significand + internal byte Significand { get { - return (ushort)(TrailingSignificand | ((BiasedExponent != 0) ? (1U << BiasedExponentShift) : 0U)); + return (byte)(TrailingSignificand | ((BiasedExponent != 0) ? (1U << BiasedExponentShift) : 0U)); } } @@ -1010,7 +1010,7 @@ int IFloatingPoint.GetExponentShortestBitLength() } /// - int IFloatingPoint.GetSignificandByteCount() => sizeof(ushort); + int IFloatingPoint.GetSignificandByteCount() => sizeof(byte); /// int IFloatingPoint.GetSignificandBitLength() => SignificandLength; @@ -1046,9 +1046,10 @@ bool IFloatingPoint.TryWriteExponentLittleEndian(Span destinatio /// bool IFloatingPoint.TryWriteSignificandBigEndian(Span destination, out int bytesWritten) { - if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, Significand)) + if (destination.Length >= sizeof(byte)) { - bytesWritten = sizeof(ushort); + destination[0] = Significand; + bytesWritten = sizeof(byte); return true; } @@ -1059,9 +1060,10 @@ bool IFloatingPoint.TryWriteSignificandBigEndian(Span destinatio /// bool IFloatingPoint.TryWriteSignificandLittleEndian(Span destination, out int bytesWritten) { - if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, Significand)) + if (destination.Length >= sizeof(byte)) { - bytesWritten = sizeof(ushort); + destination[0] = Significand; + bytesWritten = sizeof(byte); return true; } diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs index 86d314f8000789..c4e3e40c3adce7 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Numerics/BFloat16Tests.cs @@ -2273,22 +2273,22 @@ public static void RadiansToDegreesTest(BFloat16 value, BFloat16 expectedResult, public static IEnumerable TryWriteSignificandBigEndianTest_TestData() => [ - [BFloat16.NegativeInfinity, 2, new byte[] { 0x00, 0x80 }], - [BFloat16.MinValue, 2, new byte[] { 0x00, 0xFF }], - [(BFloat16)(-1.0f), 2, new byte[] { 0x00, 0x80 }], - [-BFloat16.Epsilon, 2, new byte[] { 0x00, 0x01 }], - [BFloat16.NaN, 2, new byte[] { 0x00, 0xC0 }], - [(BFloat16)0.0f, 2, new byte[] { 0x00, 0x00 }], - [(BFloat16)1.0f, 2, new byte[] { 0x00, 0x80 }], - [BFloat16.MaxValue, 2, new byte[] { 0x00, 0xFF }], - [BFloat16.PositiveInfinity, 2, new byte[] { 0x00, 0x80 }], + [BFloat16.NegativeInfinity, 1, new byte[] { 0x80 }], + [BFloat16.MinValue, 1, new byte[] { 0xFF }], + [(BFloat16)(-1.0f), 1, new byte[] { 0x80 }], + [-BFloat16.Epsilon, 1, new byte[] { 0x01 }], + [BFloat16.NaN, 1, new byte[] { 0xC0 }], + [(BFloat16)0.0f, 1, new byte[] { 0x00 }], + [(BFloat16)1.0f, 1, new byte[] { 0x80 }], + [BFloat16.MaxValue, 1, new byte[] { 0xFF }], + [BFloat16.PositiveInfinity, 1, new byte[] { 0x80 }], ]; [Theory] [MemberData(nameof(TryWriteSignificandBigEndianTest_TestData))] public static void TryWriteSignificandBigEndianTest(BFloat16 value, int expectedBytesWritten, byte[] expectedBytes) { - Span destination = [0, 0]; + Span destination = [0]; Assert.True(FloatingPointHelper.TryWriteSignificandBigEndian(value, destination, out int bytesWritten)); Assert.Equal(expectedBytesWritten, bytesWritten); Assert.Equal(expectedBytes, destination.ToArray()); @@ -2303,22 +2303,22 @@ public static void TryWriteSignificandBigEndianTest_EmptyDestination() public static IEnumerable TryWriteSignificandLittleEndianTest_TestData() => [ - [BFloat16.NegativeInfinity, 2, new byte[] { 0x80, 0x00 }], - [BFloat16.MinValue, 2, new byte[] { 0xFF, 0x00 }], - [(BFloat16)(-1.0f), 2, new byte[] { 0x80, 0x00 }], - [-BFloat16.Epsilon, 2, new byte[] { 0x01, 0x00 }], - [BFloat16.NaN, 2, new byte[] { 0xC0, 0x00 }], - [(BFloat16)0.0f, 2, new byte[] { 0x00, 0x00 }], - [(BFloat16)1.0f, 2, new byte[] { 0x80, 0x00 }], - [BFloat16.MaxValue, 2, new byte[] { 0xFF, 0x00 }], - [BFloat16.PositiveInfinity, 2, new byte[] { 0x80, 0x00 }], + [BFloat16.NegativeInfinity, 1, new byte[] { 0x80 }], + [BFloat16.MinValue, 1, new byte[] { 0xFF }], + [(BFloat16)(-1.0f), 1, new byte[] { 0x80 }], + [-BFloat16.Epsilon, 1, new byte[] { 0x01 }], + [BFloat16.NaN, 1, new byte[] { 0xC0 }], + [(BFloat16)0.0f, 1, new byte[] { 0x00 }], + [(BFloat16)1.0f, 1, new byte[] { 0x80 }], + [BFloat16.MaxValue, 1, new byte[] { 0xFF }], + [BFloat16.PositiveInfinity, 1, new byte[] { 0x80 }], ]; [Theory] [MemberData(nameof(TryWriteSignificandLittleEndianTest_TestData))] public static void TryWriteSignificandLittleEndianTest(BFloat16 value, int expectedBytesWritten, byte[] expectedBytes) { - Span destination = [0, 0]; + Span destination = [0]; Assert.True(FloatingPointHelper.TryWriteSignificandLittleEndian(value, destination, out int bytesWritten)); Assert.Equal(expectedBytesWritten, bytesWritten); Assert.Equal(expectedBytes, destination.ToArray());