Dragon4()

static unsafe uint System.Number.Dragon4 ( ulong mantissa, int exponent, uint mantissaHighBitIdx, bool hasUnequalMargins, int cutoffNumber, bool isSignificantDigits, Span< byte > buffer, out int decimalExponent )

inlinestaticprivate

Definition at line 1335 of file Number.cs.

    {
        int num = 0;
        BigInteger lhs;
        BigInteger rhs;
        BigInteger result;
        BigInteger* ptr;
        if (hasUnequalMargins)
        {
            BigInteger result2;
            if (exponent > 0)
            {
                BigInteger.SetUInt64(out lhs, 4 * mantissa);
                lhs.ShiftLeft((uint)exponent);
                BigInteger.SetUInt32(out rhs, 4u);
                BigInteger.Pow2((uint)exponent, out result);
                BigInteger.Pow2((uint)(exponent + 1), out result2);
            }
            else
            {
                BigInteger.SetUInt64(out lhs, 4 * mantissa);
                BigInteger.Pow2((uint)(-exponent + 2), out rhs);
                BigInteger.SetUInt32(out result, 1u);
                BigInteger.SetUInt32(out result2, 2u);
            }
            ptr = &result2;
        }
        else
        {
            if (exponent > 0)
            {
                BigInteger.SetUInt64(out lhs, 2 * mantissa);
                lhs.ShiftLeft((uint)exponent);
                BigInteger.SetUInt32(out rhs, 2u);
                BigInteger.Pow2((uint)exponent, out result);
            }
            else
            {
                BigInteger.SetUInt64(out lhs, 2 * mantissa);
                BigInteger.Pow2((uint)(-exponent + 1), out rhs);
                BigInteger.SetUInt32(out result, 1u);
            }
            ptr = &result;
        }
        int num2 = (int)Math.Ceiling((double)((int)mantissaHighBitIdx + exponent) * 0.3010299956639812 - 0.69);
        if (num2 > 0)
        {
            rhs.MultiplyPow10((uint)num2);
        }
        else if (num2 < 0)
        {
            BigInteger.Pow10((uint)(-num2), out var result3);
            lhs.Multiply(ref result3);
            result.Multiply(ref result3);
            if (ptr != &result)
            {
                BigInteger.Multiply(ref result, 2u, out *ptr);
            }
        }
        bool flag = mantissa % 2 == 0;
        bool flag2 = false;
        if (cutoffNumber == -1)
        {
            BigInteger.Add(ref lhs, ref *ptr, out var result4);
            int num3 = BigInteger.Compare(ref result4, ref rhs);
            flag2 = (flag ? (num3 >= 0) : (num3 > 0));
        }
        else
        {
            flag2 = BigInteger.Compare(ref lhs, ref rhs) >= 0;
        }
        if (flag2)
        {
            num2++;
        }
        else
        {
            lhs.Multiply10();
            result.Multiply10();
            if (ptr != &result)
            {
                BigInteger.Multiply(ref result, 2u, out *ptr);
            }
        }
        int num4 = num2 - buffer.Length;
        if (cutoffNumber != -1)
        {
            int num5 = 0;
            num5 = ((!isSignificantDigits) ? (-cutoffNumber) : (num2 - cutoffNumber));
            if (num5 > num4)
            {
                num4 = num5;
            }
        }
        num2 = (decimalExponent = num2 - 1);
        uint block = rhs.GetBlock((uint)(rhs.GetLength() - 1));
        if (block < 8 || block > 429496729)
        {
            uint num6 = (uint)BitOperations.Log2(block);
            uint shift = (59 - num6) % 32;
            rhs.ShiftLeft(shift);
            lhs.ShiftLeft(shift);
            result.ShiftLeft(shift);
            if (ptr != &result)
            {
                BigInteger.Multiply(ref result, 2u, out *ptr);
            }
        }
        bool flag3;
        bool flag4;
        uint num7;
        if (cutoffNumber == -1)
        {
            while (true)
            {
                num7 = BigInteger.HeuristicDivide(ref lhs, ref rhs);
                BigInteger.Add(ref lhs, ref *ptr, out var result5);
                int num8 = BigInteger.Compare(ref lhs, ref result);
                int num9 = BigInteger.Compare(ref result5, ref rhs);
                if (flag)
                {
                    flag3 = num8 <= 0;
                    flag4 = num9 >= 0;
                }
                else
                {
                    flag3 = num8 < 0;
                    flag4 = num9 > 0;
                }
                if (flag3 || flag4 || num2 == num4)
                {
                    break;
                }
                buffer[num] = (byte)(48 + num7);
                num++;
                lhs.Multiply10();
                result.Multiply10();
                if (ptr != &result)
                {
                    BigInteger.Multiply(ref result, 2u, out *ptr);
                }
                num2--;
            }
        }
        else
        {
            if (num2 < num4)
            {
                num7 = BigInteger.HeuristicDivide(ref lhs, ref rhs);
                if (num7 > 5 || (num7 == 5 && !lhs.IsZero()))
                {
                    decimalExponent++;
                    num7 = 1u;
                }
                buffer[num] = (byte)(48 + num7);
                return (uint)(num + 1);
            }
            flag3 = false;
            flag4 = false;
            while (true)
            {
                num7 = BigInteger.HeuristicDivide(ref lhs, ref rhs);
                if (lhs.IsZero() || num2 <= num4)
                {
                    break;
                }
                buffer[num] = (byte)(48 + num7);
                num++;
                lhs.Multiply10();
                num2--;
            }
        }
        bool flag5 = flag3;
        if (flag3 == flag4)
        {
            lhs.ShiftLeft(1u);
            int num10 = BigInteger.Compare(ref lhs, ref rhs);
            flag5 = num10 < 0;
            if (num10 == 0)
            {
                flag5 = (num7 & 1) == 0;
            }
        }
        if (flag5)
        {
            buffer[num] = (byte)(48 + num7);
            num++;
        }
        else if (num7 == 9)
        {
            while (true)
            {
                if (num == 0)
                {
                    buffer[num] = 49;
                    num++;
                    decimalExponent++;
                    break;
                }
                num--;
                if (buffer[num] != 57)
                {
                    buffer[num]++;
                    num++;
                    break;
                }
            }
        }
        else
        {
            buffer[num] = (byte)(48 + num7 + 1);
            num++;
        }
        return (uint)num;
    }

References System.Number.BigInteger.Add(), System.buffer, System.Math.Ceiling(), System.Number.BigInteger.Compare(), System.Number.BigInteger.GetBlock(), System.Number.BigInteger.GetLength(), System.Number.BigInteger.HeuristicDivide(), System.Numerics.BitOperations.Log2(), System.Number.BigInteger.Multiply(), System.Number.BigInteger.Multiply10(), System.Number.BigInteger.MultiplyPow10(), System.Number.BigInteger.Pow10(), System.Number.BigInteger.Pow2(), System.Number.BigInteger.SetUInt32(), System.Number.BigInteger.SetUInt64(), and System.Number.BigInteger.ShiftLeft().

Referenced by System.Number.Dragon4Double(), System.Number.Dragon4Half(), and System.Number.Dragon4Single().