Talk:Gray code/Archive 1

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search

The following was at Gray_coding, and is moved here in case anyone wants to add some of it to the Gray_code article.


A gray code is a special coding system designed to prevent spurious output from practical electromechanical switches and is specifically relevant to encoding of position information for a rotating object. For example, if we create a device that indicates position by closing and opening switches, we could use the binary code to represent position:

Binary Code
Input position Output 3 Output 2 Output 1
0 0 0 0
1 0 0 1
2 0 1 0
3 0 1 1
4 1 0 0
5 1 0 1
6 1 1 0
7 1 1 1

The problem is that, with real (mechanical) switches, it is very unlikely that two switches will change states exactly in synchrony. For example, in the transistion from state 3 to state 4, all three switches change state. In the brief period while all are changing, the switches will read some spurious position.

A gray code solves this problem by changing only one switch at a time, so there is never any ambiguity of position:

Gray Code
Input position Output 3 Output 2 Output 1
0 0 0 0
1 0 0 1
2 0 1 1
3 0 1 0
4 1 1 0
5 1 1 1
6 1 0 1
7 1 0 0

Notice also that state seven can roll over to state zero with only one switch change.


I liked the less-technical introduction, so I copied it to the article.

I wish this article had a photo of an "encoder disk".

-- DavidCary 14:13, 12 Jun 2004 (UTC)

updates

Hi all, my first contribution to Wikipedia, hopefully it will go over well. I changed the example from a 4-bit BRGC to a 3-bit BRGC because it's a little bit simpler at first glance. I also added a lot of info about special types of Gray codes. Since this came from a paper I wrote, I added many of the references at the bottom that I used for the paper. I have some trivial C++ code to recursively generate an n-bit BRGC but I don't know if that would really be appropriate to attach to this. Thoughts? Rob 05:16, 6 Sep 2004 (UTC)

Real numbers?

Isn't it possible to give the real numbers a gray code representation? But the article only mentions integers. A5 18:42, 20 Apr 2005 (UTC)

Maybe....though I had never heard of doing it. I suppose you can define a Gray code sequence for non-binary numbers such that only one digit changes. Following the same method for generating binary Gray codes, for trinary:

(trinary Gray code moved to main article)

You can extend this to decimal if you wish. Hmm, maybe I'll add trinary to the article. Cburnett 19:03, Apr 20, 2005 (UTC)

This doesn't exactly answer the original question. You can have gray codes for other bases, but can you have one for the real numbers? The immediate answer seems to be no, since there's no such thing in the real numbers as two "successive" numbers. Deco 00:25, 21 Apr 2005 (UTC)
You can represent real numbers in Gray code....but to finite precision. The point of the above is that you can easily find a Gray code for base 10 so its just if you care about infinite precision. Cburnett 01:25, Apr 21, 2005 (UTC)
Gray codes are codes where neighbouring elements only differ in one symbol. On the real number line, there is no such thing as a neighbour - between any two numbers, there are infinitely many other numbers--Niels Ø 08:45, Apr 21, 2005 (UTC).

There are times when it is convenient to think of the bits from a sensor (whether it uses natural binary codes or gray codes) as bits of a binary fraction (i.e., a value from 0 to 1), rather than the bits of a binary integer.

Let's think about rotary encoders (like the one in the article) with 2, 3, 4, 5, 6, ... and N rings. (It doesn't matter what order the rings are in, so let's put the coarser rings nearer the center).

If you look carefully, the 7-ring encoder is just like the 8-ring coder with the 8th (outermost) ring filed off. The 6-ring encoder is just like the 7-ring encoder with the 7th (outermost) ring filed off.

If we represent these as fractional bits (rather than trying to make an integer out of them), it makes it easier to write software that can handle any kind of encoder (with any number of rings).

When encoder positions are represented as (fixed-point arithmetic) fractions such as

0.0100100111000000 and
0.0110110111000000

, software can find the angle between encoder position without needing to know exactly how many rings the encoder has. Then it is easy to upgrade to a more-precise encoder (more rings) or reduce cost by substituding a cheaper encoder (fewer rings), without changing any software.

When encoder positions are represented as integers such as

01001001110. and
01101101110.

, software needs to know exactly how many rings the encoder has, and usually needs to be re-compiled whenever the number of rings changes (which can be annoying).

Getting back to the original point: If you can give me a natural binary representation of a "real number", I can give you a (binary) Gray code representation of that number.

Does that answer the original question?

Is this something that should go into the article ?

--DavidCary 18:23, 14 May 2005 (UTC)

n-ary gray codes

Currently, two sections in the article deals with non-binary Gray codes. Both sections may have merit, so I guess they should be merged. --Niels Ø 08:24, Apr 21, 2005 (UTC)

Doh, I missed the n-ary section. Merged. Cburnett 16:28, Apr 21, 2005 (UTC)

Are n-ary gray codes actually *used* for anything, or are they only interesting to mathematicians? --DavidCary 05:37, 6 November 2005 (UTC)

An example: I'm generating a list of colours such that each colour is "nearby" to the next in RGB-space. If each coordinate can take n values, then an (n, 3)-Gray code is what I'm after. --Taejo|대조 13:21, 23 June 2007 (UTC)

Jos.koot 23:24, 23 November 2006 (UTC) : added a real working Scheme implementation of the algorithm together with an algorithm computing one single element of a Gray code and its inverse. In the pseudo algorithm the use of array n[k+1] is not needed and the arrays can be properly sized to k elements by halting when i grows out of range.

other applications of gray codes

Added some explanation on Gray Codes in Genetic Algorithms. -Shiri (a newbie)

am i correct in thinking

that a grey code cannot exist for a circular sequence with an odd number of values? Plugwash 01:43, 26 December 2005 (UTC)

Correct. This is evident because going from one number to the next toggles one bit. An odd number of toggles cannot produce the original value; at least one bit must be different. Non-circular sequences are possible, of course. Deco 02:13, 26 December 2005 (UTC)
What about the sequence (00, 01, 11, 10, 20, 21, 22, 12, 02)? --Pezezin 23:22, 30 June 2006 (UTC)
The argument applies to binary Gray codes only. For larger bases, the situation is different.--Niels Ø 09:31, 24 November 2006 (UTC)

