Binaire et représentation des données

Un bit prend l’une de deux valeurs : 0 ou 1. Le matériel peut distinguer de façon fiable deux états physiques, comme une tension haute ou basse, des directions d’aimantation opposées, ou la présence et l’absence de lumière. Les chiffres écrits décrivent ces états ; ils n’ont pas besoin d’apparaître littéralement dans un appareil.

Compter les configurations

Chaque nouveau bit double les possibilités. Deux bits donnent quatre configurations : 00, 01, 10 et 11. Trois bits en donnent huit. En général, $n$ bits donnent $2^n$ configurations. Un demi-octet comporte 4 bits et un octet en comporte 8 : un octet donne donc 256 configurations. L’octet est aussi la plus petite unité de mémoire adressable sur la plupart des ordinateurs modernes.

Pour coder un ensemble de valeurs, choisis assez de configurations pour chacune d’elles. Pour 26 lettres, quatre bits ne donnent que 16 configurations ; cinq bits en donnent 32 et suffisent donc. Pour 1 000 valeurs, neuf bits en donnent 512 et dix en donnent 1 024. Des configurations peuvent rester inutilisées. Avec 16 bits, on dispose de 65 536 configurations, et avec 32 bits, de 4 294 967 296.

Le nombre de configurations diffère du plus grand nombre non signé. Quatre bits donnent 16 configurations, mais le décompte commence à zéro : les valeurs vont donc de 0 à 15. Une configuration est déjà utilisée pour zéro.

Pour trouver systématiquement le nombre minimal de bits, compare les puissances successives de deux au nombre de possibilités nécessaires. Arrête-toi à la première puissance suffisamment grande. Pour N valeurs distinctes, le critère est $2^n\ge N$. L’égalité exacte est permise : huit possibilités tiennent sur trois bits, tandis qu’une neuvième nécessite un quatrième bit. Un nombre de bits plus grand convient aussi, mais ce n’est plus le minimum.

Donner un sens à la configuration

L’octet 01000001 peut représenter l’entier 65, la lettre ASCII « A » ou une intensité de canal de couleur de 65 sur une échelle de 0 à 255. Les bits seuls ne déterminent pas la lecture à choisir. Le type de données d’un programme et le format du fichier déterminent leur interprétation.

Lire les unités de stockage

Deux familles de préfixes sont courantes :

Les préfixes décimaux sont des préfixes SI ; les préfixes binaires sont des préfixes CEI. À chaque échelon décimal, l’unité est multipliée par 1 000 ; à chaque échelon binaire, elle est multipliée par 1 024. Pour exprimer des octets dans une unité plus grande, divise par le nombre d’octets de cette unité.

Un disque indiqué comme ayant une capacité de 500 GB contient 500 000 000 000 d’octets. La division par 1 073 741 824 donne environ 465,66 GiB. Un logiciel peut noter cette quantité binaire « GB », ce qui donne l’impression que la capacité affichée est plus petite. Le changement d’unité en lui-même n’a supprimé aucun octet ; le formatage et les fichiers système sont d’autres questions.

Distinguer les bits des octets

Un b minuscule désigne un bit ; un B majuscule désigne un octet. Une connexion à 100 Mbit/s transfère au maximum 100 millions de bits par seconde. La division par 8 donne 12,5 millions d’octets par seconde, soit 12,5 MB/s, avant la surcharge protocolaire. Lire ce débit comme 100 MB/s revient à le multiplier par huit.

Le binaire est un système de numération de position : la valeur d’un chiffre dépend de sa place. Le décimal utilise dix chiffres et des puissances de 10. Le binaire utilise deux chiffres, 0 et 1, et des puissances de 2. Pour lire un nombre binaire, on additionne les valeurs des positions contenant un 1.

Lire un entier binaire

De droite à gauche, les valeurs de position sont 1, 2, 4, 8, 16, 32, 64, 128, et ainsi de suite. Chacune est le double de la précédente, car $2^0=1$, $2^1=2$ et $2^2=4$.

Pour ${101101}_2$, aligne les six bits sur leurs valeurs de position :

La valeur est $32+8+4+1=45$. Un zéro n’ajoute rien, mais il maintient les autres chiffres à leur place. Les zéros à gauche ne changent pas la valeur : 00101101 vaut aussi 45.

Le bit le plus à gauche est le bit de poids fort. Celui le plus à droite est le bit de poids faible. Toutes les valeurs de position sauf la dernière sont paires : un entier binaire est donc impair exactement lorsque son bit de poids faible vaut 1.

Convertir par soustraction de puissances de deux

Pour écrire 156 en binaire, commence par la plus grande puissance de deux qui ne dépasse pas ce nombre : 128. Soustrais-la : il reste 28. Les valeurs de position 64 et 32 sont trop grandes, elles reçoivent donc toutes deux 0. Prends 16, il reste 12 ; prends 8, il reste 4 ; prends 4, il reste 0. Les positions inutilisées de valeurs 2 et 1 reçoivent 0.

Dans l’ordre des positions, le résultat est $156={10011100}_2$. Vérifie en additionnant les valeurs de position choisies : $128+16+8+4=156$. Sauter une colonne inutilisée déplacerait tous les bits suivants et changerait le nombre.

La méthode par soustraction fonctionne parce que chaque position binaire ne peut être utilisée qu’une fois. Après avoir pris la plus grande puissance qui convient, le reste est inférieur à cette puissance. Continue en descendant toutes les positions, y compris celles qui reçoivent zéro, jusqu’à remplir celle des unités. Les bits choisis sont ainsi alignés sur des puissances distinctes, au lieu de former une liste de puissances sans position.

Convertir par divisions successives

Une autre méthode consiste à diviser successivement par 2. Garde le quotient pour la division suivante et note le reste :

Lis les restes de bas en haut, ce qui donne 10011100. Le premier reste correspond à la position des unités : lire de haut en bas inverse donc l’ordre des positions. Ici, cela donnerait 00111001, soit 57.

Garder la base visible

L’indice de ${10}_2$ indique la base 2 : sa valeur est donc deux. Les mêmes chiffres dans ${10}_{10}$ valent dix. On lit généralement le binaire chiffre par chiffre : « un zéro ». Le décompte est 0, 1, 10, 11, 100, 101, 110, 111, 1000 ; on passe à la colonne suivante lorsqu’une colonne atteint 2. Une suite de huit uns vaut $2^8-1=255$. Ajouter un zéro à droite décale chaque position vers la gauche et double la valeur : 101 devient 1010, faisant passer la valeur de cinq à dix.

