DivRem()

static unsafe void System.Number.BigInteger.DivRem ( ref BigInteger lhs, ref BigInteger rhs, out BigInteger quo, out BigInteger rem )

inlinestatic

Definition at line 136 of file Number.cs.

        {
            if (lhs.IsZero())
            {
                SetZero(out quo);
                SetZero(out rem);
                return;
            }
            int length = lhs._length;
            int length2 = rhs._length;
            if (length == 1 && length2 == 1)
            {
                var (value, value2) = Math.DivRem(lhs._blocks[0], rhs._blocks[0]);
                SetUInt32(out quo, value);
                SetUInt32(out rem, value2);
                return;
            }
            if (length2 == 1)
            {
                int num = length;
                ulong right = rhs._blocks[0];
                ulong num2 = 0uL;
                for (int num3 = num - 1; num3 >= 0; num3--)
                {
                    ulong left = (num2 << 32) | lhs._blocks[num3];
                    ulong num4;
                    (num4, num2) = Math.DivRem(left, right);
                    if (num4 == 0L && num3 == num - 1)
                    {
                        num--;
                    }
                    else
                    {
                        quo._blocks[num3] = (uint)num4;
                    }
                }
                quo._length = num;
                SetUInt32(out rem, (uint)num2);
                return;
            }
            if (length2 > length)
            {
                SetZero(out quo);
                SetValue(out rem, ref lhs);
                return;
            }
            int num5 = length - length2 + 1;
            SetValue(out rem, ref lhs);
            int num6 = length;
            uint num7 = rhs._blocks[length2 - 1];
            uint num8 = rhs._blocks[length2 - 2];
            int num9 = BitOperations.LeadingZeroCount(num7);
            int num10 = 32 - num9;
            if (num9 > 0)
            {
                num7 = (num7 << num9) | (num8 >> num10);
                num8 <<= num9;
                if (length2 > 2)
                {
                    num8 |= rhs._blocks[length2 - 3] >> num10;
                }
            }
            for (int num11 = length; num11 >= length2; num11--)
            {
                int num12 = num11 - length2;
                uint num13 = ((num11 < length) ? rem._blocks[num11] : 0u);
                ulong num14 = ((ulong)num13 << 32) | rem._blocks[num11 - 1];
                uint num15 = ((num11 > 1) ? rem._blocks[num11 - 2] : 0u);
                if (num9 > 0)
                {
                    num14 = (num14 << num9) | (num15 >> num10);
                    num15 <<= num9;
                    if (num11 > 2)
                    {
                        num15 |= rem._blocks[num11 - 3] >> num10;
                    }
                }
                ulong num16 = num14 / num7;
                if (num16 > uint.MaxValue)
                {
                    num16 = 4294967295uL;
                }
                while (DivideGuessTooBig(num16, num14, num15, num7, num8))
                {
                    num16--;
                }
                if (num16 != 0)
                {
                    uint num17 = SubtractDivisor(ref rem, num12, ref rhs, num16);
                    if (num17 != num13)
                    {
                        num17 = AddDivisor(ref rem, num12, ref rhs);
                        num16--;
                    }
                }
                if (num5 != 0)
                {
                    if (num16 == 0L && num12 == num5 - 1)
                    {
                        num5--;
                    }
                    else
                    {
                        quo._blocks[num12] = (uint)num16;
                    }
                }
                if (num11 < num6)
                {
                    num6--;
                }
            }
            quo._length = num5;
            for (int num18 = num6 - 1; num18 >= 0; num18--)
            {
                if (rem._blocks[num18] == 0)
                {
                    num6--;
                }
            }
            rem._length = num6;
        }

References System.Number.BigInteger.AddDivisor(), System.Number.BigInteger.DivideGuessTooBig(), System.Math.DivRem(), System.L, System.Numerics.BitOperations.LeadingZeroCount(), System.length, System.length2, System.Number.BigInteger.SetUInt32(), System.Number.BigInteger.SetValue(), System.Number.BigInteger.SetZero(), System.Number.BigInteger.SubtractDivisor(), and System.value.

Referenced by System.Number.NumberToFloatingPointBitsSlow().