La révolution numérique a transformé notre monde d'une manière aussi profonde que l'invention de l'écriture ou de l'imprimerie. Aujourd'hui, chaque seconde, des milliards de dispositifs échangent des téraoctets d'informations : smartphones qui géolocalisent, capteurs IoT qui surveillent des infrastructures critiques, algorithmes d'intelligence artificielle qui analysent des données massives, ou encore réseaux 5G qui interconnectent des véhicules autonomes.
Cette omniprésence du numérique repose sur un paradoxe fascinant : toute cette complexité émane de la manipulation d'une unité d'information élémentaire, le bit, qui ne peut prendre que deux valeurs (0 ou 1). Comment cette simplicité binaire permet-elle de représenter la richesse du monde réel ? Comment les ordinateurs transforment-ils des séquences de 0 et de 1 en images haute définition, en conversations vidéo intercontinentales, ou en calculs de modèles climatiques ?
Pour un ingénieur en systèmes et réseaux, comprendre ces fondamentaux n'est pas qu'une curiosité académique : c'est un prérequis essentiel. Ces concepts déterminent les performances des systèmes, expliquent les limites des protocoles réseau, et permettent d'anticiper les défis de sécurité. Ils éclairent pourquoi un processeur x86 et un ARM n'organisent pas les données de la même façon en mémoire, pourquoi TCP vérifie l'intégrité des données, ou encore pourquoi la compression vidéo en temps réel est un défi technologique majeur.
Ce cours explore ces concepts fondamentaux : de l'algèbre de Boole qui gouverne les circuits logiques, aux techniques de numérisation qui transforment le monde analogique en données binaires, en passant par les subtilités de représentation qui conditionnent la portabilité des applications. Chaque notion abordée constitue une pierre angulaire de l'édifice numérique contemporain.
L'information analogique se caractérise par :
- Une infinité continue de valeurs entre un minimum et un maximum
- Une représentation qui varie de façon continue, comme l'échelle du temps
- Des signaux qui peuvent prendre n'importe quelle valeur dans une plage donnée
- Une nature proche des phénomènes physiques du monde réel
- Des exemples concrets : la voix humaine, la température, la pression, etc.
L'information analogique est naturelle mais présente des inconvénients : imprécision, sensibilité aux perturbations, difficulté de stockage et de reproduction exacte.
L'information numérique est fondée sur le principe binaire :
- Elle ne peut prendre que deux états possibles : 0 ou 1
- Ces deux états sont parfaitement distincts et sans ambiguïté
- Elle est discrète par nature (valeurs distinctes et séparées)
- Elle permet de représenter toute information pouvant être discrétisée et codée sous forme de nombres ou de symboles
Avantages de l'information numérique :
- Précision et fiabilité
- Possibilité de copie et transmission sans perte
- Facilité de stockage et de traitement
- Résistance aux perturbations
Le bit (binary digit) est l'unité élémentaire d'information numérique :
- Il ne peut prendre que deux valeurs : 0 ou 1
- Il peut représenter différents concepts : vrai/faux, allumé/éteint, présence/absence, etc.
Avec n bits, on peut représenter 2^n combinaisons différentes :
- 1 bit : 2^1 = 2 combinaisons (0, 1)
- 2 bits : 2^2 = 4 combinaisons (00, 01, 10, 11)
- 3 bits : 2^3 = 8 combinaisons (000, 001, 010, 011, 100, 101, 110, 111)
Plus le nombre de bits est élevé, plus on peut représenter d'informations différentes. Par exemple, avec 8 bits, on peut représenter 256 niveaux différents (suffisant pour une image en niveaux de gris).
Le transistor est l'élément fondamental de l'informatique moderne :
- C'est un composant électronique qui fonctionne comme un interrupteur commandé électriquement
- Il peut être dans deux états : passant (1) ou bloquant (0)
- Les transistors sont assemblés pour créer des fonctions logiques
- La miniaturisation des transistors a permis l'évolution exponentielle des capacités informatiques
Les opérations logiques de base permettent de traiter l'information binaire :
Cette fonction inverse simplement la valeur d'entrée. Voici sa table de vérité :
Schéma utilisant les symboles usuels de l'électronique numérique :
- Donne 1 si au moins une des entrées est à 1
- Table de vérité :
- A=0, B=0 → A OU B = 0
- A=0, B=1 → A OU B = 1
- A=1, B=0 → A OU B = 1
- A=1, B=1 → A OU B = 1
¶ La fonction ET (AND)
- Donne 1 uniquement si toutes les entrées sont à 1
- Table de vérité :
- A=0, B=0 → A ET B = 0
- A=0, B=1 → A ET B = 0
- A=1, B=0 → A ET B = 0
- A=1, B=1 → A ET B = 1
- Donne 1 si les entrées sont différentes, 0 si elles sont identiques
- Table de vérité :
- A=0, B=0 → A XOR B = 0
- A=0, B=1 → A XOR B = 1
- A=1, B=0 → A XOR B = 1
- A=1, B=1 → A XOR B = 0
Le XOR a une importance particulière en informatique :
- Il permet la détection de parité (nombre pair ou impair de bits à 1)
- Il est utilisé dans les circuits d'addition binaire (demi-additionneur et additionneur complet)
- Il sert au chiffrement symétrique simple (propriété : A XOR B XOR B = A)
- Il permet d'échanger deux valeurs sans variable temporaire (A = A XOR B; B = A XOR B; A = A XOR B)
- Il est employé dans les codes correcteurs d'erreurs et les sommes de contrôle (checksums)
Ces fonctions logiques sont à la base de tous les circuits électroniques de traitement de l'information.
Ces fonctions logiques élémentaires sont réalisées concrètement par des assemblages de transistors :
- Une porte NON (inverseur) peut être réalisée avec un seul transistor et une résistance
- Une porte ET nécessite généralement 3-4 transistors selon la technologie
- Une porte OU utilise également 3-4 transistors
- Une porte XOR est plus complexe et nécessite 8-10 transistors
Ces fonctions sont regroupées dans des puces électroniques appelées "circuits intégrés logiques", classés en familles technologiques :
- TTL (Transistor-Transistor Logic) - série 74xx historique
- CMOS (Complementary Metal-Oxide-Semiconductor) - faible consommation
- ECL (Emitter-Coupled Logic) - très haute vitesse
- LSTTL, HC, HCT, etc. - variantes optimisées pour différents critères
Ces portes logiques de base sont assemblées pour créer des composants plus complexes selon une organisation hiérarchique :
- Premier niveau : Bascules, registres à décalage, multiplexeurs, décodeurs
- Deuxième niveau : Additionneurs, soustracteurs, comparateurs, compteurs
- Troisième niveau : Unités arithmétiques et logiques (UAL/ALU), registres spécialisés
- Quatrième niveau : Processeurs, mémoires, interfaces d'entrée/sortie
- Mémoire : Une cellule mémoire SRAM utilise une boucle de rétroaction avec des portes NON
- Addition : Un additionneur complet combine des portes XOR, ET et OU
- Calcul : L'Unité Arithmétique et Logique (ALU) d'un processeur utilise toutes ces portes
- Contrôle : Les séquenceurs et machines à états utilisent des combinaisons de bascules construites à partir de ces portes
- Un microprocesseur moderne contient des milliards de transistors organisés en millions de portes logiques
- Toute la complexité des systèmes numériques actuels émerge de l'assemblage et de l'interconnexion de ces fonctions élémentaires
- Les algorithmes les plus sophistiqués sont ultimement exécutés par ces opérations binaires de base
Cette hiérarchie illustre comment l'algèbre de Boole, théorie mathématique abstraite développée au XIXe siècle, a permis la révolution numérique en devenant le fondement de tous les systèmes informatiques via ces fonctions logiques implémentées en électronique.
Le traitement de l'information numérique repose sur trois fonctions fondamentales :
- Calculer (computing) : traitement des données selon des algorithmes
- Stocker (storage) : conservation des données
- Communiquer (networking) : transmission des données entre systèmes
Ces trois piliers sont interdépendants et constituent le fondement des systèmes et réseaux informatiques.
- Blaise Pascal (1623-1662, France) : inventeur de la Pascaline, première machine à calculer mécanique
- Gottfried Wilhelm Leibniz (1646-1716, Allemagne) : conceptualisation du système binaire, travaux précurseurs sur les calculateurs
- Charles Babbage (1791-1871, GB) : conception de la machine analytique, ancêtre théorique de l'ordinateur
- Ada Lovelace (1815-1852, UK) : première programmeuse de l'histoire, travaux sur la machine de Babbage
- George Boole (1815-1864, UK) : création de l'algèbre booléenne, fondement des circuits logiques
- Claude Shannon (1916-2001, US) : père de la théorie de l'information, établissement du lien entre l'algèbre de Boole et l'électronique
- John von Neumann (1903-1957, HU/USA) : architecture fondamentale des ordinateurs modernes
- Alan Turing (1912-1954, UK) : fondateur de l'informatique théorique, concept de machine universelle
- Le transistor (1947) : John Bardeen, William Shockley et Walter Brattain (Laboratoires Bell)
- Le transistor MOSFET (1960) : Mohamed M. Atalla et Dawon Kahng, favorisant miniaturisation et faible consommation
- Le circuit intégré (1958) : Jack Kilby, intégration de plusieurs composants sur un même support
- Le microprocesseur (1969-1971) : Marcian Hoff et Federico Faggin (Intel), premier CPU sur une seule puce
La loi de Moore (1965) a longtemps décrit l'évolution de l'informatique :
- Le nombre de transistors sur une puce double tous les deux ans
- Cette progression exponentielle a permis l'évolution rapide des capacités informatiques
- La limite physique (atomique) tend aujourd'hui à ralentir cette progression
- 1969-1983 : De ARPANET à Internet, création des protocoles d'interconnexion
- 1971 : Premier email, première application d'Internet
- 1990 : Naissance du World Wide Web par Tim Berners-Lee et Robert Cailliau
- Concepts fondamentaux : HTML, HTTP, TCP/IP, URL, DNS, navigateurs, moteurs de recherche
- Autres technologies clés : Ethernet (1973), Wi-Fi (1999), réseaux mobiles (1992), smartphone (2007)
Le bit (binary digit) est l'unité élémentaire de l'information numérique :
- Il représente deux états opposés : 0/1, vrai/faux, allumé/éteint, etc.
- Il possède trois usages principaux : logique, symbolique et arithmétique
L'algèbre de Boole permet de manipuler des valeurs logiques (vrai/faux) :
- Les opérateurs logiques (NON, ET, OU) suivent des règles précises
- Ces opérations peuvent être implémentées électroniquement par des circuits
- L'algèbre booléenne possède des propriétés mathématiques (commutativité, distributivité, etc.)
- Elle est le fondement des langages de programmation et des circuits logiques
Le binaire permet de coder des symboles par association :
- Un mot de n bits permet 2^n combinaisons
- Chaque combinaison peut être associée à un symbole (lettre, chiffre, signe, etc.)
- Cette association constitue un encodage (comme l'ASCII, l'Unicode, etc.)
Le système binaire permet de représenter et manipuler des nombres :
- C'est un système de numération en base 2 (comme le décimal est en base 10)
- Il utilise uniquement les chiffres 0 et 1
- Les positions ont des poids qui sont des puissances de 2 (2^0, 2^1, 2^2, etc.)
- L'octet (8 bits) est l'unité de base pour le stockage et le traitement de l'information
Différentes bases sont utilisées en informatique :
- Utilise les chiffres 0 et 1
- Exemple : 1001 (binaire) = 1×2^3 + 0×2^2 + 0×2^1 + 1×2^0 = 9 (décimal)
- Système courant, utilise les chiffres 0 à 9
- Utilise les chiffres 0 à 9 et les lettres A à F
- Exemple : 1A (hexadécimal) = 1×16^1 + 10×16^0 = 26 (décimal)
- Utilise les chiffres 0 à 7
L'hexadécimal est particulièrement utile en informatique car un chiffre hexadécimal représente exactement 4 bits. Voici la table de correspondance :
| Binaire (4 bits) |
Hexadécimal |
Décimal |
| 0000 |
0 |
0 |
| 0001 |
1 |
1 |
| 0010 |
2 |
2 |
| 0011 |
3 |
3 |
| 0100 |
4 |
4 |
| 0101 |
5 |
5 |
| 0110 |
6 |
6 |
| 0111 |
7 |
7 |
| 1000 |
8 |
8 |
| 1001 |
9 |
9 |
| 1010 |
A |
10 |
| 1011 |
B |
11 |
| 1100 |
C |
12 |
| 1101 |
D |
13 |
| 1110 |
E |
14 |
| 1111 |
F |
15 |
Cette correspondance permet de convertir facilement un nombre binaire en hexadécimal en groupant les bits par 4 et en remplaçant chaque groupe par son équivalent hexadécimal.
Les quantités d'information binaire sont mesurées en octets (bytes) :
- 1 octet (byte) = 8 bits
- 1 Ko (kilooctet) = 10^3 octets (système SI) ou 2^10 octets (système binaire, Kio pour kibioctet)
- 1 Mo (mégaoctet) = 10^6 octets (système SI) ou 2^20 octets (système binaire, Mio pour mébioctet)
- 1 Go (gigaoctet) = 10^9 octets (système SI) ou 2^30 octets (système binaire, Gio pour gibioctet)
- Et ainsi de suite pour téraoctet (To/Tio), pétaoctet (Po/Pio), exaoctet (Eo/Eio), zettaoctet (Zo/Zio), yottaoctet (Yo/Yio), etc.
Cette distinction est importante car la différence entre les deux systèmes devient significative avec les grandes unités (par exemple, 1 To = 1 000 000 000 000 octets tandis que 1 Tio = 1 099 511 627 776 octets, soit une différence d'environ 10%).
- American Standard Code for Information Interchange (1975)
- Codage sur 7 bits permettant 128 combinaisons
- Représente l'alphabet latin (majuscules et minuscules), les chiffres, les signes de ponctuation et les caractères de contrôle
- Limité aux caractères anglo-américains
- Extension de l'ASCII sur 8 bits (256 combinaisons)
- Ajout des caractères accentués et spéciaux des langues d'Europe occidentale
- Variantes pour d'autres langues (ISO8859-2, 3, etc.)
- Variante Windows : Windows-1252
- Standard universel visant à représenter tous les systèmes d'écriture et symboles
- Unicode : attribution d'un numéro unique à chaque caractère
- UTF-8 : méthode d'encodage à longueur variable (1 à 4 octets)
- Avantages d'UTF-8 :
- Compatible avec ASCII (les 128 premiers caractères)
- Adapté au Web (standard actuel)
- Supporte tous les alphabets, idéogrammes et symboles
Le codage des entiers naturels est relativement simple :
- Utilisation directe du système binaire
- Codage sur un nombre fixe de bits (8, 16, 32, 64 bits selon les besoins)
- Plages de valeurs dépendant du nombre de bits
Quelques désignations usuelles (dépendent des langages, ici le C) :
| Désignation |
Taille |
Plage de valeurs |
| UNSIGNED CHAR |
1 octet |
0 à 255 |
| UNSIGNED SHORT INT |
2 octets |
0 à 65 535 |
| UNSIGNED LONG INT |
4 octets |
0 à 4 294 967 295 |
| UNSIGNED LONG LONG INT |
8 octets |
0 à 18 446 744 073 709 551 615 |
Pour représenter les nombres négatifs en informatique, plusieurs méthodes ont été développées, mais celle qui s'est imposée est le complément à deux.
Le complément à deux est une méthode élégante qui permet de :
- Représenter aussi bien les nombres positifs que négatifs
- Réaliser des opérations arithmétiques (addition, soustraction) avec les mêmes circuits électroniques que pour les nombres positifs
- Assurer que le zéro n'ait qu'une seule représentation
Principe fondamental : Dans un système à n bits, un nombre négatif -X est représenté par 2^n - X.
Méthode formelle :
- Calculer 2^n - X (où n est le nombre de bits)
- Exemple sur 8 bits : complément à deux de 5 = 2^8 - 5 = 256 - 5 = 251
Méthode pratique (plus couramment utilisée) :
- Inverser tous les bits (complément à un)
- Ajouter 1 au résultat
Représentation de +5 : 00000101
Pour obtenir -5 :
- Inverser tous les bits :
11111010
- Ajouter 1 :
11111011
- Donc -5 en complément à deux sur 8 bits :
11111011
- Le bit de poids fort (le plus à gauche) sert de bit de signe : 0 pour positif, 1 pour négatif
- Sur n bits, on peut représenter des nombres de -2^(n-1) à +2^(n-1)-1
- Sur 8 bits : -128 à +127
- Sur 16 bits : -32 768 à +32 767
- Sur 32 bits : -2 147 483 648 à +2 147 483 647
- Une seule représentation du zéro (contrairement au complément à un)
- Les opérations d'addition et de soustraction fonctionnent naturellement
- Addition : -X + Y = complément à deux de X + Y
- Soustraction : X - Y = X + complément à deux de Y
- Dépassement facilement détectable
Le nombre -2^(n-1) n'a pas de correspondant positif dans le même format :
- Sur 8 bits : -128 (
10000000) n'a pas de correspondant positif
- C'est une asymétrie intrinsèque au complément à deux
Addition :
00000101 (+5)
+ 11111011 (-5)
----------
00000000 (0)
Soustraction (5 - 3) :
00000101 (+5)
+ 11111101 (-3, complément à deux de 00000011)
----------
00000010 (+2)
Cette représentation en complément à deux est utilisée dans pratiquement tous les processeurs modernes pour manipuler les nombres relatifs, car elle simplifie considérablement la conception des circuits arithmétiques.
| Désignation |
Taille |
Plage de valeurs |
| SIGNED CHAR |
1 octet |
-128 à +127 |
| SIGNED SHORT INT |
2 octets |
-32 768 à +32 767 |
| SIGNED LONG INT |
4 octets |
-2 147 483 648 à +2 147 483 647 |
| SIGNED LONG LONG INT |
8 octets |
-9 223 372 036 854 775 808 à +9 223 372 036 854 775 807 |
La représentation des nombres réels en informatique pose des défis particuliers car les ordinateurs ne peuvent manipuler qu'un nombre fini de bits, alors que les nombres réels forment un ensemble infini et continu. Le standard IEEE 754 (1985, révisé en 2008) définit la représentation universelle des nombres à virgule flottante.
Un nombre à virgule flottante est représenté sous la forme : ±M × 2^E où :
- M est la mantisse (partie fractionnaire)
- E est l'exposant
- Le signe détermine si le nombre est positif ou négatif
Cette représentation permet de couvrir une très large gamme de valeurs, des très petits aux très grands nombres, au prix d'une précision variable.
| S | E (8 bits) | M (23 bits) |
| 1 | 7 6 5 4 3 2 1 0 | 22 21 20 ... 3 2 1 0 |
- S (1 bit) : bit de signe (0 = positif, 1 = négatif)
- E (8 bits) : exposant biaisé (biais de 127)
- M (23 bits) : mantisse fractionnaire
| S | E (11 bits) | M (52 bits) |
| 1 | 10 9 8 7 6 5 4 3 2 1 0 | 51 50 49 ... 2 1 0 |
- S (1 bit) : bit de signe
- E (11 bits) : exposant biaisé (biais de 1023)
- M (52 bits) : mantisse fractionnaire
Prenons le nombre 12,75 en décimal :
Conversion en binaire :
- Partie entière : 12 = 1100₂
- Partie fractionnaire : 0,75 = 0,11₂ (car 0,5 + 0,25 = 0,75)
- Donc : 12,75 = 1100,11₂
Normalisation :
- 1100,11₂ = 1,10011₂ × 2³
- Mantisse : 10011 (le "1," initial est implicite)
- Exposant : 3
Codage en simple précision :
- Signe : 0 (positif)
- Exposant : 3 + 127 = 130 = 10000010₂
- Mantisse : 10011000000000000000000₂ (complétée à 23 bits)
Résultat : 01000001010011000000000000000000
Le standard IEEE 754 définit des valeurs spéciales :
| Exposant |
Mantisse |
Valeur |
| 00000000 |
00000... |
±0 |
| 00000000 |
≠0000... |
Nombres dénormalisés |
| 11111111 |
00000... |
±∞ (infini) |
| 11111111 |
≠0000... |
NaN (Not a Number) |
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1 + 0.2 == 0.3
False
Explication : 0,1 et 0,2 ne peuvent pas être représentés exactement en binaire, car ils correspondent à des fractions périodiques en base 2.
>>> x = 1.0
>>> for i in range(10):
... x += 0.1
>>> x
1.9999999999999998
>>> x == 2.0
False
Il ne faut jamais comparer directement des flottants avec ==. Il faut utiliser une tolérance :
#include <math.h>
#define EPSILON 1e-9
int float_equals(double a, double b) {
return fabs(a - b) < EPSILON;
}
- Simple précision (float) : plus rapide, moins de mémoire
- Double précision (double) : plus précis, plus lent
- Calculs financiers : utiliser des bibliothèques décimales exactes
- Calculs scientifiques : double précision généralement nécessaire
- Graphisme/jeux : simple précision souvent suffisante
¶ Ordres de grandeur
- Float (32 bits) : ~7 chiffres significatifs, plage ±3,4 × 10³⁸
- Double (64 bits) : ~15 chiffres significatifs, plage ±1,8 × 10³⁰⁸
#include <math.h>
if (isnan(result)) {
printf("Résultat indéfini (NaN)\n");
}
if (isinf(result)) {
printf("Résultat infini\n");
}
La compréhension d'IEEE 754 est cruciale pour éviter les pièges des calculs flottants et développer des applications numériquement robustes.
Lorsqu'un nombre occupe plusieurs octets en mémoire (comme un entier de 16, 32 ou 64 bits), se pose la question de l'ordre dans lequel ces octets sont stockés. C'est ce qu'on appelle l'endianness ou l'ordre des octets.
- L'octet de poids fort (Most Significant Byte - MSB) est stocké en premier (à l'adresse la plus basse)
- L'ordre correspond à notre façon habituelle d'écrire les nombres : de gauche à droite, du plus significatif au moins significatif
- Utilisé par : PowerPC, SPARC, certains ARM, protocoles réseau (d'où le terme "network byte order")
- L'octet de poids faible (Least Significant Byte - LSB) est stocké en premier (à l'adresse la plus basse)
- Utilisé par : processeurs x86/x64 (Intel/AMD), certains ARM en mode little endian
Prenons le nombre décimal 305 419 896 qui s'écrit 0x12345678 en hexadécimal.
Ce nombre sur 32 bits se décompose en 4 octets :
- Octet 1 (MSB) : 0x12
- Octet 2 : 0x34
- Octet 3 : 0x56
- Octet 4 (LSB) : 0x78
En Big Endian :
Adresse : 0x1000 0x1001 0x1002 0x1003
Contenu : 0x12 0x34 0x56 0x78
(MSB) (LSB)
En Little Endian :
Adresse : 0x1000 0x1001 0x1002 0x1003
Contenu : 0x78 0x56 0x34 0x12
(LSB) (MSB)
- Les fichiers binaires créés sur un système big endian ne peuvent pas être lus directement sur un système little endian sans conversion
- Les protocoles réseau utilisent généralement big endian ("network byte order")
- Les formats de fichiers doivent spécifier leur endianness (exemple : TIFF peut être dans les deux formats)
Lors de la programmation en C, les fonctions de conversion sont essentielles :
htons() : Host TO Network Short (16 bits)htonl() : Host TO Network Long (32 bits)ntohs() : Network TO Host Shortntohl() : Network TO Host Long
En assembleur ou lors du débogage, il faut toujours tenir compte de l'endianness pour interpréter correctement les dumps mémoire.
Sur les architectures modernes, les processeurs peuvent souvent gérer les deux endianness, mais l'une des deux est généralement plus efficace (l'endianness native).
Voici un exemple de code C pour détecter l'endianness du système :
#include <stdio.h>
int main() {
unsigned int test = 0x12345678;
unsigned char *ptr = (unsigned char*)&test;
if (*ptr == 0x78) {
printf("Système Little Endian\n");
} else if (*ptr == 0x12) {
printf("Système Big Endian\n");
}
return 0;
}
Le terme "endian" provient du livre "Les Voyages de Gulliver" de Jonathan Swift, où deux peuples se disputaient sur la façon de casser les œufs : par le gros bout ou par le petit bout. Cette métaphore illustre parfaitement le caractère arbitraire mais important de cette convention.
L'endianness est un concept fondamental en informatique système et réseau, particulièrement important lors du développement d'applications multi-plateformes, de protocoles réseau, ou de formats de fichiers portables.
Dans les systèmes numériques, les données peuvent être corrompues lors du stockage, de la transmission ou du traitement. Les codes correcteurs d'erreurs permettent de détecter et parfois de corriger automatiquement ces altérations, garantissant ainsi la fiabilité des systèmes informatiques.
- Bruit électromagnétique sur les câbles réseau
- Interférences radio dans les communications sans fil
- Atténuation du signal sur de longues distances
- Défauts physiques sur les disques durs ou SSD
- Rayonnement cosmique affectant la mémoire RAM (bit flips)
- Usure des cellules dans les mémoires flash
- Permet de détecter qu'une erreur s'est produite
- Moins coûteuse en termes d'overhead (bits supplémentaires)
- Nécessite une retransmission en cas d'erreur détectée
- Permet de corriger automatiquement les erreurs détectées
- Plus coûteuse en overhead mais évite les retransmissions
- Particulièrement utile quand la retransmission est impossible ou coûteuse
Le code de parité est le plus simple des codes détecteurs d'erreurs.
Ajouter un bit de parité pour que le nombre total de bits à "1" soit pair.
Exemple avec le caractère 'A' (01000001) :
- Bits à 1 : 2 (nombre pair)
- Bit de parité : 0
- Code transmis : 001000001
Ajouter un bit de parité pour que le nombre total de bits à "1" soit impair.
- Détecte les erreurs affectant un nombre impair de bits
- Ne détecte pas les erreurs affectant un nombre pair de bits
- Aucune capacité de correction
Développé par Richard Hamming en 1950, ce code permet la détection de 2 erreurs et la correction de 1 erreur.
- Placer des bits de contrôle à des positions spécifiques (puissances de 2)
- Chaque bit de contrôle vérifie la parité d'un sous-ensemble de bits
- La combinaison des résultats de parité localise l'erreur
Codage de 4 bits de données avec 3 bits de contrôle :
Position : 1 2 3 4 5 6 7
Rôle : P1 P2 D1 P3 D2 D3 D4
Calcul des bits de parité :
- P1 contrôle les positions 1,3,5,7 (positions avec bit 1 en position 1)
- P2 contrôle les positions 2,3,6,7 (positions avec bit 1 en position 2)
- P3 contrôle les positions 4,5,6,7 (positions avec bit 1 en position 3)
Exemple avec les données 1101 :
- D1=1, D2=1, D3=0, D4=1
- P1 = parité de (P1,D1,D2,D4) = parité de (?,1,1,1) = 1
- P2 = parité de (P2,D1,D3,D4) = parité de (?,1,0,1) = 0
- P3 = parité de (P3,D2,D3,D4) = parité de (?,1,0,1) = 0
Code Hamming : 1011010
Si une erreur affecte le bit en position 6 (D3), le décodage donne :
- Vérification P1 : OK ✓
- Vérification P2 : KO ✗ (erreur détectée)
- Vérification P3 : KO ✗ (erreur détectée)
Syndrome d'erreur = P3P2P1 = 110₂ = 6₁₀ → erreur en position 6
Les Codes de Redondance Cyclique sont très utilisés dans les protocoles réseau et le stockage.
- Traiter les données comme un polynôme binaire
- Diviser par un polynôme générateur prédéfini
- Le reste de la division constitue le code CRC
- CRC-16 : x¹⁶ + x¹⁵ + x² + 1 (USB, modems)
- CRC-32 : x³² + x²⁶ + x²³ + ... (Ethernet, ZIP)
- CRC-64 : utilisé dans certains systèmes de stockage
- Détection garantie de toutes les erreurs de 1, 2 ou 3 bits
- Détection probable des erreurs multiples (probabilité très élevée)
- Efficacité computationnelle (implémentation matérielle simple)
- TCP : checksum 16 bits pour détecter les erreurs de transmission
- IP : checksum sur l'en-tête pour vérifier l'intégrité
- Ethernet : CRC-32 pour détecter les collisions et erreurs de trame
- SECDED (Single Error Correction, Double Error Detection)
- Utilise un code de Hamming étendu
- Critique pour les serveurs et systèmes embarqués
- RAID 1 : redondance par miroir
- RAID 5 : parité distribuée (reconstruction en cas de panne d'un disque)
- RAID 6 : double parité (tolérance à 2 pannes simultanées)
- Reed-Solomon : correction d'erreurs dans les QR codes
- Permet la lecture même si une partie du code est endommagée
La distance de Hamming entre deux mots de code est le nombre de positions où ils diffèrent.
Capacité de détection et correction :
- Pour détecter d erreurs : distance minimale ≥ d + 1
- Pour corriger t erreurs : distance minimale ≥ 2t + 1
Cette théorie, développée par Claude Shannon et Richard Hamming, constitue le fondement mathématique de tous les codes correcteurs modernes et garantit la fiabilité des systèmes numériques contemporains.
Les fonctions de hachage sont des algorithmes mathématiques qui transforment des données de taille arbitraire en une empreinte numérique de taille fixe appelée hash, digest ou checksum. Ces fonctions sont omniprésentes en informatique et constituent un pilier de la sécurité, de l'intégrité des données et de l'efficacité des systèmes.
Une fonction de hachage h prend en entrée un message M de taille variable et produit une sortie h(M) de taille fixe :
h : {0,1}* → {0,1}^n
Où n est la taille du hash en bits (ex: 128, 256, 512 bits).
Déterminisme :
- La même entrée produit toujours la même sortie
- h(M₁) = h(M₂) si et seulement si M₁ = M₂ (idéalement)
Uniformité :
- Les valeurs de sortie sont équitablement distribuées
- Chaque bit de sortie a 50% de chance d'être 0 ou 1
Effet avalanche :
- Un changement minimal en entrée provoque un changement drastique en sortie
- Exemple : h("Hello") ≠ h("hello") avec des hashs complètement différents
Somme de contrôle modulo :
checksum = (sum of all bytes) mod 256
Avantages : très rapide à calculer
Inconvénients : faible détection d'erreurs, vulnérable aux attaques
Déjà vu dans les codes correcteurs, les CRC sont optimisés pour la détection d'erreurs :
- CRC-32 : 32 bits, détection d'erreurs excellente
- CRC-64 : 64 bits, pour de très gros volumes de données
// Exemple simplifié de CRC-32
uint32_t crc32(uint8_t *data, size_t length) {
uint32_t crc = 0xFFFFFFFF;
for (size_t i = 0; i < length; i++) {
crc ^= data[i];
for (int j = 0; j < 8; j++) {
crc = (crc >> 1) ^ (0xEDB88320 & (-(crc & 1)));
}
}
return ~crc;
}
MD5 (Message Digest 5) :
- Sortie : 128 bits (32 caractères hexadécimaux)
- Obsolète pour la sécurité (collisions trouvées en 2004)
- Encore utilisé pour la vérification d'intégrité non-critique
SHA-1 (Secure Hash Algorithm 1) :
- Sortie : 160 bits (40 caractères hexadécimaux)
- Déprécié depuis 2017 (collisions pratiques démontrées)
SHA-2 (famille) :
- SHA-256 : 256 bits, standard actuel pour la sécurité
- SHA-512 : 512 bits, pour les applications très sensibles
- Résistant aux attaques connues à ce jour
SHA-3 (Keccak) :
- Nouveau standard depuis 2015
- Architecture différente de SHA-2 (réseau de substitution-permutation)
- Alternative de sécurité en cas de faille dans SHA-2
Téléchargement de fichiers :
# Vérification d'un fichier téléchargé
$ sha256sum ubuntu-22.04.iso
84aeaf7823c8c61baa0ae862d0a06b03409394800000b3235854a6ac1e462345 ubuntu-22.04.iso
Sauvegarde et synchronisation :
- rsync utilise des checksums pour détecter les fichiers modifiés
- Git utilise SHA-1 pour identifier chaque commit et objet
Structure de données fondamentale permettant un accès en O(1) moyen :
# Table de hachage simple en Python
class HashTable:
def __init__(self, size=16):
self.size = size
self.table = [[] for _ in range(size)]
def _hash(self, key):
return hash(key) % self.size
def put(self, key, value):
index = self._hash(key)
self.table[index].append((key, value))
def get(self, key):
index = self._hash(key)
for k, v in self.table[index]:
if k == key:
return v
return None
Applications :
- Bases de données : index pour accès rapide
- Compilateurs : tables de symboles
- Caches : mémorisation de résultats de calculs
Stockage sécurisé :
import hashlib
import os
def hash_password(password):
# Génération d'un sel aléatoire
salt = os.urandom(32)
# Hash avec SHA-256 + sel
key = hashlib.pbkdf2_hmac('sha256', password.encode(), salt, 100000)
return salt + key
def verify_password(password, stored_hash):
salt = stored_hash[:32]
key = stored_hash[32:]
new_key = hashlib.pbkdf2_hmac('sha256', password.encode(), salt, 100000)
return key == new_key
Bonnes pratiques :
- Utiliser un sel pour éviter les attaques par rainbow tables
- Fonctions spécialisées : bcrypt, scrypt, Argon2 (plus lentes intentionnellement)
Bitcoin :
- Utilise SHA-256 en double pour les hashs de blocs
- La preuve de travail consiste à trouver un hash commençant par des zéros
- Chaque transaction est identifiée par son hash
def find_duplicates(file_list):
hash_dict = {}
duplicates = []
for file_path in file_list:
file_hash = compute_file_hash(file_path)
if file_hash in hash_dict:
duplicates.append((file_path, hash_dict[file_hash]))
else:
hash_dict[file_hash] = file_path
return duplicates
Trouver deux messages M₁ et M₂ tels que h(M₁) = h(M₂)
Paradoxe des anniversaires :
- Pour un hash de n bits, une collision a 50% de chance d'apparaître après environ 2^(n/2) tentatives
- SHA-256 : collision attendue après ~2¹²⁸ tentatives (actuellement infaisable)
Étant donné un hash h, trouver un message M tel que h(M) = h
- Utiliser des fonctions récentes (SHA-2, SHA-3)
- Sels aléatoires pour les mots de passe
- Considérer la vitesse : plus lent = plus sécurisé pour l'authentification
Les fonctions de hachage sont donc un outil fondamental qui allie mathématiques, informatique et sécurité, permettant de garantir l'intégrité des données tout en optimisant les performances des systèmes.
En 1948, Claude Shannon révolutionne notre compréhension de l'information avec son article fondateur "A Mathematical Theory of Communication". Cette théorie établit les limites fondamentales de la compression, de la transmission et du stockage de l'information, formant la base mathématique de l'ère numérique.
Shannon transforme l'information d'un concept abstrait en une grandeur mathématique quantifiable. L'unité d'information devient le bit, défini comme la quantité d'information nécessaire pour distinguer entre deux alternatives équiprobables.
Pour un événement de probabilité P, la quantité d'information est :
I = -log₂(P) bits
Intuition : Plus un événement est rare (P petit), plus il apporte d'information quand il se produit.
Exemples :
- Pile ou Face équitable : I = -log₂(1/2) = 1 bit
- Dé à 6 faces équitable : I = -log₂(1/6) ≈ 2,58 bits
- Événement certain (P=1) : I = -log₂(1) = 0 bit (aucune information)
L'entropie H(X) d'une source d'information X représente la quantité moyenne d'information par symbole :
H(X) = -Σ P(xᵢ) × log₂(P(xᵢ)) bits/symbole
Mesure de l'incertitude :
- Entropie élevée = événements difficiles à prédire
- Entropie faible = événements prévisibles
Limite de compression :
- Théorème fondamental : impossible de compresser une source en dessous de son entropie
- L'entropie définit la compression optimale théorique
Source binaire équilibrée (0 et 1 équiprobables) :
- P(0) = P(1) = 1/2
- H = -1/2 × log₂(1/2) - 1/2 × log₂(1/2) = 1 bit/symbole
- Compression impossible (déjà optimal)
Source binaire déséquilibrée :
- P(0) = 0.9, P(1) = 0.1
- H = -0.9 × log₂(0.9) - 0.1 × log₂(0.1) ≈ 0.47 bit/symbole
- Compression possible jusqu'à ~47% de la taille originale
Texte en français :
- Entropie ≈ 1.3 bits/caractère (tenant compte des fréquences des lettres)
- Explique pourquoi ZIP compresse efficacement les textes
R = 1 - H(X)/H_max
Où H_max = log₂(n) pour un alphabet de n symboles.
Redondance du français :
- Alphabet : 26 lettres → H_max = log₂(26) ≈ 4.7 bits/lettre
- Entropie réelle ≈ 1.3 bits/lettre
- Redondance ≈ 1 - 1.3/4.7 ≈ 72%
Cette redondance explique :
- Pourquoi nous pouvons comprendre des textes avec des fautes
- L'efficacité des algorithmes de compression de texte
- La possibilité des codes correcteurs d'erreurs
Redondance statistique :
- Certaines lettres (E, A, S) plus fréquentes que d'autres (Z, W, K)
- Exploitée par le codage de Huffman
Redondance contextuelle :
- Certaines séquences plus probables ("QU", "TH" en anglais)
- Exploitée par les algorithmes LZ (ZIP, gzip)
Redondance sémantique :
- Sens du message apporte des contraintes
- Exploitée par l'intelligence artificielle (GPT, compression sémantique)
Shannon définit la capacité C d'un canal comme le débit maximum de transmission fiable :
C = B × log₂(1 + S/N) bits/seconde
Où :
- B = bande passante en Hz
- S/N = rapport signal/bruit
Théorème fondamental de Shannon :
- Si le débit de la source < C : transmission sans erreur possible
- Si le débit de la source > C : erreurs inévitables
- Définit la limite théorique de tout système de communication
Exemples :
- Ligne téléphonique (B=3000Hz, S/N=1000) : C ≈ 30 kbits/s
- Wi-Fi 802.11n (B=20MHz, S/N élevé) : C ≈ plusieurs centaines de Mbits/s
Compression sans perte :
- ZIP, gzip : s'approchent de l'entropie pour les textes
- PNG : compression optimale pour les images à forte redondance
Compression avec perte :
- JPEG, MP3 : éliminent l'information peu perceptible
- Entropie calculée sur l'information perceptuellement significative
Chiffrement parfait (chiffre de Vernam) :
- Clé aussi longue que le message et parfaitement aléatoire
- Entropie de la clé = entropie du message
- Sécurité théorique absolue démontrée par Shannon
Modèles de langage (GPT, etc.) :
- Estiment l'entropie conditionnelle du langage naturel
- Compression = prédiction = intelligence (hypothèse de Solomonoff)
Génome humain :
- Entropie ≈ 1.6 bits/nucléotide (théorique : 2 bits)
- Redondance exploitée pour la compression des séquences ADN
- Complexité algorithmique d'une chaîne = longueur du plus court programme la générant
- Généralise l'entropie de Shannon aux séquences individuelles
- Qubit : unité d'information quantique
- Entropie de von Neumann pour les systèmes quantiques
- Base de l'informatique quantique et de la cryptographie quantique
La théorie de Shannon reste universellement applicable : elle définit les limites fondamentales de la compression, de la transmission et du stockage d'information, constituant le socle théorique de toutes les technologies numériques modernes.
Le son est une vibration mécanique qui se propage sous forme d'ondes. Sa numérisation se fait en deux étapes principales :
- Mesure de l'amplitude du signal à intervalles réguliers
- La fréquence d'échantillonnage détermine la qualité (théorème de Nyquist-Shannon)
- Elle doit être au moins le double de la fréquence maximale du signal
- Conversion des valeurs continues en valeurs discrètes
- Le nombre de bits utilisés détermine la précision (résolution)
- Plus il y a de bits, plus la dynamique est grande
Nombre de canaux : mono (1), stéréo (2), multicanal (5.1, 7.1, etc.)
Fréquence d'échantillonnage : nombre d'échantillons par seconde (Hz)
- 8 kHz : téléphonie
- 44,1 kHz : qualité CD
- 48 kHz : standard professionnel audio et audiovisuel
- 96/192 kHz : haute définition
Résolution : nombre de bits par échantillon
- 8 bits : qualité basse (téléphonie)
- 16 bits : qualité CD (65 536 niveaux)
- 24 bits : qualité studio (16 777 216 niveaux)
La compression permet de réduire la taille des fichiers audio :
- Conserve toute l'information du signal original
- Se base sur la redondance et les motifs statistiques dans le signal
- Formats : FLAC (Free Lossless Audio Codec), ALAC (Apple Lossless), APE, WavPack
- Taux de compression typique : 30-50% de réduction (ratio 2:1)
- Utilisée principalement pour l'archivage et l'audiophilie
- Exploite les limites de la perception auditive humaine (psychoacoustique)
- Principe du masquage : un son fort masque les sons faibles proches en fréquence
- Supprime les fréquences peu ou pas perceptibles à l'oreille humaine
- Compression par bandes de fréquences avec allocation dynamique de bits
- Formats : MP3, AAC, Ogg Vorbis, Opus
- Division du signal en trames et bandes de fréquences
- Analyse psychoacoustique (seuils d'audition, masquage)
- Quantification et codage des différentes bandes selon leur importance perceptive
- Codage entropique (Huffman) pour compresser davantage
- G.711 (téléphonie) : 64 kbit/s (mono)
- GSM (téléphonie mobile) : 13 kbit/s (mono)
- MP3 : 128-320 kbit/s (stéréo) - qualité variable
- AAC : 96-256 kbit/s (stéréo) - meilleure efficacité que MP3
- Opus : 6-510 kbit/s - très polyvalent, de la VoIP à la HiFi
- FLAC : environ 50-70% de la taille non compressée
Il existe deux grands types d'images numériques :
- Composées de primitives géométriques (points, lignes, courbes, polygones)
- Indépendantes de la résolution (redimensionnables sans perte de qualité)
- Formats : SVG, PDF, DWG, EPS, etc.
- Applications : dessin technique, logos, polices de caractères, infographie
- Composées de pixels (points élémentaires)
- Dépendantes de la résolution
- Formats : BMP, JPEG, PNG, GIF, TIFF, etc.
- Applications : photographie, retouche d'image, numérisation
La numérisation d'une image comprend :
- Nombre de pixels horizontaux × nombre de pixels verticaux
- Exemples : 1920×1080 (Full HD), 3840×2160 (Ultra HD ou UHD-4K), 4096×2160 (4K cinéma/DCI-4K)
- La résolution est la densité de pixels (ppp/dpi)
Différents modèles colorimétriques sont utilisés selon les besoins :
RVB (RGB) - Synthèse additive
- Trois composantes : Rouge, Vert, Bleu
- Codage typique : 8 bits par composante (24 bits par pixel, "True Color")
- 16,7 millions de couleurs possibles (2^24)
- Notation hexadécimale : #RRGGBB (ex. #FF0000 pour le rouge pur)
- Utilisé pour les écrans et l'affichage
CMJN (CMYK) - Synthèse soustractive
- Quatre composantes : Cyan, Magenta, Jaune, Noir
- Utilisé principalement pour l'impression
Niveaux de gris
- Une seule composante de luminosité
- Typiquement 8 bits (256 niveaux de gris)
- Utilisé pour les images monochromes
TSL (HSL) - Teinte, Saturation, Luminosité
- Représentation plus intuitive pour les utilisateurs
- La teinte représente la couleur (0-360°)
- La saturation représente la pureté de la couleur (0-100%)
- La luminosité représente la clarté de la couleur (0-100%)
La compression est nécessaire pour réduire la taille des fichiers :
- Préserve toute l'information de l'image
- Formats : PNG, TIFF, GIF
- Élimine les détails moins perceptibles
- Format JPEG : utilise la transformation en cosinus discrète (DCT)
- Décompose l'image en blocs de 8×8 pixels
- Quantifie les coefficients DCT selon un facteur de qualité
La compression vidéo combine la compression spatiale (intra-image, comme JPEG) et la compression temporelle (inter-images).
Elle exploite trois types de redondance :
- Spatiale : similarité dans une même image (zones de couleurs uniformes)
- Temporelle : similarité entre images successives
- Statistique : fréquence d'apparition des motifs
- Images I (Intra) : images complètes, codées de façon autonome comme un JPEG
- Images P (Predicted) : contiennent seulement les différences par rapport à l'image précédente
- Images B (Bidirectional) : codées par référence aux images précédentes ET suivantes
- Estimation et compensation de mouvement par blocs (macroblocs)
- Prédiction de mouvement multi-références
- Transformées fréquentielles adaptatives (DCT, transformée entière)
- Filtres de déblocage pour réduire les artefacts
- MPEG-2 : DVD, télévision numérique SD (années 1990)
- H.264/AVC : Blu-ray, streaming HD, vidéoconférence (années 2000)
- H.265/HEVC : 4K, HDR, 50% plus efficace que H.264 (années 2010)
- AV1 : codec ouvert, conçu pour le streaming, plus efficace que HEVC (années 2020)
- H.266/VVC : conçu pour la 8K, 30-50% plus efficace que HEVC
L'information numérique repose sur des concepts fondamentaux qui permettent de représenter et manipuler sous forme binaire tout type d'information. La compréhension de ces principes est essentielle pour appréhender l'informatique moderne et les technologies numériques.
L'évolution des technologies numériques a permis des avancées considérables en termes de capacité de stockage, de puissance de calcul et de vitesse de transmission. Ces progrès continuent d'ouvrir de nouvelles possibilités dans tous les domaines, de la communication à la médecine, en passant par l'éducation et le divertissement.
Les concepts fondamentaux abordés dans ce cours constituent le socle de connaissances nécessaires pour comprendre et maîtriser les systèmes et réseaux informatiques, ainsi que pour s'adapter aux évolutions technologiques futures.