L’hexadécimal écrit les nombres en base 16. Ses chiffres vont de 0 à 9, suivis de A, B, C, D, E et F, qui représentent les valeurs de 10 à 15. Un seul chiffre hexadécimal peut décrire tous les groupes possibles de quatre bits, ce qui facilite la lecture des longues configurations binaires.

Associer quatre bits à un chiffre

Puisque $16=2^4$, chaque position hexadécimale correspond exactement à quatre positions binaires :

Pour passer du binaire à l’hexadécimal, forme les groupes à partir de la droite. La configuration 10011100 devient 1001 1100, soit 0x9C. Si le dernier groupe à gauche est plus court, ajoute des zéros à gauche : 101101 devient 0010 1101, soit 0x2D. Le regroupement à partir de la gauche sous la forme 1011 01 placerait les chiffres aux mauvaises positions.

Pour effectuer la conversion inverse, développe chaque chiffre en quatre bits. Ainsi, 0x3E8 devient 0011 1110 1000. Garde les quatre bits dans chaque groupe, même lorsqu’un groupe commence par des zéros. Seuls les zéros situés tout à gauche du nombre entier peuvent être supprimés sans changer sa valeur.

Utiliser les valeurs de position en base 16

De droite à gauche, les valeurs de position en hexadécimal sont 1, 16, 256 et 4 096. Multiplie la valeur de chaque chiffre par sa valeur de position, puis additionne. Pour 0x2F, le calcul est $2\times 16+15=47$. Pour 0x3E8 :

La conversion du décimal à l’hexadécimal fonctionne aussi par divisions successives, cette fois par 16. Pour 1 000, le premier quotient est 62 et le reste 8. La division de 62 donne un quotient de 3 et un reste de 14, écrit E. La division de 3 donne un quotient de 0 et un reste de 3. Lis les restes en remontant : 3, E, 8.

Le regroupement fonctionne grâce à la valeur de position, et pas seulement grâce à une table de correspondance. Dans un nombre hexadécimal à deux chiffres, le demi-octet de gauche contribue pour sa valeur multipliée par 16, et celui de droite pour sa valeur multipliée par 1. En binaire, décaler un demi-octet de quatre positions vers la gauche multiplie aussi sa valeur par 16. Ce facteur commun permet de lire les deux groupes séparément sans d’abord convertir le nombre entier en décimal.

Reconnaître les usages courants

Un octet comporte deux demi-octets : il correspond donc exactement à deux chiffres hexadécimaux, de 0x00 à 0xFF. Une visionneuse d’octets peut afficher un long fichier de façon quatre fois plus compacte en hexadécimal qu’en binaire, tout en gardant visibles les séparations entre groupes.

Les couleurs du Web comme #FF8000 utilisent des paires de chiffres hexadécimaux pour le rouge, le vert et le bleu. Les adresses mémoire et les points de code Unicode comme U+00E9 utilisent aussi l’hexadécimal. Une adresse MAC comme 3C:22:FB:9A:01:7E écrit six octets avec douze chiffres hexadécimaux, avec des séparateurs entre les octets.

Le préfixe 0x, un indice de base comme dans $2F_{16}$ ou le # d’un code couleur indique la notation. L’ordinateur stocke les mêmes bits quelle que soit la notation utilisée. En particulier, 0x10 vaut seize. La valeur quinze correspond au seul chiffre F ; écrire « 15 » occupe deux positions hexadécimales et représente vingt et un.

Un entier non signé représente un nombre entier positif ou nul. Tous ses bits ont les poids binaires positifs habituels. Le nombre de bits fixe celui des positions disponibles : un octet ne peut donc pas gagner un neuvième bit simplement parce qu’un résultat en a besoin.

Trouver la plage de valeurs

Avec $n$ bits, il existe $2^n$ configurations. En commençant à zéro, on obtient la plage de $0\grave{\text{a}}{2}^n-1$. La plus grande valeur comporte un 1 à chaque position :

Le nombre de valeurs disponibles et la valeur maximale diffèrent de un. Huit bits permettent de représenter 256 possibilités, mais 256 lui-même nécessite neuf positions, soit 1 0000 0000.

Une valeur stockée est complétée par des zéros à gauche pour occuper tous les bits. Par exemple, 45 sur 16 bits s’écrit 0000000000101101, soit 0x002D. Ces zéros indiquent le nombre de bits sans changer la valeur. Un nombre négatif n’a pas de représentation non signée, quel que soit le nombre de bits choisi.

Choisir suffisamment de positions

Une plage d’âges de 0 à 150 tient sur 8 bits, car 150 est inférieur à 255. Un décompte de 0 à 100 000 comprend 100 001 valeurs possibles. Seize bits ne donnent que 65 536 configurations. Dix-sept en donnent 131 072 : 17 est donc le minimum mathématique. Un programme utilisant les nombres de bits courants 8, 16, 32 et 64 choisirait 32 bits.

Le même raisonnement s’applique à tout compteur borné : vérifie la plus grande valeur que le compteur doit effectivement contenir, en tenant compte des deux extrémités. Une plage de 0 à 256 nécessite 257 configurations et ne tient donc pas dans un octet.

Une vérification utile aux limites consiste à comparer deux nombres de bits consécutifs. Le maximum non signé sur 8 bits est 255 et, sur 9 bits, il est de 511. Ajouter un bit double le nombre de configurations ; le maximum devient le double de l’ancien maximum plus un. Cette distinction compte lorsqu’une valeur requise correspond exactement à une puissance de deux : cette extrémité nécessite une nouvelle position, même si le nombre de bits précédent donne autant de configurations.

Suivre un résultat hors de la plage

Un dépassement de capacité signifie qu’un résultat ne tient pas dans la représentation choisie. Si un calcul sur 8 bits ne conserve que les huit bits de poids faible, 255 plus 1 produit 1 0000 0000 et stocke 00000000 : zéro. La position supplémentaire est éliminée.

Pour 200 plus 100, le résultat mathématique est 300. Le nombre de bits disponible conserve le reste après un cycle complet de 256 configurations : $300-256=44$. L’octet stocké est 00101100. Ce comportement s’appelle le rebouclage. Il ne change pas le fait arithmétique que 200 plus 100 vaut 300 ; il décrit ce que le stockage limité conserve.

Le comportement en cas de dépassement dépend du système. Certaines opérations rebouclent, d’autres signalent une erreur et certains types de nombres s’agrandissent. Dans un calcul qui porte sur le rebouclage, ce comportement doit être précisé avant que tu élimines les bits de poids fort.

Observer les nombres fixes de bits dans les données