A remark should be added that cyclic ternary gray codes do exists for every k. (I don't know about (n,k) codes with n>3) Examples: (2,3) : (000 200 210 010 110 112 212 012 022 222 122 102 202 002 001 101 201 211 111 011 021 121 221 220 020 120 100)

(2,4): (0000 1000 1200 0200 2200 2210 0210 1210 1010 0010 2010 2110 0110 1110 1112 2112 0112 0212 2212 1212 1012 2012 0012 0022 2022 1022 1222 2222 0222 0122 2122 1122 1102 2102 0102 0202 2202 1202 1002 2002 0002 0001 1001 2001 2101 1101 0101 0201 1201 2201 2211 1211 0211 0111 1111 2111 2011 1011 0011 0021 1021 2021 2121 1121 0121 0221 1221 2221 2220 0220 1220 1020 0020 2020 2120 0120 1120 1100 0100 2100 2000)

These circular ternary gray codes can easily be produced by

(define (circular-ternary-gray-code k)
 (let-values (((f t r) (values 0 1 2))) ; permutations of 0, 1 and 2 generate different gray codes
  (define (long h f t r)
   (if (positive? h)
    (let ((h (sub1 h)))
     (long h f t r)
     (move h f r t)
     (long h t f r)
     (move h r t f)
     (long h f t r))))
  (define (strt h f t r)
   (if (positive? h)
    (let ((h (sub1 h)))
     (strt h f r t)
     (move h f t r)
     (long h r t f))))
  (define (fini h f t r)
   (if (positive? h)
    (let ((h (sub1 h)))
     (long h f r t)
     (move h f t r) 
     (fini h r t f))))
  (define result ())
  (define pattern (make-vector k f))
  (define (move h f t r)
   (vector-set! pattern h t)
   (set! result (cons (vector->list pattern) result)))
  (if (positive? k)
   (let ((h (sub1 k)))
    (strt h f r t) 
    (move h f t r) 
    (long h r f t) 
    (move h t r f) 
    (long h f t r) 
    (move h r f t)
    (fini h t f r)))
  result))

Furthermore a O(k) algorithm exists for computing the i-th element of the gray codes produced by the above algorithm. The inverse exists too, i.e. a function that accepts a gray code and returns the i telling which element it is. In fact the ternary gray codes produced by the above algorithm show how to move a tower of hanoi Tower of hanoi from one peg back onto the same peg while passing every feasible distribution of disks exactly once (circular Hamilton path)

Jos.koot 13:40, 29 November 2006 (UTC)

Single-Track Gray Codes

It's the inner two tracks of Figure 1 that are the same except for an angular offset, and the inner track supplies the most significant bit. I have changed the text to correspond. It seems an unlikely error, though - has the figure been changed?

I made the same changes in the rotary encoder article.

       - Jim Van Zandt

Are those programming examples really necessary?

If you think it would help, I could provide some alternative versions in Javascript, BASIC, FORTRAN and Z80 opcodes. We could even go the whole hog and and merge this page with the list of hello world programs. What do you reckon? -- Sakurambo 22:06, 17 May 2006 (UTC)

Assuming you're being sarcastic, people have a bizarre tendency to add implementations in their favourite language to articles. Just cut out the ones you don't like. Deco 23:28, 30 June 2006 (UTC)
The proposed languages are not bizarre enough for the bizarre tendency! If you can write it for Atanasoff-Berry Computer or at least in assembler for PDP-8/System360, it would be another story :-) Beyond the joke, I would say that all those implementations are subject to WikiBooks and should be moved there (leaving just a link here). -- Goldie (tell me) 20:49, 5 September 2006 (UTC)
Or for my wiki, LiteratePrograms. </plug> :-) Deco 13:01, 20 November 2006 (UTC)

Gray code is not invented by Frank Gray

Frank Gray have not been born when the reflective binary code was invented. I do not know who have invented it either but the code was already in use in the mid-XIX century. In the Gray's patent it is clearly stated that he is claiming only the receiver and the implemented method for translation.

Elisha Gray does have some good chances to be the first who have put the code in an electrical aparatus but anyone's "invention" will have to be proved. I have no enough time to fix the name across the whole article. -- Goldie (tell me) 21:39, 5 September 2006 (UTC)

There is no evidence to connect Elisha Gray to the Gray code, but several gray-code-like patterns and devices do pre-date Frank Gray's patent, according to the study by Don Knuth. Dicklyon 23:30, 23 November 2006 (UTC)

Code Bug

The following code can become an infinite loop:

In the programming language C, a conversion from a Gray code g to an unsigned binary representation b can be achieved efficiently through:

 b = g;
 while (g >>= 1) {b ^= g;}

INTERNATIONAL STANDARD ISO/IEC 9899, Programming languages — C

6.5.7 Bitwise shift operators

4 The result of E1 << E2 is E1 left-shifted E2 bit positions; vacated bits are filled with zeros. If E1 has an unsigned type, the value of the result is E1 ´ 2E2, reduced modulo one more than the maximum value representable in the result type. If E1 has a signed type and nonnegative value, and E1 ´ 2E2 is representable in the result type, then that is the resulting value; otherwise, the behavior is undefined.

5 The result of E1 >> E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type or if E1 has a signed type and a nonnegative value, the value of the result is the integral part of the quotient of E1 / 2E2. If E1 has a signed type and a negative value, the resulting value is implementation-defined. —The preceding unsigned comment was added by Crm123 (talkcontribs) 17:24, 7 May 2007 (UTC).

gray code toy worth a mention?

The Brain Puzzler [1] was a mechanical toy produced in the 1970s or early 80s. The solution to the puzzle was a RBGC. Worth a link from the article? 216.220.208.238 16:24, 15 December 2006 (UTC)

The "Tower of hanoi" external link is dead (404).

Single track Gray code image

I've added an image to the section, corresponding with the table, but I'm too lazy to write a caption. Shinobu 11:14, 17 May 2007 (UTC)

Is that the image that the text in that section is calling "Figure 1"? Rather than refer to the figure, the figure needs a caption that calls to the reference.

No, figure 1 refers to the normal rotary encoder. Shinobu 08:39, 11 June 2007 (UTC)

haskell code?

Quoting the article :

(The base case can also be thought of as a single zero-bit Gray code (n=0, G = { " " }) which is made into the one-bit code by the recursive process, as demonstrated in the Haskell example below).

I don't see any haskell code in the article. Anyone does? Stdazi (talk) 09:06, 18 August 2008 (UTC)

  • I have added some Haskell code, if someone thinks that this code is in wrong place, cut and paste as is to move it.

I had some problems to format this code, because wiki translated lists to links. The style is very simple, because I take into account that imperative languages programers are not familiar with recursive definitions, much more less with higher order functions. But, I used map, a higher order function, if you think it obscures the program, change transpose to:

transpose :: [ anytype_t ] -> [ anytype_t ]
transpose [] = []
transpose ([]:xss) = []
transpose ((x:xs):xss)=
      (heads ((x:xs):xss)):(transpose (tails ((x:xs):xss)))
  where heads [] = []
        heads (x:xs) = (head x):(heads xs)
        tails [] = [] 
        tails (x:xs) = (tail x):(tails xs)

or let them search more about haskell and map in Wikipedia :) —Preceding unsigned comment added by Elias (talkcontribs) 04:30, 3 January 2009 (UTC)

Algorithm correct?

A test using Java with grayN(21, 3, 3) gives me: {-1,2,2}

Obviously that is not correct!

