Add Decimal32, Decimal64, Decimal128 by RaymondHuy · Pull Request #100729 · dotnet/runtime

RaymondHuy · 2024-04-06T17:29:27Z

ghost · 2024-04-06T17:29:33Z

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.

tannergooding · 2024-04-09T17:06:13Z

This is on my radar to take a look at; just noting it might be a bit delayed due to other priorities for the .NET 9 release.

CC. @jeffhandley

Copilot

Pull request overview

Copilot reviewed 16 out of 16 changed files in this pull request and generated 9 comments.

Comments suppressed due to low confidence (2)

src/libraries/System.Runtime/ref/System.Runtime.cs:1

The reference assembly declarations for Decimal32/Decimal64/Decimal128 appear to be missing public members that exist in the implementations (notably public override bool Equals(object? obj) and public override int GetHashCode()). Ref/impl mismatches will break API surface validation and can cause binding inconsistencies. Add these overrides (and any other public members present in the CoreLib implementations) to the ref file so the public contract matches.
src/libraries/System.Runtime/ref/System.Runtime.cs:1
The Decimal32 implementation is annotated with [StructLayout(LayoutKind.Sequential)], but the ref assembly declaration does not include this attribute. Since layout is part of the public interop contract, the ref should mirror it (or the implementation should drop it if not required).

Copilot

Pull request overview

Copilot reviewed 16 out of 16 changed files in this pull request and generated 5 comments.

Copilot

Pull request overview

Copilot reviewed 16 out of 16 changed files in this pull request and generated 5 comments.

Copilot

Pull request overview

Copilot reviewed 16 out of 16 changed files in this pull request and generated 3 comments.

Comments suppressed due to low confidence (1)

src/libraries/System.Runtime/ref/System.Runtime.cs:1

These new numeric types expose ToString(string?, IFormatProvider?) overloads but do not implement IFormattable. As a result, composite formatting / interpolated string format specifiers (e.g., string.Format(\"{0:N}\", value) or $\"{value:N}\") may ignore the format string and fall back to parameterless ToString(). Consider adding System.IFormattable to Decimal32/Decimal64/Decimal128 (and updating the CoreLib implementations accordingly); optionally also implement ISpanFormattable to match other numerics.

RaymondHuy · 2026-05-06T17:02:00Z

Hi @tannergooding I have resolved all Copilot comments. You can re-review it when you have time ;)

tannergooding · 2026-05-13T15:46:36Z

+        private const uint NaNMask = 0x7C00_0000;
+        private const uint InfinityMask = 0x7800_0000;
+        private const uint MaxSignificand = 9_999_999;
+        private const uint MaxInternalValue = 0x77F8_967F; // 9,999,999 x 10^90


The comment here is potentially confusing as it mismatches the standard value documented, it'd help to have both specified.

In particular you have significand * 10^(exponent-bias), which allows treating significand as a positive integer. But more typically its represented in standard scientific notation and so you get 9.999999 instead of 9999999, this shifts the bias by p-1, where p is 7/16/34 for decimal32/64/128

In this case, that changes it from 9_999_999 * 10^90 to 9.999_999 * 10^96.

I'd recommend just doc'ing this as something like // +9.999_999 * 10^96; aka +9_999_999 * 10^90

tannergooding · 2026-05-13T15:56:23Z

+        public Decimal32(int significand, int exponent)
+        {
+            bool isNegative = significand < 0;
+            uint unsignedSignificand = isNegative ? (uint)(-(long)significand) : (uint)significand;


nit: This can just be (uint)(-significand). Every negative int except int.MinValue becomes the appropriate positive int when negated. MinValue stays the same, but then when cast to uint becomes the right positive value anyways.

tannergooding · 2026-05-13T16:07:10Z

+        private static readonly UInt128 PositiveInfinityValue = new UInt128(upper: 0x7800_0000_0000_0000, lower: 0);
+        private static readonly UInt128 NegativeInfinityValue = new UInt128(upper: 0xf800_0000_0000_0000, lower: 0);
+        private static readonly UInt128 ZeroValue = new UInt128(0, 0);
+        private static readonly UInt128 NegativeZeroValue = new UInt128(0x8000_0000_0000_0000, 0);
+        private static readonly UInt128 QuietNaNValue = new UInt128(0xFC00_0000_0000_0000, 0);
+        private static readonly UInt128 MaxInternalValue = new UInt128(upper: 0x5FFF_ED09_BEAD_87C0, lower: 0x378D_8E63_FFFF_FFFF);
+        private static readonly UInt128 MinInternalValue = new UInt128(upper: 0xDFFF_ED09_BEAD_87C0, lower: 0x378D_8E63_FFFF_FFFF);


This had been commented on before and I think got handled, but looks like it was since lost.

The UInt128 cases need to be properties, not static readonly, it will help improve codegen and make it easier for the JIT to see its just constant

It may even be better to just have the internal Decimal128 constructor take ulong upperBits, ulong lowerBits instead of UInt128 and then you can just have:

public static Decimal128 PositiveInfinity => new Decimal128(0x7800_0000_0000_0000, 0x0000_0000_0000_0000);

tannergooding · 2026-05-13T17:30:34Z

+                1000000,
+            ];
+
+        public Decimal32(int significand, int exponent)


This still has the pending comment that it shouldn't be public as I'm not convinced its the right shape and UX. Please make it and the corresponding constructor on the other types internal

tannergooding · 2026-05-13T17:34:31Z

+            uint comb = decimalBits & NaNMask;
+            return comb != NaNMask && comb != InfinityMask;


this can do (value & signMask) > Infinity to avoid multiple comparisons or extracting small parts

tannergooding · 2026-05-13T18:05:55Z

+                return ClampExponentOverflow(signed, significand, exponent);
+            }
+
+            if (exponent < TDecimal.MinAdjustedExponent)