Une adresse IPv4 comporte 32 bits, soit environ 4,3 milliards de configurations possibles. Cet espace d’adresses limité a contribué au besoin d’un système d’adressage plus grand. Un canal de couleur RVB ordinaire comporte 8 bits, ce qui explique son échelle d’intensité de 0 à 255. Dans les deux cas, le maximum découle du nombre de bits ; une écriture décimale plus longue n’ajoute aucune capacité de stockage.

Un entier négatif nécessite une règle de représentation : il ne suffit pas d’écrire un signe moins à côté d’un octet. Le complément à deux attribue un poids négatif au bit de poids fort. Les autres positions gardent leurs poids positifs : chaque configuration correspond ainsi à une seule valeur signée et zéro à une seule configuration.

Comparer deux lectures signées

Une méthode plus simple, la représentation en signe et valeur absolue, utilise le bit de poids fort uniquement pour le signe et les autres bits pour la valeur absolue. Sur 8 bits, +5 s’écrit 00000101 et −5 s’écrit 10000101. Cette méthode comporte deux zéros, 00000000 et 10000000, et l’addition de nombres de signes différents nécessite des règles supplémentaires.

En complément à deux sur 8 bits, les poids sont −128, 64, 32, 16, 8, 4, 2 et 1. Ainsi, 11010011 représente $-128+64+16+2+1=-45$. Lire les sept autres bits comme une valeur absolue de 83 donnerait −83, ce qui correspond à une autre représentation.

En général, la plage va de $-2^{n-1}\grave{\text{a}}{2}^{n-1}-1$. Zéro et les valeurs positives s’écrivent comme en binaire ordinaire avec un 0 initial. Une suite composée uniquement de uns représente −1.

Écrire une valeur négative

Pour changer le signe d’une valeur représentable, inverse tous les bits et ajoute 1, en conservant le même nombre de bits. Pour coder −45 sur 8 bits :

1. Écris +45 sous la forme 00101101.
2. Inverse les huit bits : 11010010.
3. Ajoute 1 : 11010011, soit 0xD3.

S’arrêter après l’inversion donne −46. Appliquer le processus complet à 11010011 donne à nouveau 00101101 et permet de retrouver +45.

Une autre méthode consiste à coder $-x$ comme la valeur non signée $2^n-x$. Ici, $256-45=211$, dont l’écriture binaire est 11010011. L’octet représente donc 211 en non signé ou −45 en signé. Les bits n’ont pas changé ; c’est le type qui a changé.

L’inversion suivie de l’addition a aussi une explication arithmétique. Pour une valeur positive x sur n bits, l’inversion la transforme en la valeur non signée $2^n-1-x$. Ajouter un donne $2^n-x$, dont l’interprétation signée est −x. Cela relie la méthode bit par bit à la méthode par soustraction et explique pourquoi l’omission du 1 final donne une valeur négative incorrecte.

Préserver une valeur signée sur davantage de bits

L’extension de signe copie le bit de poids fort dans les nouvelles positions à gauche. −3 sur quatre bits s’écrit 1101 ; sur 8 bits, il s’écrit 11111101. Son poids négatif de gauche et les poids positifs ajoutés donnent toujours un total de −3. Le compléter avec des zéros donnerait 00001101, soit +13. Les valeurs positives sont étendues avec des zéros : 0011 devient 00000011.

Reconnaître les extrémités de la plage

Le complément à deux permet l’addition binaire ordinaire pour les résultats qui tiennent dans la plage. Sur 4 bits, 0101 plus 1101, soit 5 plus −3, donne 1 0010. Les quatre bits de poids faible conservés donnent 0010, soit 2. Le même matériel d’addition de base peut ainsi traiter les valeurs signées et non signées.

Un résultat hors plage est différent : sur 8 bits, 127 plus 1 laisse 10000000, qui se lit −128. De plus, −128 n’a pas d’opposé positif sur 8 bits. Inverser 10000000 et ajouter 1 redonne 10000000, car +128 est hors de la plage. Augmente le nombre de bits avant de former cette valeur positive.

La première position après la virgule binaire vaut un demi. Chaque position suivante vaut la moitié de la précédente : un quart, un huitième, un seizième, et ainsi de suite. Un 1 ajoute la fraction correspondante ; un 0 ne l’ajoute pas. Les positions de la partie entière à gauche conservent leurs puissances de deux habituelles.

Lire et construire une fraction binaire

Pour ${\mathrm{101,101}}_2$, la partie entière vaut 4 plus 1. La partie fractionnaire vaut un demi plus un huitième, ce qui donne $4+1+\mathrm{0,5}+\mathrm{0,125}=\mathrm{5,625}$.

Pour convertir une fraction décimale, multiplie-la successivement par 2. La partie entière de chaque résultat est le chiffre binaire suivant ; ne garde que la partie fractionnaire pour la multiplication suivante. Pour 0,375 :

1. $\mathrm{0,375}\times 2=\mathrm{0,75}$, donc le premier bit est 0.
2. $\mathrm{0,75}\times 2=\mathrm{1,5}$, donc le bit suivant est 1 ; garde 0,5.
3. $\mathrm{0,5}\times 2=\mathrm{1,0}$, donc le bit suivant est 1 et le processus s’arrête.

Le résultat est ${\mathrm{0,011}}_2$. Sa valeur est un quart plus un huitième, soit 0,375. Ces bits se lisent dans l’ordre où ils ont été trouvés, contrairement aux restes de la division d’un entier.

Déterminer si le développement est fini

Réduis la fraction. Son développement binaire est fini exactement lorsque son dénominateur est une puissance de 2. Des valeurs comme 0,5, 0,25, 0,75 et 0,375 satisfont ce critère. Par exemple, 0,375 vaut 3/8, et huit est une puissance de deux.

Le nombre décimal 0,1 vaut 1/10. Son dénominateur comprend un facteur 5, donc son développement binaire se répète : $\mathrm{0,0001100110011}{\dots }_2$. Tout comme un tiers ne peut pas avoir d’écriture décimale finie, un dixième ne peut pas avoir d’écriture binaire finie. La forme écrite courte « 0,1 » nécessite donc une approximation lorsque seul un nombre limité de positions binaires est disponible. Le même problème concerne 0,2 et 0,3.

La règle du dénominateur découle des positions elles-mêmes. Une suite finie qui se termine à la f-ième position fractionnaire peut s’écrire comme un entier divisé par $2^f$. Réduire cette fraction peut supprimer des facteurs deux, mais ne peut pas introduire un autre facteur premier dans le dénominateur. Un dénominateur réduit contenant le facteur cinq ne peut donc correspondre à aucune somme binaire finie de ce type.

Réserver une échelle fixe