Using this code:

    static int[] grayN(int value, int base, int digits)
    {
        // parameters: value, base, digits
        // Convert a value to a graycode with the given base and digits. Iterating
        // through a sequence of values would result in a sequence of graycodes in
        // which only one digit changes at a time.

        int baseN[] = new int[digits];  // Stores the ordinary base-N number, one digit per entry
        int gray[] = new int[digits];   // Stores the base-N graycode number

        int i;
        // Put the normal baseN number into the baseN array. For base 10, 109
        // would be stored as [9,0,1]
        for (i = 0; i < digits; i++)
        {
            baseN[i] = (value / (int) Math.pow(base, i)) % base;
        }

        // Convert the normal baseN number into the graycode equivalent. Note that
        // the loop starts at the most significant digit and goes down.
        int shift = 0;
        for (i = digits - 1; i >= 0; i--)
        {
            // The gray digit gets shifted down equal to the sum of the higher
            // digits.
            gray[i] = (baseN[i] + base - shift) % base;  // + base to prevent neg
            shift += gray[i];
        }

        return gray;
    }

Is my code wrong, or is there a bug in the algorithm shown on the article?  —CobraA1 01:15, 13 February 2009 (UTC)

The C code is wrong in some senses. First, the first loop gets the digits in the reverse order to the stated one; the comment is right as is your code, but the C code does it wrong. Second, just adding base does not avoid negatives. Third, it does not declare the loop variable. I'm fixing all these issues, but ultimately I think this fragment should be replaced by pseudocode or a description. --pgimeno (talk) 16:21, 7 August 2009 (UTC)

Code snippets

Why so many code snippets? Most of them are not even particularly intelligible. I bet if we wanted clarity and precision, then matlab code would beat them all. Any opinions? Dicklyon 06:58, 10 December 2006 (UTC)

For example, compare this to the others to convert binary B to Gray G:

 G = bitxor(B, bitshift(B, -1));

The other direction probably requires a loop and more bit twiddling, though. Dicklyon 07:11, 10 December 2006 (UTC)

OK, even though I wasn't kidding, I take it back. Reading the talk above, I took the suggestion and removed the ones I didn't like, which was all of them. Pseudocode is enough, since the details of the others only obscure the point, except for programmers who know the language; and they don't need it. Dicklyon 07:21, 10 December 2006 (UTC)

I am totally in favour of this. Gray codes are generally used in electronic hardware, so personally I don't see the need for any software examples at all. -- Sakurambo 桜ん坊 11:25, 10 December 2006 (UTC)
Well, now that hardware is usually designed by writing Verilog code, code is the lingua-franca of algorithms, so we really out to have something. But showing off programming language features and syntax is not the point. Dicklyon 17:31, 10 December 2006 (UTC)
I would like to add here that LISP is one of those languages famous for being unreadable to someone unfamiliar with it. Pseudocode? Better formatting? I'll leave it to you all, but as it stands I didn't find the snippets very illuminating. Shinobu 11:37, 17 May 2007 (UTC)

Would it be okay to bring back one pseudo-code (or C-like language) example for encoding, and one example for decoding? I actually came back to this page looking for them, since it is useful sometimes for encoding integers in genetic algorithms. I do agree that previously there were too many, and it was messy, but I think a single snippet for each of encoding/decoding would be nice. Fstonedahl (talk) 20:52, 11 January 2009 (UTC)

The useful 'C-like' language for a web page is JavaScript. There could be code snippets which actually demonstrate something in the browser: an edit box to a text output, for example. —Preceding unsigned comment added by 81.108.210.118 (talk) 09:31, 8 October 2009 (UTC)

Iterative construction

I came to this page looking for the information below, and didn't find it, so I added it in the section Constructing an n-bit gray code. I don't think I explained it brilliantly though, so I'd appreciate improvements.

To construct the binary-reflected Gray code iteratively, start with the code 0, and at step i find the bit position of the least significant '1' in the binary representation of i - flip the bit at that position in the previous code to get the next code. The bit positions start 0, 1, 0, 2, 0, 1, 0, 3, ... (sequence A007814 in the OEIS).

Motivation: I'm writing code that needs to traverse all 2edges possible graphs of n nodes, and easiest is to change one edge at a time from the previous graph. Hv (talk) 12:12, 2 January 2010 (UTC)

another example

http://blog.plover.com/2009/06/21/ (maybe this is worth adding it) —Preceding unsigned comment added by 91.37.9.19 (talk) 23:51, 21 June 2009 (UTC)

The conversion methods in the last couple of lines are interesting, but the small error described in the bulk of the article is chance: the height happened to occur where the least significant bit changed; if it had occurred where the most significant bit changed the reading could be very inacurate! —Preceding unsigned comment added by 81.108.210.118 (talk) 09:43, 8 October 2009 (UTC)

You are completely wrong. The whole point of gray code is that there isn't a "most significant" bit. —Dominus (talk) 12:44, 3 January 2010 (UTC)

Examples please

Snakes and coils - in the Snake-in-the-box codes section - sound interesting - but what do they look like? Not every reader capable of understanding the description has the chops to actually construct something from an abstract definition. If anyone could add an example or two of each of these objects, it would communicate the notions involved much better. Simple folk like me need plenty of concrete examples to wrap my head around. ;-) yoyo (talk) 10:07, 9 June 2010 (UTC)

Iterative construction cleanup.

Some proposed wording: Informally, to construct a Gray code on n bits from one on n - 1 bits, take the previous Gray code and list the elements first in order, then in reverse order. Prepend a 0 to the elements that are listed in order, and a 1 to the elements that are listed in reverse order.

Somewhat more formally, let Gn be the canonical Gray code on n bits, let Gn(k) be the k-th entry in the code, where 0 ≤ k < 2n, and let #Gn(k) be the k-th entry of the code preceded by # (where # is either 1 or 0). The following constructs the canonical Gray code on n bits:

G1 = (0, 1).

If n > 1, then:

  • If 0 ≤ k ≤ 2n - 1 - 1, then Gn(k)=0Gn - 1(k).
  • If 2n - 1k ≤ 2n - 1, then Gn(k)=1Gn-1(2n - (k + 1)).

So G2(0) = 0G1(0) = 00. Similarly, G2(1) = 0G1(1) = 01.

How does this sound? --147.26.161.144 (talk) 20:51, 18 July 2010 (UTC)

The first paragraph is OK. The subsequent formalism doesn't contribute much: harder to understand and less helpful than the current text. The [01]G(n) notation feels sort of ad hoc. The example could be more illustrative (e.g., pick one of the values from the reversed sequence). (I am, of course, not exactly a disinterested party!) -- Elphion (talk) 16:53, 19 July 2010 (UTC)
My use of the phrase "iterative construction" was intended to convey the concept of "determining the next value from the previous one". Your proposal however looks to be a rewrite of the presentation of the recursive algorithm at the start of the Constructing an n-bit Gray code section, which already seems to me quite adequate as it stands. What issue are you aiming to address with this? Hv (talk) 09:22, 21 July 2010 (UTC)

Connection to symbolic dynamics

I'd like to hint at a connection with Symbolic dynamics, specifically the Tent map. A sort of Gray code of real numbers is constructed as follows. Let be the Tent map with slope 2 and be a set of symbols. Define an address map by letting whenever , only for and otherwise. Then the infinite Gray code of is given as the sequence . This sequence is an element of the so-called Shift space . Now, for an integer with consider the real number . Then the m-digit Gray code of is the first m digits of the sequence defined above. 80.1.165.108 (talk) 01:04, 26 March 2011 (UTC) O. Klinke, University of Birmingham, UK

