Серый код в .NET

Question

Есть ли встроенный в Gray code тип данных в любом месте в .NET Framework? Или утилита преобразования между серой и двоичной? Я мог бы сделать это сам, но если колесо уже было изобретено ...

Answer 1

Использование 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; 
} 

на засыпку Trick: до 2^п бит, вы можете преобразовать Грея в двоичный код, выполнения (2^N) - 1 двоичным к конверсии Грея. Все, что вам нужно, это функция выше и цикл «для».

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

Нет ничего встроенный до серого кода в .NET.

Answer 3

Вот C# реализация, которая предполагает, что вы только хотите сделать это на неотрицательных 32-разрядных целых чисел:

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

Вы могли бы также прочитать this blog post, который обеспечивает методы для преобразования в обоих направления, хотя автор решил представить код как массив из int, содержащий один или ноль в каждой позиции. Лично я бы подумал, что лучший выбор - BitArray.

Answer 4

Graphical Explanation о преобразовании кода Грея - это может помочь немного

Answer 5

Возможно, это набор методов является полезным

• на основе BitArray
• оба направления
• Int или просто п Биты

просто наслаждайтесь.

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