Une représentation à virgule fixe attribue un nombre défini de bits à la partie fractionnaire. Avec quatre bits pour la partie entière et quatre pour la partie fractionnaire, 0110,1000 vaut 6,5. Le plus petit pas est $2^{-4}=\mathrm{0,0625}$ et la plus grande valeur non signée est 1111,1111, soit 15,9375.

De façon équivalente, l’entier stocké sur huit bits est multiplié par 1/16. La configuration 01101000 a pour valeur non signée 104 ; la division par 16 donne 6,5. La virgule fait partie de l’interprétation : elle n’a donc pas besoin d’être stockée comme symbole supplémentaire.

Si l’on garde huit bits au total mais qu’on utilise cinq bits pour la partie entière et trois pour la partie fractionnaire, le pas devient 0,125 et le maximum 31,875. On gagne en plage de valeurs, mais on perd en finesse. Dans sa plage, la virgule fixe représente exactement les multiples de son pas.

Un décompte exact de centimes utilise une idée d’échelle apparentée : 19,99 unités monétaires deviennent l’entier 1 999 centimes. Pour les mesures couvrant des grandeurs très différentes, la virgule flottante stocke une échelle mobile, ce qui permet au même nombre de bits de couvrir une plage bien plus large que la virgule fixe.

La virgule flottante écrit une valeur en notation scientifique binaire. Par exemple, 6,25 s’écrit ${\mathrm{110,01}}_2={\mathrm{1,1001}}_2\times 2^2$. La partie initiale est le significande et l’exposant détermine son échelle. IEEE 754 définit des formats largement utilisés pour stocker ces parties.

Connaître les champs

Pour une valeur normale, la lecture est $(-1{)}^s\times (\mathrm{1,}f{)}_2\times 2^{E-\text{biais}}$. Ici, $s$ est le bit de signe, $E$ l’exposant stocké non signé et $f$ le champ de fraction. Un bit de signe égal à 0 indique une valeur positive ; égal à 1, une valeur négative. Modifier uniquement le bit de signe change le signe d’une valeur à virgule flottante.

L’exposant stocké est égal à l’exposant réel plus le biais. En simple précision, l’exposant 2 devient 129, soit 10000001 ; l’exposant −3 devient 124, soit 01111100. Les exposants stockés des nombres normaux vont de 1 à 254 et représentent les exposants réels de −126 à 127.

Un significande binaire normal commence toujours par 1 : le format omet donc ce bit implicite. Seuls les bits après la virgule entrent dans le champ de fraction. Cela donne 24 chiffres binaires significatifs en simple précision et 53 en double précision.

Coder −6,25 étape par étape

Commence par normaliser sa valeur absolue : ${\mathrm{110,01}}_2={\mathrm{1,1001}}_2\times 2^2$. Remplis ensuite les champs :

1. Valeur négative : signe 1.
2. Exposant 2 : ajoute 127 pour obtenir 129, écrit 10000001.
3. Fraction ,1001 : stocke 1001 suivi de 19 zéros.

Le résultat est 1 10000001 10010000000000000000000, soit 0xC0C80000. La fraction est complétée par des zéros à droite, car ces positions se prolongent après la virgule. Stocker le 1 initial décalerait le sens de la fraction.

Un exposant réel négatif donne une échelle inférieure à un. Pour 0,15625, l’écriture binaire est ${\mathrm{0,00101}}_2={\mathrm{1,01}}_2\times 2^{-3}$. Son signe en binary32 est 0 et son exposant stocké est 124, soit 01111100. La fraction commence par 01 et est complétée à droite. Le 1 implicite appartient toujours au significande normalisé, même si le nombre complet est inférieur à un.

Décoder une configuration

La configuration en simple précision 0x41200000 se décompose en 0 10000010 01000000000000000000000. Le signe est positif. Le champ d’exposant vaut 130 : soustrais donc 127 pour obtenir 3. Rétablis le 1 implicite pour obtenir ${\mathrm{1,01}}_2=\mathrm{1,25}$. Enfin, $\mathrm{1,25}\times 2^3=10$.

Vérifier d’abord les exposants réservés

La formule des nombres normaux ne décrit pas toutes les configurations :

Les valeurs dénormalisées représentent de très petites valeurs sans le 1 implicite. NaN peut résulter d’une opération numérique non valide comme 0 divisé par 0. IEEE 754-2019 définit ces formats.

Un format à virgule flottante peut couvrir une immense plage sans représenter toutes les valeurs de cette plage. L’exposant détermine l’échelle ; le champ de fraction détermine le nombre de bits significatifs qui distinguent les valeurs voisines. La plage de valeurs et la précision répondent à des questions différentes.

Comparer la simple et la double précision

La simple précision atteint environ $\mathrm{3,4}\times {10}^{38}$ et conserve environ sept chiffres décimaux significatifs. Sa plus petite valeur normale positive est d’environ $\mathrm{1,18}\times {10}^{-38}$. La double précision atteint environ $\mathrm{1,8}\times {10}^{308}$, conserve environ 15 à 16 chiffres décimaux significatifs et a une plus petite valeur normale positive d’environ $\mathrm{2,2}\times {10}^{-308}$. Les valeurs dénormalisées descendent en dessous du minimum normal dans chaque format.

Les chiffres significatifs sont comptés à partir du premier chiffre qui a un sens, et non à partir de la virgule. Un exposant élevé ne crée pas davantage de bits de fraction. En simple précision, l’écart au-dessus de 1 est $2^{-23}\approx \mathrm{1,19}\times {10}^{-7}$. Entre $2^{24}$ et $2^{25}$, l’écart est de 2 : l’entier 16 777 217 n’est donc pas représentable, bien qu’il soit très inférieur à la valeur finie maximale.

Arrondir à une valeur représentable

La règle par défaut d’IEEE 754 est l’arrondi au plus proche, au pair en cas d’égalité. Choisis la valeur représentable la plus proche ; si le nombre est exactement à mi-chemin, choisis celle dont le dernier bit du significande conservé est pair. Ainsi, 16 777 217 est arrondi à 16 777 216 en simple précision.

L’écart entre la valeur voulue et la valeur stockée est l’erreur d’arrondi. En simple précision, 0,1 est stocké sous la forme 0,100000001490116119384765625. En double précision, il vaut approximativement 0,10000000000000000555. Une plus grande précision réduit cette erreur, mais ne peut pas rendre fini un développement périodique.

Comprendre un résultat connu

