NumberToFloatingPointBitsSlow()

static ulong System.Number.NumberToFloatingPointBitsSlow ( ref NumberBuffer number, in FloatingPointInfo info, uint positiveExponent, uint integerDigitsPresent, uint fractionalDigitsPresent )

inlinestaticprivate

Definition at line 3761 of file Number.cs.

    {
        uint num = (uint)(info.NormalMantissaBits + 1);
        uint digitsCount = (uint)number.DigitsCount;
        uint num2 = positiveExponent - integerDigitsPresent;
        uint lastIndex = digitsCount;
        AccumulateDecimalDigitsIntoBigInteger(ref number, 0u, integerDigitsPresent, out var result);
        if (num2 != 0)
        {
            if (num2 > info.OverflowDecimalExponent)
            {
                return info.InfinityBits;
            }
            result.MultiplyPow10(num2);
        }
        uint num3 = BigInteger.CountSignificantBits(ref result);
        if (num3 >= num || fractionalDigitsPresent == 0)
        {
            return ConvertBigIntegerToFloatingPointBits(ref result, in info, num3, fractionalDigitsPresent != 0);
        }
        uint num4 = fractionalDigitsPresent;
        if (number.Scale < 0)
        {
            num4 += (uint)(-number.Scale);
        }
        if (num3 == 0 && num4 - (int)digitsCount > info.OverflowDecimalExponent)
        {
            return info.ZeroBits;
        }
        AccumulateDecimalDigitsIntoBigInteger(ref number, integerDigitsPresent, lastIndex, out var result2);
        if (result2.IsZero())
        {
            return ConvertBigIntegerToFloatingPointBits(ref result, in info, num3, fractionalDigitsPresent != 0);
        }
        BigInteger.Pow10(num4, out var result3);
        uint num5 = BigInteger.CountSignificantBits(ref result2);
        uint num6 = BigInteger.CountSignificantBits(ref result3);
        uint num7 = 0u;
        if (num6 > num5)
        {
            num7 = num6 - num5;
        }
        if (num7 != 0)
        {
            result2.ShiftLeft(num7);
        }
        uint num8 = num - num3;
        uint num9 = num8;
        if (num3 != 0)
        {
            if (num7 > num9)
            {
                return ConvertBigIntegerToFloatingPointBits(ref result, in info, num3, fractionalDigitsPresent != 0);
            }
            num9 -= num7;
        }
        uint num10 = num7;
        if (BigInteger.Compare(ref result2, ref result3) < 0)
        {
            num10++;
        }
        result2.ShiftLeft(num9);
        BigInteger.DivRem(ref result2, ref result3, out var quo, out var rem);
        ulong num11 = quo.ToUInt64();
        bool flag = !number.HasNonZeroTail && rem.IsZero();
        uint num12 = BigInteger.CountSignificantBits(num11);
        if (num12 > num8)
        {
            int num13 = (int)(num12 - num8);
            flag = flag && (num11 & (ulong)((1L << num13) - 1)) == 0;
            num11 >>= num13;
        }
        ulong num14 = result.ToUInt64();
        ulong initialMantissa = (num14 << (int)num8) + num11;
        int initialExponent = (int)((num3 != 0) ? (num3 - 2) : (0 - num10 - 1));
        return AssembleFloatingPointBits(in info, initialMantissa, initialExponent, flag);
    }

References System.Number.AccumulateDecimalDigitsIntoBigInteger(), System.Number.AssembleFloatingPointBits(), System.Number.BigInteger.Compare(), System.Number.ConvertBigIntegerToFloatingPointBits(), System.Number.BigInteger.CountSignificantBits(), System.Number.BigInteger.DivRem(), System.info, System.L, and System.Number.BigInteger.Pow10().

Referenced by System.Number.NumberToDoubleFloatingPointBits(), System.Number.NumberToHalfFloatingPointBits(), and System.Number.NumberToSingleFloatingPointBits().