C'est un code binaire particulier, qui a pour caractéristique principale de passer d'un nombre au nombre suivant en ne changeant qu'un seul bit.

Par exemple, on passe de 3=“00000010” à 4=“00000110”: seul le 3ème bit en partant de la droite est passé de “0” à “1”.

Ce code est très utilisé en automatisme et en informatique (hardware), parce que, dans ces techniques, le changement d'état simultané de plusieurs organes logiques est une source d'instabilité.

Il est aussi utilisé pour résoudre certains casse-tête (comme le baguenaudier par exemple: http://www.recreomath.qc.ca/dict_baguenaudier.htm). D'ailleurs, c'est pour résoudre ce jeu que ce code a été publié pour la première fois par un certain Louis Gros, clerc de notaire à Lyon, en 1872. Mais c'est l'américain Frank Gray qui déposa un brevet sur ce code en 1953.

Pour en connaitre plus: http://fr.wikipedia.org/wiki/Arithm%C3%A9tique_binaire

Voilà un exemple de progression comparée entre le code binaire normal et le code de Gray. Vous pouvez constater qu'on passe d'une ligne à la suivante en ne changeant qu'un seul bit pour le code de Gray, ce qui n'est pas vrai pour le code binaire normal:

dec.  binaire   code Gray
00    00000000  00000000
01    00000001  00000001
02    00000010  00000011
03    00000011  00000010
04    00000100  00000110
05    00000101  00000111
06    00000110  00000101
07    00000111  00000100
08    00001000  00001100
09    00001001  00001101
10    00001010  00001111
11    00001011  00001110
12    00001100  00001010
13    00001101  00001011
14    00001110  00001001
15    00001111  00001000
16    00010000  00011000
17    00010001  00011001
18    00010010  00011011
19    00010011  00011010
20    00010100  00011110

Code proposé (script inspiré de la page de wikipedia):

#!/usr/bin/python
# -*- coding: utf-8 -*-
from __future__ import division
# Python v2.7
 
def dec2gray(num):
    """retourne le code gray correspondant au nombre entier 'num' """
    return (num>>1)^num
 
# dec2bin améliore l'affichage binaire des nombres en ajoutant si nécessaire des zéros à gauche
dec2bin = lambda x, n=8: bin(x)[2:].zfill(n)
 
# exemple d'utilisation
print dec2bin(dec2gray(14))  
# affiche: "00001001"
 
print dec2bin(dec2gray(14),16)  
# affiche: "0000000000001001"

En entrée de cette fonction dec2gray, num est le nombre décimal que l'on veut convertir en code de Gray. La fonction dec2gray est valable pour des mots de plus de 8 bits.

Pour obtenir le nombre décimal correspondant à un code de Gray donné (script inspiré de la page de wikipedia):

def gray2dec(num):
    """retourne le nombre entier correspondant au code Gray num"""
    shift = 1
    while True:
        idiv = num >> shift
        num ^= idiv
        if idiv <= 1 or shift == 32: 
            return num
        shift <<= 1
 
# exemple d'utilisation
print gray2dec(int("00001001",2))  # affiche: 14

En entrée de cette fonction, num est le nombre entier décimal représentant le code de Gray. Si celui-ci est connu sous forme de chaine binaire (ex: “00001001”), il faut faire une conversion comme: int(“00001001”,2).

Amusez-vous bien!