Gray code in .NET

Question

Is there a built in Gray code datatype anywhere in the .NET framework? Or conversion utility between Gray and binary? I could do it myself, but if the wheel has already been invented...

Answer 1

Use this trick.

/*
        The purpose of this function is to convert an unsigned
        binary number to reflected binary Gray code.
*/
unsigned short binaryToGray(unsigned short num)
{
        return (num>>1) ^ num;
}

A tricky Trick: for up to 2^n bits, you can convert Gray to binary by performing (2^n) - 1 binary-to Gray conversions. All you need is the function above and a 'for' loop.

/*
        The purpose of this function is to convert a reflected binary
        Gray code number to a binary number.
*/
unsigned short grayToBinary(unsigned short num)
{
        unsigned short temp = num ^ (num>>8);
        temp ^= (temp>>4);
        temp ^= (temp>>2);
        temp ^= (temp>>1);
       return temp;
}

Answer 2

Here is a C# implementation that assumes you only want to do this on non-negative 32-bit integers:

static uint BinaryToGray(uint num)
{
    return (num>>1) ^ num;
}

You might also like to read this blog post which provides methods for conversions in both directions, though the author chose to represent the code as an array of int containing either one or zero at each position. Personally I would think a BitArray might be a better choice.

Answer 3

Perhaps this collection of methods is useful

• based on BitArray
• both directions
• int or just n Bits

just enjoy.

public static class GrayCode
{
    public static byte BinaryToByte(BitArray binary)
    {
        if (binary.Length > 8)
            throw new ArgumentException("bitarray too long for byte");

        var array = new byte[1];
        binary.CopyTo(array, 0);
        return array[0];
    }

    public static int BinaryToInt(BitArray binary)
    {
        if (binary.Length > 32)
            throw new ArgumentException("bitarray too long for int");

        var array = new int[1];
        binary.CopyTo(array, 0);
        return array[0];
    }

    public static BitArray BinaryToGray(BitArray binary)
    {
        var len = binary.Length;
        var gray = new BitArray(len);
        gray[len - 1] = binary[len - 1]; // copy high-order bit
        for (var i = len - 2; i >= 0; --i)
        {
            // remaining bits 
            gray[i] = binary[i] ^ binary[i + 1];
        }
        return gray;
    }

    public static BitArray GrayToBinary(BitArray gray)
    {
        var len = gray.Length;
        var binary = new BitArray(len);
        binary[len - 1] = gray[len - 1]; // copy high-order bit
        for (var i = len - 2; i >= 0; --i)
        {
            // remaining bits 
            binary[i] = !gray[i] ^ !binary[i + 1];
        }
        return binary;
    }

    public static BitArray ByteToGray(byte value)
    {
        var bits = new BitArray(new[] { value });
        return BinaryToGray(bits);
    }

    public static BitArray IntToGray(int value)
    {
        var bits = new BitArray(new[] { value });
        return BinaryToGray(bits);
    }

    public static byte GrayToByte(BitArray gray)
    {
        var binary = GrayToBinary(gray);
        return BinaryToByte(binary);
    }

    public static int GrayToInt(BitArray gray)
    {
        var binary = GrayToBinary(gray);
        return BinaryToInt(binary);
    }

    /// <summary>
    ///     Returns the bits as string of '0' and '1' (LSB is right)
    /// </summary>
    /// <param name="bits"></param>
    /// <returns></returns>
    public static string AsString(this BitArray bits)
    {
        var sb = new StringBuilder(bits.Length);
        for (var i = bits.Length - 1; i >= 0; i--)
        {
            sb.Append(bits[i] ? "1" : "0");
        }
        return sb.ToString();
    }

    public static IEnumerable<bool> Bits(this BitArray bits)
    {
        return bits.Cast<bool>();
    }

    public static bool[] AsBoolArr(this BitArray bits, int count)
    {
        return bits.Bits().Take(count).ToArray();
    }
}