Numération binaire

Repères historiques

• Neper (vers 1610) et son abaque
• Leibniz en 1703
• Le binaire dans l'Encyclopédie (vers 1750)

Pour la suite, il est bon de connaître par cœur les premières puissances de 2 : 1, 2, 4, 8, 16, 32, 64, 128 et 256...

I/ Conversion binaire→décimal

1) Octets

Le nombre représenté en binaire ci-dessus est 0.

Chaque bit vaut deux fois plus que le bit suivant, comme on peut le vérifier sur cette activité.

2) Algorithme

Chaque chiffre est égal à 0 ou à 1. En multipliant chaque chiffre par son poids on a donc, ou bien le poids, ou bien 0. Il suffit alors d'additionner ces produits pour avoir le nombre représenté en binaire.

Pour construire le tableau des poids, on initialise sa dernière valeur à 1 puis on met dans chaque case (sauf la dernière qui vaut déjà 1) le double de la case suivante :

def tableau_poids(liste):
    nb_chiffres = len(liste)
    poids = nb_chiffres*[0]
    poids[-1] = 1
    for k in range(nb_chiffres-2,-1,-1):
        poids[k] = 2*poids[k+1]
    return poids

3) Programmation de l'algorithme

a) En Python

def decimal(L):
    nc = len(L)
    tp = tableau_poids(L)
    return sum([int(L[k])*tp[k] for k in range(nc)])

b) En bash

decimal(){
    local somme=0
    for k in "$@"; do
        let "somme*=2"
        let "somme+=$k"
    done
    echo $somme
}

c) En Javascript

let p2= x => Math.pow(2,x)
let longueur = x => x.length

let decimal = function(n) {
    let ln = longueur(n)
    for (s=0, p=p2(ln-1), k=0; k<ln; k+=1, p/=2) {
        if (n.charAt(k)=="1") { s += p }
    } 
    return s
}

donne ceci :

Écrire une suite de 0 et 1 ici :

Le nombre représenté en binaire est 0.

d) En Haskell

decimal :: [Int] -> Int
decimal [] = 0
decimal [x] = x
decimal (x:xs) = (2^length xs)*x + decimal xs

II/ Conversion décimal→binaire

1) Quartets

On peut tester cette activité pour saisir le principe. Les divisions par 2 sont euclidiennes : le quotient est entier et il peut y avoir un reste de 1.

Si la division par 2 a un reste, c'est que l'entier divisé par 2 est impair et dans ce cas le dernier bit est égal à 1. En fait le bit des unités est le reste dans la division par 2. L'opération qui donne ce reste est notée %2 en bash, en JavaScript et et en Python, et `mod` (comme modulo) en Haskell.

2) Algorithme

On construit les chiffres par poids croissant. Pour obtenir le dernier chiffre, on fait une division euclidienne par 2 : le dernier chiffre est le reste de cette division. Ensuite on remplace le nombre à convertir par sa moitié (le quotient de la division euclidienne). On s'arrête lorsque le nombre qu'il reste à convertir est nul.

Chaque chiffre est ajouté à la gauche des chiffres précédemment calculés.

3) Programmation de l'algorithme

a) En bash

binaire(){
    local n=$1
    local s=""
    while [ $n -ge 1 ]; do
        if [ $(($n%2)) -eq 0 ]
            then s=0$s
            else s=1$s
        fi
        let "n/=2"
    done
    echo $s
}

b) En Python

Laissé en exercice (fréquent au bac)

c) En JavaScript

let binaire = function(n) {
    let s
    for (s="";n>0;n=parseInt(n/2)) {
        if (n%2==0) {s = "0"+s}
        else {s = "1"+s}
    }
    return s
}

donne ceci :

Le nombre 1 s'écrit 1 en binaire.

d) En Haskell

binaire :: Int -> [Int]
binaire 0 = [0]
binaire n = binaire (n `div` 2) ++ [n `mod` 2]

e) Programmation objet

Si on entre (en Python)

dir(5)

on a toutes les méthodes de l'entier 5. Parmi celles-ci on trouve __str__ qui donne l'écriture décimale de l'entier (ici, "5") pour affichage.

Cette chaîne de caractères (string ou str) s'obtient en appliquant la méthode __str__() à l'objet 5 :

(5).__str__()

donne la même chose que

str(5)

4) Étude de l'algorithme

Elle est faite au début de cet article.

III/ Octal et hexadécimal

1) Octal

d comme dossier, u comme utilisateur, g comme groupe, o comme others (autres).

r comme read (droit de lecture), w comme write (modification), x comme execute (exécuter).

La représentation binaire de ce mot de 10 bits est 0, la représentation octale est 0 et la représentation donnée par ls -l est ----------.

2) Hexadécimal

Le chiffre 0 représente le nombre 0 écrit en binaire 0.