DblToRgbPrecise()

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

inlinestatic

Definition at line 708 of file XPathConvert.cs.

        {
            BigInteger bigInteger = new BigInteger();
            BigInteger bigInteger2 = new BigInteger();
            BigInteger bigInteger3 = new BigInteger();
            BigInteger bigInteger4 = new BigInteger();
            BigInteger bigInteger5 = new BigInteger();
            uint num = DblHi(dbl);
            uint num2 = DblLo(dbl);
            bigInteger2.InitFromDigits(1u, 0u, 1);
            bigInteger3.InitFromDigits(1u, 0u, 1);
            int num3 = (int)(((num & 0x7FF00000) >> 20) - 1075);
            uint num4 = num & 0xFFFFFu;
            uint num5 = num2;
            int num6 = 2;
            bool flag = false;
            double num7;
            int num8;
            if (num3 == -1075)
            {
                if (num4 == 0)
                {
                    num6 = 1;
                }
                num7 = BitConverter.Int64BitsToDouble(5760103923406864384L);
                num7 *= dbl;
                num8 = (int)(((DblHi(num7) & 0x7FF00000) >> 20) - 1279);
                num = DblHi(num7);
                num &= 0xFFFFFu;
                num |= 0x3FF00000u;
                num7 = BitConverter.UInt64BitsToDouble(((ulong)num << 32) | DblLo(num7));
                num3++;
            }
            else
            {
                num &= 0xFFFFFu;
                num |= 0x3FF00000u;
                num7 = BitConverter.UInt64BitsToDouble(((ulong)num << 32) | num2);
                num8 = num3 + 52;
                if (num5 == 0 && num4 == 0 && num3 > -1074)
                {
                    num4 = 2097152u;
                    num3--;
                    flag = true;
                }
                else
                {
                    num4 |= 0x100000u;
                }
            }
            num7 = (num7 - 1.5) * 0.289529654602168 + 0.1760912590558 + (double)num8 * 0.301029995663981;
            int num9 = (int)num7;
            if (num7 < 0.0 && num7 != (double)num9)
            {
                num9--;
            }
            int num10;
            int num11;
            if (num3 >= 0)
            {
                num10 = num3;
                num11 = 0;
            }
            else
            {
                num10 = 0;
                num11 = -num3;
            }
            int num12;
            int num13;
            if (num9 >= 0)
            {
                num12 = 0;
                num13 = num9;
                num11 += num9;
            }
            else
            {
                num10 -= num9;
                num12 = -num9;
                num13 = 0;
            }
            if (num10 > 0 && num11 > 0)
            {
                num8 = ((num10 < num11) ? num10 : num11);
                num10 -= num8;
                num11 -= num8;
            }
            num10++;
            num11++;
            if (num12 > 0)
            {
                bigInteger3.MulPow5(num12);
                bigInteger.InitFromBigint(bigInteger3);
                if (1 == num6)
                {
                    bigInteger.MulAdd(num5, 0u);
                }
                else
                {
                    bigInteger.MulAdd(num4, 0u);
                    bigInteger.ShiftLeft(32);
                    if (num5 != 0)
                    {
                        bigInteger5.InitFromBigint(bigInteger3);
                        bigInteger5.MulAdd(num5, 0u);
                        bigInteger.Add(bigInteger5);
                    }
                }
            }
            else
            {
                bigInteger.InitFromDigits(num5, num4, num6);
                if (num13 > 0)
                {
                    bigInteger2.MulPow5(num13);
                }
            }
            num8 = CbitZeroLeft(bigInteger2[bigInteger2.Length - 1]);
            num8 = (num8 + 28 - num11) & 0x1F;
            num10 += num8;
            num11 += num8;
            bigInteger.ShiftLeft(num10);
            if (num10 > 1)
            {
                bigInteger3.ShiftLeft(num10 - 1);
            }
            bigInteger2.ShiftLeft(num11);
            BigInteger bigInteger6;
            if (flag)
            {
                bigInteger6 = bigInteger4;
                bigInteger6.InitFromBigint(bigInteger3);
                bigInteger3.ShiftLeft(1);
            }
            else
            {
                bigInteger6 = bigInteger3;
            }
            int num14 = 0;
            while (true)
            {
                byte b = (byte)bigInteger.DivRem(bigInteger2);
                if (num14 == 0 && b == 0)
                {
                    num9--;
                    goto IL_03c7;
                }
                num8 = bigInteger.CompareTo(bigInteger6);
                int num15;
                if (bigInteger2.CompareTo(bigInteger3) < 0)
                {
                    num15 = 1;
                }
                else
                {
                    bigInteger5.InitFromBigint(bigInteger2);
                    bigInteger5.Subtract(bigInteger3);
                    num15 = bigInteger.CompareTo(bigInteger5);
                }
                if (num15 == 0 && (num2 & 1) == 0)
                {
                    if (b != 9)
                    {
                        if (num8 > 0)
                        {
                            b++;
                        }
                        mantissa[num14++] = b;
                        break;
                    }
                }
                else
                {
                    if (num8 < 0 || (num8 == 0 && (num2 & 1) == 0))
                    {
                        if (num15 > 0)
                        {
                            bigInteger.ShiftLeft(1);
                            num15 = bigInteger.CompareTo(bigInteger2);
                            if ((num15 > 0 || (num15 == 0 && ((uint)b & (true ? 1u : 0u)) != 0)) && b++ == 9)
                            {
                                goto IL_0412;
                            }
                        }
                        mantissa[num14++] = b;
                        break;
                    }
                    if (num15 <= 0)
                    {
                        mantissa[num14++] = b;
                        goto IL_03c7;
                    }
                    if (b != 9)
                    {
                        mantissa[num14++] = (byte)(b + 1);
                        break;
                    }
                }
                goto IL_0412;
                IL_0412:
                while (true)
                {
                    if (num14 > 0)
                    {
                        if (mantissa[--num14] != 9)
                        {
                            mantissa[num14++]++;
                            break;
                        }
                        continue;
                    }
                    num9++;
                    mantissa[num14++] = 1;
                    break;
                }
                break;
                IL_03c7:
                bigInteger.MulAdd(10u, 0u);
                bigInteger3.MulAdd(10u, 0u);
                if (bigInteger6 != bigInteger3)
                {
                    bigInteger6.MulAdd(10u, 0u);
                }
            }
            exponent = num9 + 1;
            mantissaSize = num14;
        }

References System.Xml.Xsl.XPathConvert.CbitZeroLeft(), System.Xml.Xsl.XPathConvert.DblHi(), System.Xml.Xsl.XPathConvert.DblLo(), System.Xml.Dictionary, System.Xml.Xsl.XPathConvert.BigInteger.InitFromBigint(), System.BitConverter.Int64BitsToDouble(), System.Xml.L, and System.BitConverter.UInt64BitsToDouble().

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