Avec l’arithmétique ordinaire en double précision IEEE 754, l’addition de 0,1 et 0,2 produit un résultat stocké généralement affiché sous la forme 0.30000000000000004. Il diffère de l’approximation stockée de 0,3 : 0.1 + 0.2 == 0.3 est donc faux dans des langages comme Python et JavaScript. Pour des résultats de mesure, compare la différence à une tolérance choisie selon l’échelle et l’objectif de la tâche.

De nombreuses valeurs sont exactes. La double précision stocke exactement tous les entiers de $-2^{53}$ à $2^{53}$. Des valeurs comme 0,5 et 0,375 ont aussi des écritures binaires courtes qui tiennent dans son significande et sa plage d’exposants.

Choisir un type de nombre adapté

Les entiers conviennent aux décomptes et aux identifiants. Pour des montants financiers exacts, on peut utiliser des unités monétaires fractionnaires entières, comme des centimes, ou un type de nombre décimal. La virgule flottante convient souvent aux mesures et aux calculs scientifiques. Une grandeur trop grande pour le format peut entraîner un dépassement de capacité vers l’infini ; avec la règle d’arrondi par défaut, ${10}^{39}$ en simple précision devient l’infini positif. Les très petits résultats peuvent devenir dénormalisés ou être arrondis à zéro.

Les conventions d’affichage sont distinctes du stockage. Les écritures "3.14" et "3,14" peuvent désigner le même nombre selon le pays. Un logiciel qui lit du texte doit connaître la convention utilisée ; sinon, il risque de rejeter la virgule ou de lire la valeur comme 314. Changer le séparateur affiché n’améliore pas la précision binaire.

Pour stocker du texte, un système attribue des codes numériques aux caractères et écrit ces nombres sous forme de bits. Un code de caractère ne fonctionne que si le lecteur utilise la même convention que l’auteur. L’octet qui représente une lettre est une notation codée ; ce n’est pas une minuscule image de cette lettre.

Lire la table ASCII

ASCII, l’American Standard Code for Information Interchange, a été publié pour la première fois en 1963. Il utilise 7 bits pour 128 codes numérotés de 0 à 127. Dans un stockage par octets, un code ASCII occupe généralement un octet avec un 0 initial.

La ponctuation occupe les espaces restants. Les codes de 32 à 126 forment 95 caractères imprimables, espace compris. Les caractères de contrôle agissent sur le traitement du texte sans imprimer de symbole visible : la tabulation est 9, le saut de ligne est 10 et le retour chariot est 13.

Encoder une courte chaîne de caractères

Le texte « Hi! » comporte trois caractères. Leurs codes décimaux sont 72, 105 et 33 ; en hexadécimal, ce sont 0x48, 0x69 et 0x21. Sous forme d’octets complets, le texte devient 01001000 01101001 00100001. Le point d’exclamation a besoin d’un code tout comme les lettres.

Le code ASCII d’une lettre minuscule est supérieur de 32 à celui de sa version majuscule. « A » vaut 65, soit 01000001, tandis que « a » vaut 97, soit 01100001. La différence tient à ce seul bit modifié. Cet ordre place aussi toutes les majuscules avant toutes les minuscules. Un simple tri fondé sur les codes place donc « Zebra » avant « apple » ; il ne suit pas l’ordre habituel du dictionnaire.

Distinguer un chiffre d’un nombre

Le caractère « 7 » a pour code décimal 55 et pour octet 00110111. L’entier 7 correspond à l’octet 00000111. Pour retrouver la valeur numérique d’un chiffre à partir de son code ASCII, soustrais 48, le code de « 0 » : $55-48=7$. Cela fonctionne parce que les dix codes des chiffres sont consécutifs.

L’espace de stockage dépend de la représentation choisie. Le texte « 2026 » nécessite quatre octets ASCII, un par chiffre. L’entier 2026 tient dans deux octets comme valeur non signée sur 16 bits. Le texte préserve la suite des caractères ; un entier représente la valeur numérique. Par exemple, un identifiant textuel peut conserver des zéros à gauche qu’un entier ne distingue pas.

Pour encoder une chaîne plus longue, traite chaque caractère dans l’ordre, y compris les espaces, la ponctuation et les caractères de contrôle. Le décodage effectue la recherche inverse, un code à la fois, dans la même table. L’ordre compte : échanger deux codes valides peut produire un texte encore valide en ASCII, mais différent. Une recherche réussie établit que les codes sont reconnus, pas qu’ils ont l’ordre ou le sens voulu.

Comprendre les problèmes causés par les pages de codes

ASCII ne contient ni les lettres accentuées comme « é », « ñ » ou « ü », ni les caractères grecs, cyrilliques, arabes ou chinois. Les pages de codes sur 8 bits apparues plus tard ont utilisé les valeurs de 128 à 255 pour des symboles supplémentaires, mais elles ne s’accordaient pas sur ces ajouts.

Par exemple, l’octet 0xE9 représente « é » en Latin-1, mais « й » en Windows-1251. Windows-1252 est une autre page de codes courante. La valeur d’un octet ne peut donc pas identifier un caractère non ASCII sans que l’on connaisse l’encodage. Utiliser la mauvaise table peut produire des symboles qui semblent lisibles, mais constituent néanmoins un texte incorrect.

Unicode attribue aux caractères des systèmes d’écriture du monde entier un ensemble commun de numéros appelés points de code. « A » est U+0041, « é » est U+00E9, « Ж » est U+0416, « 中 » est U+4E2D et « 😀 » est U+1F600. La notation U+ utilise l’hexadécimal avec au moins quatre chiffres.

Distinguer un point de code de ses octets

L’espace de codes va de U+0000 à U+10FFFF, soit 1 114 112 positions, avec plus de 150 000 caractères attribués. Un point de code identifie un caractère ou une position réservée ; un encodage détermine sa représentation en octets.

La plage des points de substitution U+D800–U+DFFF est réservée au mécanisme de paires d’UTF-16 ; les points de substitution isolés ne sont pas des caractères valides à encoder sous ces formes. Une paire d’unités de code UTF-16 représente un point de code supplémentaire. Par exemple, « 😀 » s’écrit D83D DE00 en UTF-16.

Lire les plages d’octets d’UTF-8

UTF-8 préserve ASCII : les points de code de U+0000 à U+007F utilisent un octet. Ceux de U+0080 à U+07FF en utilisent deux ; les points de code valides correspondant à des caractères de U+0800 à U+FFFF en utilisent trois ; ceux de U+10000 à U+10FFFF en utilisent quatre. Le texte anglais en ASCII est ainsi compatible octet par octet avec UTF-8.

Un caractère sur un seul octet commence par 0. Les caractères plus longs commencent par 110, 1110 ou 11110 pour deux, trois ou quatre octets. Chaque octet de continuation commence par 10. Les bits restants contiennent le point de code.