Incorrect link to Chain code?

In Gray code#Single-track Gray code, there is "(compared to chain codes, also called De Bruijn sequences)". But the chain codes described at that article are for compressing monochrome images and seem unrelated to De Bruijn sequences. There's also a reference to “code chains”. Could someone more familiar with this material correct these links or add explanation of how they're related? — Unbitwise (talk) 21:03, 22 June 2011 (UTC)

Vietnamese-rings puzzle?

The binary-reflected Gray code can also be used to serve as a solution guide for the Tower of Hanoi problem, as well a classical Vietnamese-rings puzzle and a sequential mechanical puzzle mechanism. Apart from the unclear syntax ("as well a" = as well as for a?), what is a classical Vietnamese-rings puzzle? Some variant of the Chinese rings puzzle?--85.75.178.41 (talk) 11:27, 23 June 2011 (UTC)

Irrelevant reference?

The reference "Venn Diagram Survey — Symmetric Diagrams" for the sentence "Note that each column is a cyclic shift of the first column, and from any row to the next row only one bit changes." in the Single-track Gray code section makes no sense to me in relation to that sentence. I'm not familiar with Venn Diagrams, but as far as I can tell the reference doesn't relate in any way to the subject. Am I correct? If not, what is the relation? -- Sjock (talk) 20:32, 28 September 2011 (UTC)

Simple conversion to binary

I read this page for a class assignment and noticed that most algorithms were in needlessly complicated code form. I found that the slides on this website did a much better job at explaining how to convert between binary and Gray. Therefore I propose to add an example (sub)section which basically reads something like this: assume you have a Gray code (X3,X2,X1,X0) = 1010 and would like to convert it to binary(Y3,Y2,Y1,Y0), then Y3 = X3 and Y2 = X2 XOR Y3, Y1 = X1 XOR Y2 ... Y[n] = X[n] XOR Y[n+1] ==> Y1,Y2,Y3,Y4 = 1100. Likewise, to go from binary to Gray, X3 = Y3, X2 = Y3 XOR Y2... I admit, I do not know the rules of WP very well and this is the first time editing anything other than typos, but would anyone have any problems with this addition? — Preceding unsigned comment added by 98.249.63.58 (talk) 02:32, 3 October 2011 (UTC)

Looks like a reliable source, and I don't see an equivalently simple method in the article, so it looks like it might be a good addition. Dicklyon (talk) 05:14, 3 October 2011 (UTC)
The last few paragraphs of the construction section already say this. I agree it could be said more clearly. The bit-by-bit formulas already present should be incorporated into any new discussion. It would help to relate the two conversions more clearly to the preceding theoretical construction (which makes clear that Gray codes have the properties they do). -- Elphion (talk) 13:51, 3 October 2011 (UTC)

Ternary Gray Code

The section explains that other gray codes exist but would benefit from at least one example. Since the given algorithm is cyclic, perhaps a reflected version would help make the point. Is this a viable alternative?:

 0 -> 000
 1 -> 001
 2 -> 002
 10 -> 012
 11 -> 011
 12 -> 010
 20 -> 020
 21 -> 021
 22 -> 022
100 -> 122
101 -> 121
102 -> 120
110 -> 110
111 -> 111
112 -> 112
120 -> 102
121 -> 101
122 -> 100
200 -> 200
201 -> 201
202 -> 202
210 -> 212
211 -> 211
212 -> 210
220 -> 220
221 -> 221
222 -> 222

81.108.210.118 (talk) 11:06, 9 October 2009 (UTC)

I first had the same idea: on each digit position, alternate 0,1,2,2,1,0 (like the binary sequence 0,1,1,0). But because 3 is not a multiple of 2, the code can NOT be cyclic this way: 22 is too far from 00, 222 is too far from 000, etc. Teuxe (talk) 16:31, 20 January 2012 (UTC)

Anti-Gray Codes?

Is there a code where the bit patterns of successive elements differ from each other by a maximal, rather than minimal, number of bits?

The problem with Gray codes for positional measurements is that you're vulnerable to misreads: if you get some birdshit on one of your black blobs and it goes white, for instance, if it's the bit that differs between that position and one of its neighbours, you can no longer detect that transition. Ditto if your photocell is flaky or something. With an anti-Gray code, you have multiple bits changing at every transition, so you're much more likely to detect it. If you have a shitty photocell or a shitted-on mark, you won't get the pattern you expected, but you will get a transition to an unexpected state - at which point you declare an error condition, call the repairman or cleaner, and either stop or or take a gamble on being where you think you should be, and hope the next transition works out.

Kind of like 8b/10b encoding if you think about it in precisely the wrong way.

-- Tom Anderson 2007-09-19 2330 +0100 —Preceding unsigned comment added by 128.40.81.22 (talk) 22:31, 19 September 2007 (UTC)

If you consider the recursive method for Gray Code construction, one solution to creating "Anti-Gray Codes" is to add 01010101... instead of 00000...11111... to the code at every step. E.g.: (0, 1), (00, 11, 01, 10), (000, 111, 001, 110, 010, 101, 011, 100)... this creates a large distance between adjacent codes, but not necessarily between further codes.72.231.157.16 (talk) 05:27, 18 April 2009 (UTC)

While that does create some distance you'll notice that many of your generated numbers share several bits from the 4th place on. 110,010 is a hamming distance of 1. Optimally anti-gray code for a set of three binary numbers will always alternate between hamming distances of 2 and 3. 000,111,001,110,101,010,100,011 you'll note is better having hamming distances of 3,2,3,2,3,2,3. Tat (talk) 23:17, 17 August 2012 (UTC)


Took me a while to figure it out, I needed one too. Take any gray code. Shift all the bits to the left by 1. Double the list. And alternate XOR flips. Done. You have an anti-gray code.

Take gray code. 0 1

Shift all the bits to the left by 1. 00 10

Double the list. 00 00 10 10

Alternate XOR flips. 00 11 10 01

The reason this works is because gray codes by definition have the minimal amount of distance. Xor flips have the maximum (they flip every bit). If you interweave them you will have maximum, maximum -1, maximum, maximum -1, maximum, maximum -1... which is an optimal anti-gray code. Also note, you don't really *need* to shift the bits to the left. You can introduce a zero *anywhere*, so long as you do it consistently. Watch, I'll do it with the middle digit.

    00,01,11,10

-> 000,001,101,100 -> 000,000,001,001,101,101,100,100 -> 000,111,001,110,101,010,100,011 (perfect anti-grey code).

Fast conversion to binary

This is an implementation of n.log(n) conversion in C designed to be independent of the type width.

unsigned short grayToBinary(unsigned short num)
{
        unsigned short shift, mask;
        for(shift=1; mask=num>>shift-1>>1; shift<<=1)
                num ^= mask;
        return num;
}

