Question

The following code checks to see if a given number follows a specific binary pattern.

I wrote this code without considering endian order and how the number is signed.

public static bool IsDiagonalToPowerOfTwo (this System.Numerics.BigInteger number)
{
    byte [] bytes = null;
    bool moreOnesPossible = true;

    if (number == 0) // 00000000
    {
        return (true); // All bits are zero.
    }
    else
    {
        bytes = number.ToByteArray();

        if ((bytes [bytes.Length - 1] & 1) == 1)
        {
            return (false);
        }
        else
        {
            for (byte b=0; b < bytes.Length; b++)
            {
                if (moreOnesPossible)
                {
                    if (bytes [b] == 255)
                    {
                        // Continue.
                    }
                    else if
                    (
                        ((bytes [b] & 128) == 128) // 10000000
                        || ((bytes [b] & 192) == 192) // 11000000
                        || ((bytes [b] & 224) == 224) // 11100000
                        || ((bytes [b] & 240) == 240) // 11110000
                        || ((bytes [b] & 248) == 248) // 11111000
                        || ((bytes [b] & 252) == 252) // 11111100
                        || ((bytes [b] & 254) == 254) // 11111110
                    )
                    {
                        moreOnesPossible = false;
                    }
                    else
                    {
                        return (false);
                    }
                }
                else
                {
                    if (bytes [b] > 0)
                    {
                        return (false);
                    }
                }
            }
        }
    }

    return (true);
}

How could I adjust this code to accommodate little endian order and sign? I have tried to follow MSDN but without luck.

Answer 1

The test

else if
        (
            ((bytes [b] & 128) == 128) // 10000000
            || ((bytes [b] & 192) == 192) // 11000000
            || ((bytes [b] & 224) == 224) // 11100000
            || ((bytes [b] & 240) == 240) // 11110000
            || ((bytes [b] & 248) == 248) // 11111000
            || ((bytes [b] & 252) == 252) // 11111100
            || ((bytes [b] & 254) == 254) // 11111110
        )

can be reduced to else if ((bytes[b] & 128) == 128). Any of the later tests implies the first, so that already determines the outcome completely. I think what you really want here is

else if (bytes[b] == 128
         || bytes[b] == 192
         || bytes[b] == 224
         || bytes[b] == 240
         || bytes[b] == 248
         || bytes[b] == 252
         || bytes[b] == 254
        )

Apart from that, the representation is fixed, ToByteArray gives the same representation regardless of machine endianness.