Pour « é », U+00E9, la valeur sur 11 bits est 00011101001. Sépare-la en cinq bits et six bits : 00011 et 101001. Insère-les dans 110xxxxx 10xxxxxx pour obtenir 11000011 10101001, soit C3 A9. Le point de code 00E9 n’est pas lui-même la suite d’octets UTF-8.

L’encodage et le décodage doivent aussi respecter les préfixes des octets. Un octet de continuation UTF-8 n’est pas un octet ASCII autonome : ses deux premiers bits sont 10, il appartient donc à une séquence d’octets codant un caractère plus long. Supprimer une partie d’un caractère à plusieurs octets à la limite d’un nombre d’octets peut laisser une séquence incomplète. La longueur de stockage et les endroits où le texte peut être découpé sont donc liés.

Compter les bons éléments

« café » comporte quatre caractères affichés mais cinq octets UTF-8 : 63 61 66 C3 A9. « € » utilise E2 82 AC, soit trois octets ; « 中 » utilise E4 B8 AD, également trois ; « 😀 » utilise F0 9F 98 80, soit quatre. Une limite en octets peut donc accepter moins de caractères que sa valeur numérique ne le laisse penser.

Un caractère affiché peut aussi contenir plusieurs points de code. « é » peut être U+00E9 ou « e » suivi de U+0301, un accent aigu combinant. La deuxième forme utilise trois octets UTF-8, 65 CC 81. La normalisation convertit des séquences équivalentes sous une forme commune pour les comparer. L’emoji affiché « 👍🏽 » contient deux points de code, U+1F44D et U+1F3FD, soit huit octets UTF-8 au total.

Diagnostiquer un texte illisible

« café » en UTF-8 lu comme du Windows-1252 devient « café » : C3 et A9 sont traités comme des caractères distincts. C’est du mojibake, causé par un décodage avec le mauvais encodage. Un décodage correct peut retrouver le texte tant que les octets d’origine restent intacts. Une page Web peut déclarer son encodage avec <meta charset="utf-8">.

Une image matricielle est une grille de pixels. Chaque pixel contient une valeur de couleur. La largeur et la hauteur donnent la résolution de l’image : 1920 sur 1080 signifie $1920\times 1080=2073600$ pixels. Un nombre de pixels décrit la grille, et non sa taille imprimée en mètres.

Attribuer assez de bits à chaque pixel

La profondeur de couleur est le nombre de bits utilisés pour la couleur d’un pixel. Une profondeur de $k$ bits permet $2^k$ codes possibles. Un bit permet de distinguer deux couleurs. Les niveaux de gris sur huit bits permettent de distinguer 256 intensités, généralement de 0 pour le noir à 255 pour le blanc.

Une image simple de 3 sur 3 peut utiliser 1 pour le noir et 0 pour le blanc. Un signe plus noir est représenté par les lignes 010, 111 et 010. Neuf pixels à un bit chacun nécessitent neuf bits d’information de pixel. Le stockage réel du fichier peut comprendre du remplissage et d’autres informations en plus de ces bits.

Mélanger la lumière avec le RVB

Le RVB stocke les intensités de lumière rouge, verte et bleue. Avec 8 bits par canal, chaque intensité va de 0 à 255 et un pixel utilise 24 bits. Le nombre de couleurs possibles est ${256}^3=2^{24}=16777216$.

Le RVB est un mélange additif de lumière. La combinaison de lumière rouge et verte donne du jaune. Une prévision fondée sur le mélange des peintures utilise un autre procédé et donne un modèle incorrect pour un écran.

Lire les codes couleur hexadécimaux

Une couleur du Web utilise #RRGGBB : deux chiffres hexadécimaux pour le rouge, puis pour le vert, puis pour le bleu. #FF8000 correspond à (255 ; 128 ; 0), un orange. #808080 correspond à (128 ; 128 ; 128), un gris moyen ; des valeurs de canal égales produisent un gris. #0000FF donne la valeur maximale de bleu avec le rouge et le vert à zéro.

Chaque paire correspond à un octet. Ainsi, FF vaut 255 et ne représente pas deux intensités de couleur distinctes. Le # indique l’ensemble du code RVB et n’occupe pas de canal.

Les modèles RVB et à palette donnent accès à la couleur d’un pixel de deux façons différentes. En RVB direct, la lecture du pixel donne immédiatement les intensités de ses trois canaux. En couleurs indexées, la lecture du pixel donne un numéro d’entrée, puis une seconde recherche fournit les intensités. Modifier une entrée de la palette peut donc changer de nombreux pixels affichés qui partagent le même indice, même si les indices stockés des pixels restent inchangés.

Stocker un indice de palette

Lorsqu’une image utilise peu de couleurs, elle peut conserver une palette, une table des couleurs sélectionnées. Un pixel stocke alors un indice dans cette table. Une palette de 16 couleurs nécessite quatre bits par pixel, car quatre bits permettent de distinguer 16 entrées. La palette elle-même occupe aussi de l’espace. GIF permet jusqu’à 256 couleurs dans la palette, ce qui permet un indice sur 8 bits par pixel.

Ajouter de la transparence

Un canal alpha décrit l’opacité. Une échelle courante sur 8 bits utilise 0 pour une transparence totale et 255 pour une opacité totale, avec des valeurs intermédiaires pour une transparence partielle. Ajouter ce canal au RVB sur 24 bits donne du RGBA sur 32 bits. Le canal alpha est distinct du rouge, du vert et du bleu : un pixel totalement transparent peut toujours avoir des valeurs de couleur stockées qui n’apparaissent pas dans l’image finale.

La quantité de données des pixels d’une image matricielle non compressée augmente avec son nombre de pixels et son nombre de bits par pixel. Garder les unités à chaque étape aide à distinguer la quantité d’information de la taille en octets indiquée par une visionneuse de fichiers.

Calculer les données des pixels

Utilise $\text{bits}=\text{largeur}\times \text{hauteur}\times \text{bits par pixel}$. Divise par 8 pour obtenir des octets. La largeur et la hauteur doivent être multipliées, car chaque ligne contient toute la largeur de pixels.

Pour 1920 sur 1080 à 24 bits par pixel, trouve d’abord 2 073 600 pixels. Multiplie par 24 pour obtenir 49 766 400 bits, puis divise par 8 pour obtenir 6 220 800 octets. Cela représente environ 6,2 MB, soit 5,93 MiB. Changer d’unité ne modifie pas les données des pixels elles-mêmes.

