Add Decimal32, Decimal64, Decimal128

src/libraries/Common/src/System/Number.NumberBuffer.cs

@@ -21,6 +21,9 @@ internal static partial class Number
         internal const int UInt32NumberBufferLength = 10 + 1;   // 10 for the longest input: 4,294,967,295
         internal const int UInt64NumberBufferLength = 20 + 1;   // 20 for the longest input: 18,446,744,073,709,551,615
         internal const int UInt128NumberBufferLength = 39 + 1; // 39 for the longest input: 340,282,366,920,938,463,463,374,607,431,768,211,455
+        internal const int Decimal32NumberBufferLength = 97 + 1 + 1; // 97 for the longest input + 1 for rounding
+        internal const int Decimal64NumberBufferLength = 385 + 1 + 1; // 385 for the longest input + 1 for rounding
+        internal const int Decimal128NumberBufferLength = 6145 + 1 + 1; // 6145 for the longest input + 1 for rounding
 
         internal unsafe ref struct NumberBuffer
         {

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

@@ -531,6 +531,15 @@
   <data name="Arg_MustBeDecimal" xml:space="preserve">
     <value>Object must be of type Decimal.</value>
   </data>
+  <data name="Arg_MustBeDecimal32" xml:space="preserve">
+    <value>Object must be of type Decimal32.</value>
+  </data>
+  <data name="Arg_MustBeDecimal64" xml:space="preserve">
+    <value>Object must be of type Decimal64.</value>
+  </data>
+  <data name="Arg_MustBeDecimal128" xml:space="preserve">
+    <value>Object must be of type Decimal128.</value>
+  </data>
   <data name="Arg_MustBeDelegate" xml:space="preserve">
     <value>Type must derive from Delegate.</value>
   </data>
@@ -3197,6 +3206,15 @@
   <data name="Overflow_Decimal" xml:space="preserve">
     <value>Value was either too large or too small for a Decimal.</value>
   </data>
+  <data name="Overflow_Decimal32" xml:space="preserve">
+    <value>Value was either too large or too small for a Decimal32.</value>
+  </data>
+  <data name="Overflow_Decimal64" xml:space="preserve">
+    <value>Value was either too large or too small for a Decimal64.</value>
+  </data>
+  <data name="Overflow_Decimal128" xml:space="preserve">
+    <value>Value was either too large or too small for a Decimal128.</value>
+  </data>
   <data name="Overflow_Duration" xml:space="preserve">
     <value>The duration cannot be returned for TimeSpan.MinValue because the absolute value of TimeSpan.MinValue exceeds the value of TimeSpan.MaxValue.</value>
   </data>

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

@@ -425,6 +425,10 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IFormatProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IFormattable.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Index.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Number.DecimalIeee754.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\Decimal128.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\Decimal32.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\Decimal64.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\SearchValues\Any1CharPackedSearchValues.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\SearchValues\Any1CharPackedIgnoreCaseSearchValues.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\SearchValues\Any2CharPackedIgnoreCaseSearchValues.cs" />

src/libraries/System.Private.CoreLib/src/System/Number.DecimalIeee754.cs

@@ -0,0 +1,252 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Numerics;
+
+namespace System
+{
+    internal interface IDecimalIeee754ConstructorInfo<TSelf, TSignificand, TValue>
+        where TSelf : unmanaged, IDecimalIeee754ConstructorInfo<TSelf, TSignificand, TValue>
+        where TSignificand : IBinaryInteger<TSignificand>
+        where TValue : IBinaryInteger<TValue>
+    {
+        static abstract TSignificand MaxSignificand { get; }
+        static abstract int MaxDecimalExponent { get; }
+        static abstract int MinDecimalExponent { get; }
+        static abstract int NumberDigitsPrecision { get; }
+        static abstract int Bias { get; }
+        static abstract int CountDigits(TSignificand number);
+        static abstract TSignificand Power10(int exponent);
+        static abstract int MostSignificantBitNumberOfSignificand { get; }
+        static abstract int NumberBitsEncoding { get; }
+        static abstract int NumberBitsCombinationField { get; }
+        static abstract int NumberBitsExponent { get; }
+        static abstract TValue PositiveInfinityBits { get; }
+        static abstract TValue NegativeInfinityBits { get; }
+        static abstract TValue Zero { get; }
+    }
+
+    internal interface IDecimalIeee754UnpackInfo<TSelf, TSignificand, TValue>
+        where TSelf : unmanaged, IDecimalIeee754UnpackInfo<TSelf, TSignificand, TValue>
+        where TSignificand : IBinaryInteger<TSignificand>
+        where TValue : IBinaryInteger<TValue>
+    {
+        static abstract TValue SignMask { get; }
+        static abstract int NumberBitsEncoding { get; }
+        static abstract int NumberBitsExponent { get; }
+        static abstract int NumberDigitsPrecision { get; }
+        static abstract int Bias { get; }
+        static abstract TSignificand TwoPowerMostSignificantBitNumberOfSignificand { get; }
+        static abstract int ConvertToExponent(TValue value);
+        static abstract TSignificand ConvertToSignificand(TValue value);
+        static abstract TSignificand Power10(int exponent);
+    }
+
+    internal static partial class Number
+    {
+        internal static TValue CalDecimalIeee754<TDecimal, TSignificand, TValue>(TSignificand significand, int exponent)
+            where TDecimal : unmanaged, IDecimalIeee754ConstructorInfo<TDecimal, TSignificand, TValue>
+            where TSignificand : IBinaryInteger<TSignificand>
+            where TValue : IBinaryInteger<TValue>
+        {
+            if (significand == TSignificand.Zero)
+            {
+                return TValue.Zero;
+            }
+
+            TSignificand unsignedSignificand = significand > TSignificand.Zero ? significand : -significand;
+
+            if (unsignedSignificand > TDecimal.MaxSignificand && exponent > TDecimal.MaxDecimalExponent)
+            {
+                return significand > TSignificand.Zero ? TDecimal.PositiveInfinityBits : TDecimal.NegativeInfinityBits;
+            }
+
+            TSignificand ten = TSignificand.CreateTruncating(10);
+            if (exponent < TDecimal.MinDecimalExponent)
+            {
+                while (unsignedSignificand >= ten)
+                {
+                    unsignedSignificand /= ten;
+                    ++exponent;
+                }
+                if (exponent < TDecimal.MinDecimalExponent)
+                {
+                    throw new OverflowException(SR.Overflow_Decimal);
+                }
+            }
+
+            if (unsignedSignificand > TDecimal.MaxSignificand)
+            {
+                int numberDigitsRemoving = TDecimal.CountDigits(unsignedSignificand) - TDecimal.NumberDigitsPrecision;
+
+                if (exponent + numberDigitsRemoving > TDecimal.MaxDecimalExponent)
+                {
+                    throw new OverflowException(SR.Overflow_Decimal);
+                }
+
+                exponent += numberDigitsRemoving;
+                TSignificand two = TSignificand.CreateTruncating(2);
+                TSignificand divisor = TDecimal.Power10(numberDigitsRemoving);
+                TSignificand quotient = unsignedSignificand / divisor;
+                TSignificand remainder = unsignedSignificand % divisor;
+                TSignificand midPoint = divisor / two;
+                bool needRouding = remainder > midPoint || (remainder == midPoint && quotient % two == TSignificand.One);
+
+                if (needRouding && quotient == TDecimal.MaxSignificand && exponent < TDecimal.MaxDecimalExponent)
+                {
+                    unsignedSignificand = TDecimal.Power10(TDecimal.NumberDigitsPrecision - 1);
+                    exponent++;
+                }
+                else if (needRouding && quotient < TDecimal.MaxSignificand)
+                {
+                    unsignedSignificand = quotient + TSignificand.One;
+                }
+                else
+                {
+                    unsignedSignificand = quotient;
+                }
+            }
+            else if (exponent > TDecimal.MaxDecimalExponent)
+            {
+                int numberZeroDigits = exponent - TDecimal.MaxDecimalExponent;
+                int numberSignificandDigits = TDecimal.CountDigits(unsignedSignificand);
+
+                if (numberSignificandDigits + numberZeroDigits > TDecimal.NumberDigitsPrecision)
+                {
+                    throw new OverflowException(SR.Overflow_Decimal);
+                }
+                unsignedSignificand *= TDecimal.Power10(numberZeroDigits);
+                exponent -= numberZeroDigits;
+            }
+
+            exponent += TDecimal.Bias;
+            bool msbSignificand = (unsignedSignificand & TSignificand.One << TDecimal.MostSignificantBitNumberOfSignificand) != TSignificand.Zero;
+
+            TValue value = TValue.Zero;
+            TValue exponentVal = TValue.CreateTruncating(exponent);
+            TValue significandVal = TValue.CreateTruncating(unsignedSignificand);
+
+            if (significand < TSignificand.Zero)
+            {
+                value = TValue.One << TDecimal.NumberBitsEncoding - 1;
+            }
+
+            if (msbSignificand)
+            {
+                value ^= TValue.One << TDecimal.NumberBitsEncoding - 2;
+                value ^= TValue.One << TDecimal.NumberBitsEncoding - 3;
+                exponentVal <<= TDecimal.NumberBitsEncoding - 4;
+                value ^= exponentVal;
+                significandVal <<= TDecimal.NumberBitsEncoding - TDecimal.MostSignificantBitNumberOfSignificand;
+                significandVal >>= TDecimal.NumberBitsCombinationField;
+                value ^= significandVal;
+            }
+            else
+            {
+                exponentVal <<= TDecimal.NumberBitsEncoding - TDecimal.NumberBitsExponent - 1;
+                value ^= exponentVal;
+                value ^= significandVal;
+            }
+
+            return value;
+        }
+
+        internal struct DecimalIeee754<TSignificand>
+            where TSignificand : IBinaryInteger<TSignificand>
+        {
+            public bool Signed { get; }
+            public int Exponent { get; }
+            public TSignificand Significand { get; }
+
+            public DecimalIeee754(bool signed, int exponent, TSignificand significand)
+            {
+                Signed = signed;
+                Exponent = exponent;
+                Significand = significand;
+            }
+        }
+
+        internal static DecimalIeee754<TSignificand> UnpackDecimalIeee754<TDecimal, TSignificand, TValue>(TValue value)
+            where TDecimal : unmanaged, IDecimalIeee754UnpackInfo<TDecimal, TSignificand, TValue>
+            where TSignificand : IBinaryInteger<TSignificand>
+            where TValue : IBinaryInteger<TValue>
+        {
+            bool signed = (value & TDecimal.SignMask) != TValue.Zero;
+            TValue g0g1Bits = (value << 1) >> TDecimal.NumberBitsEncoding - 2;
+            TSignificand significand;
+            int exponent;
+
+            if (g0g1Bits == TValue.CreateTruncating(3))
+            {
+                exponent = TDecimal.ConvertToExponent((value << 3) >> TDecimal.NumberBitsEncoding - TDecimal.NumberBitsExponent);
+                significand = TDecimal.ConvertToSignificand((value << TDecimal.NumberBitsEncoding + 3) >> TDecimal.NumberBitsEncoding + 3);
+                significand += TDecimal.TwoPowerMostSignificantBitNumberOfSignificand;
+            }
+            else
+            {
+                exponent = TDecimal.ConvertToExponent((value << 1) >> TDecimal.NumberBitsEncoding - TDecimal.NumberBitsExponent);
+                significand = TDecimal.ConvertToSignificand((value << TDecimal.NumberBitsExponent + 1) >> TDecimal.NumberBitsExponent + 1);
+            }
+
+            return new DecimalIeee754<TSignificand>(signed, exponent - TDecimal.Bias, significand);
+        }
+
+        internal static int CompareDecimalIeee754<TDecimal, TSignificand, TValue>(TValue currentValue, TValue otherValue)
+            where TDecimal : unmanaged, IDecimalIeee754UnpackInfo<TDecimal, TSignificand, TValue>
+            where TSignificand : IBinaryInteger<TSignificand>
+            where TValue : IBinaryInteger<TValue>
+        {
+            if (currentValue == otherValue)
+            {
+                return 0;
+            }
+            DecimalIeee754<TSignificand> current = UnpackDecimalIeee754<TDecimal, TSignificand, TValue>(currentValue);
+            DecimalIeee754<TSignificand> other = UnpackDecimalIeee754<TDecimal, TSignificand, TValue>(otherValue);
+
+            if (current.Signed && !other.Signed) return -1;
+
+            if (!current.Signed && other.Signed) return 1;
+
+            if (current.Exponent > other.Exponent)
+            {
+                return current.Signed ? -InternalUnsignedCompare(current, other) : InternalUnsignedCompare(current, other);
+            }
+
+            if (current.Exponent < other.Exponent)
+            {
+                return current.Signed ? InternalUnsignedCompare(other, current) : -InternalUnsignedCompare(current, other);
+            }
+
+            if (current.Significand == other.Significand) return 0;
+
+            if (current.Significand > other.Significand)
+            {
+                return current.Signed ? -1 : 1;
+            }
+            else
+            {
+                return current.Signed ? 1 : -1;
+            }
+
+            static int InternalUnsignedCompare(DecimalIeee754<TSignificand> biggerExp, DecimalIeee754<TSignificand> smallerExp)
+            {
+                if (biggerExp.Significand >= smallerExp.Significand) return 1;
+
+                int diffExponent = biggerExp.Exponent - smallerExp.Exponent;
+                if (diffExponent < TDecimal.NumberDigitsPrecision)
+                {
+                    TSignificand factor = TDecimal.Power10(diffExponent);
+                    TSignificand quotient = smallerExp.Significand / biggerExp.Significand;
+                    TSignificand remainder = smallerExp.Significand % biggerExp.Significand;
+
+                    if (quotient < factor) return 1;
+                    if (quotient > factor) return -1;
+                    if (remainder > TSignificand.Zero) return -1;
+                    return 0;
+                }
+
+                return 1;
+            }
+        }
+    }
+}