operator>>()

static BigInteger System.Numerics.BigInteger.operator>> ( BigInteger value, int shift )

inlinestatic

Definition at line 1736 of file BigInteger.cs.

    {
        if (shift == 0)
        {
            return value;
        }
        if (shift == int.MinValue)
        {
            return value << int.MaxValue << 1;
        }
        if (shift < 0)
        {
            return value << -shift;
        }
        (int Quotient, int Remainder) tuple = Math.DivRem(shift, 32);
        int item = tuple.Quotient;
        int item2 = tuple.Remainder;
        Span<uint> span = stackalloc uint[1];
        Span<uint> span2 = span;
        Span<uint> xd = span2;
        bool partsForBitManipulation = GetPartsForBitManipulation(ref value, ref xd);
        bool flag = false;
        if (partsForBitManipulation)
        {
            if (shift >= 32 * xd.Length)
            {
                return MinusOne;
            }
            if (xd != span2)
            {
                if (xd.Length <= 64)
                {
                    span = stackalloc uint[64];
                    span2 = span.Slice(0, xd.Length);
                    xd.CopyTo(span2);
                    xd = span2;
                }
                else
                {
                    xd = xd.ToArray();
                }
            }
            NumericsHelpers.DangerousMakeTwosComplement(xd);
            flag = item2 == 0 && xd[^1] == 0;
        }
        int num = xd.Length - item + (flag ? 1 : 0);
        uint[] valueArray = null;
        Span<uint> span3 = default(Span<uint>);
        if (num > 0)
        {
            Span<uint> span4;
            if (num <= 64)
            {
                span = stackalloc uint[64];
                span4 = span.Slice(0, num);
            }
            else
            {
                span4 = (valueArray = new uint[num]);
            }
            span3 = span4;
        }
        if (item2 == 0)
        {
            for (int num2 = xd.Length - 1; num2 >= item; num2--)
            {
                span3[num2 - item] = xd[num2];
            }
        }
        else
        {
            int num3 = 32 - item2;
            uint num4 = 0u;
            for (int num5 = xd.Length - 1; num5 >= item; num5--)
            {
                uint num6 = xd[num5];
                if (partsForBitManipulation && num5 == xd.Length - 1)
                {
                    span3[num5 - item] = (num6 >> item2) | (uint)(-1 << num3);
                }
                else
                {
                    span3[num5 - item] = (num6 >> item2) | num4;
                }
                num4 = num6 << num3;
            }
        }
        if (partsForBitManipulation)
        {
            if (flag)
            {
                span3[^1] = uint.MaxValue;
            }
            NumericsHelpers.DangerousMakeTwosComplement(span3);
        }
        return new BigInteger(span3, valueArray, partsForBitManipulation);
    }

References System.Numerics.BigInteger.BigInteger(), System.Span< T >.CopyTo(), System.Numerics.NumericsHelpers.DangerousMakeTwosComplement(), System.Math.DivRem(), System.Numerics.BigInteger.GetPartsForBitManipulation(), System.item, System.Span< T >.Length, System.Numerics.BigInteger.MinusOne, System.Numerics.BigInteger.Remainder(), System.Span< T >.Slice(), System.Span< T >.ToArray(), and System.value.