Pour 640 sur 480 en niveaux de gris sur 8 bits, il y a 307 200 pixels. Huit bits chacun donnent 2 457 600 bits ; la division par 8 donne 307 200 octets, soit environ 307 kB. Ici, un octet par pixel rend le nombre final d’octets égal au nombre de pixels.

Prévoir les changements avant de calculer

Doubler la largeur double le nombre de pixels dans chaque ligne. Doubler la hauteur double le nombre de lignes. Doubler les deux multiplie donc par quatre le nombre de pixels et l’espace de stockage. Passer d’une profondeur de 8 à 24 bits par pixel triple le stockage à résolution égale. Ces facteurs se multiplient si les deux changent.

Le calcul brut donne les données des pixels, pas nécessairement un fichier image complet. Un fichier stocke aussi des métadonnées, comme la largeur, la hauteur, la profondeur de couleur et le format. Une photo peut enregistrer les réglages de l’appareil, la date et le lieu. Les tables de palette, les en-têtes, le remplissage et la compression peuvent aussi modifier la taille finale en octets.

Pour les profondeurs inférieures à huit bits, calcule toutes les données en bits avant la conversion. Une image de 100 sur 60 à un bit contient 6 000 bits de pixels, soit 750 octets une fois regroupés. Traiter chaque pixel comme un octet multiplierait cette quantité par huit. Si un format complète chaque ligne jusqu’à une limite particulière, ce remplissage doit être ajouté séparément ; il ne change pas la profondeur de couleur.

Étendre le calcul à la vidéo

Une vidéo présente une suite d’images. À 30 images par seconde, une vidéo RVB de 1920 sur 1080 nécessite $6220800\times 30=186624000$ octets de données d’image non compressées par seconde, soit environ 187 MB/s. La multiplication par la durée donne le total des données d’image. Le son nécessite son propre espace de stockage.

Ce débit élevé explique pourquoi les fichiers vidéo ordinaires sont compressés. Le débit d’une vidéo compressée est une grandeur distincte ; on ne peut pas le déduire de la seule résolution.

Comparer les images matricielles et vectorielles

Un fichier vectoriel peut décrire une ligne allant de (0 ; 0) à (100 ; 50), ou un cercle par son centre, son rayon et son remplissage. Il n’a pas besoin de stocker une valeur de couleur distincte pour chaque point à l’intérieur du cercle. Les dessins simples peuvent donc être peu volumineux. SVG est un format vectoriel courant.

Un écran a toujours besoin de pixels. La rastérisation transforme les formes en une grille de pixels à la taille demandée. Redimensionner les instructions vectorielles préserve la géométrie des formes ; agrandir une image matricielle existante ne peut pas retrouver les détails que sa grille d’origine n’a jamais enregistrés.

Le son est une vibration de la pression de l’air. Un microphone le transforme en un signal électrique analogique qui varie de façon continue. Un convertisseur analogique-numérique prend des mesures régulières, appelées échantillons, et stocke chacune sous forme d’un nombre.

Distinguer le temps de la finesse des mesures

La fréquence d’échantillonnage, mesurée en hertz, est le nombre d’échantillons pris chaque seconde par canal. Une fréquence de 44 100 Hz vaut 44,1 kHz. Les CD utilisent 44,1 kHz, les bandes-son vidéo utilisent généralement 48 kHz et la téléphonie traditionnelle utilise 8 kHz. Les échantillons enregistrent des valeurs à ces instants ; ils ne constituent pas un enregistrement continu de tous les instants intermédiaires.

La profondeur de quantification détermine le nombre de niveaux que peut prendre chaque échantillon. Huit bits donnent 256 niveaux, 16 en donnent 65 536 et 24 en donnent 16 777 216. L’arrondi d’une mesure à un niveau est la quantification. La différence avec la mesure d’origine produit une erreur de quantification, qui peut être entendue comme du bruit. Davantage de bits offrent des niveaux plus fins et réduisent cette erreur.

La fréquence d’échantillonnage détermine la précision dans le temps ; la profondeur de quantification détermine la finesse de l’amplitude mesurée. Augmenter l’une ne remplace pas l’augmentation de l’autre.

Capter la plage de fréquences

Le théorème d’échantillonnage impose une fréquence d’échantillonnage supérieure au double de la fréquence la plus élevée à capter. Pour capter 20 kHz, la fréquence doit dépasser 40 kHz. Exactement le double ne suffit pas pour un signal quelconque à cette limite.

À 44,1 kHz, la limite théorique est inférieure à 22,05 kHz. L’écart au-dessus d’environ 20 kHz, limite supérieure approximative de l’audition humaine, laisse de la place pour un filtre anti-repliement. Les fréquences supérieures à la moitié de la fréquence d’échantillonnage peuvent apparaître comme de fausses fréquences plus basses : c’est le repliement spectral. Un convertisseur filtre ces hautes fréquences avant l’échantillonnage.

Une fréquence de 44 100 Hz s’applique à chaque canal, et non à l’enregistrement comme flux combiné. La stéréo stocke donc 88 200 valeurs d’échantillons chaque seconde. Le facteur correspondant aux canaux figure dans la formule de stockage, car chaque instant comporte une valeur à gauche et une à droite. Il ne double pas la fréquence maximale que chaque canal peut capter ; cette limite dépend toujours de sa propre fréquence d’échantillonnage.

Calculer la taille d’un fichier audio non compressé

Le mono a un canal ; la stéréo en a deux. La taille des données est

Pour un enregistrement stéréo de trois minutes à 44 100 Hz et sur 16 bits, le débit est de $44100\times 16\times 2=1411200$ bit/s. Multiplie par 180 secondes pour obtenir 254 016 000 bits, puis divise par 8 : 31 752 000 octets, soit environ 31,8 MB.

Un enregistrement mono de dix secondes à 8 000 Hz et sur 8 bits donne $8000\times 8\times 1\times 10=640000$ bits, soit 80 000 octets. Un enregistrement stéréo avec les mêmes réglages utiliserait deux fois plus d’espace.

Choisir ce qu’il faut stocker

Des fréquences et des profondeurs plus élevées nécessitent davantage d’espace. Les réglages du CD suffisent généralement pour l’écoute ; les studios utilisent souvent 24 bits et 48 kHz ou plus pour garder une marge de traitement et de montage.

Le MIDI enregistre des instructions sur les notes : lesquelles sont jouées, quand elles commencent, leur intensité et les instruments choisis. Il peut être bien plus petit qu’une interprétation échantillonnée, mais la lecture dépend des sons d’instruments disponibles. Le MIDI peut décrire la mélodie d’une personne qui chante sous forme de notes ; il ne peut pas contenir la voix réellement enregistrée.

