Provide support for alternative rounding modes for division and remainder of division #106795

AlexRadch · 2024-08-22T04:51:33Z

…nder of division

ghost · 2024-08-22T04:51:39Z

Note regarding the new-api-needs-documentation label:

This serves as a reminder for when your PR is modifying a ref *.cs file and adding/modifying public APIs, please make sure the API implementation in the src *.cs file is documented with triple slash comments, so the PR reviewers can sign off that change.

ghost · 2024-08-22T04:51:41Z

Note regarding the new-api-needs-documentation label:

This serves as a reminder for when your PR is modifying a ref *.cs file and adding/modifying public APIs, please make sure the API implementation in the src *.cs file is documented with triple slash comments, so the PR reviewers can sign off that change.

src/libraries/System.Private.CoreLib/src/System/Numerics/IBinaryInteger.cs

src/libraries/System.Private.CoreLib/src/System/Numerics/DivisionRounding.cs

huoyaoyuan · 2024-08-22T05:05:25Z

This is also duplicated with #104589

AlexRadch · 2024-08-22T05:17:20Z

This is also duplicated with #104589

I overlooked this PR. My PR has many tests that you can use.

Corrected the file path for `DivisionRounding.cs` from a lowercase 's' in "system" to an uppercase 'S' in "System" to ensure consistency with the project structure.

Copilot

Pull Request Overview

This PR implements support for alternative division rounding modes by introducing a new DivisionRounding enum and extending the IBinaryInteger<TSelf> interface with new overloads for Divide, DivRem, and Remainder methods that accept a DivisionRounding parameter. The implementation provides five rounding strategies: Truncate, Floor, Ceiling, AwayFromZero, and Euclidean.

Key Changes:

Added DivisionRounding enum with five rounding modes
Extended IBinaryInteger<TSelf> interface with rounding mode overloads for division operations
Added comprehensive test coverage for all integer types across all rounding modes

Reviewed Changes

Copilot reviewed 19 out of 19 changed files in this pull request and generated 10 comments.

Show a summary per file

File	Description
DivisionRounding.cs	Defines the new enum with five division rounding modes
IBinaryInteger.cs	Implements default logic for division operations with rounding modes
System.Runtime.cs	Adds API surface for the new enum and interface methods
System.Private.CoreLib.Shared.projitems	Registers the new DivisionRounding.cs file in the build
GenericMathHelpers.cs	Adds test helper methods to compute expected values for different rounding modes
*Tests.GenericMath.cs (multiple)	Expands existing DivRem tests and adds new tests for mode-based division operations

Copilot · 2025-10-24T16:04:21Z

src/libraries/System.Private.CoreLib/src/System/Numerics/DivisionRounding.cs

+        // Graph for ceiling division with negative divisor https://www.wolframalpha.com/input?i=Plot%5B%7BCeiling%5B-n%5D%2C+n+%2B+Ceiling%5B-n%5D%7D%2C+%7Bn%2C+-3%2C+3%7D%5D
+
+        /// <summary>
+        /// AwayFromZero division (rounding away zero — round the division result away from zero to the nearest integer.


Missing closing parenthesis in the documentation comment. The opening parenthesis after 'zero' should be closed before the em dash.

Suggested change

/// AwayFromZero division (rounding away zero — round the division result away from zero to the nearest integer.

/// AwayFromZero division (rounding away zero) — round the division result away from zero to the nearest integer.

Copilot · 2025-10-24T16:04:22Z

src/libraries/System.Private.CoreLib/src/System/Numerics/IBinaryInteger.cs

+                }
+                default:
+                    ThrowHelper.ThrowArgumentException_InvalidEnumValue(mode);
+                    break;


The ThrowArgumentException_InvalidEnumValue call is not wrapped in a throw statement. While ThrowHelper methods typically throw exceptions internally, this break statement is unreachable and should be removed for clarity, or the method call should explicitly throw.

Suggested change

break;

Copilot · 2025-10-24T16:04:22Z

src/libraries/System.Private.CoreLib/src/System/Numerics/IBinaryInteger.cs

+                    break;
+                }
+                default:
+                    ThrowHelper.ThrowArgumentException_InvalidEnumValue(mode);


The ThrowArgumentException_InvalidEnumValue call is not wrapped in a throw statement. While ThrowHelper methods typically throw exceptions internally, this break statement is unreachable and should be removed for clarity, or the method call should explicitly throw.

Copilot · 2025-10-24T16:04:22Z

src/libraries/System.Private.CoreLib/src/System/Numerics/IBinaryInteger.cs

+                }
+                default:
+                    ThrowHelper.ThrowArgumentException_InvalidEnumValue(mode);
+                    break;


