Gray-Code in .NET

Question

Gibt es einen eingebauten Gray code-Datentyp irgendwo im .NET-Framework? Oder Konvertierungsprogramm zwischen Grau und Binär? Ich könnte es selbst tun, aber wenn das Rad bereits erfunden wurde ...

Answer 1

Verwenden Sie 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 heikel Trick: - 1-binäres Gray Konvertierungen für bis zu 2^n Bits, können Sie Gray binäre durch Durchführen (2^n umzuwandeln. Alles, was Sie brauchen, ist die Funktion oben und eine 'for' Schleife.

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

Es gibt nichts eingebaut so weit wie Gray-Code in .NET.

Answer 3

Hier ist eine C# -Implementierung, dass Sie nur diese auf nicht-negativen 32-Bit-Integer tun möchten gelten folgende Voraussetzungen:

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

Sie vielleicht gefallen this blog post auch lesen, die Methoden für Umsetzungen in beide bietet Richtungen, obwohl der Autor wählte den Code als ein Array von int mit entweder eins oder Null an jeder Position zu vertreten. Persönlich würde ich denken, dass eine BitArray eine bessere Wahl sein könnte.

Answer 4

Graphical Explanation über Gray-Code-Konvertierung - dies kann eine Hilfe wenig

Answer 5

Vielleicht ist diese Sammlung von Methoden nützlich ist

• basierend auf BitArray
• beiden Richtungen
• int oder nur n Bits

einfach genießen.

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