ToUInt32Span()

ReadOnlySpan< uint > System.Numerics.BigInteger.ToUInt32Span ( Span< uint > scratch )

inlineprivate

Definition at line 1235 of file BigInteger.cs.

    {
        if (_bits == null && _sign == 0)
        {
            scratch[0] = 0u;
            return scratch.Slice(0, 1);
        }
        Span<uint> span = scratch;
        bool flag = true;
        uint num;
        if (_bits == null)
        {
            span[0] = (uint)_sign;
            span = span.Slice(0, 1);
            num = ((_sign < 0) ? uint.MaxValue : 0u);
        }
        else if (_sign == -1)
        {
            if (span.Length >= _bits.Length)
            {
                _bits.AsSpan().CopyTo(span);
                span = span.Slice(0, _bits.Length);
            }
            else
            {
                span = (uint[])_bits.Clone();
            }
            NumericsHelpers.DangerousMakeTwosComplement(span);
            num = uint.MaxValue;
        }
        else
        {
            span = _bits;
            num = 0u;
            flag = false;
        }
        int num2 = span.Length - 1;
        while (num2 > 0 && span[num2] == num)
        {
            num2--;
        }
        bool flag2 = (span[num2] & 0x80000000u) != (num & 0x80000000u);
        int num3 = num2 + 1 + (flag2 ? 1 : 0);
        bool flag3 = true;
        if (num3 <= scratch.Length)
        {
            scratch = scratch.Slice(0, num3);
            flag3 = !flag;
        }
        else
        {
            scratch = new uint[num3];
        }
        if (flag3)
        {
            span.Slice(0, num2 + 1).CopyTo(scratch);
        }
        if (flag2)
        {
            scratch[^1] = num;
        }
        return scratch;
    }

References System.Numerics.BigInteger._bits, System.Numerics.BigInteger._sign, System.Numerics.NumericsHelpers.DangerousMakeTwosComplement(), System.Span< T >.Length, and System.Span< T >.Slice().

Referenced by System.Numerics.BigInteger.operator&(), System.Numerics.BigInteger.operator^(), and System.Numerics.BigInteger.operator|().