I don't think this is correct. For underflow for decimal 32, for example, it's ±1.0 ×10^−101 for subnormals, in conrast to ±1.000000 * 10^−95 for normals (noting this is the x.yyyyy form where its got exactly 1 integral digit)

In particular while while MinAdjustedExponent is correct given TSelf.MinExponent - TSelf.Precision + 1; which is -95 - 7 + 1, so -102 + 1, or `-101, the issue is that you have to account for midpoint rounding

This is simple to explain with float where float.MaxValue + 50 doesn't become infinity, it rather stays float.MaxValue. You have to add at least half the delta to move it "closer" to infinity and make it round over.

Likewise float.Epsilon / float.BitDecrement(2) stays float.Epsilon, it's only for float.Epislon / 2 or greater that it becomes zero.

So I similarly believe that ±0.500000.......1 * 10^−96 becomes epsilon. -- This is notably a tricky edge case for binary floats too and is why we have to track up to 768 digits for double there and have to parse the whole string at least tracking "any non-zero digits", because we have to handle the case where its exactly a midpoint +/- 1

Hi @tannergooding Correct me if I am wrong. Epsilon is the smallest positive value that is greater than zero. In this Decimal32 case I think it should be 1 * 10^-101.
Therefore "So I similarly believe that ±0.500000.......1 * 10^−96 becomes epsilon" I don't think it will become epsilon.

Epsilon is the smallest positive value that is greater than zero.

Close. It is rather the smallest representable value that compares greater than zero. The representable here is key because values smaller than it may still round to it.

This can be seen with this trivial program, which showcases that float.Epsilon / 2 produces 0, but float.Epsilon / LargestValueThatComparesLessThanTwo still produces float.Epsilon (despite it clearly having an infinitely precise value that must be less than float.Epsilon):

Console.WriteLine($"{float.Epsilon:G99}"); Console.WriteLine($"{float.Epsilon / float.BitDecrement(2.0f):G99}"); Console.WriteLine($"{float.Epsilon / 2.0f:G99}");

which outputs:

1.40129846432481707092372958328991613128026194187651577175706828388979108268586060148663818836212158E-45 1.40129846432481707092372958328991613128026194187651577175706828388979108268586060148663818836212158E-45 0

You can also see the same thing in the inverse direction as well:

var delta = float.MaxValue - float.BitDecrement(float.MaxValue); Console.WriteLine($"{float.MaxValue:G99}"); Console.WriteLine($"{float.MaxValue + (delta / 2):G99}"); Console.WriteLine($"{float.MaxValue + (delta / float.BitIncrement(2)):G99}");

which outputs:

340282346638528859811704183484516925440 ∞ 340282346638528859811704183484516925440

This is because MaxValue + (delta / 2) puts it at exactly the midpoint value, so it rounds "up" to infinity. While the value just below that puts it below the midpoint, so despite being greater than MaxValue it rounds back down to MaxValue

decimal32/64/128 must handle these same edges correctly and so we need to account for the fact that any value > (Epsilon / 2) becomes Epsilon

Hi @tannergooding, thanks for the detailed explanation.

1 * 10^-101 is representable in Decimal32. Would it be correct to conclude that this should be Epsilon? Its encoded value is:

0_0000_0000_000_0000_0000_0000_0000_0001

For your example, ±0.500000.......1 * 10^-96, I don't think it would round to ±Epsilon if Epsilon means 1 * 10^-101, since this value is much larger than 1 * 10^-101 and should still be representable as a Decimal32 subnormal value.

Would it be correct to conclude that this should be Epsilon

Yes

For your example, ±0.500000.......1 * 10^-96, I don't think it would round to ±Epsilon

Correct, I was commenting in part from memory and used the small normal value by accident

It would be 5.00000.....1 * 10^-102 as the actual boundary, where values less than this become 0 and values greater than or equal to this, but less than Epsilon, round to Epsilon

RaymondHuy added 5 commits March 11, 2024 13:08

add constructor info

ac5e447

Add Decimal32

1af3337

add test cases

cee05c8

Add Decimal128

da72dcd

add tests

6f3827c

ghost added area-System.Numerics new-api-needs-documentation labels Apr 6, 2024

RaymondHuy marked this pull request as draft April 6, 2024 17:29

dotnet-policy-service Bot added the community-contribution Indicates that the PR has been added by a community member label Apr 6, 2024

RaymondHuy added 2 commits April 7, 2024 07:42

Merge commit '83b0d939bedadf7d782b0b26307c2d8c1d5b76f4' into issue-81376

7e9344b

Fix digits pointer

f882b96

RaymondHuy marked this pull request as ready for review April 7, 2024 01:22

RaymondHuy marked this pull request as draft April 7, 2024 01:23

This was referenced Apr 7, 2024

slow macOS - "##[error]The job running on agent Azure Pipelines 9 ran longer than the maximum time of 60 minutes." dotnet/dnceng#1883

Open

[browser][MT] TIMED_OUT but 0 was expected #99888

Closed

huoyaoyuan reviewed Apr 7, 2024

View reviewed changes

RaymondHuy added 2 commits April 9, 2024 23:22

Implement ToString() method.

762f56d

resolve comments

66a1127

resolve comments

83937d2

RaymondHuy marked this pull request as ready for review April 9, 2024 17:21

build-analysis Bot mentioned this pull request Apr 9, 2024

[browser] Process terminated assert handling at icall.c:6162 #100249

Closed

Refactor shift operators to mask

19755ba

build-analysis Bot mentioned this pull request Apr 10, 2024

ComInterfaceGenerator.Unit.Tests failed on linux-x64 running interpreter #100683

Closed

RaymondHuy added 2 commits April 10, 2024 18:05

Extract common mask to property.

ede6ca3

add more tests

b4e5d34

build-analysis Bot mentioned this pull request Apr 10, 2024

System.Text.RegularExpressions.Tests on Mono_Minijit_Debug-Ubuntu #100715

Closed

RaymondHuy added 2 commits April 11, 2024 13:21

add comments

504f042

Add overflow message.

31ffd5c

Copilot AI reviewed May 3, 2026

View reviewed changes

resolve copilot comments

7b7b6c1

build-analysis Bot mentioned this pull request May 3, 2026

browser-wasm linux Release LibraryTests queues timing out #117974

Open

resolve copilot comments

632f1db

Copilot AI review requested due to automatic review settings May 5, 2026 17:08

Copilot AI reviewed May 5, 2026

View reviewed changes

RaymondHuy added 2 commits May 6, 2026 00:18

replace PositiveInfinityValue/NegativeInfinityValue comment

5617f55

resolve copilot comments

0c85607

Copilot AI review requested due to automatic review settings May 5, 2026 18:01

Copilot AI reviewed May 5, 2026

View reviewed changes

RaymondHuy added 3 commits May 6, 2026 16:23

Merge branch 'master' into issue-81376

f5dd84b

resolve copilot comment

a0a2782

resolve copilot comments

951b897

Copilot AI review requested due to automatic review settings May 6, 2026 14:20

Copilot AI reviewed May 6, 2026

View reviewed changes

Comment thread src/libraries/System.Private.CoreLib/src/System/Number.DecimalIeee754.cs Outdated

Comment thread src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Decimal64Tests.cs Outdated

Comment thread src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Decimal32Tests.cs

resolve copilot comments

2f2db22

RaymondHuy requested review from Copilot and tannergooding May 6, 2026 15:13

RaymondHuy added 2 commits May 7, 2026 23:30

Merge branch 'main' into issue-81376

428b504

Merge branch 'main' into issue-81376

4e33fa6

tannergooding reviewed May 13, 2026

View reviewed changes

		uint comb = decimalBits & NaNMask;
		return comb != NaNMask && comb != InfinityMask;

Conversation

RaymondHuy commented Apr 6, 2024

Uh oh!

ghost commented Apr 6, 2024

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

tannergooding commented Apr 9, 2024

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Uh oh!

Uh oh!

RaymondHuy commented May 6, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

tannergooding May 15, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

tannergooding May 15, 2026 •

edited

Loading