c# - .NET 中的格雷码

Question

.NET 框架中的任何地方是否都有内置的格雷码数据类型？或者灰色和二进制之间的转换实用程序？我可以自己做，但如果轮子已经被发明出来......

Answer 1

使用这个技巧。

/*
        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;
}

一个棘手的技巧：对于最多 2^n 位，您可以通过执行 (2^n) - 1 个二进制到灰度的转换将灰度转换为二进制。你所需要的只是上面的函数和一个'for'循环。

/*
        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

这是一个 C# 实现，假设您只想对非负 32 位整数执行此操作：

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

您可能还想阅读这篇博客文章，它提供了双向转换的方法，尽管作者选择将代码表示为int每个位置包含 1 或 0 的数组。我个人认为aBitArray可能是一个更好的选择。

Answer 3

也许这个方法集合很有用

• 基于位阵列
• 两个方向
• int 或只是 n 位

享受就好。

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();
    }
}

Answer 4

.NET中没有任何内置的格雷码。

Answer 5

关于格雷码转换的图形解释- 这可以帮助一点