Is it worth of replacing the current example? --egg 22:11, 3 November 2011 (UTC)

Am I dense, or is the expression num>>shift-1>>1 nonsensical? And why don't you put some spaces around binary operators, and maybe some courtesy parens, to give us a clue what it means? I expect it means (num >> (shift - 1)) >> 1, but it's unclear to me how that differs from num >> shift; sorry I'm not more familiar with c semantics. And it's not clear when/why this loop terminates; for 16-bit shorts, you'd want shift values of 1, 2, 4, 8, but it goes on through 16, 32, 64, ... 32768, doesn't it? Dicklyon (talk) 05:54, 4 November 2011 (UTC)
Plus I'm dense. I see why I misinterpreted now. Dicklyon (talk) 15:54, 4 November 2011 (UTC)

The expression essentially means num>>shift but the >> operator has undefined behaviour for shifts longer or equal to the width of type, which is the case we need to stop the loop. This might be a more readable version of the same algorithm:

unsigned short grayToBinary(unsigned short num)
{
        unsigned short shift;
        for(shift=1; shift<8*sizeof(num); shift*=2)
                num ^= num>>shift;
        return num;
}

Both versions work well. BTW, why do we use the short type instead of the common unsigned int?.. --egg 13:20, 4 November 2011 (UTC)

The second example is far superior to the first. (The first completely obscures the principle being illustrated.) Applying the principle of self-documenting code, how about:

unsigned short grayToBinary(unsigned short num)
{
        unsigned short shift;
        unsigned short numBits = 8 * sizeof(num);
        for(shift=1; shift<numBits; shift*=2) {
                num ^= num>>shift;
        }
        return num;
}

A final version should include something like the documentation in the example in the article. It's probably worth a comment that the algorithm assumes that the bitwidth of the argument is a power of 2. (I've worked on machines where that's not true.) Why "unsigned short"? That's the likely domain of discourse. ints are probably overkill, though the additional execution cost wouldn't amount to much. In C++ you might accommodate both with templates. -- Elphion (talk) 15:10, 4 November 2011 (UTC)

Yes, much better. I'd style it nicer and use int though: Dicklyon (talk) 15:54, 4 November 2011 (UTC)
unsigned int grayToBinary(unsigned int num)
{
    unsigned int numBits = 8 * sizeof(num);
    unsigned int shift;
    for (shift = 1; shift < numBits; shift *= 2)
    {
        num ^= num >> shift;
    }
    return num;
}

Correction

As user:Mikron30 has pointed out, this version does not work: it converts 12 to 9 rather than to the correct value (8). The problem is that num should be XORed with the shift of its original value, not of its current value, as follows:

unsigned int grayToBinary(unsigned int num)
{
    unsigned int numBits = 8 * sizeof(num);
    unsigned int shift;
    unsigned int mask = num;
    for (shift = 1; shift < numBits; shift *= 2)
    {
        num ^= mask >> shift;
    }
    return num;
}

Since in this case mask will always shift eventually to 0, it suffices to loop while mask is non-zero. Counting the bits is not necessary. I've updated the algorithm in the article accordingly.

-- Elphion (talk) 06:49, 15 April 2013 (UTC)

How many Gray codes are there?

I was asked recently how many distinct binary Gray codes there are are n bits. Given the canonical Gray code on n bits, you can easily create (2^n)*n! Gray codes by choosing any of the 2^n vertices as starting points, and permuting the columns of bitflips. Example, if the bits are numbered from right to left as this: 4 3 2 1, then the Gray code on 4 bits is made by flipping the following positions in order: 1 2 1 3 1 2 1 4 1 2 1 3 1 2 1. Now this can be permuted by anything in S4, so for any of the 16 starting points, there are 24 Gray codes. Does this hit all possible ones? If so, they are all isomorphic to the canonical one, and the formula is nice. If not, then the problem is more interesting. --147.26.161.144 (talk) 20:23, 18 July 2010 (UTC)

There are many more because the ones you described are “only” those for one specific transition-sequence. The section types of Gray codes describes many more possible sequences. Every single one of those has, again, different code-representations. — Preceding unsigned comment added by 91.112.63.30 (talk) 12:46, 24 June 2013 (UTC)

Gillham code

I have been searching and searching for hours and did not find any theory behind Gillham code which is another type of Gray code. Gillham code is used in aviation altitude encoders/ transponders. I would really appreciate if someone could post some info on Gillham code, conversion algorithm, etc... —Preceding unsigned comment added by Myval (talkcontribs) 07:29, 25 September 2008 (UTC)

I agree that this "Gray code" article should at least mention Gillham code. But now that we have a Gillham code article, that article would be a better place for details about it. --DavidCary (talk) 17:53, 25 June 2013 (UTC)
I would also like to see a reference to Gillham code and to its application in aviation, as this is IMHO one of the most important applications of a type of Gray code - Sswitcher (talk) 08:21, 16 June 2014 (UTC)

PCM tube?

Should PCM tube reference Pulse Code Modulation or the subsection on that page? — Preceding unsigned comment added by 59.167.182.149 (talk) 03:09, 13 December 2014 (UTC)

Yes; but what subsection do you have in mind? Dicklyon (talk) 03:45, 13 December 2014 (UTC)

Baudot code, one of the first use of Gray code

In article page, Baudot code might be given as historically it was one of the first use of gray code, has shown by next illustration:

Illustration: Baudot code

Let ·Fig. · V · IV·   · I · II·III·
----+-----+---+---+---+---+---+---+
 A  · 1   ·   ·   ·   · ● ·   ·   ·    
É / · 1/  ·   ·   ·   · ● · ● ·   ·    
 E  · 2   ·   ·   ·   ·   · ● ·   ·    
 I  · 3/  ·   ·   ·   ·   · ● · ● ·    
 O  · 5   ·   ·   ·   · ● · ● · ● ·    
 U  · 4   ·   ·   ·   · ● ·   · ● ·    
 Y  · 3   ·   ·   ·   ·   ·   · ● ·    
 
 B  · 8   ·   · ● ·   ·   ·   · ● ·    
 C  · 9   ·   · ● ·   · ● ·   · ● ·    
 D  · 0   ·   · ● ·   · ● · ● · ● ·    
 F  · 5/  ·   · ● ·   ·   · ● · ● ·    
 G  · 7   ·   · ● ·   ·   · ● ·   ·    
 H  · ¹   ·   · ● ·   · ● · ● ·   ·    
 J  · 6   ·   · ● ·   · ● ·   ·   ·    
 Fig. Bl. ·   · ● ·   ·   ·   ·   ·    
 *  · *   · ● · ● ·   ·   ·   · 
 K  · (   · ● · ● ·   · ● ·   · 
 L  · =   · ● · ● ·   · ● · ● · 
 M  · )   · ● · ● ·   ·   · ● · 
 N  · £   · ● · ● ·   ·   · ● · ●
 P  · +   · ● · ● ·   · ● · ● · ●
 Q  · /   · ● · ● ·   · ● ·   · ●
 R  · –   · ● · ● ·   ·   ·   · ●
 S  · 7/  · ● ·   ·   ·   ·   · ●
 T  · ²   · ● ·   ·   · ● ·   · ●
 V  · ¹   · ● ·   ·   · ● · ● · ●
 W  ·  ?  · ● ·   ·   ·   · ● · ●
 X  · 9/  · ● ·   ·   ·   · ● · 
 Z  ·  :  · ● ·   ·   · ● · ● · 
 –  · .   · ● ·   ·   · ● ·   · 
 Let. Bl. · ● ·   ·   ·   ·   ·   ·  