The ThrowArgumentException_InvalidEnumValue call is not wrapped in a throw statement. While ThrowHelper methods typically throw exceptions internally, this break statement is unreachable and should be removed for clarity, or the method call should explicitly throw.

Suggested change

break;

Copilot · 2025-10-24T16:04:23Z

src/libraries/System.Runtime/tests/System.Runtime.Tests/System/IntPtrTests.GenericMath.cs

+                        Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivRemExpected((nint)0x0000000000000000, 0, mode));
+                        Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivRemExpected((nint)0x0000000000000001, 0, mode));
+                        Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivRemExpected((nint)0xFFFFFFFFFFFFFFFF, 0, mode));


These assertions test DivRemExpected instead of DivRem. The test should verify that DivRem throws the exception, not the helper method. Change to BinaryIntegerHelper<nint>.DivRem(...).

Suggested change

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivRemExpected((nint)0x0000000000000000, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivRemExpected((nint)0x0000000000000001, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivRemExpected((nint)0xFFFFFFFFFFFFFFFF, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivRem((nint)0x0000000000000000, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivRem((nint)0x0000000000000001, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivRem((nint)0xFFFFFFFFFFFFFFFF, 0, mode));

Copilot · 2025-10-24T16:04:23Z

src/libraries/System.Runtime/tests/System.Runtime.Tests/System/IntPtrTests.GenericMath.cs

+                        Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivideExpected((nint)0x0000000000000000, 0, mode));
+                        Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivideExpected((nint)0x0000000000000001, 0, mode));
+                        Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivideExpected((nint)0xFFFFFFFFFFFFFFFF, 0, mode));


These assertions test DivideExpected instead of Divide. The test should verify that Divide throws the exception, not the helper method. Change to BinaryIntegerHelper<nint>.Divide(...).

Suggested change

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivideExpected((nint)0x0000000000000000, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivideExpected((nint)0x0000000000000001, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.DivideExpected((nint)0xFFFFFFFFFFFFFFFF, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.Divide((nint)0x0000000000000000, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.Divide((nint)0x0000000000000001, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.Divide((nint)0xFFFFFFFFFFFFFFFF, 0, mode));

Copilot · 2025-10-24T16:04:23Z

src/libraries/System.Runtime/tests/System.Runtime.Tests/System/IntPtrTests.GenericMath.cs

+                        Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.RemainderExpected((nint)0x0000000000000000, 0, mode));
+                        Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.RemainderExpected((nint)0x0000000000000001, 0, mode));
+                        Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.RemainderExpected((nint)0xFFFFFFFFFFFFFFFF, 0, mode));


These assertions test RemainderExpected instead of Remainder. The test should verify that Remainder throws the exception, not the helper method. Change to BinaryIntegerHelper<nint>.Remainder(...).

Suggested change

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.RemainderExpected((nint)0x0000000000000000, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.RemainderExpected((nint)0x0000000000000001, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.RemainderExpected((nint)0xFFFFFFFFFFFFFFFF, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.Remainder((nint)0x0000000000000000, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.Remainder((nint)0x0000000000000001, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<nint>.Remainder((nint)0xFFFFFFFFFFFFFFFF, 0, mode));

Copilot · 2025-10-24T16:04:24Z

src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Int64Tests.GenericMath.cs

+                    Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivRemExpected((long)0x0000000000000000, 0, mode));
+                    Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivRemExpected((long)0x0000000000000001, 0, mode));
+                    Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivRemExpected((long)0xFFFFFFFFFFFFFFFF, 0, mode));


These assertions test DivRemExpected instead of DivRem. The test should verify that DivRem throws the exception, not the helper method. Change to BinaryIntegerHelper<long>.DivRem(...).

Suggested change

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivRemExpected((long)0x0000000000000000, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivRemExpected((long)0x0000000000000001, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivRemExpected((long)0xFFFFFFFFFFFFFFFF, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivRem((long)0x0000000000000000, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivRem((long)0x0000000000000001, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivRem((long)0xFFFFFFFFFFFFFFFF, 0, mode));

Copilot · 2025-10-24T16:04:24Z

src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Int64Tests.GenericMath.cs

+                    Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivideExpected((long)0x0000000000000000, 0, mode));
+                    Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivideExpected((long)0x0000000000000001, 0, mode));
+                    Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivideExpected((long)0xFFFFFFFFFFFFFFFF, 0, mode));


These assertions test DivideExpected instead of Divide. The test should verify that Divide throws the exception, not the helper method. Change to BinaryIntegerHelper<long>.Divide(...).

Suggested change

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivideExpected((long)0x0000000000000000, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivideExpected((long)0x0000000000000001, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.DivideExpected((long)0xFFFFFFFFFFFFFFFF, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.Divide((long)0x0000000000000000, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.Divide((long)0x0000000000000001, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.Divide((long)0xFFFFFFFFFFFFFFFF, 0, mode));

Copilot · 2025-10-24T16:04:24Z

src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Int64Tests.GenericMath.cs

+                    Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.RemainderExpected((long)0x0000000000000000, 0, mode));
+                    Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.RemainderExpected((long)0x0000000000000001, 0, mode));
+                    Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.RemainderExpected((long)0xFFFFFFFFFFFFFFFF, 0, mode));


These assertions test RemainderExpected instead of Remainder. The test should verify that Remainder throws the exception, not the helper method. Change to BinaryIntegerHelper<long>.Remainder(...).

Suggested change

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.RemainderExpected((long)0x0000000000000000, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.RemainderExpected((long)0x0000000000000001, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.RemainderExpected((long)0xFFFFFFFFFFFFFFFF, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.Remainder((long)0x0000000000000000, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.Remainder((long)0x0000000000000001, 0, mode));

Assert.Throws<DivideByZeroException>(() => BinaryIntegerHelper<long>.Remainder((long)0xFFFFFFFFFFFFFFFF, 0, mode));

Provide support for alternative rounding modes for division and remai…

d2c5662

…nder of division

ghost added area-System.Numerics new-api-needs-documentation labels Aug 22, 2024

dotnet-policy-service bot added the community-contribution Indicates that the PR has been added by a community member label Aug 22, 2024

huoyaoyuan reviewed Aug 22, 2024

View reviewed changes

src/libraries/System.Private.CoreLib/src/System/Numerics/IBinaryInteger.cs Outdated Show resolved Hide resolved

src/libraries/System.Private.CoreLib/src/System/Numerics/DivisionRounding.cs Outdated Show resolved Hide resolved

AlexRadch added 2 commits August 22, 2024 12:49

IBinaryInteger DivRem optimization

80ff9b2

Removed external links from documentation comments.

78b0f68

retrigger checks

809e6c7

build-analysis bot mentioned this pull request Sep 22, 2024

GetAsync_ServerNeedsAuthAndNoCredential_StatusCodeUnauthorized got cancelled #108019

Open

Merge branch 'main' into DivisionRounding

4f7c885

build-analysis bot mentioned this pull request Jan 10, 2025

System.Data.OleDb.Tests timeout in net48 x86 Release leg #87783

Closed

Fix casing in DivisionRounding.cs file path

4e6c359

Corrected the file path for `DivisionRounding.cs` from a lowercase 's' in "system" to an uppercase 'S' in "System" to ensure consistency with the project structure.

AlexRadch requested a review from huoyaoyuan January 12, 2025 06:46

This was referenced Jan 12, 2025

The Operation will be canceled. The next steps may not contain expected logs. dotnet/dnceng#3008

Open

[wasm] Out of memory exception in System.Xml.XmlWriterApiTests.TCFullEndElement tests #110090

Closed

jeffhandley requested a review from tannergooding September 1, 2025 19:23

jeffhandley assigned tannergooding Sep 1, 2025

Merge branch 'main' into DivisionRounding

5f1aef9

tannergooding requested a review from Copilot October 24, 2025 16:02

Copilot AI reviewed Oct 24, 2025

View reviewed changes

build-analysis bot mentioned this pull request Oct 24, 2025

[wasm] System.Net.WebSockets.Client.Tests.InvokerCloseTest.CloseOutputAsync_ClientInitiated_CanReceive_CanClose failing with WebSocketException #117964

Open

	/// AwayFromZero division (rounding away zero — round the division result away from zero to the nearest integer.
	/// AwayFromZero division (rounding away zero) — round the division result away from zero to the nearest integer.

Provide support for alternative rounding modes for division and remainder of division #106795

Are you sure you want to change the base?

Provide support for alternative rounding modes for division and remainder of division #106795

Uh oh!

Conversation

AlexRadch commented Aug 22, 2024

Uh oh!

ghost commented Aug 22, 2024

Uh oh!

ghost commented Aug 22, 2024

Uh oh!

Uh oh!

Uh oh!

huoyaoyuan commented Aug 22, 2024

Uh oh!

AlexRadch commented Aug 22, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull Request Overview

Reviewed Changes

Uh oh!

Copilot AI Oct 24, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Oct 24, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Oct 24, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Oct 24, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Oct 24, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Oct 24, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Oct 24, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Oct 24, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Oct 24, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Oct 24, 2025

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

AlexRadch commented Aug 22, 2024 •

edited

Loading