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.

huoyaoyuan · 2024-04-07T15:27:03Z

+        static int IDecimalIeee754UnpackInfo<Decimal128, Int128, UInt128>.NumberDigitsPrecision => NumberDigitsPrecision;
+
+
+        private static Int128[] Int128Powers10 =>


If Int128 is not optimized, this can be optimally stored as a ReadOnlySpan of Int32/Int64 like Number.BigInteger.Pow10BigNumTable

huoyaoyuan · 2024-04-07T15:28:42Z

+        public override int GetHashCode()
+        {
+            return _value.GetHashCode();
+        }


+0 and -0 should have the same hash code. The easiest way can be stripping the sign bit.

I also remember that there can be same values with different representations.

runtime/src/libraries/System.Private.CoreLib/src/System/Numerics/TotalOrderIeee754Comparer.cs

Lines 125 to 132 in 9b57a26

else

{

// Equivalant values are compared by their exponent parts,

// and the value with smaller exponent is considered closer to zero.

// This only applies to IEEE 754 decimals. Consider to add support if decimals are added into .NET.

return 0;

}

@huoyaoyuan Thanks for your review. However this PR targets only the first phase as following: #81376 (comment) so I haven't added NegativeZero and PositiveZero. I will update GetHashCode method in the next phase.

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

RaymondHuy · 2026-02-16T17:56:58Z

Hi @jeffhandley , thanks for your review, I have resolved all of them and also added test case to bit-shifting comment.

tannergooding · 2026-04-02T15:30:17Z

+        internal Decimal128(UInt128 value)
+        {
+            _upper = value.Upper;
+            _lower = value.Lower;
+        }


nit: While this is convenient, it requires an extra step compared to just taking the upper/lower bits directly.

tannergooding · 2026-04-02T15:31:56Z

+        private static UInt128 NegativeInfinityValue => new UInt128(upper: 0xf800_0000_0000_0000, lower: 0);
+        private static UInt128 ZeroValue => new UInt128(0, 0);
+        private static UInt128 NegativeZeroValue => new UInt128(0x8000_0000_0000_0000, 0);
+        private static UInt128 QuietNaNValue => new UInt128(0x7C00_0000_0000_0000, 0);


nit: The canonical qNaN value used on .NET tends to be the -qNaN as that is what xarch has historically produced. We should continue matching that semantic for the decimal types.

Thanks, I have updated it.

tannergooding · 2026-04-02T15:35:05Z

+        private const int MaxExponent = 6111;
+        private const int MinExponent = -6176;


Where do these come from?

emax should be 6144 and emin should therefore be -6143

Looks like this might be tracking the stored values rather than the actual exponents of the underlying values (i.e. they are off by precision, 34, as they aren't taking into account the number of coefficient digits).

There likely needs to be a better name chosen and/or a clarifying comment that helps readers understand the nuance and correlate it to what the IEEE 754 spec details.

Thanks, I have updated it to following the same with IEEE 754 specs.

tannergooding · 2026-04-02T15:45:20Z

+        private const int MinExponent = -6176;
+        private const int Precision = 34;
+        private const int ExponentBias = 6176;
+        private const int NumberBitsExponent = 14;


This one has a bit of a confusing name. Unlike for binary based floating-point, there is no explicit exponent bitfield. Rather there is the sign bit, the combination field which is 17 bits, and the trailing significand field which is 110 bits.

The exponent is then extracted from the combination field based on the value of the first 2-5 leading bits, giving us a 14-bit value which never starts with 0b11....

Hi @tannergooding according to IEEE 754 specs,

i) If G0 and G1 together are one of 00, 01, or 10, then the biased exponent E is formed from G0 through Gw+1 and the significand is formed from bits Gw+2 through the end of the encoding (including T). ii) If G0 and G1 together are 11 and G2 and G3 together are one of 00, 01, or 10, then the biased exponent E is formed from G2 through Gw+3 and the significand is formed by prefixing the 4 bits (8 + Gw+4) to T. Where k is a positive multiple of 32, for these encodings all of the following are true:

therefore, the number of bits for biased exponent in both cases is always (w + 1) bits so I calculated and treat it as 14. However, I have replaced it by two methods EncodeExponentToG0ThroughGwPlus1, EncodeExponentToG2ThroughGwPlus3 to make it familiar with original specs.

tannergooding · 2026-04-02T16:06:56Z

+            _lower = value.Lower;
+        }
+
+        public Decimal128(Int128 significand, int exponent)