— Preceding unsigned comment added by 86.67.203.56 (talk) 15:47, 29 June 2014 (UTC)

  • Comment. I am lost here. Baudot may have used a Gray code for the character assignments, but there does not seem to be any advantage in what is an arbitrary assignment. Where is the encoder-style problem? If I need to send a Q, then being off by 1 bit is an error. I'd remove the reference to Baudot being a Gray code. Glrx (talk) 00:57, 4 July 2014 (UTC)
Here I found a description on how the Baudot system was working:
original version english version
Le combinateur qui est la cheville ouvrière du système se compose de cinq disques à rayon tantôt métallique tantôt isolant, sur lesquels se meut un frotteur, armé de cinq ressorts, qui tourne synchroniquement (...).

Les armatures (...) forment (...) une genre de commutateur d'un genre particulier qui ouvre une issue au courant local chargé de produire l'impression, au moment précis où la caractère transmis passe en regard du papier.[1]

The combinateur which is the main working part of the system is made of five disks à rayon one time metallic, one time non metallic, on which move a frotteur, armed with five ressorts, which turn simultaneously (...).

The armatures (...) makes (...) some kind of commutateur from a new specific kind which open one way to local electricity which role is to produce the printing, at the accurate time when the transmitted character is in regard (in front) of the paper.

From my understanding, if you use a code different of the gray one, you might encounter some intermediate values while the disk is turning between two characters which might print something you do not want? — Preceding unsigned comment added by 77.199.96.122 (talk) 23:08, 6 September 2016 (UTC)
Baudot's equipment did not have transition problems because it was synchronous. The operator would hear a click and then press the next code chord. The keys would lock down until the commutator released them. The character assignments are essentially arbitrary, but Baudot apparently made some effort to minimize operator fatigue: vowels did not use the left hand keys.
For Wikipedia's purpose, we would need a reliable reference that says Baudot was a Gray code. I doubt there is such a reference. Baudot was not trying to solve the measurement uncertainty issue, so it seems that Baudot may have done a gray-like sequencing, but that may be because he did not think of a binary code assignment. Also, the gray sequence above had to insert the FIGS shift in the middle of the consonants and the digits are not in numerical order. Some assignments look simple and obvious: the infrequent FIGS and LTRS codes are one left finger assignments with repeats in that shift block being blank.
Glrx (talk) 18:31, 11 September 2016 (UTC)

References

  1. ^ cnum.cnam.fr/CGI/fpage.cgi?8XAE277-11.2/35/100/74/0/0

Gray code code example changes

Please look again at my edit to the Gray code article, which you undid. My provided code re-write still makes use of doubling the shift at each step, just like the replaced code. I think that is the point you refer to in your edit comment. My edit just reverses the order of the XORs, which is legitimate, and puts them in a loop that self-detects when it can stop. Thank you -- 64.132.59.226 (talk) 16:28, 14 September 2017 (UTC)

