Gray code: Difference between revisions
Added Modula-2.
m (→{{header|Picat}}: Added {{out}}) |
(Added Modula-2.) |
||
| (23 intermediate revisions by 14 users not shown) | |||
Line 31:
{{trans|Python: on integers}}
<
R n (+) n >> 1
Line 45:
V gray = gray_encode(i)
V dec = gray_decode(gray)
print(‘ #2, #. => #. => #2’.format(i, bin(i).zfill(5), bin(gray).zfill(5), dec))</
{{out}}
Line 87:
<
xra a ; set A=0
loop: push psw ; print number as decimal
Line 170:
jmp 5
arrow: db ' ==> $'
nl: db 13,10,'$'</
{{out}}
Line 207:
30 ==> 11110 ==> 10001 ==> 11110 ==> 30
31 ==> 11111 ==> 10000 ==> 11111 ==> 31
</pre>
=={{header|8051 Assembly}}==
<syntaxhighlight lang="8051asm">
.equ cin, 0x0032
.equ cout, 0x0030
.equ phex, 0x0034
.equ phex16, 0x0036
.equ nl, 0x0048
.org 0x2000
main:
mov r7, #0
next:
mov a, r7
lcall phex
mov a, #' '
lcall cout
mov a, r7
acall genc
lcall phex
mov r6, a
mov a, #' '
lcall cout
mov a, r6
acall gdec
lcall phex
lcall nl
inc r7
cjne r7, #0, next
lcall cin
ljmp 0x0000
;--------
genc:
mov r0, a
clr c
rrc a
xrl a, r0
ret
;--------
;--------
gdec:
mov r0, a
gdec_shift_xor:
clr c
rrc a
jz gdec_out
xch a, r0
xrl a, r0
xch a, r0
sjmp gdec_shift_xor
gdec_out:
xch a, r0
ret
;--------
</syntaxhighlight>
{{out}}
<pre>
00 00 00
01 01 01
02 03 02
03 02 03
04 06 04
05 07 05
06 05 06
07 04 07
08 0C 08
09 0D 09
0A 0F 0A
0B 0E 0B
0C 0A 0C
0D 0B 0D
0E 09 0E
0F 08 0F
10 18 10
11 19 11
12 1B 12
13 1A 13
14 1E 14
15 1F 15
16 1D 16
17 1C 17
18 14 18
19 15 19
1A 17 1A
1B 16 1B
1C 12 1C
1D 13 1D
1E 11 1E
1F 10 1F
20 30 20
21 31 21
22 33 22
23 32 23
24 36 24
25 37 25
26 35 26
27 34 27
28 3C 28
29 3D 29
2A 3F 2A
2B 3E 2B
2C 3A 2C
2D 3B 2D
2E 39 2E
2F 38 2F
30 28 30
31 29 31
32 2B 32
33 2A 33
34 2E 34
35 2F 35
36 2D 36
37 2C 37
38 24 38
39 25 39
3A 27 3A
3B 26 3B
3C 22 3C
3D 23 3D
3E 21 3E
3F 20 3F
40 60 40
41 61 41
42 63 42
43 62 43
44 66 44
45 67 45
46 65 46
47 64 47
48 6C 48
49 6D 49
4A 6F 4A
4B 6E 4B
4C 6A 4C
4D 6B 4D
4E 69 4E
4F 68 4F
50 78 50
51 79 51
52 7B 52
53 7A 53
54 7E 54
55 7F 55
56 7D 56
57 7C 57
58 74 58
59 75 59
5A 77 5A
5B 76 5B
5C 72 5C
5D 73 5D
5E 71 5E
5F 70 5F
60 50 60
61 51 61
62 53 62
63 52 63
64 56 64
65 57 65
66 55 66
67 54 67
68 5C 68
69 5D 69
6A 5F 6A
6B 5E 6B
6C 5A 6C
6D 5B 6D
6E 59 6E
6F 58 6F
70 48 70
71 49 71
72 4B 72
73 4A 73
74 4E 74
75 4F 75
76 4D 76
77 4C 77
78 44 78
79 45 79
7A 47 7A
7B 46 7B
7C 42 7C
7D 43 7D
7E 41 7E
7F 40 7F
80 C0 80
81 C1 81
82 C3 82
83 C2 83
84 C6 84
85 C7 85
86 C5 86
87 C4 87
88 CC 88
89 CD 89
8A CF 8A
8B CE 8B
8C CA 8C
8D CB 8D
8E C9 8E
8F C8 8F
90 D8 90
91 D9 91
92 DB 92
93 DA 93
94 DE 94
95 DF 95
96 DD 96
97 DC 97
98 D4 98
99 D5 99
9A D7 9A
9B D6 9B
9C D2 9C
9D D3 9D
9E D1 9E
9F D0 9F
A0 F0 A0
A1 F1 A1
A2 F3 A2
A3 F2 A3
A4 F6 A4
A5 F7 A5
A6 F5 A6
A7 F4 A7
A8 FC A8
A9 FD A9
AA FF AA
AB FE AB
AC FA AC
AD FB AD
AE F9 AE
AF F8 AF
B0 E8 B0
B1 E9 B1
B2 EB B2
B3 EA B3
B4 EE B4
B5 EF B5
B6 ED B6
B7 EC B7
B8 E4 B8
B9 E5 B9
BA E7 BA
BB E6 BB
BC E2 BC
BD E3 BD
BE E1 BE
BF E0 BF
C0 A0 C0
C1 A1 C1
C2 A3 C2
C3 A2 C3
C4 A6 C4
C5 A7 C5
C6 A5 C6
C7 A4 C7
C8 AC C8
C9 AD C9
CA AF CA
CB AE CB
CC AA CC
CD AB CD
CE A9 CE
CF A8 CF
D0 B8 D0
D1 B9 D1
D2 BB D2
D3 BA D3
D4 BE D4
D5 BF D5
D6 BD D6
D7 BC D7
D8 B4 D8
D9 B5 D9
DA B7 DA
DB B6 DB
DC B2 DC
DD B3 DD
DE B1 DE
DF B0 DF
E0 90 E0
E1 91 E1
E2 93 E2
E3 92 E3
E4 96 E4
E5 97 E5
E6 95 E6
E7 94 E7
E8 9C E8
E9 9D E9
EA 9F EA
EB 9E EB
EC 9A EC
ED 9B ED
EE 99 EE
EF 98 EF
F0 88 F0
F1 89 F1
F2 8B F2
F3 8A F3
F4 8E F4
F5 8F F5
F6 8D F6
F7 8C F7
F8 84 F8
F9 85 F9
FA 87 FA
FB 86 FB
FC 82 FC
FD 83 FD
FE 81 FE
FF 80 FF
</pre>
=={{header|Action!}}==
<
BYTE i
Line 267 ⟶ 596:
PrintB2(b) PutE()
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Gray_code.png Screenshot from Atari 8-bit computer]
Line 309 ⟶ 638:
Values are implemented with 8 bits according to representation clause
of Unsigned_8 (check package Interfaces).
<
use Ada.Text_IO, Interfaces;
Line 355 ⟶ 684:
New_Line;
end loop;
end Gray;</
Check compactness of assembly code generated by GNAT :http://pastebin.com/qtNjeQk9<br>
{{out}}
Line 394 ⟶ 723:
=={{header|Aime}}==
{{trans|C}}
<
gray_encode(integer n)
{
Line 411 ⟶ 740:
p;
}</
Demonstration code:
<
main(void)
{
Line 436 ⟶ 765:
return 0;
}</
{{out}}
<pre> 0: 00000 => 00000 => 00000: 0
Line 473 ⟶ 802:
=={{header|ALGOL 68}}==
In Algol 68 the BITS mode is specifically designed for manipulating machine words as a row of bits so it is natural to treat Gray encoded integers as values of MODE BITS. The standard operator BIN (INT) : BITS converts an INT value to a BITS value. The ABS (BITS) : INT operator performs the reverse conversion, though it has not been needed for this task. It is also natural in the language for simple operations on values to be implemented as operators, rather than as functions, as in the program below.
<
OP GRAY = (BITS b) BITS : b XOR (b SHR 1); CO Convert to Gray code CO
OP YARG = (BITS g) BITS : CO Convert from Gray code CO
Line 484 ⟶ 813:
printf (($zd, ": ", 2(2r5d, " >= "), 2r5dl$, i, BIN i, GRAY BIN i, YARG GRAY BIN i))
OD
END</
{{out}}
<pre> 0: 00000 >= 00000 >= 00000
Line 523 ⟶ 852:
{{trans|C}}
Version: Hopper-BASIC.
<syntaxhighlight lang="amazing hopper">
#proto GrayEncode(_X_)
#synon _GrayEncode *getGrayEncode
Line 555 ⟶ 884:
Wend
Return (p)
</syntaxhighlight>
{{out}}
<pre>
Line 596 ⟶ 925:
Generate the complete N-bit Gray sequence as a matrix:<sup>[http://ngn.github.io/apl/web/index.html#code=N%u21905%0A%28%7B%280%2C%u2375%29%u236A1%2C%u2296%u2375%7D%u2363N%29%281%200%u2374%u236C%29,run=1 run]</sup>
<
({(0,⍵)⍪1,⊖⍵}⍣N)(1 0⍴⍬)</
{{out}}
<pre style="overflow: auto; height: 20em;">0 0 0 0 0
Line 633 ⟶ 962:
Encode and decode an individual integer:<sup>[http://ngn.github.io/apl/web/index.html#code=N%u21905%0AgrayEncode%u2190%7Ba%u2260N%u2191%280%2Ca%u2190%28N%u23742%29%u22A4%u2375%29%7D%0AgrayDecode%u2190%7B2%u22A5%u2260%u233FN%20N%u2191N%282%D7N%29%u2374%u2375%2C0%2CN%u23740%7D%0A%0AgrayEncode%2019,run=1 run]</sup>
<
grayEncode←{a≠N↑(0,a←(N⍴2)⊤⍵)}
grayDecode←{2⊥≠⌿N N↑N(2×N)⍴⍵,0,N⍴0}
grayEncode 19</
{{out}}
<pre>1 1 0 1 0</pre>
Line 643 ⟶ 972:
=={{header|Arturo}}==
<
fromGray: function [n][
p: n
Line 664 ⟶ 993:
pad to :string decoded 2
]
]</
{{out}}
Line 702 ⟶ 1,031:
=={{header|AutoHotkey}}==
<
return n ^ (n >> 1)
}
Line 724 ⟶ 1,053:
n:=A_Index-1, out .= n " : " BinString(n) " => " BinString(e:=gray_encode(n))
. " => " BinString(gray_decode(e)) " => " BinString(n) "`n"
MsgBox % clipboard := out</
{{out}}
<pre style="overflow: auto; height: 20em;">0 : 00000 => 00000 => 00000 => 00000
Line 760 ⟶ 1,089:
=={{header|AWK}}==
<
function bits2str(bits, data, mask)
Line 796 ⟶ 1,125:
for (i=0; i < 32; i++)
printf "%-3s => %05d => %05d => %05d\n",i, bits2str(i),bits2str(gray_encode(i)), bits2str(gray_decode(gray_encode(i)))
}</
{{out}}
<pre>0 => 00000 => 00000 => 00000
Line 830 ⟶ 1,159:
30 => 11110 => 10001 => 11110
31 => 11111 => 10000 => 11111</pre>
=={{header|BASIC}}==
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> 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%</syntaxhighlight>
==={{header|FreeBASIC}}===
<syntaxhighlight lang="freebasic">' version 18-01-2017
' compile with: fbc -s console
Function gray2bin(g As UInteger) As UInteger
Dim As UInteger b = g
While g
g Shr= 1
b Xor= g
Wend
Return b
End Function
Function bin2gray(b As UInteger) As UInteger
Return b Xor (b Shr 1)
End Function
' ------=< MAIN >=------
Dim As UInteger i
Print " i binary gray gra2bin"
Print String(32,"=")
For i = 0 To 31
Print Using "## --> "; i;
print Bin(i,5); " --> ";
Print Bin(bin2gray(i),5); " --> ";
Print Bin(gray2bin(bin2gray(i)),5)
Next
' empty keyboard buffer
While Inkey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End</syntaxhighlight>
{{out}}
<pre> i binary gray gra2bin
================================
0 --> 00000 --> 00000 --> 00000
1 --> 00001 --> 00001 --> 00001
2 --> 00010 --> 00011 --> 00010
3 --> 00011 --> 00010 --> 00011
4 --> 00100 --> 00110 --> 00100
5 --> 00101 --> 00111 --> 00101
6 --> 00110 --> 00101 --> 00110
7 --> 00111 --> 00100 --> 00111
8 --> 01000 --> 01100 --> 01000
9 --> 01001 --> 01101 --> 01001
10 --> 01010 --> 01111 --> 01010
11 --> 01011 --> 01110 --> 01011
12 --> 01100 --> 01010 --> 01100
13 --> 01101 --> 01011 --> 01101
14 --> 01110 --> 01001 --> 01110
15 --> 01111 --> 01000 --> 01111
16 --> 10000 --> 11000 --> 10000
17 --> 10001 --> 11001 --> 10001
18 --> 10010 --> 11011 --> 10010
19 --> 10011 --> 11010 --> 10011
20 --> 10100 --> 11110 --> 10100
21 --> 10101 --> 11111 --> 10101
22 --> 10110 --> 11101 --> 10110
23 --> 10111 --> 11100 --> 10111
24 --> 11000 --> 10100 --> 11000
25 --> 11001 --> 10101 --> 11001
26 --> 11010 --> 10111 --> 11010
27 --> 11011 --> 10110 --> 11011
28 --> 11100 --> 10010 --> 11100
29 --> 11101 --> 10011 --> 11101
30 --> 11110 --> 10001 --> 11110
31 --> 11111 --> 10000 --> 11111</pre>
==={{header|GW-BASIC}}===
{{works with|BASICA}}
<syntaxhighlight lang="basic">10 DEFINT A-Z
20 FOR I=0 TO 31
30 N=I:GOSUB 200:E=R:REM Encode
40 N=E:GOSUB 300:D=R:REM Decode
50 N=I:GOSUB 400:I$=R$:REM Binary format of input
60 N=E:GOSUB 400:E$=R$:REM Binary format of encoded value
70 N=D:GOSUB 400:D$=R$:REM Binary format of decoded value
80 PRINT USING "##: \ \ => \ \ => \ \ => ##";I;I$;E$;D$;D
90 NEXT
100 END
200 REM Gray encode
210 R = N XOR N\2
220 RETURN
300 REM Gray decode
310 R = N
320 N = N\2
330 IF N=0 THEN RETURN
340 R = R XOR N
350 GOTO 320
400 REM Binary format
410 R$ = ""
420 R$ = CHR$(48+(N AND 1))+R$
430 N = N\2
440 IF N=0 THEN RETURN ELSE 420</syntaxhighlight>
{{out}}
<pre> 0: 0 => 0 => 0 => 0
1: 1 => 1 => 1 => 1
2: 10 => 11 => 10 => 2
3: 11 => 10 => 11 => 3
4: 100 => 110 => 100 => 4
5: 101 => 111 => 101 => 5
6: 110 => 101 => 110 => 6
7: 111 => 100 => 111 => 7
8: 1000 => 1100 => 1000 => 8
9: 1001 => 1101 => 1001 => 9
10: 1010 => 1111 => 1010 => 10
11: 1011 => 1110 => 1011 => 11
12: 1100 => 1010 => 1100 => 12
13: 1101 => 1011 => 1101 => 13
14: 1110 => 1001 => 1110 => 14
15: 1111 => 1000 => 1111 => 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</pre>
==={{header|Liberty BASIC}}===
{{works with|Just BASIC}}
<syntaxhighlight lang="lb">
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
</syntaxhighlight>
{{out}}
<pre>
Decimal 0 is binary 00000000. Binary 00000000 is 00000000 in Gray code, or 00000000 in pure binary.
Decimal 1 is binary 00000001. Binary 00000001 is 00000001 in Gray code, or 00000001 in pure binary.
Decimal 2 is binary 00000010. Binary 00000010 is 00000011 in Gray code, or 00000010 in pure binary.
Decimal 3 is binary 00000011. Binary 00000011 is 00000010 in Gray code, or 00000011 in pure binary.
Decimal 4 is binary 00000100. Binary 00000100 is 00000110 in Gray code, or 00000100 in pure binary.
Decimal 5 is binary 00000101. Binary 00000101 is 00000111 in Gray code, or 00000101 in pure binary.
Decimal 6 is binary 00000110. Binary 00000110 is 00000101 in Gray code, or 00000110 in pure binary.
Decimal 7 is binary 00000111. Binary 00000111 is 00000100 in Gray code, or 00000111 in pure binary.
Decimal 8 is binary 00001000. Binary 00001000 is 00001100 in Gray code, or 00001000 in pure binary.
Decimal 9 is binary 00001001. Binary 00001001 is 00001101 in Gray code, or 00001001 in pure binary.
Decimal 10 is binary 00001010. Binary 00001010 is 00001111 in Gray code, or 00001010 in pure binary.
Decimal 11 is binary 00001011. Binary 00001011 is 00001110 in Gray code, or 00001011 in pure binary.
Decimal 12 is binary 00001100. Binary 00001100 is 00001010 in Gray code, or 00001100 in pure binary.
Decimal 13 is binary 00001101. Binary 00001101 is 00001011 in Gray code, or 00001101 in pure binary.
Decimal 14 is binary 00001110. Binary 00001110 is 00001001 in Gray code, or 00001110 in pure binary.
Decimal 15 is binary 00001111. Binary 00001111 is 00001000 in Gray code, or 00001111 in pure binary.
Decimal 16 is binary 00010000. Binary 00010000 is 00011000 in Gray code, or 00010000 in pure binary.
Decimal 17 is binary 00010001. Binary 00010001 is 00011001 in Gray code, or 00010001 in pure binary.
Decimal 18 is binary 00010010. Binary 00010010 is 00011011 in Gray code, or 00010010 in pure binary.
Decimal 19 is binary 00010011. Binary 00010011 is 00011010 in Gray code, or 00010011 in pure binary.
Decimal 20 is binary 00010100. Binary 00010100 is 00011110 in Gray code, or 00010100 in pure binary.
Decimal 21 is binary 00010101. Binary 00010101 is 00011111 in Gray code, or 00010101 in pure binary.
Decimal 22 is binary 00010110. Binary 00010110 is 00011101 in Gray code, or 00010110 in pure binary.
Decimal 23 is binary 00010111. Binary 00010111 is 00011100 in Gray code, or 00010111 in pure binary.
Decimal 24 is binary 00011000. Binary 00011000 is 00010100 in Gray code, or 00011000 in pure binary.
Decimal 25 is binary 00011001. Binary 00011001 is 00010101 in Gray code, or 00011001 in pure binary.
Decimal 26 is binary 00011010. Binary 00011010 is 00010111 in Gray code, or 00011010 in pure binary.
Decimal 27 is binary 00011011. Binary 00011011 is 00010110 in Gray code, or 00011011 in pure binary.
Decimal 28 is binary 00011100. Binary 00011100 is 00010010 in Gray code, or 00011100 in pure binary.
Decimal 29 is binary 00011101. Binary 00011101 is 00010011 in Gray code, or 00011101 in pure binary.
Decimal 30 is binary 00011110. Binary 00011110 is 00010001 in Gray code, or 00011110 in pure binary.
Decimal 31 is binary 00011111. Binary 00011111 is 00010000 in Gray code, or 00011111 in pure binary.
</pre>
==={{header|PowerBASIC}}===
<syntaxhighlight lang="powerbasic">function gray%(byval n%)
gray%=n% xor (n%\2)
end function
function igray%(byval n%)
r%=0
while n%>0
r%=r% xor n%
shift right n%,1
wend
igray%=r%
end function
print " N GRAY INV"
for n%=0 to 31
g%=gray%(n%)
print bin$(n%);" ";bin$(g%);" ";bin$(igray%(g%))
next</syntaxhighlight>
==={{header|PureBasic}}===
<syntaxhighlight lang="purebasic">Procedure.i gray_encode(n)
ProcedureReturn n ! (n >> 1)
EndProcedure
Procedure.i gray_decode(g)
Protected bit = 1 << (8 * SizeOf(Integer) - 2)
Protected b = g & bit, p = b >> 1
While bit > 1
bit >> 1
b | (p ! (g & bit))
p = (b & bit) >> 1
Wend
ProcedureReturn b
EndProcedure
If OpenConsole()
PrintN("Number Gray Binary Decoded")
Define i, n
For i = 0 To 31
g = gray_encode(i)
Print(RSet(Str(i), 2, "0") + Space(5))
Print(RSet(Bin(g, #PB_Byte), 5, "0") + Space(2))
n = gray_decode(g)
Print(RSet(Bin(n, #PB_Byte), 5, "0") + Space(3))
PrintN(RSet(Str(n), 2, "0"))
Next
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</syntaxhighlight>
{{out}}
<pre>Number Gray Binary Decoded
00 00000 00000 00
01 00001 00001 01
02 00011 00010 02
03 00010 00011 03
04 00110 00100 04
05 00111 00101 05
06 00101 00110 06
07 00100 00111 07
08 01100 01000 08
09 01101 01001 09
10 01111 01010 10
11 01110 01011 11
12 01010 01100 12
13 01011 01101 13
14 01001 01110 14
15 01000 01111 15
16 11000 10000 16
17 11001 10001 17
18 11011 10010 18
19 11010 10011 19
20 11110 10100 20
21 11111 10101 21
22 11101 10110 22
23 11100 10111 23
24 10100 11000 24
25 10101 11001 25
26 10111 11010 26
27 10110 11011 27
28 10010 11100 28
29 10011 11101 29
30 10001 11110 30
31 10000 11111 31</pre>
==={{header|VBScript}}===
<syntaxhighlight lang="vb">Function Encoder(ByVal n)
Encoder = n Xor (n \ 2)
End Function
Function Decoder(ByVal n)
Dim g : g = 0
Do While n > 0
g = g Xor n
n = n \ 2
Loop
Decoder = g
End Function
' Decimal to Binary
Function Dec2bin(ByVal n, ByVal length)
Dim i, strbin : strbin = ""
For i = 1 to 5
strbin = (n Mod 2) & strbin
n = n \ 2
Next
Dec2Bin = strbin
End Function
WScript.StdOut.WriteLine("Binary -> Gray Code -> Binary")
For i = 0 to 31
encoded = Encoder(i)
decoded = Decoder(encoded)
WScript.StdOut.WriteLine(Dec2Bin(i, 5) & " -> " & Dec2Bin(encoded, 5) & " -> " & Dec2Bin(decoded, 5))
Next</syntaxhighlight>
{{Out}}
<pre style="overflow: auto; height: 20em;">Binary -> Gray Code -> Binary
00000 -> 00000 -> 00000
00001 -> 00001 -> 00001
00010 -> 00011 -> 00010
00011 -> 00010 -> 00011
00100 -> 00110 -> 00100
00101 -> 00111 -> 00101
00110 -> 00101 -> 00110
00111 -> 00100 -> 00111
01000 -> 01100 -> 01000
01001 -> 01101 -> 01001
01010 -> 01111 -> 01010
01011 -> 01110 -> 01011
01100 -> 01010 -> 01100
01101 -> 01011 -> 01101
01110 -> 01001 -> 01110
01111 -> 01000 -> 01111
10000 -> 11000 -> 10000
10001 -> 11001 -> 10001
10010 -> 11011 -> 10010
10011 -> 11010 -> 10011
10100 -> 11110 -> 10100
10101 -> 11111 -> 10101
10110 -> 11101 -> 10110
10111 -> 11100 -> 10111
11000 -> 10100 -> 11000
11001 -> 10101 -> 11001
11010 -> 10111 -> 11010
11011 -> 10110 -> 11011
11100 -> 10010 -> 11100
11101 -> 10011 -> 11101
11110 -> 10001 -> 11110
11111 -> 10000 -> 11111</pre>
==={{header|XBasic}}===
{{trans|DWScript}}
Intrinsic function <code>BIN$</code> has been used.
{{works with|Windows XBasic}}
<syntaxhighlight lang="xbasic">' Gray code
PROGRAM "graycode"
VERSION "0.0001"
DECLARE FUNCTION Entry()
INTERNAL FUNCTION Encode(v&)
INTERNAL FUNCTION Decode(v&)
FUNCTION Entry()
PRINT "decimal binary gray decoded"
FOR i& = 0 TO 31
g& = Encode(i&)
d& = Decode(g&)
PRINT FORMAT$(" ##", i&); " "; BIN$(i&, 5); " "; BIN$(g&, 5);
PRINT " "; BIN$(d&, 5); FORMAT$(" ##", d&)
NEXT i&
END FUNCTION
FUNCTION Encode(v&)
END FUNCTION v& ^ (v& >> 1)
FUNCTION Decode(v&)
result& = 0
DO WHILE v& > 0
result& = result& ^ v&
v& = v& >> 1
LOOP
END FUNCTION result&
END PROGRAM
</syntaxhighlight>
{{out}}
<pre>
decimal binary gray decoded
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
</pre>
=={{header|Batch File}}==
<
:: Batch File Implementation
Line 893 ⟶ 1,689:
echo(%%n -^> !bin! -^> !gray! -^> !rebin!
)
exit /b 0</
{{Out}}
<pre style="overflow: auto; height: 20em;"># -> bin -> enc -> dec
Line 928 ⟶ 1,724:
30 -> 11110 -> 10001 -> 11110
31 -> 11111 -> 10000 -> 11111</pre>
=={{header|bc}}==
This language has no bitwise logic. We must repeat, with each bit, the exclusive-or calculation. This solution uses <tt>h % 2</tt> and <tt>i % 2</tt> to grab the low bits, and repeats <tt>if (h % 2 != i % 2)</tt> to check if the exclusive-or is one. Our encoding and decoding functions are identical except that <tt>h</tt> always comes from the decoded integer.
<
/* encode Gray code */
Line 995 ⟶ 1,773:
"
}
quit</
{{out}}
Line 1,030 ⟶ 1,808:
11110 => 10001 => 11110
11111 => 10000 => 11111</pre>
=={{header|BCPL}}==
<syntaxhighlight lang="bcpl">get "libhdr"
let grayEncode(n) = n neqv (n >> 1)
let grayDecode(n) = grayDecodeStep(0, n)
and grayDecodeStep(r, n) =
n = 0 -> r,
grayDecodeStep(r neqv n, n >> 1)
let binfmt(n) =
n = 0 -> 0,
(n & 1) + 10 * binfmt(n >> 1)
let printRow(n) be
$( let enc = grayEncode(n)
let dec = grayDecode(enc)
writef("%I2: %I5 => %I5 => %I5 => %I2*N",
n, binfmt(n), binfmt(enc), binfmt(dec), dec)
$)
let start() be
for i = 0 to 31 do printRow(i)</syntaxhighlight>
{{out}}
<pre> 0: 0 => 0 => 0 => 0
1: 1 => 1 => 1 => 1
2: 10 => 11 => 10 => 2
3: 11 => 10 => 11 => 3
4: 100 => 110 => 100 => 4
5: 101 => 111 => 101 => 5
6: 110 => 101 => 110 => 6
7: 111 => 100 => 111 => 7
8: 1000 => 1100 => 1000 => 8
9: 1001 => 1101 => 1001 => 9
10: 1010 => 1111 => 1010 => 10
11: 1011 => 1110 => 1011 => 11
12: 1100 => 1010 => 1100 => 12
13: 1101 => 1011 => 1101 => 13
14: 1110 => 1001 => 1110 => 14
15: 1111 => 1000 => 1111 => 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</pre>
=={{header|C}}==
{{trans|Tcl}}
<
return n ^ (n >> 1);
}
Line 1,041 ⟶ 1,876:
while (n >>= 1) p ^= n;
return p;
}</
Demonstration code:
<
/* Simple bool formatter, only good on range 0..31 */
Line 1,066 ⟶ 1,901:
}
return 0;
}</
{{out}}
<pre>
Line 1,104 ⟶ 1,939:
=={{header|C sharp}}==
<
public class Gray {
Line 1,126 ⟶ 1,961:
}
}
}</
{{out}}
<pre>
Line 1,165 ⟶ 2,000:
=={{header|C++}}==
<
#include <bitset>
#include <iostream>
Line 1,203 ⟶ 2,038:
std::cout << n << "\t" << to_binary(n) << "\t" << to_binary(g) << "\t" << g << "\n";
}
}</
{{out}}
<pre>
Line 1,242 ⟶ 2,077:
=={{header|CoffeeScript}}==
<
gray_encode = (n) ->
n ^ (n >> 1)
Line 1,253 ⟶ 2,088:
for i in [0..32]
console.log gray_decode gray_encode(i)
</syntaxhighlight>
=={{header|Common Lisp}}==
<
(logxor n (ash n -1)))
Line 1,266 ⟶ 2,101:
(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)))</
{{out}}
Line 1,306 ⟶ 2,141:
=={{header|Component Pascal}}==
BlackBox Component Builder
<
MODULE GrayCodes;
IMPORT StdLog,SYSTEM;
Line 1,358 ⟶ 2,193:
END GrayCodes.
</syntaxhighlight>
Execute: ^QGrayCodes.Do<br/>
{{out}}
Line 1,398 ⟶ 2,233:
32 100000%2 110000%2
</pre>
=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";
sub gray_encode(n: uint8): (r: uint8) is
r := n ^ n >> 1;
end sub;
sub gray_decode(n: uint8): (r: uint8) is
r := n;
while n > 0 loop
n := n >> 1;
r := r ^ n;
end loop;
end sub;
sub print_binary(n: uint8) is
var buf: uint8[9];
var ptr := &buf[8];
[ptr] := 0;
loop
ptr := @prev ptr;
[ptr] := (n & 1) + '0';
n := n >> 1;
if n == 0 then break; end if;
end loop;
print(ptr);
end sub;
sub print_row(n: uint8) is
print_i8(n);
print(":\t");
print_binary(n);
print("\t=>\t");
var gray_code := gray_encode(n);
print_binary(gray_code);
print("\t=>\t");
var decoded := gray_decode(gray_code);
print_i8(decoded);
print_nl();
end sub;
var i: uint8 := 0;
while i <= 31 loop
print_row(i);
i := i + 1;
end loop;</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|Crystal}}==
{{trans|C}}
<
def gray_encode(bin)
bin ^ (bin >> 1)
Line 1,414 ⟶ 2,329:
bin
end
</syntaxhighlight>
Demonstration code:
<
(0..31).each do |n|
gr = gray_encode n
Line 1,422 ⟶ 2,337:
printf "%2d : %05b => %05b => %05b : %2d\n", n, n, gr, bin, bin
end
</syntaxhighlight>
{{out}}
<pre>
Line 1,460 ⟶ 2,375:
=={{header|D}}==
<
return n ^ (n >> 1);
}
Line 1,481 ⟶ 2,396:
assert(d == n);
}
}</
{{out}}
<pre> N N2 enc dec2 dec
Line 1,523 ⟶ 2,438:
then the decode table is calculated and appended.
Same output.
<
T[] gray(int N : 1, T)() pure nothrow {
Line 1,560 ⟶ 2,475:
writefln("%2d: %5b => %5b : %2d", i, i, encoded, decoded);
}
}</
===Short Functional-Style Generator===
<
string[] g(in uint n) pure nothrow {
Line 1,573 ⟶ 2,488:
void main() {
4.g.writeln;
}</
{{out}}
<pre>["0000", "0001", "0011", "0010", "0110", "0111", "0101", "0100", "1100", "1101", "1111", "1110", "1010", "1011", "1001", "1000"]</pre>
Line 1,579 ⟶ 2,494:
=={{header|Delphi}}==
{{trans|DWScript}}
<
{$APPTYPE CONSOLE}
Line 1,623 ⟶ 2,538:
Writeln(Format(' %2d %s %s %s %2d', [i, IntToBin(i, 5), IntToBin(g, 5), IntToBin(d, 5), d]));
end;
end.</
{{out}}
<pre>
Line 1,661 ⟶ 2,576:
</pre>
=={{header|Draco}}==
<syntaxhighlight lang="draco">proc gray_encode(word n) word:
n >< (n >> 1)
corp
proc gray_decode(word n) word:
word r;
r := n;
while
n := n >> 1;
n > 0
do
r := r >< n
od;
r
corp
proc main() void:
word i, enc, dec;
for i from 0 upto 31 do
enc := gray_encode(i);
dec := gray_decode(enc);
writeln(i:2, ": ",
i:b:5, " => ",
enc:b:5, " => ",
dec:b:5, " => ",
dec:2)
od
corp</syntaxhighlight>
{{out}}
<pre> 0: 0 => 0 => 0 => 0
1: 1 => 1 => 1 => 1
2: 10 => 11 => 10 => 2
3: 11 => 10 => 11 => 3
4: 100 => 110 => 100 => 4
5: 101 => 111 => 101 => 5
6: 110 => 101 => 110 => 6
7: 111 => 100 => 111 => 7
8: 1000 => 1100 => 1000 => 8
9: 1001 => 1101 => 1001 => 9
10: 1010 => 1111 => 1010 => 10
11: 1011 => 1110 => 1011 => 11
12: 1100 => 1010 => 1100 => 12
13: 1101 => 1011 => 1101 => 13
14: 1110 => 1001 => 1110 => 14
15: 1111 => 1000 => 1111 => 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</pre>
=={{header|DWScript}}==
<
begin
Result := v xor (v shr 1);
Line 1,685 ⟶ 2,662:
PrintLn(Format(' %2d %s %s %s %2d',
[i, IntToBin(i, 5), IntToBin(g, 5), IntToBin(d, 5), d]));
end;</
=={{header|EasyLang}}==
<syntaxhighlight>
func$ bin n .
for i to 5
r$ = n mod 2 & r$
n = n div 2
.
return r$
.
func gray_encode b .
return bitxor b bitshift b -1
.
func gray_decode g .
b = g
while g > 0
g = bitshift g -1
b = bitxor b g
.
return b
.
for n = 0 to 31
g = gray_encode n
b = gray_decode g
print bin n & " -> " & bin g & " -> " & bin b
.
</syntaxhighlight>
{{out}}
<pre>
00000 -> 00000 -> 00000
00001 -> 00001 -> 00001
00010 -> 00011 -> 00010
00011 -> 00010 -> 00011
00100 -> 00110 -> 00100
00101 -> 00111 -> 00101
00110 -> 00101 -> 00110
00111 -> 00100 -> 00111
01000 -> 01100 -> 01000
01001 -> 01101 -> 01001
01010 -> 01111 -> 01010
01011 -> 01110 -> 01011
01100 -> 01010 -> 01100
01101 -> 01011 -> 01101
01110 -> 01001 -> 01110
01111 -> 01000 -> 01111
10000 -> 11000 -> 10000
10001 -> 11001 -> 10001
10010 -> 11011 -> 10010
10011 -> 11010 -> 10011
10100 -> 11110 -> 10100
10101 -> 11111 -> 10101
10110 -> 11101 -> 10110
10111 -> 11100 -> 10111
11000 -> 10100 -> 11000
11001 -> 10101 -> 11001
11010 -> 10111 -> 11010
11011 -> 10110 -> 11011
11100 -> 10010 -> 11100
11101 -> 10011 -> 11101
11110 -> 10001 -> 11110
11111 -> 10000 -> 11111
</pre>
=={{header|EDSAC order code}}==
The only logical operation on EDSAC was AND, or "collate" as it was called, but it's possible to calculate XOR from AND together with arithmetical operations. For converting Gray code to binary on EDSAC, I couldn't think up any shorter method than the one below.
<syntaxhighlight lang="edsac">
[Gray code task for Rosetta Code.
EDSAC program, Initial Orders 2.]
[Library subroutine M3. Prints header at load time,
then M3 and header are overwritten.]
PFGKIFAFRDLFUFOFE@A6FG@E8FEZPF
*BINARY!!GRAY!!!!ROUND!TRIP@&
..PK [after header, blank tape and PK (WWG, 1951, p. 91)]
T64K [load at location 64 (arbitrary choice)]
GK [set @ (theta) parameter]
[Subroutine to print 5-bit number in binary.
Input: 1F = number (preserved) in low 5 bits.
Workspace: 0F, 4F.]
[0] A3F T17@ [plant return link as usual]
H19@ [mult reg := mask to remove top 4 bits]
A1F [acc := code in low 5 bits]
L32F [shift 7 left]
TF [store in workspace]
S18@ [initialize negative count of digits]
[7] T4F [update negative count]
AF LD TF [shift workspace 1 left]
CF [remove top 4 bits]
TF [store result]
OF [print character '0' or '1' in top 5 bits]
A4F A2F G7@ [inc count, loop if not yet 0]
[17] ZF [{planted} jump back to caller]
[18] P5F [addres field = number of bits]
[19] Q2047D [00001111111111111 binary]
[Subroutine to convert binary code to Gray code.
Input: 1F = binary code (preserved).
Output: 0F = Gray code.]
[20] A3F T33@ [plant return link as usual]
A1F RD TF [0F := binary shifted 1 right]
[One way to get p XOR q on EDSAC: Let r = p AND q.
Then p XOR q = (p - r) + (q - r) = -(2r - p - q).]
HF [mult reg := 0F]
C1F [acc := 0F AND 1F]
LD [times 2]
SF S1F [subtract 0F and 1F]
TF SF TF [return result negated]
[33] ZF [{planted} jump back to caller]
[Subroutine to convert 5-digit Gray code to binary.
Uses a chain of XORs.
If bits in Gray code are ghijk then bits in binary are
g, g.h, g.h.i, g.h.i.j, g.h.i.j.k where dot means XOR.
Input: 1F = Gray code (preserved).
Output: 0F = binary code.
Workspace: 4F, 5F.]
[34] A3F T55@ [plant return link as usual]
A1F UF [initialize result to Gray code]
T5F [5F = shifted Gray code, shift = 0 initialiy]
S56@ [initialize negative count]
[40] T4F [update negative count]
HF [mult reg := partial result]
A5F RD T5F [shift Gray code 1 right]
[Form 5F XOR 0F as in the previous subroutine]
C5F LD SF S5F TF SF
TF [update partial result]
A4F A2F G40@ [inc count, loop back if not yet 0]
[55] ZF [{planted} jump back to caller]
[56] P4F [address field = 1 less than number of bits]
[Main routine]
[Variable]
[57] PF [binary code is in low 5 bits]
[Constants]
[58] P16F [exclusive maximum code, 100000 binary]
[59] PD [17-bit 1]
[60] #F [teleprinter figures mode]
[61] !F [space]
[62] @F [carriage return]
[63] &F [line feed]
[Enter with acc = 0]
[64] O60@ [set teleprinter to figures]
S58@ [to make acc = 0 after next instruction]
[66] A58@ [loop: restore acc after test below]
U57@ T1F [save binary code, and pass it to print soubroutine]
[69] A69@ G@ [print binary code]
O61@ O61@ O61@ [print 3 spaces]
[74] A74@ G20@ [convert binary (still in 1F) to Gray]
AF T1F [pass Gray code to print subroutine]
[78] A78@ G@ [print Gray code]
O61@ O61@ O61@ [print 3 spaces]
[83] A83@ G34@ [convert Gray (still in 1F) back to binary]
AF T1F [pass binary code to print subroutine]
[87] A87@ G@ [print binary]
O62@ O63@ [print CR, LF]
A57@ A59@ [inc binary]
S58@ [test for all done]
G66@ [loop back if not]
O60@ [dummy character to flush teleprinter buffer]
ZF [stop]
E64Z [define entry point]
PF [acc = 0 on entry]
[end]
</syntaxhighlight>
{{out}}
<pre>
BINARY GRAY ROUND TRIP
00000 00000 00000
00001 00001 00001
00010 00011 00010
00011 00010 00011
00100 00110 00100
00101 00111 00101
00110 00101 00110
00111 00100 00111
01000 01100 01000
01001 01101 01001
01010 01111 01010
01011 01110 01011
01100 01010 01100
01101 01011 01101
01110 01001 01110
01111 01000 01111
10000 11000 10000
10001 11001 10001
10010 11011 10010
10011 11010 10011
10100 11110 10100
10101 11111 10101
10110 11101 10110
10111 11100 10111
11000 10100 11000
11001 10101 11001
11010 10111 11010
11011 10110 11011
11100 10010 11100
11101 10011 11101
11110 10001 11110
11111 10000 11111
</pre>
=={{header|Elixir}}==
{{trans|Erlang}}
<
use Bitwise
def encode(n), do: bxor(n, bsr(n,1))
Line 1,703 ⟶ 2,881:
d = Gray_code.decode(g)
:io.fwrite("~2B : ~5.2.0B : ~5.2.0B : ~5.2.0B : ~2B~n", [n, n, g, d, d])
end)</
output is the same as "Erlang".
=={{header|Erlang}}==
{{trans|Euphoria}}
<
-export([encode/1, decode/1]).
Line 1,717 ⟶ 2,895:
decode(0,N) -> N;
decode(G,N) -> decode(G bsr 1, G bxor N).
</syntaxhighlight>
Demonstration code:
<
test_encode(N) ->
Line 1,730 ⟶ 2,908:
test_encode(I, N) when I < N -> test_encode(I), test_encode(I+1, N).
main(_) -> test_encode(0,32).</
{{out}}
Line 1,769 ⟶ 2,947:
=={{header|Euphoria}}==
<
return xor_bits(n,floor(n/2))
end function
Line 1,802 ⟶ 2,980:
j = gray_decode(j)
printf(1,"%05d\n",dcb(j))
end for</
{{out}}
Line 1,840 ⟶ 3,018:
=={{header|F_Sharp|F#}}==
===The Function===
<
// Functıons to translate bınary to grey code and vv. Nigel Galloway: December 7th., 2018
let grayCode,invGrayCode=let fN g (n:uint8)=n^^^(n>>>g) in ((fN 1),(fN 1>>fN 2>>fN 4))
</syntaxhighlight>
===The Task===
<
[0uy..31uy]|>List.iter(fun n->let g=grayCode n in printfn "%2d -> %5s (%2d) -> %2d" n (System.Convert.ToString(g,2)) g (invGrayCode g))</
{{out}}
<pre>
Line 1,885 ⟶ 3,063:
=={{header|Factor}}==
Translation of C.
<
IN: rosetta-gray
Line 1,901 ⟶ 3,079:
MAIN: main
</syntaxhighlight>
Running above code prints:
<
{ 0 "0" "0" 0 }
{ 1 "1" "1" 1 }
Line 1,936 ⟶ 3,114:
{ 30 "11110" "10001" 30 }
{ 31 "11111" "10000" 31 }
{ 32 "100000" "110000" 32 }</
=={{header|Forth}}==
Line 1,942 ⟶ 3,120:
These functions take input parameters from the stack and return the result on the stack.
<
\ 2/ is Forth divide by 2, ie: shift right 1
: gray> ( n -- n )
Line 1,963 ⟶ 3,141:
loop
decimal ; \ revert to BASE 10
</
{{out}}
<pre>
Line 2,002 ⟶ 3,180:
=={{header|Fortran}}==
Using [http://www.everyspec.com/MIL-STD/MIL-STD+(1700+-+1799)/download.php?spec=MIL-STD-1753.011044.PDF MIL-STD-1753] extensions in '''Fortran 77''', and formulas found at OEIS for [[oeis:A003188|direct]] and [[oeis:A006068|inverse]] Gray code :
<
IMPLICIT NONE
INTEGER IGRAY,I,J,K
Line 2,047 ⟶ 3,225:
10 CONTINUE
S(1:L-K)=''
END</
<pre> 0 : 00000 => 00000 => 00000 : 0
Line 2,081 ⟶ 3,259:
30 : 11110 => 10001 => 11110 : 30
31 : 11111 => 10000 => 11111 : 31</pre>
=={{header|Frink}}==
Frink has built-in functions to convert to and from binary reflected Gray code.
<
for i=0 to 31
{
Line 2,169 ⟶ 3,269:
println[(i->binary) + "\t" + (gray->binary) + "\t" + (back->binary)]
}
</syntaxhighlight>
=={{header|Go}}==
{{trans|Euphoria}}
Binary reflected, as described in the task. Reading down through the solutions, the Euphoria decode algorithm caught my eye as being concise and easy to read.
<
import "fmt"
Line 2,196 ⟶ 3,296:
fmt.Printf(" %2d %05b %05b %05b %2d\n", b, b, g, d, d)
}
}</
{{out}}
<pre>
Line 2,236 ⟶ 3,336:
=={{header|Groovy}}==
Solution:
<
i ^ (i >>> 1)
}
Line 2,245 ⟶ 3,345:
def h = grayDecode(code >>> 1)
return (h << 1) + ((code ^ h) & 1)
}</
Test:
<
def remainder = i
def bin = []
Line 2,268 ⟶ 3,368:
it, iB[4],iB[3],iB[2],iB[1],iB[0], cB[4],cB[3],cB[2],cB[1],cB[0], decode)
println()
}</
Results:
Line 2,309 ⟶ 3,409:
For zero padding, replace the %5s specifiers in the format string with %05s.
<
import Data.Char
import Numeric
Line 2,331 ⟶ 3,431:
printf "int: %2d -> bin: %5s -> gray: %5s\n" num bin gray
main = forM_ [0..31::Int] showGrayCode</
=={{header|Icon}} and {{header|Unicon}}==
The following works in both languages:
<
procedure main()
Line 2,353 ⟶ 3,453:
every i := 2 to *g do b ||:= if g[i] == b[i-1] then "0" else "1"
return b
end</
Sample run:
Line 2,376 ⟶ 3,476:
<code>G2B</code> is an invertible function which will translate Gray code to Binary:
<
Thus <code>G2B inv</code> will translate binary to Gray code.
Line 2,382 ⟶ 3,482:
Required example:
<
G2B=: ~:/\&.|:
(,: ,.@".&.>) 'n';'#:n';'G2B inv#:n';'#.G2B G2B inv#:n'
Line 2,420 ⟶ 3,520:
|30|1 1 1 1 0|1 0 0 0 1 |30 |
|31|1 1 1 1 1|1 0 0 0 0 |31 |
+--+---------+----------+----------------+</
=={{header|Java}}==
{{trans|C}}
<
import java.math.BigInteger;
public class GrayCode {
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 BigInteger grayEncode(BigInteger n) {
return n.xor(n.shiftRight(1));
}
public static BigInteger grayDecode(BigInteger n) {
BigInteger p = n;
while ( ( n = n.shiftRight(1) ).signum() != 0 ) {
p = p.xor(n);
}
return p;
}
/**
* An alternative version of grayDecode,
* less efficient, but demonstrates the principal of gray decoding.
*/
public static BigInteger grayDecode2(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 using characters
result += nBits.charAt(i) != result.charAt(i - 1) ? "1" : "0";
}
return new BigInteger(result, 2);
}
/**
* An alternative version of grayEncode,
* less efficient, but demonstrates the principal of gray encoding.
*/
public static long grayEncode2(long n) {
long result = 0;
for ( int exp = 0; n > 0; n >>= 1, exp++ ) {
long nextHighestBit = ( n >> 1 ) & 1;
if ( nextHighestBit == 1 ) {
result += ( ( n & 1 ) == 0 ) ? ( 1 << exp ) : 0; // flip this bit
} else {
result += ( n & 1 ) * ( 1 << exp ); // don't flip this bit
}
}
return result;
}
public static void main(String[] args){
System.out.println("i\tBinary\tGray\tGray2\tDecoded");
System.out.println("=======================================");
for ( int i = 0; 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.print(Long.toBinaryString(grayEncode2(i)) + "\t");
System.out.println(grayDecode(grayEncode(i)));
}
System.out.println();
final BigInteger base = BigInteger.TEN.pow(25).add( new BigInteger("12345678901234567890") );
for ( int i = 0; i < 5; i++ ) {
BigInteger test = base.add(BigInteger.valueOf(i));
System.out.println("test decimal = " + test);
System.out.println("gray code decimal = " + grayEncode(test));
System.out.println("gray code binary = " + grayEncode(test).toString(2));
System.out.println("decoded decimal = " + grayDecode(grayEncode(test)));
System.out.println("decoded2 decimal = " + grayDecode2(grayEncode(test)));
System.out.println();
}
}
}
</syntaxhighlight>
{{ out }}
<pre>
i Binary Gray Gray2 Decoded
=======================================
0 0 0 0 0
1 1 1 1 1
2 10 11 11 2
3 11 10 10 3
4 100 110 110 4
5 101 111 111 5
6 110 101 101 6
7 111 100 100 7
8 1000 1100 1100 8
9 1001 1101 1101 9
10 1010 1111 1111 10
11 1011 1110 1110 11
12 1100 1010 1010 12
13 1101 1011 1011 13
14 1110 1001 1001 14
15 1111 1000 1000 15
16 10000 11000 11000 16
17 10001 11001 11001 17
18 10010 11011 11011 18
19 10011 11010 11010 19
20 10100 11110 11110 20
21 10101 11111 11111 21
22 10110 11101 11101 22
23 10111 11100 11100 23
24 11000 10100 10100 24
25 11001 10101 10101 25
26 11010 10111 10111 26
27 11011 10110 10110 27
28 11100 10010 10010 28
29 11101 10011 10011 29
30 11110 10001 10001 30
31 11111 10000 10000 31
test decimal = 10000012345678901234567890
gray code decimal = 14995268463904422838177723
gray code binary = 110001100111010111110010000111011100111111111011111110101111100100001000111110111011
decoded decimal = 10000012345678901234567890
decoded2 decimal = 10000012345678901234567890
test decimal = 10000012345678901234567891
gray code decimal = 14995268463904422838177722
gray code binary = 110001100111010111110010000111011100111111111011111110101111100100001000111110111010
decoded decimal = 10000012345678901234567891
decoded2 decimal = 10000012345678901234567891
test decimal = 10000012345678901234567892
gray code decimal = 14995268463904422838177726
gray code binary = 110001100111010111110010000111011100111111111011111110101111100100001000111110111110
decoded decimal = 10000012345678901234567892
decoded2 decimal = 10000012345678901234567892
test decimal = 10000012345678901234567893
gray code decimal = 14995268463904422838177727
gray code binary = 110001100111010111110010000111011100111111111011111110101111100100001000111110111111
decoded decimal = 10000012345678901234567893
decoded2 decimal = 10000012345678901234567893
test decimal = 10000012345678901234567894
gray code decimal = 14995268463904422838177725
gray code binary = 110001100111010111110010000111011100111111111011111110101111100100001000111110111101
decoded decimal = 10000012345678901234567894
decoded2 decimal = 10000012345678901234567894
</pre>
=={{header|Javascript}}==
Line 2,515 ⟶ 3,684:
'''Module''' <code>gray-code.js</code>
<
return number ^ (number >> 1)
}
Line 2,527 ⟶ 3,696:
return number
}</
'''Test'''
<
import * as gray from './gray-code.js'
Line 2,550 ⟶ 3,719:
decodedGrayCode
))
}</
{{out}}
<pre>
Line 2,586 ⟶ 3,755:
30 11110 10001 30
31 11111 10000 31
</pre>
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
'''Works with jaq, the Rust implementation of jq'''
The following is slightly more verbose than it need be but for the
sake of jaq.
<syntaxhighlight lang="jq">
def encode:
def flip: if . == 1 then 0 else 1 end;
. as $b
| reduce range(1; length) as $i ($b;
if $b[$i-1] == 1 then .[$i] |= flip
else .
end ) ;
def decode:
def xor($a;$b): ($a + $b) % 2;
. as $g
| reduce range(1; length) as $i (.[:1];
.[$i] = xor($g[$i]; .[$i-1]) ) ;
# input: a non-negative integer
# output: a binary array, least-significant bit first
def to_binary:
if . == 0 then [0]
else [recurse( if . == 0 then empty else ./2 | floor end ) % 2]
| .[:-1] # remove the uninteresting 0
end ;
def lpad($len; $fill):
tostring
| ($len - length) as $l
| if $l <= 0 then .
else ($fill * $l)[:$l] + .
end;
def pp: map(tostring) | join("") | lpad(5; "0");
### The task
"decimal binary gray roundtrip",
(range(0; 32) as $i
| ($i | to_binary | reverse) as $b
| ($b|encode) as $g
| " \($i|lpad(2;" ")) \($b|pp) \($g|pp) \($g|decode == $b)" )
</syntaxhighlight>
{{output}}
<pre>
decimal binary gray roundtrip
0 00000 00000 true
1 00001 00001 true
2 00010 00011 true
3 00011 00010 true
4 00100 00110 true
5 00101 00111 true
6 00110 00101 true
7 00111 00100 true
8 01000 01100 true
9 01001 01101 true
10 01010 01111 true
11 01011 01110 true
12 01100 01010 true
13 01101 01011 true
14 01110 01001 true
15 01111 01000 true
16 10000 11000 true
17 10001 11001 true
18 10010 11011 true
19 10011 11010 true
20 10100 11110 true
21 10101 11111 true
22 10110 11101 true
23 10111 11100 true
24 11000 10100 true
25 11001 10101 true
26 11010 10111 true
27 11011 10110 true
28 11100 10010 true
29 11101 10011 true
30 11110 10001 true
31 11111 10000 true
</pre>
Line 2,591 ⟶ 3,846:
{{works with|Julia|0.6}}
{{trans|C}}
<
function graydecode(n::Integer)
r = n
Line 2,598 ⟶ 3,853:
end
return r
end</
Note that these functions work for any integer type, including arbitrary-precision integers (the built-in <code>BigInt</code> type).
Line 2,606 ⟶ 3,861:
Binary to Gray code
<
gray:{x[0],xor':x}
Line 2,613 ⟶ 3,868:
/ variant: iterative
gray2:{x[0],{:[x[y-1]=1;~x[y];x[y]]}[x]'1+!(#x)-1}</
Line 2,619 ⟶ 3,874:
"Accumulated xor"
<syntaxhighlight lang
An alternative is to find the inverse of the gray code by tracing until fixpoint.
Here we find that 1 1 1 1 1 is the inverse of 1 0 0 0 0
<
(1 0 0 0 0
1 1 0 0 0
Line 2,632 ⟶ 3,887:
1 0 1 0 1
1 1 1 1 1)
</syntaxhighlight>
As a function (*| takes the last result)
<
Iterative version with "do"
<
Presentation
<
g2b:xor\
/ using allcomb instead of 2_vs'!32 for nicer presentation
Line 2,649 ⟶ 3,904:
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</
{{out}}
Line 2,686 ⟶ 3,941:
=={{header|Kotlin}}==
<
object Gray {
Line 2,709 ⟶ 3,964:
println("${Integer.toBinaryString(g)}\t${Gray.decode(g)}")
}
}</
{{out}}
Line 2,746 ⟶ 4,001:
30 11110 10001 30
31 11111 10000 31
</pre>
=={{header|Limbo}}==
{{trans|Go}}
<syntaxhighlight lang="limbo">implement Gray;
include "sys.m"; sys: Sys;
Line 2,894 ⟶ 4,054:
}
return s;
}</
{{out}}
Line 2,934 ⟶ 4,094:
=={{header|Lobster}}==
{{trans|C}}
<
return n ^ (n >> 1)
Line 2,952 ⟶ 4,112:
number_to_string(g, 2, 5) + " ⇾ " +
number_to_string(b, 2, 5) + " : " +
number_to_string(b, 10, 2))</
{{out}}
<pre>
Line 2,991 ⟶ 4,151:
=={{header|Logo}}==
{{trans|Euphoria}}
<
output bitxor :number lshift :number -1
end
Line 3,003 ⟶ 4,163:
]
output :value
end</
Demonstration code, including formatters:
<
while [(count :str) < :width] [
make "str word :pad :str
Line 3,034 ⟶ 4,194:
print (sentence (format :num 2) ": (binary :num 5) ": (binary :gray 5) ":
(binary :decoded 5) ": (format :decoded 2)) ]
bye</
{{out}}
Line 3,074 ⟶ 4,234:
{{trans|Euphoria}}
This code uses the [http://bitop.luajit.org/index.html Lua BitOp] module. Designed to be a module named <tt>gray.lua</tt>.
<
local bit = require('bit')
Line 3,091 ⟶ 4,251:
end
return _M</
Demonstration code:
<
local gray = require 'gray'
Line 3,117 ⟶ 4,277:
to_bit_string(i,5), to_bit_string(g, 5),
to_bit_string(gd,5), gd))
end</
{{out}}
Line 3,161 ⟶ 4,321:
Additions to showing the modules/functions replacement mechanism of M2000
<syntaxhighlight lang="m2000 interpreter">
Module Code32 (&code(), &decode()){
Const d$="{0::-2} {1:-6} {2:-6} {3:-6} {4::-2}"
Line 3,191 ⟶ 4,351:
// pass Code32 to GrayCode in place of doit
GrayCode ; doit as Code32
</syntaxhighlight>
{{out}}
<pre style="overflow: auto; height: 20em;">
Line 3,230 ⟶ 4,390:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
graydecode[n_]:=Fold[BitXor,0,FixedPointList[BitShiftRight,n]]</
{{out}}
<pre>Required example:
Line 3,247 ⟶ 4,407:
=={{header|MATLAB}}==
<syntaxhighlight lang="matlab">
%% Gray Code Generator
% this script generates gray codes of n bits
Line 3,291 ⟶ 4,451:
disp(result);
end
</syntaxhighlight>
{{out}}
Line 3,344 ⟶ 4,504:
The additional <tt>gray.coerce/2</tt> predicate converts the ''representation'' underlying a <tt>gray</tt> value into an <tt>int</tt> value or vice versa (it is moded in both directions). For type safety reasons we do not wish to generally expose the underlying representation, but for some purposes, most notably I/O or storage or their ilk we have to break the type safety. The <tt>coerce/2</tt> predicate is used for this purpose.
<
:- interface.
Line 3,373 ⟶ 4,533:
gray.coerce(gray(I), I).
:- end_module gray.</
The following program tests the above code:
<
:- interface.
Line 3,416 ⟶ 4,576:
io.format("%8d %8s %8s\n", [i(Number), s(NumBin), s(GrayBin)], !IO).
:- end_module gray_test.</
The <tt>main/2</tt> predicate generates a list of numbers from 0 to 31 inclusive and then checks that conversion is working properly.
Line 3,473 ⟶ 4,633:
30 11110 10001
31 11111 10000</tt>
=={{header|Modula-2}}==
{{trans|DWScript|<code>CARDINAL</code> (unsigned integer) used instead of integer.}}
{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}
<syntaxhighlight lang="modula2">
MODULE GrayCode;
FROM STextIO IMPORT
WriteString, WriteLn;
FROM SWholeIO IMPORT
WriteInt;
FROM Conversions IMPORT
LongBaseToStr;
FROM FormatString IMPORT
FormatString; (* for justifying *)
VAR
I, G, D: CARDINAL;
Ok: BOOLEAN;
BinS, OutBinS: ARRAY[0 .. 5] OF CHAR;
PROCEDURE Encode(V: CARDINAL): CARDINAL;
BEGIN
RETURN V BXOR (V SHR 1)
END Encode;
PROCEDURE Decode(V: CARDINAL): CARDINAL;
VAR
Result: CARDINAL;
BEGIN
Result := 0;
WHILE V > 0 DO
Result := Result BXOR V;
V := V SHR 1
END;
RETURN Result
END Decode;
BEGIN
WriteString("decimal binary gray decoded");
WriteLn;
FOR I := 0 TO 31 DO
G := Encode(I);
D := Decode(G);
WriteInt(I, 4);
WriteString(" ");
Ok := LongBaseToStr(I, 2, BinS);
Ok := FormatString("%'05s", OutBinS, BinS);
(* Padded with 0; width: 5; type: string *)
WriteString(OutBinS);
WriteString(" ");
Ok := LongBaseToStr(G, 2, BinS);
Ok := FormatString("%'05s", OutBinS, BinS);
WriteString(OutBinS);
WriteString(" ");
Ok := LongBaseToStr(D, 2, BinS);
Ok := FormatString("%'05s", OutBinS, BinS);
WriteString(OutBinS);
WriteInt(D, 4);
WriteLn;
END
END GrayCode.
</syntaxhighlight>
{{out}}
<pre>
decimal binary gray decoded
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
</pre>
=={{header|Nim}}==
{{trans|C}}
<
n xor (n shr 1)
Line 3,484 ⟶ 4,743:
while t > 0:
t = t shr 1
result = result xor t</
Demonstration code:
<
for i in 0 .. 32:
echo &"{i:>2} => {toBin(grayEncode(i), 6)} => {grayDecode(grayEncode(i)):>2}"</
{{out}}
<pre> 0 => 000000 => 0
Line 3,527 ⟶ 4,786:
=={{header|NOWUT}}==
adapted from C
<
sectiondata
Line 3,591 ⟶ 4,850:
endfunc
returnex $0C ; clean off 3 parameters from the stack
</syntaxhighlight>
{{out}}
<pre style="overflow: auto; height: 20em;">00 : 00000 => 00000 => 00000
Line 3,628 ⟶ 4,887:
=={{header|OCaml}}==
<
b lxor (b lsr 1)
Line 3,653 ⟶ 4,912:
let b = gray_decode g in
Printf.printf "%2d : %s => %s => %s : %2d\n" i (s i) (s g) (s b) b
done</
=={{header|PARI/GP}}==
This code may have exposed a bug in PARI 2.4.4: <code>apply(Str, 1)</code> fails.
As a workaround I used a closure: <code>apply(k->Str(k), 1)</code>.
<
fromGray(n)=my(k=1,m=n);while(m>>k,n=bitxor(n,n>>k);k+=k);n;
bin(n)=concat(apply(k->Str(k),binary(n)))
for(n=0,31,print(n"\t"bin(n)"\t"bin(g=toGray(n))"\t"fromGray(g)))</
{{out}}
<pre>0 0 0 0
Line 3,702 ⟶ 4,961:
=={{header|Perl}}==
<
{
return $_[0] ^ ($_[0] >> 1);
Line 3,721 ⟶ 4,980:
my $gr= bin2gray($_);
printf "%d\t%b\t%b\t%b\n", $_, $_, $gr, gray2bin($gr);
}</
=={{header|Phix}}==
{{Trans|Delphi}} (turned out to be almost the same as Euphoria)
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">gray_encode</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
Line 3,748 ⟶ 5,007:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%2d %05b %05b %2d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e</span><span style="color: #0000FF;">,</span><span style="color: #000000;">d</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</
{{out}}
<pre>
Line 3,788 ⟶ 5,047:
=={{header|PHP}}==
<
<?php
Line 3,817 ⟶ 5,076:
printf("%2d : %05b => %05b => %05b : %2d \n",$i, $i, $gray_encoded, $gray_encoded, gray_decode($gray_encoded));
}
</syntaxhighlight>
{{out}}
<pre>
Line 3,855 ⟶ 5,114:
=={{header|Picat}}==
<
foreach(I in 0..2**5-1)
G = gray_encode1(I),
Line 3,880 ⟶ 5,139:
P := P ^ N,
N := N >> 1
end. </
{{out}}
Line 3,920 ⟶ 5,179:
=={{header|PicoLisp}}==
<
(bin (x| N (>> 1 N))) )
Line 3,929 ⟶ 5,188:
(mapcar
'((C) (setq X (x| X (format C))))
(chop G) ) ) ) ) )</
Test:
<
(for I (range 0 31)
(let G (grayEncode I)
(tab (4 9 9 9) I (bin I) G (grayDecode G)) ) )</
{{out}}
<pre> Binary Gray Decoded
Line 3,971 ⟶ 5,230:
=={{header|PL/I}}==
<
Gray_code: procedure options (main); /* 15 November 2013 */
declare (bin(0:31), g(0:31), b2(0:31)) bit (5);
Line 4,001 ⟶ 5,260:
put skip edit (i, bin(i), g(i), b2(i)) (f(2), 3(x(1), b));
end;
end Gray_code;</
<pre>
0 00000 00000 00000
Line 4,037 ⟶ 5,296:
</pre>
=={{header|
<syntaxhighlight lang="plm">100H:
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; GO TO 0; END EXIT;
PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT;
PRINT$NUM: PROCEDURE (N, BASE);
DECLARE S (17) BYTE INITIAL ('................$');
DECLARE (N, P) ADDRESS, (DGT BASED P, BASE) BYTE;
P = .S(16);
DIGIT:
P = P - 1;
DGT = N MOD BASE + '0';
N = N / BASE;
IF N > 0 THEN GO TO DIGIT;
CALL PRINT(P);
END PRINT$NUM;
GRAY$ENCODE: PROCEDURE (N) BYTE;
DECLARE N BYTE;
RETURN N XOR SHR(N, 1);
END GRAY$ENCODE;
GRAY$DECODE: PROCEDURE (N) BYTE;
DECLARE (N, R, I) BYTE;
R = N;
DO WHILE (N := SHR(N,1)) > 0;
R = R XOR N;
END;
RETURN R;
END GRAY$DECODE;
DECLARE (I, G) BYTE;
DO I = 0 TO 31;
CALL PRINT$NUM(I, 10);
CALL PRINT(.(':',9,'$'));
CALL PRINT$NUM(I, 2);
CALL PRINT(.(9,'=>',9,'$'));
CALL PRINT$NUM(G := GRAY$ENCODE(I), 2);
CALL PRINT(.(9,'=>',9,'$'));
CALL PRINT$NUM(GRAY$DECODE(G), 10);
CALL PRINT(.(10,13,'$'));
END;
CALL EXIT;
EOF</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|Prolog}}==
=== Codecs ===
The encoding and decoding predicates are simple and will work
Line 4,065 ⟶ 5,383:
{{works with|SWI Prolog}}
{{works with|YAP}}
<
N0 is N >> 1,
G is N xor N0.
Line 4,074 ⟶ 5,392:
from_gray(S, N0),
N is G xor N0
; N is G ).</
=== Test Code ===
Line 4,082 ⟶ 5,400:
{{works with|SWI Prolog}}
{{works with|YAP}}
<
to_gray(N, G) :-
Line 4,113 ⟶ 5,431:
maplist(write_record, Numbers, Grays, Decodeds).
go :- halt(1).
</syntaxhighlight>
{{out}}
Line 4,153 ⟶ 5,471:
30 11110 10001 11110 30
31 11111 10000 11111 31</pre>
=={{header|Python}}==
===Python: on integers===
Works with python integers
<syntaxhighlight lang="text">def gray_encode(n):
return n ^ n >> 1
Line 4,241 ⟶ 5,491:
gray = gray_encode(i)
dec = gray_decode(gray)
print(f" {i:>2d}, {i:>05b} => {gray:>05b} => {dec:>2d}")</
{{out}}
Line 4,283 ⟶ 5,533:
;First some int<>bin conversion routines:
<
'From positive integer to list of binary bits, msb at index 0'
if n:
Line 4,299 ⟶ 5,549:
for bit in bits:
i = i * 2 + bit
return i</
;Now the bin<>gray converters.
These follow closely the methods in the animation seen here: [http://www.wisc-online.com/Objects/ViewObject.aspx?ID=IAU8307 Converting Between Gray and Binary Codes].
<
return bits[:1] + [i ^ ishift for i, ishift in zip(bits[:-1], bits[1:])]
Line 4,309 ⟶ 5,559:
b = [bits[0]]
for nextb in bits[1:]: b.append(b[-1] ^ nextb)
return b</
;Sample output
<
print('int:%2i -> bin:%12r -> gray:%12r -> bin:%12r -> int:%2i' %
( i,
Line 4,338 ⟶ 5,588:
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
>>> </
=={{header|Quackery}}==
<
[ dup
Line 4,363 ⟶ 5,613:
i^ encodegray dup 5 echobin
say " -> "
decodegray 5 echobin cr ]</
{{out}}
Line 4,403 ⟶ 5,653:
=={{header|R}}==
<syntaxhighlight lang="r">
GrayEncode <- function(binary) {
gray <- substr(binary,1,1)
Line 4,429 ⟶ 5,679:
return (binary)
}
</syntaxhighlight>
=={{header|Racket}}==
<
#lang racket
Line 4,451 ⟶ 5,701:
(~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"))))
</syntaxhighlight>
{{out}}
<pre style="overflow: auto; height: 20em;">> (show-table)
Line 4,489 ⟶ 5,739:
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
return $n +^ ( $n +> 1 );
}
Line 4,504 ⟶ 5,754:
printf "%2d: %5b => %5b => %5b: %2d\n", $n, $n, $g, $d, $d;
die if $d != $n;
}</
{{out}}
Line 4,547 ⟶ 5,797:
=={{header|REXX}}==
The leading zeroes for the binary numbers and the gray code could've easily been elided.
<
parse arg N . /*get the optional argument from the CL*/
if N=='' | N=="," then N=31 /*Not specified? Then use the default.*/
Line 4,571 ⟶ 5,821:
end /*g*/ /* ↑ */
/* │ */
return $ /*this is an eXclusive OR ►─────────┘ */</
'''output''' when using the default input:
<pre>
Line 4,610 ⟶ 5,860:
=={{header|Ring}}==
<
# Project : Gray code
Line 4,647 ⟶ 5,897:
result = result + string(binary)
return result
</syntaxhighlight>
Output:
<pre>
Line 4,684 ⟶ 5,934:
</pre>
=={{header|RPL}}==
{{works with|Halcyon Calc|4.2.7}}
{| class="wikitable"
! RPL code
! Comment
|-
|
≪ #1 RR 0 ROT START RL NEXT AND #0 ≠
≫ ´'''BIT?'''´ STO
≪ # 1b 0 ROT START RR NEXT OR
≫ ‘'''STBIT'''’ STO
≪ DUP SR XOR
≫ ‘'''→GRAY'''’ STO
≪ → gray
≪ #0 IF gray 0 '''BIT?''' THEN 0 '''STBIT''' END
1 RCWS 1 - FOR b
IF gray b '''BIT?''' OVER b 1 - '''BIT?''' XOR THEN b '''STBIT''' END
NEXT
≫ ≫ ‘'''GRAY→'''’ STO
≪ { } 0 31 FOR n n R→B '''→GRAY''' + NEXT
{ } 1 3 PICK SIZE FOR g OVER g GET '''GRAY→''' + NEXT
≫ ''''SHOWG'''’ STO
|
''( #b n -- boolean )''
''( #b n -- #b )''
''( #b -- #g )''
''( #g -- #b )''
b(0) = g(0)
Loop on all other bits
b[i] = g[i] xor b[i-1]
|}
{{in}}
<pre>
SHOWG
</pre>
{{out}}
<pre>
2: { # 0b # 1b # 11b # 10b # 110b # 111b # 101b # 100b # 1100b # 1101b # 1111b # 1110b # 1010b # 1011b # 1001b # 1000b # 11000b # 11001b # 11011b # 11010b # 11110b # 11111b # 11101b # 11100b # 10100b # 10101b # 10111b # 10110b # 10010b # 10011b # 10001b # 10000b }
1: { # 0b # 1b # 10b # 11b # 100b # 101b # 110b # 111b # 1000b # 1001b # 1010b # 1011b # 1100b # 1101b # 1110b # 1111b # 10000b # 10001b # 10010b # 10011b # 10100b # 10101b # 10110b # 10111b # 11000b # 11001b # 11010b # 11011b # 11100b # 11101b # 11110b # 11111b }
</pre>
=={{header|Ruby}}==
<tt>Integer#from_gray</tt> has recursion so it can use each bit of the answer to compute the next bit.
<
# Converts a normal integer to a Gray code.
def to_gray
Line 4,711 ⟶ 6,017:
printf "%2d : %5b => %5b => %5b : %2d\n",
number, number, encoded, decoded, decoded
end</
{{out}}
<pre style="overflow: auto; height: 20em;">
Line 4,750 ⟶ 6,056:
=={{header|Rust}}==
{{works with|Rust|1.1}}
<
(integer >> 1) ^ integer
}
Line 4,767 ⟶ 6,073:
}
}</
=={{header|Scala}}==
Line 4,773 ⟶ 6,079:
The <code>scanLeft</code> function takes a sequence (here, of characters) and produces a collection containing cumulative results of applying an operator going left to right.
Here the operator is exclusive-or, "^", and we can use "_" placeholders to represent the arguments to the left and right. <code>tail</code> removes the "0" we added as the initial accumulator value, and <code>mkString</code> turns the collection back into a String, that we can parse into an integer (Integer.parseInt is directly from the java.lang package).
<
def decode(s: String) = Integer.parseInt( s.scanLeft(0)(_ ^ _.asDigit).tail.mkString , 2)
Line 4,779 ⟶ 6,085:
for (i <- 0 to 31; g = encode(i))
println("%7d %6s %5s %7s".format(i, i.toBinaryString, g, decode(g)))
</syntaxhighlight>
{{out}}
<pre style="overflow: auto; height: 20em;">decimal binary gray decoded
Line 4,816 ⟶ 6,122:
</pre>
Alternatively, more imperative style:
<
def decode(n: Long) = {
Line 4,834 ⟶ 6,140:
val g = encode(i)
println("%7d %6s %5s %7s".format(i, toBin(i), toBin(g), decode(g)))
}</
Improved version of decode using functional style (recursion+local method).
No vars and mutations.
<
def calc(g:Long,bits:Long):Long=if (bits>0) calc(g^bits, bits>>1) else g
calc(0, n)
}</
{{out}}
<pre style="overflow: auto; height: 20em;">decimal binary gray decoded
Line 4,885 ⟶ 6,191:
The type [http://seed7.sourceforge.net/libraries/bin32.htm bin32] is intended for bit operations that are not defined for [http://seed7.sourceforge.net/libraries/integer.htm integer] values.
Bin32 is used for the [http://seed7.sourceforge.net/libraries/bin32.htm#%28in_bin32%29%3E%3C%28in_bin32%29 exclusive or] ('''><''') operation.
<
include "bin32.s7i";
Line 4,909 ⟶ 6,215:
writeln(i <& " => " <& grayEncode(i) radix 2 lpad0 6 <& " => " <& grayDecode(grayEncode(i)));
end for;
end func;</
{{out}}
Line 4,950 ⟶ 6,256:
=={{header|SenseTalk}}==
Note: Inputs and outputs as strings
<
function BinaryToGray param1
set theResult to ""
Line 4,988 ⟶ 6,294:
return theResult
end GrayToBinary
</syntaxhighlight>
{{out}}
Line 5,032 ⟶ 6,338:
=={{header|Sidef}}==
{{trans|Perl}}
<
n ^ (n >> 1)
}
Line 5,045 ⟶ 6,351:
var gr = bin2gray(i)
printf("%d\t%b\t%b\t%b\n", i, i, gr, gray2bin(gr))
} << ^32</
{{out}}
<pre>
Line 5,081 ⟶ 6,387:
31 11111 10000 11111
</pre>
=={{header|SparForte}}==
As a structured script.
<syntaxhighlight lang="ada">#!/usr/local/bin/spar
pragma annotate( summary, "gray" );
pragma annotate( description, "Gray code is a form of binary encoding where " );
pragma annotate( description, "transitions between consecutive numbers differ by" );
pragma annotate( description, "only one bit. Create functions to encode a number" );
pragma annotate( description, "to and decode a number from Gray code. Display the" );
pragma annotate( description, "normal binary representations, Gray code" );
pragma annotate( description, "representations, and decoded Gray code values for all" );
pragma annotate( description, "5-bit binary numbers (0-31 inclusive, leading 0's not" );
pragma annotate( description, "necessary). There are many possible Gray codes. The" );
pragma annotate( description, "following encodes what is called 'binary reflected" );
pragma annotate( description, "Gray code.'" );
pragma annotate( see_also, "http://rosettacode.org/wiki/Gray_code" );
pragma annotate( author, "Ken O. Burtch" );
pragma license( unrestricted );
pragma restriction( no_external_commands );
procedure gray is
bits : constant natural := 5;
subtype nat_values is natural;
function encode (binary : nat_values) return nat_values is
begin
return binary xor numerics.shift_right (binary, 1);
end encode;
-- SparForte 1.3 cannot print to numbers to different bases but we
-- we can write a function
function intToBin( nat_value : nat_values ) return string is
result : string;
v : nat_values := nat_value;
begin
if v = 0 then
result := '0';
else
while v > 0 loop
if (v and 1) = 1 then
result := '1' & @;
else
result := '0' & @;
end if;
v := numerics.shift_right( @, 1 );
end loop;
end if;
return "2#" & result & "#";
end intToBin;
function decode (gray : nat_values) return nat_values is
binary : nat_values;
bit : nat_values;
mask : nat_values := 2 ** (bits - 1);
begin
bit := gray and mask;
binary := bit;
for i in 2 .. bits loop
bit := numerics.shift_right (@, 1);
mask := numerics.shift_right (mask, 1);
bit := (gray and mask) xor @;
binary := @ + bit;
end loop;
return binary;
end decode;
j : nat_values;
ibinstr : string;
jbinstr : string;
begin
put_line ("Number Binary Gray Decoded");
for i in 0..31 loop
j := encode (i);
-- convert i and j to base 2 representation
ibinstr := intToBin(i);
jbinstr := intToBin(j);
-- for binary strings, right-justify
put (i, "ZZZZZ9" ) @
(' ' & strings.insert( ibinstr, 1, (8-strings.length(ibinstr)) * ' ' ) ) @
(' ' & strings.insert( jbinstr, 1, (8-strings.length(jbinstr)) * ' ' ) ) @
( " " ) @ (decode (j), "ZZZZZ9" );
new_line;
end loop;
end gray;</syntaxhighlight>
=={{header|SQL}}==
<
DECLARE @binary AS NVARCHAR(MAX) = '001010111'
DECLARE @gray AS NVARCHAR(MAX) = ''
Line 5,116 ⟶ 6,510:
SELECT @binary
</syntaxhighlight>
=={{header|Standard ML}}==
<
Word.xorb (b, Word.>> (b, 0w1))
Line 5,144 ⟶ 6,538:
aux (i + 0w1)
end;
aux 0w0</
=={{header|Swift}}==
<
return (i >> 1) ^ i
}
Line 5,169 ⟶ 6,563:
print("\(i) (\(iStr)) => \(encode) (\(encodeStr)) => \(decode) (\(decodeStr))")
}</
{{out}}
Line 5,207 ⟶ 6,601:
=={{header|Tcl}}==
<
proc encode n {
expr {$n ^ $n >> 1}
Line 5,220 ⟶ 6,614:
return $b
}
}</
Demonstrating:
<
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]
}</
{{out}}
<pre>
Line 5,262 ⟶ 6,656:
30: 11110 => 10001 => 11110 : 30
31: 11111 => 10000 => 11111 : 31
</pre>
== {{header|TypeScript}} ==
{{trans|DWScript}}
<syntaxhighlight lang="javascript">// Gray code
function encode(v: number): number {
return v ^ (v >> 1);
}
function decode(v: number): number {
var result = 0;
while (v > 0) {
result ^= v;
v >>= 1;
}
return result;
}
console.log("decimal binary gray decoded");
for (var i = 0; i <= 31; i++) {
var g = encode(i);
var d = decode(g);
process.stdout.write(
" " + i.toString().padStart(2, " ") +
" " + i.toString(2).padStart(5, "0") +
" " + g.toString(2).padStart(5, "0") +
" " + d.toString(2).padStart(5, "0") +
" " + d.toString().padStart(2, " "));
console.log();
}
</syntaxhighlight>
{{out}}
<pre>
decimal binary gray decoded
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
</pre>
=={{header|Ursala}}==
<
#import nat
Line 5,277 ⟶ 6,738:
#show+
test = mat` * 2-$'01'***K7xSS pad0*K7 <.~&,btog,gtob+ btog>* iota32</
{{out}}
<pre>
Line 5,314 ⟶ 6,775:
</pre>
=={{header|Verilog}}==
'''Function Based Approach:'''
<syntaxhighlight lang="verilog">
`timescale 1ns/10ps
`default_nettype wire
Line 5,431 ⟶ 6,826:
`default_nettype none
</syntaxhighlight>
'''Module Based Approach:'''
<syntaxhighlight lang="verilog">
`timescale 1ns/10ps
`default_nettype none
Line 5,480 ⟶ 6,875:
`default_nettype none
</syntaxhighlight>
=={{header|VHDL}}==
Combinatorial encoder:
<
USE ieee.std_logic_1164.all;
Line 5,497 ⟶ 6,892:
begin
gray <= bin(n) & ( bin(N-1 downto 0) xor bin(N downto 1));
end architecture rtl;</
Combinatorial decoder:
<
USE ieee.std_logic_1164.all;
Line 5,516 ⟶ 6,911:
bin(i) <= gray(i) xor bin(i+1);
end generate;
end architecture rtl;</
=={{header|V (Vlang)}}==
{{trans|Go}}
Binary reflected, as described in the task. Reading down through the solutions, the Euphoria decode algorithm caught my eye as being concise and easy to read.
<
return b ^ b>>1
}
Line 5,541 ⟶ 6,936:
println(" ${b:2} ${b:05b} ${g:05b} ${d:05b} ${d:2}")
}
}</
{{out}}
<pre>Same as Go.</pre>
Line 5,547 ⟶ 6,942:
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<
var toGray = Fn.new { |n| n ^ (n>>1) }
Line 5,566 ⟶ 6,961:
System.write(" %(Fmt.bz(5, g))")
System.print(" %(Fmt.bz(5, fromGray.call(g)))")
}</
{{out}}
Line 5,603 ⟶ 6,998:
30 11110 10001 11110
31 11111 10000 11111
</pre>
=={{header|XPL0}}==
<
func Gray2Bin(N); \Convert N from Gray code to binary
Line 5,713 ⟶ 7,036:
BinOut(Gray2Bin(G)); CrLf(0);
];
]</
{{out}}
Line 5,752 ⟶ 7,075:
=={{header|zkl}}==
<
fcn grayDecode(g){ b:=g; while(g/=2){ b=b.bitXor(g) } b }</
<
g:=grayEncode(n); b:=grayDecode(g);
println("%2d(%05.2B) --> %2d(%05.2B) --> %2d(%05.2B)".fmt(n,n,g,g,b,b));
}</
{{out}}
<pre style="overflow: auto; height: 20em;">
| |||