A-M baby

Task/Gray-code/0DESCRIPTION

@@ -0,0 +1,21 @@
+[[wp:Gray code|Gray code]] is a form of binary encoding where transitions between consecutive numbers differ by only one bit. This is a useful encoding for reducing hardware data hazards with values that change rapidly and/or connect to slower hardware as inputs. It is also useful for generating inputs for [[wp:Karnaugh map|Karnaugh maps]] in order from left to right or top to bottom.
+
+Create functions to encode a number to and decode a number from Gray code. Display the normal binary representations, Gray code representations, and decoded Gray code values for all 5-bit binary numbers (0-31 inclusive, leading 0's not necessary).
+
+There are many possible Gray codes.  The following encodes what is called "binary reflected Gray code."
+
+Encoding (MSB is bit 0, b is binary, g is Gray code):
+<pre>if b[i-1] = 1
+   g[i] = not b[i]
+else
+   g[i] = b[i]</pre>
+Or:
+<pre>g = b xor (b logically right shifted 1 time)</pre>
+Decoding (MSB is bit 0, b is binary, g is Gray code):
+<pre>b[0] = g[0]
+
+for other bits:
+b[i] = g[i] xor b[i-1]</pre>
+
+;Reference
+* [http://www.wisc-online.com/Objects/ViewObject.aspx?ID=IAU8307 Converting Between Gray and Binary Codes]. It includes step-by-step animations.

Task/Gray-code/Ada/gray-code.ada

@@ -0,0 +1,47 @@
+with Ada.Text_IO, Interfaces;
+use Ada.Text_IO, Interfaces;
+
+procedure Gray is
+
+   Bits : constant := 5; -- Change only this line for 6 or 7-bit encodings
+   subtype Values is Unsigned_8 range 0 .. 2 ** Bits - 1;
+   package Values_Io is new Ada.Text_IO.Modular_IO (Values);
+
+   function Encode (Binary : Values) return Values is
+   begin
+      return Binary xor Shift_Right (Binary, 1);
+   end Encode;
+   pragma Inline (Encode);
+
+   function Decode (Gray : Values) return Values is
+      Binary, Bit : Values;
+      Mask        : Values := 2 ** (Bits - 1);
+   begin
+      Bit    := Gray and Mask;
+      Binary := Bit;
+      for I in 2 .. Bits loop
+         Bit    := Shift_Right (Bit, 1);
+         Mask   := Shift_Right (Mask, 1);
+         Bit    := (Gray and Mask) xor Bit;
+         Binary := Binary + Bit;
+      end loop;
+      return Binary;
+   end Decode;
+   pragma Inline (Decode);
+
+   HT : constant Character := Character'Val (9);
+   J  : Values;
+begin
+   Put_Line ("Num" & HT & "Binary" & HT & HT & "Gray" & HT & HT & "decoded");
+   for I in Values'Range loop
+      J := Encode (I);
+      Values_Io.Put (I, 4);
+      Put (": " & HT);
+      Values_Io.Put (I, Bits + 2, 2);
+      Put (" =>" & HT);
+      Values_Io.Put (J, Bits + 2, 2);
+      Put (" => " & HT);
+      Values_Io.Put (Decode (J), 4);
+      New_Line;
+   end loop;
+end Gray;

Task/Gray-code/AutoHotkey/gray-code.ahk

@@ -0,0 +1,23 @@
+gray_encode(n){
+	return n ^ (n >> 1)
+}
+
+gray_decode(n){
+	p := n
+	while (n >>= 1)
+		p ^= n
+	return p
+}
+
+BinString(n){
+	Loop 5
+		If ( n & ( 1 << (A_Index-1) ) )
+			o := "1" . o
+		else	o := "0" . o
+	return o
+}
+
+Loop 32
+	n:=A_Index-1, out .= n " : " BinString(n) " => " BinString(e:=gray_encode(n))
+			. " => " BinString(gray_decode(e)) " => " BinString(n) "`n"
+MsgBox % clipboard := out

Task/Gray-code/BBC-BASIC/gray-code.bbc

@@ -0,0 +1,15 @@
+      INSTALL @lib$+"STRINGLIB"
+
+      PRINT "   Decimal    Binary      Gray   Decoded"
+      FOR number% = 0 TO 31
+        gray% = FNgrayencode(number%)
+        PRINT number% "     " FN_tobase(number%, 2, 5) ;
+        PRINT "     " FN_tobase(gray%, 2, 5) FNgraydecode(gray%)
+      NEXT
+      END
+
+      DEF FNgrayencode(B%) = B% EOR (B% >>> 1)
+
+      DEF FNgraydecode(G%) : LOCAL B%
+      REPEAT B% EOR= G% : G% = G% >>> 1 : UNTIL G% = 0
+      = B%

Task/Gray-code/C++/gray-code.cpp

@@ -0,0 +1,37 @@
+#include <bitset>
+#include <iostream>
+#include <string>
+
+uint32_t gray_encode(uint32_t b)
+{
+    return b ^ (b >> 1);
+}
+
+uint32_t gray_decode(uint32_t g)
+{
+    for (uint32_t bit = 1U << 31; bit > 1; bit >>= 1)
+    {
+        if (g & bit) g ^= bit >> 1;
+    }
+    return g;
+}
+
+std::string to_binary(int value) // utility function
+{
+    const std::bitset<32> bs(value);
+    const std::string str(bs.to_string());
+    const size_t pos(str.find('1'));
+    return pos == std::string::npos ? "0" : str.substr(pos);
+}
+
+int main()
+{
+    std::cout << "Number\tBinary\tGray\tDecoded\n";
+    for (uint32_t n = 0; n < 32; ++n)
+    {
+        uint32_t g = gray_encode(n);
+        uint32_t b = gray_decode(g);
+
+        std::cout << n << "\t" << to_binary(n) << "\t" << to_binary(g) << "\t" << b << "\n";
+    }
+}

Task/Gray-code/C-sharp/gray-code.cs

@@ -0,0 +1,23 @@
+using System;
+
+public class Gray {
+    public static ulong grayEncode(ulong n) {
+        return n^(n>>1);
+    }
+
+    public static ulong grayDecode(ulong n) {
+        ulong i=1<<8*64-2; //long is 64-bit
+        ulong p, b=p=n&i;
+
+        while((i>>=1)>0)
+            b|=p=n&i^p>>1;
+        return b;
+    }
+
+    public static void Main(string[] args) {
+        Console.WriteLine("Number\tBinary\tGray\tDecoded");
+        for(ulong i=0;i<32;i++) {
+            Console.WriteLine(string.Format("{0}\t{1}\t{2}\t{3}", i, Convert.ToString((long)i, 2), Convert.ToString((long)grayEncode(i), 2), grayDecode(grayEncode(i))));
+        }
+    }
+}

Task/Gray-code/C/gray-code-1.c

@@ -0,0 +1,9 @@
+int gray_encode(int n) {
+    return n ^ (n >> 1);
+}
+
+int gray_decode(int n) {
+    int p = n;
+    while (n >>= 1) p ^= n;
+    return p;
+}

Task/Gray-code/C/gray-code-2.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+
+/* Simple bool formatter, only good on range 0..31 */
+void fmtbool(int n, char *buf) {
+    char *b = buf + 5;
+    *b=0;
+    do {
+	*--b = '0' + (n & 1);
+	n >>= 1;
+    } while (b != buf);
+}
+
+int main(int argc, char **argv) {
+    int i,g,b;
+    char bi[6],bg[6],bb[6];
+
+    for (i=0 ; i<32 ; i++) {
+	g = gray_encode(i);
+	b = gray_decode(g);
+	fmtbool(i,bi); fmtbool(g,bg); fmtbool(b,bb);
+	printf("%2d : %5s => %5s => %5s : %2d\n", i, bi, bg, bb, b);
+    }
+    return 0;
+}

Task/Gray-code/CoffeeScript/gray-code.coffee

@@ -0,0 +1,10 @@
+gray_encode = (n) ->
+  n ^ (n >> 1)
+
+gray_decode = (g) ->
+  n = g
+  n ^= g while g >>= 1
+  n
+
+for i in [0..32]
+  console.log gray_decode gray_encode(i)

Task/Gray-code/Common-Lisp/gray-code.lisp

@@ -0,0 +1,11 @@
+(defun gray-encode (n)
+  (logxor n (ash n -1)))
+
+(defun gray-decode (n)
+  (do ((p n (logxor p n)))
+    ((zerop n) p)
+    (setf n (ash n -1))))
+
+(loop for i to 31 do
+      (let* ((g (gray-encode i)) (b (gray-decode g)))
+	(format t "~2d:~6b =>~6b =>~6b :~2d~%" i i g b b)))

Task/Gray-code/D/gray-code-1.d

@@ -0,0 +1,23 @@
+import std.stdio;
+
+T enGray(T)(in T n) pure nothrow {
+    return n ^ (n >>> 1);
+}
+
+T deGray(T)(in T n) pure nothrow {
+    enum T MSB = (cast(T)1) << (T.sizeof * 8 - 1);
+
+    auto res = (n & MSB) ;
+    foreach (bit; 1 .. T.sizeof * 8)
+        res += (n ^ (res >>> 1)) & (MSB >>> bit);
+    return res;
+}
+
+void main() {
+    writeln("num  bits    encoded  decoded");
+    foreach (i; 0 .. 32) {
+        immutable encoded = enGray(i);
+        writefln("%2d: %5b ==> %5b : %2d",
+                 i, i, encoded, deGray(encoded));
+    }
+}

Task/Gray-code/D/gray-code-2.d

@@ -0,0 +1,37 @@
+import std.stdio, std.conv, std.algorithm;
+
+T[] gray(int N : 1, T)() { return [to!T(0), 1]; }
+
+/// recursively generate gray encoding mapping table
+T[] gray(int N, T)() pure nothrow {
+    assert(N <= T.sizeof * 8, "N exceed number of bit of T");
+    enum T M = to!T(2) ^^ (N - 1);
+    T[] g = gray!(N - 1, T)();
+    foreach (i; 0 .. M)
+        g ~= M + g[M - i - 1];
+    return g;
+}
+
+T[][] grayDict(int N, T)() {
+    T[][] dict = [gray!(N, T)(), [0]];
+    // append inversed gray encoding mapping
+    foreach (i; 1 .. dict[0].length)
+        dict[1] ~= countUntil(dict[0], i);
+    return dict;
+}
+
+enum M { Encode = 0, Decode = 1 };
+
+T gray(int N, T)(in T n, in int mode=M.Encode) {
+    // generated at compile time
+    enum dict = grayDict!(N, T)();
+    return dict[mode][n];
+}
+
+void main() {
+    foreach (i; 0 .. 32) {
+        immutable encoded = gray!(5)(i, M.Encode);
+        immutable decoded = gray!(5)(encoded, M.Decode);
+        writefln("%2d: %5b => %5b : %2d", i, i, encoded, decoded);
+    }
+}

Task/Gray-code/D/gray-code-3.d

@@ -0,0 +1,11 @@
+import std.stdio, std.algorithm, std.range;
+
+string[] g(in uint n) /*pure nothrow*/ {
+    return n ? g(n - 1).map!q{'0' ~ a}().array() ~
+               g(n - 1).retro().map!q{'1' ~ a}().array()
+             : [""];
+}
+
+void main() {
+    writeln(g(4));
+}

Task/Gray-code/DWScript/gray-code.dwscript

@@ -0,0 +1,23 @@
+function Encode(v : Integer) : Integer;
+begin
+   Result := v xor (v shr 1);
+end;
+
+function Decode(v : Integer) : Integer;
+begin
+   Result := 0;
+   while v>0 do begin
+      Result := Result xor v;
+	  v := v shr 1;
+   end;
+end;
+
+PrintLn('decimal  binary   gray    decoded');
+
+var i : Integer;
+for i:=0 to 31 do begin
+   var g := Encode(i);
+   var d := Decode(g);
+   PrintLn(Format('  %2d     %s   %s   %s  %2d',
+                  [i, IntToBin(i, 5), IntToBin(g, 5), IntToBin(d, 5), d]));
+end;

Task/Gray-code/Delphi/gray-code.delphi

@@ -0,0 +1,45 @@
+program GrayCode;
+
+{$APPTYPE CONSOLE}
+
+uses SysUtils;
+
+function Encode(v: Integer): Integer;
+begin
+  Result := v xor (v shr 1);
+end;
+
+function Decode(v: Integer): Integer;
+begin
+  Result := 0;
+  while v > 0 do
+  begin
+    Result := Result xor v;
+    v := v shr 1;
+  end;
+end;
+
+function IntToBin(aValue: LongInt; aDigits: Integer): string;
+begin
+  Result := StringOfChar('0', aDigits);
+  while aValue > 0 do
+  begin
+    if (aValue and 1) = 1 then
+      Result[aDigits] := '1';
+    Dec(aDigits);
+    aValue := aValue shr 1;
+  end;
+end;
+
+var
+  i, g, d: Integer;
+begin
+  Writeln('decimal  binary   gray    decoded');
+
+  for i := 0 to 31 do
+  begin
+    g := Encode(i);
+    d := Decode(g);
+    Writeln(Format('  %2d     %s   %s   %s  %2d', [i, IntToBin(i, 5), IntToBin(g, 5), IntToBin(d, 5), d]));
+  end;
+end.

Task/Gray-code/Erlang/gray-code-1.erl

@@ -0,0 +1,9 @@
+-module(gray).
+-export([encode/1, decode/1]).
+
+encode(N) -> N bxor (N bsr 1).
+
+decode(G) -> decode(G,0).
+
+decode(0,N) -> N;
+decode(G,N) -> decode(G bsr 1, G bxor N).

Task/Gray-code/Erlang/gray-code-2.erl

@@ -0,0 +1,11 @@
+-module(testgray).
+
+test_encode(N) ->
+  G = gray:encode(N),
+  D = gray:decode(G),
+  io:fwrite("~2B : ~5.2.0B : ~5.2.0B : ~5.2.0B : ~2B~n", [N, N, G, D, D]).
+
+test_encode(N, N) -> [];
+test_encode(I, N) when I < N -> test_encode(I), test_encode(I+1, N).
+
+main(_) -> test_encode(0,32).

Task/Gray-code/Euphoria/gray-code.euphoria

@@ -0,0 +1,34 @@
+function gray_encode(integer n)
+    return xor_bits(n,floor(n/2))
+end function
+
+function gray_decode(integer n)
+    integer g
+    g = 0
+    while n > 0 do
+        g = xor_bits(g,n)
+        n = floor(n/2)
+    end while
+    return g
+end function
+
+function dcb(integer n)
+    atom d,m
+    d = 0
+    m = 1
+    while n do
+        d += remainder(n,2)*m
+        n = floor(n/2)
+        m *= 10
+    end while
+    return d
+end function
+
+integer j
+for i = #0 to #1F do
+    printf(1,"%05d => ",dcb(i))
+    j = gray_encode(i)
+    printf(1,"%05d => ",dcb(j))
+    j = gray_decode(j)
+    printf(1,"%05d\n",dcb(j))
+end for

Task/Gray-code/Factor/gray-code-1.factor

@@ -0,0 +1,16 @@
+USING: math.ranges locals ;
+IN: rosetta-gray
+
+: gray-encode ( n -- n' ) dup -1 shift bitxor ;
+
+:: gray-decode ( n! -- n' )
+   n :> p!
+   [ n -1 shift dup n! 0 = not ] [
+     p n bitxor p!
+   ] while
+   p ;
+
+: main ( -- )
+  -1 32 [a,b] [ dup [ >bin ] [ gray-encode ] bi [ >bin ] [ gray-decode ] bi 4array . ] each ;
+
+MAIN: main

Task/Gray-code/Factor/gray-code-2.factor

@@ -0,0 +1,34 @@
+{ -1 "-1" "0" 0 }
+{ 0 "0" "0" 0 }
+{ 1 "1" "1" 1 }
+{ 2 "10" "11" 2 }
+{ 3 "11" "10" 3 }
+{ 4 "100" "110" 4 }
+{ 5 "101" "111" 5 }
+{ 6 "110" "101" 6 }
+{ 7 "111" "100" 7 }
+{ 8 "1000" "1100" 8 }
+{ 9 "1001" "1101" 9 }
+{ 10 "1010" "1111" 10 }
+{ 11 "1011" "1110" 11 }
+{ 12 "1100" "1010" 12 }
+{ 13 "1101" "1011" 13 }
+{ 14 "1110" "1001" 14 }
+{ 15 "1111" "1000" 15 }
+{ 16 "10000" "11000" 16 }
+{ 17 "10001" "11001" 17 }
+{ 18 "10010" "11011" 18 }
+{ 19 "10011" "11010" 19 }
+{ 20 "10100" "11110" 20 }
+{ 21 "10101" "11111" 21 }
+{ 22 "10110" "11101" 22 }
+{ 23 "10111" "11100" 23 }
+{ 24 "11000" "10100" 24 }
+{ 25 "11001" "10101" 25 }
+{ 26 "11010" "10111" 26 }
+{ 27 "11011" "10110" 27 }
+{ 28 "11100" "10010" 28 }
+{ 29 "11101" "10011" 29 }
+{ 30 "11110" "10001" 30 }
+{ 31 "11111" "10000" 31 }
+{ 32 "100000" "110000" 32 }

Task/Gray-code/Forth/gray-code.fth

@@ -0,0 +1,21 @@
+: >gray ( n -- n ) dup 2/ xor ;
+
+: gray> ( n -- n )
+  0  1 31 lshift  ( g b mask )
+  begin
+    >r
+     2dup 2/ xor
+     r@ and or
+    r> 1 rshift
+    dup 0=
+  until
+  drop nip ;
+
+: test
+  2 base !
+  32 0 do
+    cr i  dup 5 .r ."  ==> "
+    >gray dup 5 .r ."  ==> "
+    gray>     5 .r
+  loop
+  decimal ;

Task/Gray-code/Fortran/gray-code.f

@@ -0,0 +1,46 @@
+      PROGRAM GRAY
+      IMPLICIT NONE
+      INTEGER IGRAY,I,J,K
+      CHARACTER*5 A,B,C
+      DO 10 I=0,31
+      J=IGRAY(I,1)
+      K=IGRAY(J,-1)
+      CALL BINARY(A,I,5)
+      CALL BINARY(B,J,5)
+      CALL BINARY(C,K,5)
+      PRINT 99,I,A,B,C,K
+   10 CONTINUE
+   99 FORMAT(I2,3H : ,A5,4H => ,A5,4H => ,A5,3H : ,I2)
+      END
+
+      FUNCTION IGRAY(N,D)
+      IMPLICIT NONE
+      INTEGER D,K,N,IGRAY
+      IF(D.LT.0) GO TO 10
+      IGRAY=IEOR(N,ISHFT(N,-1))
+      RETURN
+   10 K=N
+      IGRAY=0
+   20 IGRAY=IEOR(IGRAY,K)
+      K=K/2
+      IF(K.NE.0) GO TO 20
+      END
+
+      SUBROUTINE BINARY(S,N,K)
+      IMPLICIT NONE
+      INTEGER I,K,L,N
+      CHARACTER*(*) S
+      L=LEN(S)
+      DO 10 I=0,K-1
+C The following line may replace the next block-if,
+C on machines using ASCII code :
+C     S(L-I:L-I)=CHAR(48+IAND(1,ISHFT(N,-I)))
+C On EBCDIC machines, use 240 instead of 48.
+      IF(BTEST(N,I)) THEN
+      S(L-I:L-I)='1'
+      ELSE
+      S(L-I:L-I)='0'
+      END IF
+   10 CONTINUE
+      S(1:L-K)=''
+      END

Task/Gray-code/Frink/gray-code.frink

@@ -0,0 +1,6 @@
+for i=0 to 31
+{
+   gray = binaryToGray[i]
+   back = grayToBinary[gray]
+   println[(i->binary) + "\t" + (gray->binary) + "\t" + (back->binary)]
+}

Task/Gray-code/Go/gray-code.go

@@ -0,0 +1,23 @@
+package main
+
+import "fmt"
+
+func enc(b int) int {
+    return b ^ b>>1
+}
+
+func dec(g int) (b int) {
+    for ; g != 0; g >>= 1 {
+        b ^= g
+    }
+    return
+}
+
+func main() {
+    fmt.Println("decimal  binary   gray    decoded")
+    for b := 0; b < 32; b++ {
+        g := enc(b)
+        d := dec(g)
+        fmt.Printf("  %2d     %05b   %05b   %05b  %2d\n", b, b, g, d, d)
+    }
+}

Task/Gray-code/Groovy/gray-code-1.groovy

@@ -0,0 +1,10 @@
+def grayEncode = { i ->
+    i ^ (i >>> 1)
+}
+
+def grayDecode;
+grayDecode = { int code ->
+    if(code <= 0) return 0
+    def h = grayDecode(code >>> 1)
+    return (h << 1) + ((code ^ h) & 1)
+}

Task/Gray-code/Groovy/gray-code-2.groovy

@@ -0,0 +1,21 @@
+def binary = { i, minBits = 1 ->
+    def remainder = i
+    def bin = []
+    while (remainder > 0 || bin.size() <= minBits) {
+        bin << (remainder & 1)
+        remainder >>>= 1
+    }
+    bin
+}
+
+println "number   binary   gray code   decode"
+println "======   ======   =========   ======"
+(0..31).each {
+    def code = grayEncode(it)
+    def decode = grayDecode(code)
+    def iB = binary(it, 5)
+    def cB = binary(code, 5)
+    printf("    %2d    %1d%1d%1d%1d%1d       %1d%1d%1d%1d%1d       %2d",
+        it, iB[4],iB[3],iB[2],iB[1],iB[0], cB[4],cB[3],cB[2],cB[1],cB[0], decode)
+    println()
+}

Task/Gray-code/Haskell/gray-code.hs

@@ -0,0 +1,28 @@
+module Main where
+
+main = mapM_ (putStrLn . flip grayconvstr 5) [0..31]
+
+-- Convert number to bit list, MSB first.  Second argument is minimum width.
+num2bin :: (Integral t) => t -> t -> [t]
+num2bin n w = num2bin' n w [] where
+  num2bin' n w acc | n <= 0 && w <= 0 = acc
+                   | otherwise = num2bin' m (w-1) (b:acc)
+    where (m, b) = divMod n 2
+
+xor2 :: (Integral t) => t -> t -> t
+xor2 x y = (x + y) `mod` 2
+
+bin2gray :: (Integral t) => [t] -> [t]
+bin2gray [] = []
+bin2gray (x:xs) = x : zipWith xor2 xs (x:xs)
+
+gray2bin :: (Integral t) => [t] -> [t]
+gray2bin = scanl1 xor2
+
+-- Prettyprinting, since it is in the task description...
+grayconvstr :: (Integral t, Show t) => t -> t -> String
+grayconvstr n w = (show n) ++ ": " ++ (show b) ++ " => " ++ (show g) ++ " => " ++ (show u)
+  where
+    b = num2bin n w
+    g = bin2gray b
+    u = gray2bin g

Task/Gray-code/J/gray-code-1.j

@@ -0,0 +1 @@
+G2B=: ~:/\&.|:

Task/Gray-code/J/gray-code-2.j

@@ -0,0 +1,39 @@
+   n=:i.32
+   G2B=: ~:/\&.|:
+   (,: ,.@".&.>) 'n';'#:n';'G2B inv#:n';'#.G2B G2B inv#:n'
++--+---------+----------+----------------+
+|n |#:n      |G2B inv#:n|#.G2B G2B inv#:n|
++--+---------+----------+----------------+
+| 0|0 0 0 0 0|0 0 0 0 0 | 0              |
+| 1|0 0 0 0 1|0 0 0 0 1 | 1              |
+| 2|0 0 0 1 0|0 0 0 1 1 | 2              |
+| 3|0 0 0 1 1|0 0 0 1 0 | 3              |
+| 4|0 0 1 0 0|0 0 1 1 0 | 4              |
+| 5|0 0 1 0 1|0 0 1 1 1 | 5              |
+| 6|0 0 1 1 0|0 0 1 0 1 | 6              |
+| 7|0 0 1 1 1|0 0 1 0 0 | 7              |
+| 8|0 1 0 0 0|0 1 1 0 0 | 8              |
+| 9|0 1 0 0 1|0 1 1 0 1 | 9              |
+|10|0 1 0 1 0|0 1 1 1 1 |10              |
+|11|0 1 0 1 1|0 1 1 1 0 |11              |
+|12|0 1 1 0 0|0 1 0 1 0 |12              |
+|13|0 1 1 0 1|0 1 0 1 1 |13              |
+|14|0 1 1 1 0|0 1 0 0 1 |14              |
+|15|0 1 1 1 1|0 1 0 0 0 |15              |
+|16|1 0 0 0 0|1 1 0 0 0 |16              |
+|17|1 0 0 0 1|1 1 0 0 1 |17              |
+|18|1 0 0 1 0|1 1 0 1 1 |18              |
+|19|1 0 0 1 1|1 1 0 1 0 |19              |
+|20|1 0 1 0 0|1 1 1 1 0 |20              |
+|21|1 0 1 0 1|1 1 1 1 1 |21              |
+|22|1 0 1 1 0|1 1 1 0 1 |22              |
+|23|1 0 1 1 1|1 1 1 0 0 |23              |
+|24|1 1 0 0 0|1 0 1 0 0 |24              |
+|25|1 1 0 0 1|1 0 1 0 1 |25              |
+|26|1 1 0 1 0|1 0 1 1 1 |26              |
+|27|1 1 0 1 1|1 0 1 1 0 |27              |
+|28|1 1 1 0 0|1 0 0 1 0 |28              |
+|29|1 1 1 0 1|1 0 0 1 1 |29              |
+|30|1 1 1 1 0|1 0 0 0 1 |30              |
+|31|1 1 1 1 1|1 0 0 0 0 |31              |
++--+---------+----------+----------------+

Task/Gray-code/Java/gray-code-1.java

@@ -0,0 +1,21 @@
+public class Gray {
+	public static long grayEncode(long n){
+		return n ^ (n >>> 1);
+	}
+	
+	public static long grayDecode(long n) {
+		long p = n;
+		while ((n >>>= 1) != 0)
+			p ^= n;
+		return p;
+	}
+	public static void main(String[] args){
+		System.out.println("i\tBinary\tGray\tDecoded");
+		for(int i = -1; i < 32;i++){
+			System.out.print(i +"\t");
+			System.out.print(Integer.toBinaryString(i) + "\t");
+			System.out.print(Long.toBinaryString(grayEncode(i))+ "\t");
+			System.out.println(grayDecode(grayEncode(i)));
+		}
+	}
+}

Task/Gray-code/Java/gray-code-2.java

@@ -0,0 +1,12 @@
+public static long grayEncode(long n){
+	long result = 0;
+	for(int exp = 0; n > 0; n /= 2, exp++){
+		long nextHighestBit = (n >> 1) & 1;
+		if(nextHighestBit == 1){
+			result += ((n & 1) == 0) ? (1 << exp) : 0; //flip the bit
+		}else{
+			result += (n & 1) * (1 << exp); //"n & 1" is "this bit", don't flip it
+		}
+	}
+	return result;
+}

Task/Gray-code/Java/gray-code-3.java

@@ -0,0 +1,11 @@
+public static BigInteger grayDecode(BigInteger n){
+	String nBits = n.toString(2);
+	String result = nBits.substring(0, 1);
+	for(int i = 1; i < nBits.length(); i++){
+		//bin[i] = gray[i] ^ bin[i-1]
+
+		//XOR with characters
+		result += nBits.charAt(i) != result.charAt(i - 1) ? "1" : "0";
+	}
+	return new BigInteger(result, 2);
+}

Task/Gray-code/K/gray-code-1.k

@@ -0,0 +1,8 @@
+   xor: {~x=y}
+   gray:{x[0],xor':x}
+
+   / variant: using shift
+   gray1:{(x[0],xor[1_ x;-1_ x])}
+
+   / variant: iterative
+   gray2:{x[0],{:[x[y-1]=1;~x[y];x[y]]}[x]'1+!(#x)-1}

Task/Gray-code/K/gray-code-2.k

@@ -0,0 +1 @@
+   g2b:xor\

Task/Gray-code/K/gray-code-3.k

@@ -0,0 +1,9 @@
+  gray\1 0 0 0 0
+(1 0 0 0 0
+ 1 1 0 0 0
+ 1 0 1 0 0
+ 1 1 1 1 0
+ 1 0 0 0 1
+ 1 1 0 0 1
+ 1 0 1 0 1
+ 1 1 1 1 1)

Task/Gray-code/K/gray-code-4.k

@@ -0,0 +1 @@
+   g2b1:*|{gray x}\

Task/Gray-code/K/gray-code-5.k

@@ -0,0 +1 @@
+   g2b2:{c:#x;b:c#0;b[0]:x[0];i:1;do[#x;b[i]:xor[x[i];b[i-1]];i+:1];b}

Task/Gray-code/K/gray-code-6.k

@@ -0,0 +1,7 @@
+   gray:{x[0],xor':x}
+   g2b:xor\
+   / using allcomb instead of 2_vs'!32 for nicer presentation
+   allcomb:{+(x#y)_vs!_ y^x}
+   a:(+allcomb . 5 2)
+   `0:,/{n:2_sv x;gg:gray x;gb:g2b gg;n2:2_sv gb;
+        ,/$((2$n)," : ",$x," -> ",$gg," -> ",$gb," : ",(2$n2),"\n") }'a

Task/Gray-code/K/gray-code-7.k

@@ -0,0 +1,32 @@
+ 0 : 00000 -> 00000 -> 00000 :  0
+ 1 : 00001 -> 00001 -> 00001 :  1
+ 2 : 00010 -> 00011 -> 00010 :  2
+ 3 : 00011 -> 00010 -> 00011 :  3
+ 4 : 00100 -> 00110 -> 00100 :  4
+ 5 : 00101 -> 00111 -> 00101 :  5
+ 6 : 00110 -> 00101 -> 00110 :  6
+ 7 : 00111 -> 00100 -> 00111 :  7
+ 8 : 01000 -> 01100 -> 01000 :  8
+ 9 : 01001 -> 01101 -> 01001 :  9
+10 : 01010 -> 01111 -> 01010 : 10
+11 : 01011 -> 01110 -> 01011 : 11
+12 : 01100 -> 01010 -> 01100 : 12
+13 : 01101 -> 01011 -> 01101 : 13
+14 : 01110 -> 01001 -> 01110 : 14
+15 : 01111 -> 01000 -> 01111 : 15
+16 : 10000 -> 11000 -> 10000 : 16
+17 : 10001 -> 11001 -> 10001 : 17
+18 : 10010 -> 11011 -> 10010 : 18
+19 : 10011 -> 11010 -> 10011 : 19
+20 : 10100 -> 11110 -> 10100 : 20
+21 : 10101 -> 11111 -> 10101 : 21
+22 : 10110 -> 11101 -> 10110 : 22
+23 : 10111 -> 11100 -> 10111 : 23
+24 : 11000 -> 10100 -> 11000 : 24
+25 : 11001 -> 10101 -> 11001 : 25
+26 : 11010 -> 10111 -> 11010 : 26
+27 : 11011 -> 10110 -> 11011 : 27
+28 : 11100 -> 10010 -> 11100 : 28
+29 : 11101 -> 10011 -> 11101 : 29
+30 : 11110 -> 10001 -> 11110 : 30
+31 : 11111 -> 10000 -> 11111 : 31

Task/Gray-code/Liberty-BASIC/gray-code.liberty

@@ -0,0 +1,55 @@
+    for r =0 to 31
+        print " Decimal "; using( "###", r); " is ";
+        B$ =dec2Bin$( r)
+        print " binary "; B$; ". Binary "; B$;
+        G$ =Bin2Gray$( dec2Bin$( r))
+        print " is "; G$; " in Gray code, or ";
+        B$ =Gray2Bin$( G$)
+        print B$; " in pure binary."
+    next r
+
+    end
+
+    function Bin2Gray$( bin$)   '   Given a binary number as a string, returns Gray code as a string.
+        g$ =left$( bin$, 1)
+        for i =2 to len( bin$)
+            bitA    =val( mid$( bin$, i -1, 1))
+            bitB    =val( mid$( bin$, i,    1))
+            AXorB   =bitA xor bitB
+            g$      =g$ +str$( AXorB)
+        next i
+        Bin2Gray$ =g$
+    end function
+
+    function Gray2Bin$( g$)     '   Given a Gray code as a string, returns equivalent binary num.
+                                '      as a string
+        gl =len(   g$)
+        b$ =left$( g$, 1)
+        for i =2 to len( g$)
+            bitA    =val( mid$( b$, i -1, 1))
+            bitB    =val( mid$( g$, i,    1))
+            AXorB   =bitA xor bitB
+            b$      =b$ +str$( AXorB)
+        next i
+        Gray2Bin$ =right$( b$, gl)
+    end function
+
+    function dec2Bin$( num) '   Given an integer decimal, returns binary equivalent as a string
+        n =num
+        dec2Bin$ =""
+        while ( num >0)
+            dec2Bin$    =str$( num mod 2) +dec2Bin$
+            num         =int( num /2)
+        wend
+        if ( n >255) then nBits =16 else nBits =8
+        dec2Bin$ =right$( "0000000000000000" +dec2Bin$, nBits)  '   Pad to 8 bit or 16 bit
+    end function
+
+    function bin2Dec( b$)   '   Given a binary number as a string, returns decimal equivalent num.
+        t =0
+        d =len( b$)
+        for k =d to 1 step -1
+            t   =t +val( mid$( b$, k, 1)) *2^( d -k)
+        next k
+        bin2Dec =t
+    end function

Task/Gray-code/Logo/gray-code-1.logo

@@ -0,0 +1,13 @@
+to gray_encode :number
+  output bitxor :number lshift :number -1
+end
+
+to gray_decode :code
+  local "value
+  make "value 0
+  while [:code > 0] [
+    make "value bitxor :code :value
+    make "code lshift :code -1
+  ]
+  output :value
+end

Task/Gray-code/Logo/gray-code-2.logo

@@ -0,0 +1,29 @@
+to format :str :width [pad (char 32)]
+  while [(count :str) < :width] [
+    make "str word :pad  :str
+  ]
+  output :str
+end
+
+; Output binary representation of a number
+to binary :number [:width 1]
+  local "bits
+  ifelse [:number = 0] [
+    make "bits 0
+  ] [
+    make "bits "
+    while [:number > 0] [
+      make "bits word (bitand :number 1) :bits
+      make "number lshift :number -1
+    ]
+  ]
+  output (format :bits :width 0)
+end
+
+repeat 32 [
+  make "num repcount - 1
+  make "gray gray_encode :num
+  make "decoded gray_decode :gray
+  print (sentence (format :num 2) ": (binary :num 5) ": (binary :gray 5) ":
+                  (binary :decoded 5) ": (format :decoded 2)) ]
+bye

Task/Gray-code/Lua/gray-code-1.lua

@@ -0,0 +1,18 @@
+local _M = {}
+
+local bit  = require('bit')
+local math = require('math')
+
+_M.encode = function(number)
+  return bit.bxor(number, bit.rshift(number, 1));
+end
+
+_M.decode = function(gray_code)
+  local value = 0
+  while gray_code > 0 do
+    gray_code, value = bit.rshift(gray_code, 1), bit.bxor(gray_code, value)
+  end
+  return value
+end
+
+return _M

Task/Gray-code/Lua/gray-code-2.lua

@@ -0,0 +1,24 @@
+local bit = require 'bit'
+local gray = require 'gray'
+
+-- simple binary string formatter
+local function to_bit_string(n, width)
+  width = width or 1
+  local output = ""
+  while n > 0 do
+    output = bit.band(n,1) .. output
+    n = bit.rshift(n,1)
+  end
+  while #output < width do
+    output = '0' .. output
+  end
+  return output
+end
+
+for i = 0,31 do
+  g = gray.encode(i);
+  gd = gray.decode(g);
+  print(string.format("%2d : %s => %s => %s : %2d", i,
+    to_bit_string(i,5), to_bit_string(g, 5),
+    to_bit_string(gd,5), gd))
+end

Task/Gray-code/Mathematica/gray-code.mathematica

@@ -0,0 +1,2 @@
+graycode[n_]:=BitXor[n,BitShiftRight[n]]
+graydecode[n_]:=Fold[BitXor,0,FixedPointList[BitShiftRight,n]]

Task/Gray-code/Perl/gray-code.pl

@@ -0,0 +1,20 @@
+sub bin2gray
+{
+    return $_[0] ^ ($_[0] >> 1);
+}
+
+sub gray2bin
+{
+    my ($num)= @_;
+    my $bin= $num;
+    while( $num >>= 1 ) {
+        # a bit ends up flipped iff an odd number of bits to its left is set.
+        $bin ^= $num;   # different from the suggested algorithm;
+    }                   # avoids using bit mask and explicit bittery
+    return $bin;
+}
+
+for (0..31) {
+    my $gr= bin2gray($_);
+    printf "%d\t%b\t%b\t%b\n", $_, $_, $gr, gray2bin($gr);
+}

Task/Gray-code/PicoLisp/gray-code-1.l

@@ -0,0 +1,10 @@
+(de grayEncode (N)
+   (bin (x| N (>> 1 N))) )
+
+(de grayDecode (G)
+   (bin
+      (pack
+         (let X 0
+            (mapcar
+               '((C) (setq X (x| X (format C))))
+               (chop G) ) ) ) ) )

Task/Gray-code/PicoLisp/gray-code-2.l

@@ -0,0 +1,4 @@
+(prinl "       Binary     Gray  Decoded")
+(for I (range 0 31)
+   (let G (grayEncode I)
+      (tab (4 9 9 9) I (bin I) G (grayDecode G)) ) )

Task/Gray-code/Python/gray-code-1.py

@@ -0,0 +1,17 @@
+>>> def int2bin(n):
+	'From positive integer to list of binary bits, msb at index 0'
+	if n:
+		bits = []
+		while n:
+			n,remainder = divmod(n, 2)
+			bits.insert(0, remainder)
+		return bits
+	else: return [0]
+
+	
+>>> def bin2int(bits):
+	'From binary bits, msb at index 0 to integer'
+	i = 0
+	for bit in bits:
+		i = i * 2 + bit
+	return i

Task/Gray-code/Python/gray-code-2.py

@@ -0,0 +1,7 @@
+>>> def bin2gray(bits):
+	return bits[:1] + [i ^ ishift for i, ishift in zip(bits[:-1], bits[1:])]
+
+>>> def gray2bin(bits):
+	b = [bits[0]]
+	for nextb in bits[1:]: b.append(b[-1] ^ nextb)
+	return b

Task/Gray-code/Python/gray-code-3.py

@@ -0,0 +1,27 @@
+>>> for i in range(16):
+	print('int:%2i -> bin:%12r -> gray:%12r -> bin:%12r -> int:%2i' %
+	      ( i,
+	        int2bin(i),
+	        bin2gray(int2bin(i)),
+	        gray2bin(bin2gray(int2bin(i))),
+	        bin2int(gray2bin(bin2gray(int2bin(i))))
+	      ))
+
+	
+int: 0 -> bin:         [0] -> gray:         [0] -> bin:         [0] -> int: 0
+int: 1 -> bin:         [1] -> gray:         [1] -> bin:         [1] -> int: 1
+int: 2 -> bin:      [1, 0] -> gray:      [1, 1] -> bin:      [1, 0] -> int: 2
+int: 3 -> bin:      [1, 1] -> gray:      [1, 0] -> bin:      [1, 1] -> int: 3
+int: 4 -> bin:   [1, 0, 0] -> gray:   [1, 1, 0] -> bin:   [1, 0, 0] -> int: 4
+int: 5 -> bin:   [1, 0, 1] -> gray:   [1, 1, 1] -> bin:   [1, 0, 1] -> int: 5
+int: 6 -> bin:   [1, 1, 0] -> gray:   [1, 0, 1] -> bin:   [1, 1, 0] -> int: 6
+int: 7 -> bin:   [1, 1, 1] -> gray:   [1, 0, 0] -> bin:   [1, 1, 1] -> int: 7
+int: 8 -> bin:[1, 0, 0, 0] -> gray:[1, 1, 0, 0] -> bin:[1, 0, 0, 0] -> int: 8
+int: 9 -> bin:[1, 0, 0, 1] -> gray:[1, 1, 0, 1] -> bin:[1, 0, 0, 1] -> int: 9
+int:10 -> bin:[1, 0, 1, 0] -> gray:[1, 1, 1, 1] -> bin:[1, 0, 1, 0] -> int:10
+int:11 -> bin:[1, 0, 1, 1] -> gray:[1, 1, 1, 0] -> bin:[1, 0, 1, 1] -> int:11
+int:12 -> bin:[1, 1, 0, 0] -> gray:[1, 0, 1, 0] -> bin:[1, 1, 0, 0] -> int:12
+int:13 -> bin:[1, 1, 0, 1] -> gray:[1, 0, 1, 1] -> bin:[1, 1, 0, 1] -> int:13
+int:14 -> bin:[1, 1, 1, 0] -> gray:[1, 0, 0, 1] -> bin:[1, 1, 1, 0] -> int:14
+int:15 -> bin:[1, 1, 1, 1] -> gray:[1, 0, 0, 0] -> bin:[1, 1, 1, 1] -> int:15
+>>>

Task/Gray-code/REXX/gray-code.rexx

@@ -0,0 +1,25 @@
+/*REXX program to convert decimal───> binary ───> gray code ───> binary.*/
+parse arg N .;    if N=='' then N=31   /*Not specified? Then use default*/
+L=max(1,length(strip(x2b(d2x(N)),'L',0)))   /*for cell width formatting.*/
+w=14                                   /*used for cell width formatting.*/
+_=center('binary',w,'─')               /*2nd and 4th part of the header.*/
+say center('decimal',w,'─')">" _">" center('gray code',w,'─')">" _ /*hdr*/
+
+     do j=0  to N;     b=right(x2b(d2x(j)),L,0)      /*handle 0  ──►  N.*/
+     g=b2gray(b)                       /*convert binary to gray code.   */
+     a=gray2b(g)                       /*convert gray code to binary.   */
+     say center(j,w+1) center(b,w+1) center(g,w+1) center(a,w+1)  /*tell*/
+     end   /*j*/
+exit                                   /*stick a fork in it, we're done.*/
+/*───────────────────────────────────B2GRAY subroutine──────────────────*/
+b2gray: procedure; parse arg x
+$=left(x,1);                    do b=2  to length(x)
+                                $=$||(substr(x,b-1,1) && substr(x,b,1))
+                                end   /*b*/        /* && is eXclusive OR*/
+return $
+/*───────────────────────────────────GRAY2B subroutine──────────────────*/
+gray2b: procedure; parse arg x
+$=left(x,1);                    do g=2  to length(x)
+                                $=$ || (right($,1)    && substr(x,g,1))
+                                end   /*g*/        /* && is eXclusive OR*/
+return $

Task/Gray-code/Racket/gray-code.rkt

@@ -0,0 +1,18 @@
+#lang racket
+
+(define (gray-encode n) (bitwise-xor n (arithmetic-shift n -1)))
+
+(define (gray-decode n)
+  (letrec ([loop (lambda(g bits)
+                   (if (> bits 0)
+                       (loop (bitwise-xor g bits) (arithmetic-shift bits -1))
+                       g))])
+	 (loop 0 n)))
+
+(define (to-bin n) (format "~b" n))
+(define (show-table)
+  (for ([i (in-range 1 32)])
+    (printf "~a | ~a | ~a ~n"
+            (~r i #:min-width 2 #:pad-string "0")
+            (~a (to-bin(gray-encode i)) #:width 5 #:align 'right #:pad-string "0")
+            (~a (to-bin (gray-decode(gray-encode i))) #:width 5 #:align 'right #:pad-string "0"))))

Task/Gray-code/Ruby/gray-code.rb

@@ -0,0 +1,26 @@
+class Integer
+  # Converts a normal integer to a Gray code.
+  def to_gray
+    raise Math::DomainError, "integer is negative" if self < 0
+    self ^ (self >> 1)
+  end
+
+  # Converts a Gray code to a normal integer.
+  def from_gray
+    raise Math::DomainError, "integer is negative" if self < 0
+    recurse = proc do |i|
+      next 0 if i == 0
+      o = recurse[i >> 1] << 1
+      o | (i[0] ^ o[1])
+    end
+    recurse[self]
+  end
+end
+
+
+(0..31).each do |number|
+  encoded = number.to_gray
+  decoded = encoded.from_gray
+  printf("%2d: %5b => %5b => %5b: %2d\n",
+         number, number, encoded, decoded, decoded)
+end

Task/Gray-code/Scala/gray-code-1.scala

@@ -0,0 +1,6 @@
+def encode(n: Int)    = (n ^ (n >>> 1)).toBinaryString
+def decode(s: String) = Integer.parseInt( s.scanLeft(0)(_ ^ _.asDigit).tail.mkString , 2)
+
+println("decimal  binary   gray  decoded")
+for (i <- 0 to 31; g = encode(i))
+  println("%7d  %6s  %5s  %7s".format(i, i.toBinaryString, g, decode(g)))

Task/Gray-code/Scala/gray-code-2.scala

@@ -0,0 +1,19 @@
+def encode(n: Long) = n ^ (n >>> 1)
+
+def decode(n: Long) = {
+  var g = 0L
+  var bits = n
+  while (bits > 0) {
+    g ^= bits
+    bits >>= 1
+  }
+  g
+}
+
+def toBin(n: Long) = ("0000" + n.toBinaryString) takeRight 5
+
+println("decimal  binary   gray  decoded")
+for (i <- 0 until 32) {
+  val g = encode(i)
+  println("%7d  %6s  %5s  %7s".format(i, toBin(i), toBin(g), decode(g)))
+}

Task/Gray-code/Scala/gray-code-3.scala

@@ -0,0 +1,4 @@
+def decode(n:Long)={
+  def calc(g:Long,bits:Long):Long=if (bits>0) calc(g^bits, bits>>1) else g
+  calc(0, n)
+}

Task/Gray-code/Tcl/gray-code-1.tcl

@@ -0,0 +1,14 @@
+namespace eval gray {
+    proc encode n {
+	expr {$n ^ $n >> 1}
+    }
+    proc decode n {
+	# Compute some bit at least as large as MSB
+	set i [expr {2**int(ceil(log($n+1)/log(2)))}]
+	set b [set bprev [expr {$n & $i}]]
+	while {[set i [expr {$i >> 1}]]} {
+	    set b [expr {$b | [set bprev [expr {$n & $i ^ $bprev >> 1}]]}]
+	}
+	return $b
+    }
+}

Task/Gray-code/Tcl/gray-code-2.tcl

@@ -0,0 +1,6 @@
+package require Tcl 8.6; # Just for %b format specifier
+for {set i 0} {$i < 32} {incr i} {
+    set g [gray::encode $i]
+    set b [gray::decode $g]
+    puts [format "%2d: %05b => %05b => %05b : %2d" $i $i $g $b $b]
+}