La compression sans perte permet à la décompression de reconstruire exactement les bits d’origine. Le texte, les fichiers de programme, les feuilles de calcul et les autres données qui doivent rester exactes ont besoin de cette propriété. ZIP, PNG, GIF et FLAC sont des formats sans perte connus. Ils exploitent la redondance : des informations répétées ou prévisibles qui peuvent être décrites plus brièvement.

Décrire les suites répétées

Le codage par plages remplace des symboles identiques consécutifs par un nombre et le symbole. La chaîne de 18 caractères « AAAAAABBBCCCCCCCCD » devient « 6A3B8C1D », soit huit caractères selon cette convention de nombre et symbole. Le décodage développe chaque paire : six A, trois B, huit C et un D.

La même idée convient aux zones d’image de couleur uniforme. La ligne de pixels 0000000011110000 peut être décrite comme huit zéros, quatre uns et quatre zéros. Un fichier réel doit définir comment les nombres et les symboles sont stockés afin que le décodage soit sans ambiguïté.

Les suites courtes peuvent augmenter la taille avec le codage par plages. « ABCD » devient « 1A1B1C1D », ce qui double le nombre de caractères avant même tout en-tête. La compression ne fonctionne que si les économies dépassent le coût de la description du motif.

Faire référence à une séquence répétée

Une méthode par dictionnaire remplace une séquence répétée par une référence. Les méthodes de la famille LZ sont à la base de formats comme ZIP et PNG. Dans « salut et toi salut », le second « salut » peut être remplacé par une instruction indiquant de reculer de 13 caractères et d’en copier cinq. Les espaces comptent comme des caractères. Le décodeur dispose déjà de ce texte antérieur et peut reproduire la séquence à partir de la référence.

Donner des codes plus courts aux symboles fréquents

Un code de longueur variable utilise des nombres de bits différents selon les symboles. Le codage de Huffman construit des codes à partir des fréquences des symboles. Dans « ABRACADABRA », A apparaît cinq fois, B et R deux fois chacun, et C et D une fois chacun. Un code de longueur fixe pour cinq symboles nécessite trois bits par symbole, soit 33 bits pour onze lettres.

Un code préfixe adapté est A = 0, B = 10, R = 110, C = 1110 et D = 1111. Les données codées utilisent $5\times 1+2\times 2+2\times 3+1\times 4+1\times 4=23$ bits. La table des codes ajoute un surcoût de stockage : 23 bits seuls ne représentent donc pas la taille complète du fichier.

Un code préfixe est tel qu’aucun code de symbole ne constitue le début du code d’un autre symbole. Lire 0110 donne donc A suivi de R sans avoir besoin de séparateurs. Cette propriété permet à un décodeur de Huffman de reconnaître un symbole dès que son code se termine.

Le décodeur doit connaître la convention de codage ainsi que les données. Pour un flux de type Huffman, il lui faut la correspondance entre symboles et codes ; pour le codage par plages, il doit distinguer un nombre d’un symbole. Un petit message peut économiser des bits de données tout en augmentant en taille totale lorsque cette description est incluse. Compare les tailles complètes d’origine et après codage pour déterminer si une méthode a effectivement réduit le fichier.

Mesurer les économies et reconnaître les limites

Le rapport de compression est la taille d’origine divisée par la taille compressée. Réduire 6 MB à 2 MB donne 3:1. Utilise la même unité des deux côtés.

Aucune méthode sans perte ne peut raccourcir tous les fichiers possibles. Il existe $2^n$ entrées différentes de n bits, mais seulement $2^n-1$ suites de bits de moins de n bits. Une récupération exacte exige que des entrées différentes restent distinctes : elles ne peuvent donc pas toutes recevoir des sorties plus courtes. Les données aléatoires et les fichiers déjà compressés diminuent souvent peu ou augmentent à cause des informations supplémentaires.

La compression avec perte supprime des informations pour réduire la taille d’un fichier. La décompression crée une version proche de l’original, dont certains détails ont définitivement disparu. Les photographies, la musique, la parole et la vidéo peuvent tolérer certaines pertes que le texte ou les données de programme, qui doivent rester exacts, ne peuvent pas accepter.

Compresser les images selon leur importance visuelle

JPEG s’appuie sur les différences de sensibilité de la vision humaine à la luminosité, à la couleur et aux détails fins. Un JPEG typique réduit la résolution des détails fins de couleur et arrondit les détails fins de l’image représentés dans des blocs de 8 × 8. Son réglage de qualité détermine la quantité d’informations éliminées. Une compression plus forte peut produire des blocs apparents, du flou ou des effets de résonance près des contours nets.

Une photographie peut souvent atteindre environ 10:1 avec peu de perte visible. À ce rapport, une image contenant 6 220 800 octets de données brutes de pixels utiliserait environ 622 080 octets compressés, soit à peu près 0,6 MB. Ce rapport est un exemple, pas une propriété fixe de tous les JPEG.

Compresser le son selon ce qui peut être entendu

MP3 et AAC utilisent le codage perceptuel. Un son faible peut être masqué par un son plus fort à une fréquence proche : l’encodeur peut donc consacrer moins de bits aux informations que l’auditeur a peu de chances d’entendre. Un fichier plus petit peut tout de même produire un son très proche de l’original.

Pour un débit binaire constant, la taille en bits est égale au débit binaire multiplié par la durée. À 128 kbit/s, un enregistrement de trois minutes nécessite $128000\times 180=23040000$ bits, soit 2 880 000 octets, environ 2,9 MB. Cela représente environ un onzième des 1 411,2 kbit/s du son non compressé d’un CD. Le débit compressé décrit déjà le flux codé ; ne le multiplie pas une nouvelle fois par la profondeur de quantification d’origine.

Exploiter les ressemblances entre images vidéo

Les images voisines montrent souvent presque la même scène. Les formats vidéo comme H.264 et AV1 compressent les détails des images et décrivent de nombreuses images au moyen des changements ou de prédictions à partir d’autres images. Cela supprime les informations répétées dans le temps ainsi qu’à l’intérieur de chaque image.

Adapter le format à l’usage

Garde un original sans perte pour les modifications futures. Des décodages et réencodages répétés avec perte peuvent ajouter une perte de génération. Convertir en PNG un JPEG déjà compressé avec perte préserve ses pixels décodés actuels, mais ne peut pas restaurer les détails supprimés auparavant.

Une compression plus forte peut coûter en qualité, en temps de traitement ou les deux. Le choix utile dépend du contenu du fichier et de son utilisation ; le fichier le plus petit n’est pas toujours le plus utile.