DblToRgbFast()

static bool System.Xml.Xsl.XPathConvert.BigNumber.DblToRgbFast ( double dbl, byte[] mantissa, out int exponent, out int mantissaSize )

inlinestatic

Definition at line 489 of file XPathConvert.cs.

        {
            int num = 0;
            uint num2 = DblHi(dbl);
            uint num3 = DblLo(dbl);
            int num4 = (int)((num2 >> 20) & 0x7FF);
            Unsafe.SkipInit(out BigNumber bigNumber);
            BigNumber bigNumber2;
            BigNumber bigNumber3;
            int num7;
            if (num4 > 0)
            {
                if (num4 >= 1023 && num4 <= 1075 && dbl == Math.Floor(dbl))
                {
                    double num5 = dbl;
                    int num6 = 0;
                    if (num5 >= C10toN[num6 + 8])
                    {
                        num6 += 8;
                    }
                    if (num5 >= C10toN[num6 + 4])
                    {
                        num6 += 4;
                    }
                    if (num5 >= C10toN[num6 + 2])
                    {
                        num6 += 2;
                    }
                    if (num5 >= C10toN[num6 + 1])
                    {
                        num6++;
                    }
                    exponent = num6 + 1;
                    num7 = 0;
                    while (0.0 != num5)
                    {
                        byte b = (byte)(num5 / C10toN[num6]);
                        num5 -= (double)(int)b * C10toN[num6];
                        mantissa[num7++] = b;
                        num6--;
                    }
                    mantissaSize = num7;
                    goto IL_05a9;
                }
                bigNumber._u2 = 0x80000000u | ((num2 & 0xFFFFFF) << 11) | (num3 >> 21);
                bigNumber._u1 = num3 << 11;
                bigNumber._u0 = 0u;
                bigNumber._exp = num4 - 1022;
                bigNumber._error = 0u;
                bigNumber2 = bigNumber;
                bigNumber2._u1 |= 1024u;
                bigNumber3 = bigNumber;
                if (AddU(u2: (int.MinValue != (int)bigNumber3._u2 || bigNumber3._u1 != 0) ? 4294966272u : 4294966784u, u1: ref bigNumber3._u1) == 0)
                {
                    AddU(ref bigNumber3._u2, uint.MaxValue);
                    if ((0x80000000u & bigNumber3._u2) == 0)
                    {
                        bigNumber3.Normalize();
                    }
                }
            }
            else
            {
                bigNumber._u2 = num2 & 0xFFFFFu;
                bigNumber._u1 = num3;
                bigNumber._u0 = 0u;
                bigNumber._exp = -1010;
                bigNumber._error = 0u;
                bigNumber2 = bigNumber;
                bigNumber2._u0 = 2147483648u;
                bigNumber3 = bigNumber2;
                if (AddU(ref bigNumber3._u1, uint.MaxValue) == 0)
                {
                    AddU(ref bigNumber3._u2, uint.MaxValue);
                }
                bigNumber.Normalize();
                bigNumber2.Normalize();
                bigNumber3.Normalize();
            }
            if (bigNumber2._exp >= 32)
            {
                int num6 = (bigNumber2._exp - 25) * 15 / -s_tenPowersNeg[45]._exp;
                if (num6 > 0)
                {
                    BigNumber numOp = s_tenPowersNeg[30 + num6];
                    bigNumber2.Mul(ref numOp);
                    bigNumber3.Mul(ref numOp);
                    num += num6 * 32;
                }
                if (bigNumber2._exp >= 32)
                {
                    num6 = (bigNumber2._exp - 25) * 32 / -s_tenPowersNeg[31]._exp;
                    BigNumber numOp = s_tenPowersNeg[num6 - 1];
                    bigNumber2.Mul(ref numOp);
                    bigNumber3.Mul(ref numOp);
                    num += num6;
                }
            }
            else if (bigNumber2._exp < 1)
            {
                int num6 = (25 - bigNumber2._exp) * 15 / s_tenPowersPos[45]._exp;
                if (num6 > 0)
                {
                    BigNumber numOp = s_tenPowersPos[30 + num6];
                    bigNumber2.Mul(ref numOp);
                    bigNumber3.Mul(ref numOp);
                    num -= num6 * 32;
                }
                if (bigNumber2._exp < 1)
                {
                    num6 = (25 - bigNumber2._exp) * 32 / s_tenPowersPos[31]._exp;
                    BigNumber numOp = s_tenPowersPos[num6 - 1];
                    bigNumber2.Mul(ref numOp);
                    bigNumber3.Mul(ref numOp);
                    num -= num6;
                }
            }
            BigNumber bigNumber4 = bigNumber2;
            bigNumber2.MakeUpperBound();
            bigNumber4.MakeLowerBound();
            uint num8 = bigNumber2.UMod1();
            uint num9 = bigNumber4.UMod1();
            BigNumber bigNumber5 = bigNumber3;
            bigNumber5.MakeUpperBound();
            bigNumber3.MakeLowerBound();
            uint num10 = bigNumber5.UMod1();
            uint num11 = bigNumber3.UMod1();
            uint num12 = 1u;
            if (num8 >= 100000000)
            {
                num12 = 100000000u;
                num += 8;
            }
            else
            {
                if (num8 >= 10000)
                {
                    num12 = 10000u;
                    num += 4;
                }
                if (num8 >= 100 * num12)
                {
                    num12 *= 100;
                    num += 2;
                }
            }
            if (num8 >= 10 * num12)
            {
                num12 *= 10;
                num++;
            }
            num++;
            num7 = 0;
            while (true)
            {
                byte b = (byte)(num8 / num12);
                num8 %= num12;
                byte b2 = (byte)(num11 / num12);
                num11 %= num12;
                if (b == b2)
                {
                    mantissa[num7++] = b;
                    if (1 != num12)
                    {
                        num12 /= 10;
                        continue;
                    }
                    num12 = 10000000u;
                    bigNumber2.Mul(ref s_tenPowersPos[7]);
                    bigNumber2.MakeUpperBound();
                    num8 = bigNumber2.UMod1();
                    if (num8 < 100000000)
                    {
                        bigNumber4.Mul(ref s_tenPowersPos[7]);
                        bigNumber4.MakeLowerBound();
                        num9 = bigNumber4.UMod1();
                        bigNumber5.Mul(ref s_tenPowersPos[7]);
                        bigNumber5.MakeUpperBound();
                        num10 = bigNumber5.UMod1();
                        bigNumber3.Mul(ref s_tenPowersPos[7]);
                        bigNumber3.MakeLowerBound();
                        num11 = bigNumber3.UMod1();
                        continue;
                    }
                }
                else
                {
                    byte b3 = (byte)(num10 / num12 % 10);
                    num10 %= num12;
                    byte b4 = (byte)(num9 / num12 % 10);
                    num9 %= num12;
                    if (b3 < b4)
                    {
                        if (b3 == 0 && num10 == 0 && bigNumber5.IsZero && (num3 & 1) == 0)
                        {
                            break;
                        }
                        if (b4 - b3 > 1)
                        {
                            mantissa[num7++] = (byte)((b4 + b3 + 1) / 2);
                            break;
                        }
                        if (num9 != 0 || !bigNumber4.IsZero || (num3 & 1) == 0)
                        {
                            mantissa[num7++] = b4;
                            break;
                        }
                    }
                }
                exponent = (mantissaSize = 0);
                return false;
            }
            exponent = num;
            mantissaSize = num7;
            goto IL_05a9;
            IL_05a9:
            return true;
        }

References System.Xml.Xsl.XPathConvert.BigNumber._exp, System.Xml.Xsl.XPathConvert.AddU(), System.Xml.Xsl.XPathConvert.C10toN, System.Xml.Xsl.XPathConvert.DblHi(), System.Xml.Xsl.XPathConvert.DblLo(), System.Xml.Dictionary, System.Math.Floor(), System.Xml.Xsl.XPathConvert.BigNumber.MakeUpperBound(), System.Xml.Xsl.XPathConvert.BigNumber.s_tenPowersNeg, and System.Xml.Xsl.XPathConvert.BigNumber.s_tenPowersPos.

Referenced by System.Xml.Xsl.XPathConvert.FloatingDecimal.InitFromDouble().