Read the edit summary, "rv - missing the point of that whole example."
Your change is both unencyclopedic, and it misses the point of that whole example. This is not a coding cookbook of examples, it's not a coding tutorial. We're not looking for good coding here, we're looking for good explanations of Gray code itself. The version without the explicit stated shifts is much clearer for that. There's also a loop-based example immediately preceding it. Andy Dingley (talk) 16:41, 14 September 2017 (UTC)
Thank you for clarifying which point you are making. However, since your note is brief, I am not completely sure that you understand the point I am making. At the risk of repeating something that is already obvious to you ... my point is that the grayToBinary example uses a loop that shifts one position at time. The grayToBinary32 example (both as originally and as I have edited it) instead doubles the shift each time. To me, that is the defining difference between these two examples, rather than that one is a loop and that the other is an unrolled loop. Unfortunately, the existing grayToBinary32 has a shortfall, in that it assumes sizeof(unsigned int) == 4, which can silently change if code is moved from one computer to another. It was my hope to repair that shortfall. Can you think of an approach that repairs the shortfall while maintaining the clarity you hope to see? Thank you for entertaining my questions and considering my perspective. 64.132.59.226 (talk) 17:04, 14 September 2017 (UTC)
This is not a coding tutorial. This is an explanation of Gray code. It needs to be the clearest explanation of Gray code that is can be, not the most optimised (for size or run time) code fragment. That alone is reason to keep the original example.
Secondly, this is a Gray code. I've never seen a 32 bit Gray code. I cannot imagine a use for a 32 bit Gray code, at least not out in the physical world of encoders. I once had a very expensive problem where a machine had been fitted with a 7 bit Gray code encoder when it needed a 9 bit encoder. We couldn't afford this (we could, but I was told we couldn't, after wasting far more chasing the problem of using a 7 bit code) and I had to make it work with a 8 bit encoder instead. Now imagine how impossible it would be to rule a grating for a 32 bit Gray code! Two billion increments! Andy Dingley (talk) 17:21, 14 September 2017 (UTC)
I fear that this discussion will not resolve with agreement. Nonetheless, I wish to note some counterarguments. The one-shift-at-a-time grayToBinary example is not an unrolled loop; do you consider it to be in need of clarification / unrolling, or is it only the doubling-shift approach that needs to remain unrolled? If so, why? Second, people may have a need to convert to a Gray code and back even in situations where they are not enumerating all 232 or larger possibilities. Suppose I want to know the 10100-th position for the 500-level Towers of Hanoi puzzle? Thank you for your time and energy. 64.132.59.226 (talk) 17:34, 14 September 2017 (UTC)
I modified the comment in the code instead of the code itself. I am hopeful that this is an acceptable compromise. 64.132.59.226 (talk) 13:10, 15 September 2017 (UTC)
I reverted. There should be a clear point to make. Glrx (talk) 03:46, 20 September 2017 (UTC)
I fixed the edit to address the submission comment that the focus should be the algorithm not the code. 64.132.59.226 (talk) 13:23, 26 September 2017 (UTC)
By "fixed" you mean "yet again re-inserted a change that others are clearly against". Andy Dingley (talk) 15:18, 26 September 2017 (UTC)
@Andy Dingley: I am attempting to find a compromise solution that addresses everyone's priorities. If I have failed, I ask you to please try for a compromise yourself. Straight out reverts are less useful in conveying your priorities, but if you feel that that is your best course of action then I understand, and I will try again. 64.132.59.226 (talk) 11:57, 27 September 2017 (UTC)
You need to get consensus on this talk page before you reinsert your edits. Do not continually "try again". Propose the change on the talk page and get consensus for it. WP is interested in algorithms. Adding comments about the potential limitations of shift instructions is about programming detail rather than the algorithm. Glrx (talk) 01:59, 28 September 2017 (UTC)
Yes, please let's try for consensus. Please express your degree of support for the following statements:
  1. As I would characterize it, the fast algorithm for converting a gray code to a number is to use a sequence of exclusive-ors with shifts of the previous intermediate results, and the specification of the algorithm necessarily describes how many of these operations are required.
  2. The current version of the code assumes 32-bit unsigned integers, which I would characterize as a coding assumption, not an algorithm essential.
  3. For reasons of efficiency, we may not want to change the code itself, but we can discuss the removal of the 32-bit coding assumption with a few words in the code comment.
64.132.59.226 (talk) 16:02, 28 September 2017 (UTC)
It has been a week of discussion and there have been no dissenters. A consensus of one is a consensus, but it is pretty weak. Please post your pros and cons. If you can envision an approach that you believe addresses everyone's priorities, please suggest it! 64.132.59.226 (talk) 11:55, 5 October 2017 (UTC)
"there have been no dissenters"
Rubbish. This is getting to the point of WP:TENDENTIOUS Andy Dingley (talk) 12:26, 5 October 2017 (UTC)
Thank you for your correction. I should have said that no one spoke up during the week. Previous to then there were dissenters. I stand corrected.
However, some of that previous dissent was of the form "What's the point?", which was not useful in arriving at consensus. There is currently a disagreement as to whether specifying when the code/algorithm terminates is a coding detail or an essential part of the algorithm. That is the topic for which I have seen no discussion. Please, please address this issue. 64.132.59.226 (talk) 15:47, 5 October 2017 (UTC)
No. You are the one trying to advocate a change. You have to make a case as to why that is a concrete improvement. If you cannot, or if you can only make "change for change sake", then you don't get to make it. Nor can you play "keep at it for longer than anyone else can be bothered". Your editing on other articles, such as United States customary units are based equally on edit-warring against other editors. Andy Dingley (talk) 16:03, 5 October 2017 (UTC)

─────────────────────────

There were no concrete proposals to edit the page; the three statements were general. I do not see that any response was required. Furthermore, 64.132 has not achieved consensus before; trying to wear down the opposition is not a good tactic. Moreover, consensus is not compromise. Editorial decisions are not trying to make everybody happy. "There is currently a disagreement as to whether specifying when the code/algorithm terminates is a coding detail or an essential part of the algorithm" completely misstates the disagreement. There is no doubt that grayToBinary32 terminates. There is no doubt that it is restricted to codes that are 32 bits or less. As Andy stated, most Gray code applications will be fewer than 16 bits. Glrx (talk) 20:03, 5 October 2017 (UTC)
A downside of using an IP address is that it changes when I move to a different location. To head off any accusations of sock puppetry, I hereby report that I am one and the same as 64.132.59.226.
Thank you, @Glrx for discussing the merits of the changes to the article. I acknowledge that you do not like the way I have formulated the disagreement and I will try to work with your formulation. I am not expert at quantifying how many people would want a Gray code of more than 32 bits for some purpose. However, I am hopeful that we would agree that it is an easy win to support such larger Gray codes if it outweighs any downside. I hope that I am remaining consistent with your formulation if I make a concrete proposal with the intent to minimize such a downside.
I would accommodate these large Gray codes with a few words in the comment without changing the program itself. I would not modify the existing sentence in the comment. I propose a new second sentence, "For Gray codes of N > 32 bits, have the bit shift amounts be the powers of two with value strictly less than N". I see this as minimally impacting the existing strong points of the present article. I see it as a fundamental truism of the algorithm, independent of coding decisions such as C vs. Java vs. Python. As a bonus, it promotes independence from code-dependent values such as sizeof(some type). 74.76.180.38 (talk) 20:05, 6 October 2017 (UTC)
@Glrx, I see you that reverted my edit with the comment "not cleared on talk page". However, the talk page shows nothing but silence on this topic from anyone but me since 5 October 2017. It is this silence that encouraged me to invoke WP:BRD, and the correct response when reverting my WP:BRD edit is not to cite the silence, but to break the silence. Let me re-state my argument: the information that I would like to add is helpful to anyone who wishes to efficiently invert a Gray code of size other than N = 32 bits. In particular, the applicability of the edit is not only to the Gray code sizes that you and Andy Dingley have deemed of little use. 64.132.59.226 (talk) 17:02, 23 October 2017 (UTC)
Yet again, silence from other people who have already opposed your changes does not mean that they have quietly changed their minds. Andy Dingley (talk) 17:15, 23 October 2017 (UTC)
@Andy Dingley, I have never made the argument that you have changed your mind, instead invoking WP:BRD to elicit dialogue on the talk page. On the talk page, I have responded multiple times to the arguments that you have made, but you have since adopted a position of silence with regards to the merits, instead responding on procedural grounds. Please spare just a moment more of your time to respond not on procedural grounds but on the newly described merits of the edit I am making. Please respond to this statement: whether it is a 5-bit Gray code, a 16-bit Gray code or a 100-bit Gray code, it is useful to the reader to know that the bit shift amounts that must be included in an algorithm like grayToBinary32 are those that are powers of two with value strictly less than the number of bits. If you are open to having this information somewhere in the article, please, please let me know. If you are not, please provide an explanation that is not procedural but based upon the merits of the information I propose to include. 64.132.59.226 (talk) 17:47, 23 October 2017 (UTC)
The information you want to add does not add much to the article and probably distracts more. The comment does not help someone trying to understand the given code; instead it is advice on how to extend the code. And the comment is in stilted language. WP is not trying to teach people how to program or provide them with code to use in their projects, code to adapt to their projects, or whatever. The article describes what a Gray code is. That is the fundamental topic. It provides general algorithms for converting arbitrary size Gray codes to and from binary. Those algorithms are relevant to understanding how Gray codes can be used with the conventional binary numbers found in computers. The general algorithms are fast enough for most applications. A programmer won't be fired for using a loop. Then there is the fast 32-bit version. It shows you don't need a loop. Andy has already pointed out that 32-bits is overkill for most applications. In other words, your comment is trying to reach an incredibly small portion of WP's audience. But the article does not need a deep dive into how-to-program-other-powers-of-two-versions of the unrolled loops. Such a digression is a distraction for the average reader. The trick is actually a standard technique for bit-bumming programmers: it is used for bit reversing and ones counting, too. But that programming lore is a needless digression in this article. A high school student or middle manager may want to learn about Gray codes, but that does not mean they need to learn how to program with them or code slightly different versions. WP is neither a how-to guide nor a tutorial.
You also know that nobody else on this page has agreed with your position. If you wanted to elicit more discussion on this page, then you could have made additional comment on this talk page rather than insert disputed content into the article. Do not take silence, once a topic has been discussed, to be consent or consensus. You acknowledge that Andy has not changed his position; neither have I. Glrx (talk) 22:21, 23 October 2017 (UTC)
@Glrx: With respect to your second paragraph: please rest assured that I do not take silence as consent. Please rest assured also that I know what your opinions were on the earlier edits that I made. The only reason that I invoked WP:BRD is that I got no feedback on the merits of the later, proposed compromises. Until now! Thank you for that.
With regard to your substantive comments: you addressed many of my questions and I thank you for that. You did not address that knowledge of the maximum bit shift needed would be of use to someone using, say, a 5-bit Gray code. For such, the quick implementation would be merely "num = num ^ (num >> 4); num = num ^ (num >> 2); num = num ^ (num >> 1);". Do you deem that worthy of mention (if the mention is sufficiently brief and not in stilted language)? Would it make a difference if it were mentioned in the accompanying text rather than as a comment in the code? 64.132.59.226 (talk) 12:40, 24 October 2017 (UTC)
Yes, I did. No. No. Glrx (talk) 14:35, 24 October 2017 (UTC)

"for" loop vs. "while" loop and the superfluous shift operation

@84.153.139.186, thank you for your ongoing edits to the Gray code article. It appears to me that you are advocating for a switch from a "for" loop to a "while" loop because it "removed superfluous shift operation". Is that right? Unfortunately, I fear that your counting is off. In one case, the first shift occurs when "mask" is first set and in the other case it occurs after "mask" has been first set to "num". Either way that counts as 1. The remaining shifts do not depend upon "for" or "while" and continue exactly until "mask" becomes zero.

Because I am not seeing any speed advantage to one formulation over the other, to me it then boils down to a comparison of which code is clearer. Since the loop has an initialization ("mask = num" or "mask = num >> 1") and an update step on the same variable ("mask = mask >> 1"), would you agree that the "for" loop captures that well? 64.132.59.226 (talk) 14:59, 2 November 2017 (UTC)

The current "for" loop implementation also has the advantage that we don't compare mask to 0 when mask == num, a savings except when num happens to be zero. (Though to me, this is minor potatoes compared to the readability issues.) 64.132.59.226 (talk) 12:14, 3 November 2017 (UTC)

OUCH! The former "for" loop had the disadvantage to perform a superfluous shift operation when num == 0, alias always performs an initial shift operation, even when not necessary, produces two shift instructions, and the result of the last shift is never used. Additionally the initial shift obscures how the algorithm works.84.153.128.88 (talk) 04:32, 4 November 2017 (UTC)
The while version is easier to read and interpret, esp. for non C programmers, and no less efficient, shifting exactly the same number of times until mask gets to 0 (and efficiency is certainly not a consideration here). Dicklyon (talk) 01:38, 4 November 2017 (UTC)
Thank you for the clarification that the while loop implementation saves a shift operation only in the case that num equals 0, and that this comes at the expense of an extra comparison against zero when num is not equal to 0. 64.132.59.226 (talk) 13:08, 6 November 2017 (UTC)

Superfluous exclusive or in grayToBinary code example

I would like to change the grayToBinary code example to the following. Reasons: the last iteration of the loop in the existing example is pointlessly taking the exclusive or of num with a mask of zero (except that it doesn't do this when num is zero because there is no looping). Additionally, conceptually there is no reason that the mask should ever be equal to num; the first reasonable mask is num >> 1.

/*
 * This function converts a reflected binary
 * Gray code number to a binary number.
 * Each Gray code bit is exclusive-ored with all
 * more significant bits.
 */
unsigned int grayToBinary(unsigned int num)
{
    unsigned int mask = num >> 1;
    while (mask != 0)
    {
        num = num ^ mask;
        mask = mask >> 1;
    }
    return num;
}

Comments? 64.132.59.226 (talk) 13:15, 10 November 2017 (UTC)

Lucal code?

The table near the top of the article says (and links to) "Lucal code" at top. The link redirects to a nonexistent section in the present article. The table itself is hard to understand; perhaps it needs a legend. What is the relationship between Gray and Lucal codes?-- (talk) 13:41, 7 June 2018 (UTC)

It acually doesn't link to a nonexistent section; it links to § Related Codes, which is tagged with anchors for all of the listed (but unexplained) codes:
== {{anchor|MRB|Lucal|Datex|Varec|Gillham|Hoklas|Gray-Excess|Glixon|O'Brien|Petherick|Tompkins|Kautz}}Related codes ==
Looking at the abstract for Lucal's paper that's cited at the various mentions of "Lucal code", it sounds like the major change was to add error detection to the Gray code. According to Lucal this also facilitates performing arithmetic on the encoded data, and he provides algorithms for that as well:

The modification for integral numbers is essentially the addition of an even parity check bit to the Gray code representation. This facilitates both the arithmetic operations and the detection of errors-in the arithmetic process as well as in transmission.

This could definitely be covered in more detail in the article, most likely enough to justify its own section (at which point the anchor should be moved from § Related Codes to the new section). -- FeRDNYC (talk) 16:31, 23 October 2018 (UTC)
Realized it would be polite to ping @: so I shall. -- FeRDNYC (talk) 16:33, 23 October 2018 (UTC)

Animation

The rotary encode and, in particular, the STGC images would benefit enormously from animation! Casual viewers could miss the magic of this concept: making paper versions to explain this to my children was time-consuming and probably less clear than an animation could be. —Preceding unsigned comment added by 81.108.210.118 (talk) 09:49, 8 October 2009 (UTC)

Animated and color-coded STGC rotor.

I have completed an animation based on the svg shown. I agreed that the static image and the discussion were obscuring the functional beauty of STGC. While my image works it may be too colorful for some tastes

The original svg and discussion did not identify the sensors, define when the sensor would switch from on to off and did not even define whether the slots or sensors would be spinning and in which direction the spin would occur. These facts made correlating the chart with the svg difficult.

Note: I discovered that the three slots are at (0, 120) (168, 204) (228, 252), and that the 5 sensors start at 0 degrees and are evenly distributed around the circle with a separation of 72 degrees. The slots rotate as this would most accurately mimic a physical device. The direction of clock-wise rotation and the identity of the sensors (red, purple, yellow, blue and green) were chosen to match the bit-patterns displayed in the Greycode article.

Preceding comment added by Perlygatekeeper (talkcontribs) 18:14, 9 June 2017 (UTC)

@Perlygatekeeper: The animation is really great, and illustrates both the concept and execution well. Thanks for doing that! I have to be honest, though — the font is a horror-show, even at full size but most especially when the image is resized for embedding in the article.
I have to wonder if it wouldn't be better to place the five digits below the animation, full-width (and proportionally taller), so that they're more visible and less corrupted by resizing. -- FeRDNYC (talk) 16:59, 23 October 2018 (UTC)
I've created an updated version incorporating that change; since I uploaded it as a new version of Perlygatekeeper's original, it should already be showing both here and in the article. Caching may occasionally show the old version; if you see a distorted (non-rectangular) version of the circular animation, then you just need to refresh your cache. -- FeRDNYC (talk) 18:47, 23 October 2018 (UTC)
And I updated that again with a gray background behind the numerals, because the yellow was really hard to make out. -- FeRDNYC (talk) 00:18, 24 October 2018 (UTC)