Still a pending comment here (https://github.com/dotnet/runtime/pull/100729/changes#r2027324363) on the constructor and how it shouldn't be public, etc.

tannergooding · 2026-04-02T16:11:02Z

+        /// </summary>
+        /// <param name="s">The input to be parsed.</param>
+        /// <returns>The equivalent <see cref="Decimal128"/> value representing the input string. If the input exceeds Decimal128's range, a <see cref="PositiveInfinityValue"/> or <see cref="NegativeInfinityValue"/> is returned. </returns>
+        public static Decimal128 Parse(string s) => Parse(s, NumberStyles.Number, provider: null);


NumberStyles.Number doesn't seem right. This should likely be NumberStyles.Float much like the binary based formats, otherwise core scenarios like 1e6 won't work as expected.

Thanks, I have replaced it by NumberStyles.Float | NumberStyles.AllowThousands.

tannergooding · 2026-04-02T16:11:58Z

+        /// <returns><see langword="true" /> if the parse was successful, <see langword="false" /> otherwise.</returns>
+        public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, [MaybeNullWhen(false)] out Decimal128 result)
+        {
+            NumberFormatInfo.ValidateParseStyleFloatingPoint(style);


We recently enabled hex-based strings and so this either needs to temporarily skip that (with a tracking item to enable it) or ensure it is working

tannergooding · 2026-04-02T16:14:09Z

+        /// </summary>
+        public override int GetHashCode()
+        {
+            return new UInt128(_upper, _lower).GetHashCode();


Suggested change

return new UInt128(_upper, _lower).GetHashCode();

return HashCode.Combine(_lower, _upper);

Well actually that's not quite right either. This needs to account for similar cases as the binary-based formats and so needs for NaN to produce the same hashcode as other NaN and for +0 and -0 to produce the same hash.

We may even want this to work the same as decimal where cases like 1 vs 1.0 vs 1.000 all produce the same hash code as well, that is they are effectively canonicalized prior to getting the hash.

tannergooding · 2026-04-02T16:20:27Z

+namespace System.Numerics
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public readonly struct Decimal32


Generally the same comments from Decimal128 apply here. Same again for Decimal64

tannergooding · 2026-04-03T13:34:04Z

+            return new DecodedDecimalIeee754<TValue>(signed, biasedExponent - TDecimal.ExponentBias, significand);
+        }
+
+        internal static int CompareDecimalIeee754<TDecimal, TValue>(TValue currentDecimalBits, TValue otherDecimalBits)


This deserves a comment covering that it follows .NET comparison semantics and so expects NaN.Equals(NaN) to be true and therefore fulfills the GetHashCode/Equals/CompareTo contract required for use in collection types and sorting.

tannergooding · 2026-04-03T13:39:52Z

+            yield return new object[] { (-567.89).ToString(), defaultStyle, null, new Decimal128(-56789, -2) };
+            yield return new object[] { "0.666666666666666666666666666666666650000000000000000000000000000000000000000000000000", defaultStyle, invariantFormat, new Decimal128(Int128.Parse(new string('6', 34)), -34) };
+
+            yield return new object[] { "0." + new string('0', 6176) + "1", defaultStyle, invariantFormat, new Decimal128(0, 0) };


There need to be tests for cases like 0.00 and 0e-5 which produce 0 with the expected exponent and sign. That is, Parse and ToString must preserve the appropriate number of trailing zero as expected for decimal types.

Hi @tannergooding do we need to preserve the negative symbol because it is not included for the current decimal type.

decimal m = decimal.Parse("-0.00"); Console.WriteLine(m.ToString()); // output 0.00

JimmyCushnie

It looks like the new types are missing a bunch of interfaces they ought to have.

Here's what System.Numerics.Decimal128 implements as of this PR:

runtime/src/libraries/System.Private.CoreLib/src/System/Numerics/Decimal128.cs

Lines 10 to 17 in 49d9e98

    
           public readonly struct Decimal128 
        
               : IComparable, 
        
                 IComparable<Decimal128>, 
        
                 IEquatable<Decimal128>, 
        
                 ISpanParsable<Decimal128>, 
        
                 IMinMaxValue<Decimal128>, 
        
                 IDecimalIeee754ParseAndFormatInfo<Decimal128, UInt128> 
        
           {

For comparison, here's all the interfaces that System.Decimal implements as of .NET 10:

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

Lines 62 to 73 in 081d220

    
           public readonly partial struct Decimal 
        
               : ISpanFormattable, 
        
                 IComparable, 
        
                 IConvertible, 
        
                 IComparable<decimal>, 
        
                 IEquatable<decimal>, 
        
                 ISerializable, 
        
                 IDeserializationCallback, 
        
                 IFloatingPoint<decimal>, 
        
                 IMinMaxValue<decimal>, 
        
                 IUtf8SpanFormattable 
        
           {

I'm not fully sure what all those other interfaces do, but at the very least, the new types ought to implement IFloatingPoint<TSelf>. I assume this was missed because this PR was created before IFloatingPoint<TSelf> existed.

^{(I am a noob, please excuse me if I'm missing something!)}

tannergooding · 2026-04-10T13:08:04Z

@JimmyCushnie this first PR is just about exposing the base struct definitions for interchange. It doesn't include exposing the dozens of arithmetic operations and other functionality

This is done to explicitly scope the size of the PR and allow incremental work.

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

This was referenced Feb 16, 2026

crossgen2 failing on Linux Arm32 intermittently #124007

Closed

Test Failure: readytorun/GenericCycleDetection/Depth1Test/Depth1Test.cmd #123982

Open

jeffhandley requested a review from PranavSenthilnathan March 23, 2026 07:05

Merge branch 'master' into issue-81376

2170fe1

build-analysis bot mentioned this pull request Mar 24, 2026

Android arm32 device not found (armeabi-v7a architecture unavailable) #125440

Open

RaymondHuy added 2 commits March 25, 2026 07:08

Merge branch 'main' into issue-81376

bb8494b

Merge branch 'main' into issue-81376

49d9e98

tannergooding reviewed Apr 2, 2026

View reviewed changes

Comment thread src/libraries/System.Private.CoreLib/src/System/Numerics/Decimal128.cs Outdated

tannergooding reviewed Apr 2, 2026

View reviewed changes

Comment thread src/libraries/System.Private.CoreLib/src/System/Numerics/Decimal128.cs Outdated

tannergooding reviewed Apr 2, 2026

View reviewed changes

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

tannergooding reviewed Apr 3, 2026

View reviewed changes

JimmyCushnie suggested changes Apr 10, 2026

View reviewed changes

resolve comments

65e9f8b

build-analysis bot mentioned this pull request Apr 13, 2026

System.Net.NameResolution.Tests DNS failures: Name or service not known #126641

Open

RaymondHuy added 4 commits April 15, 2026 23:13

preserve exponent when vaule is 0

ceec3cf

handle infinity comparision

5351416

fix wrong rounding

503ad30

correct wrong test cases

3cdb330

		static int IDecimalIeee754UnpackInfo<Decimal128, Int128, UInt128>.NumberDigitsPrecision => NumberDigitsPrecision;


		private static Int128[] Int128Powers10 =>

	else
	{
	// Equivalant values are compared by their exponent parts,
	// and the value with smaller exponent is considered closer to zero.

	// This only applies to IEEE 754 decimals. Consider to add support if decimals are added into .NET.
	return 0;
	}

		private const int MaxExponent = 6111;
		private const int MinExponent = -6176;

	return new UInt128(_upper, _lower).GetHashCode();
	return HashCode.Combine(_lower, _upper);

	public readonly struct Decimal128
	: IComparable,
	IComparable<Decimal128>,
	IEquatable<Decimal128>,
	ISpanParsable<Decimal128>,
	IMinMaxValue<Decimal128>,
	IDecimalIeee754ParseAndFormatInfo<Decimal128, UInt128>
	{

	public readonly partial struct Decimal
	: ISpanFormattable,
	IComparable,
	IConvertible,
	IComparable<decimal>,
	IEquatable<decimal>,
	ISerializable,
	IDeserializationCallback,
	IFloatingPoint<decimal>,
	IMinMaxValue<decimal>,
	IUtf8SpanFormattable
	{

Conversation

RaymondHuy commented Apr 6, 2024

Uh oh!

ghost commented Apr 6, 2024

Uh oh!

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!

Uh oh!

Uh oh!

tannergooding commented Apr 9, 2024

Uh oh!

RaymondHuy commented Feb 16, 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!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

tannergooding Apr 3, 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!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JimmyCushnie left a comment

Choose a reason for hiding this comment

Uh oh!

tannergooding commented Apr 10, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

9 participants

tannergooding Apr 3, 2026 •

edited

Loading