Représentation des données

Les ordinateurs numériques représentent les données à l'aide de deux états logiques, écrits comme 1 et 0. Un système qui n'utilise que deux chiffres est appelé binaire (base 2).

Tout type de données — nombres, texte, son et images — doit être converti en binaire avant qu'un ordinateur puisse l'utiliser. L'ordinateur traite ce binaire à l'aide de portes logiques et le stocke dans des registres (petites mémoires rapides situées à l'intérieur du processeur).

Un système de numération est une manière d'écrire les nombres en utilisant un ensemble fixe de chiffres. Il en faut trois.

• décimal est le système de comptage normal (aussi appelé décimale).
• Le binaire utilise uniquement 0 et 1.
• hexadécimal (hex) utilise seize chiffres : 0–9, puis A, B, C, D, E, F valent 10, 11, 12, 13, 14, 15.

La base indique combien de chiffres différents un système utilise.

Valeur positionnelle

Chaque colonne d'un nombre possède une valeur de position. En binaire, les valeurs de position doublent de droite à gauche. Pour un nombre à 8 bits, elles sont :

128  64  32  16  8  4  2  1

Un bit est un seul 0 ou 1. Huit bits forment un octet. Quatre bits (la moitié d'un octet) constituent un nibble.

Conversion entre systèmes de numération

Décimal → binaire. Écrire les valeurs positionnelles. Mettre un 1 sous chaque valeur nécessaire pour atteindre votre nombre ; mettre un 0 sous les autres.

Exemple : convertir le décimal 150 en binaire. $150 = 128 + 16 + 4 + 2$.

128 64 32 16 8 4 2 1
  1  0  0  1 0 1 1 0

Donc $150$ = 10010110.

Binaire → décimal. Additionner les valeurs positionnelles où il y a un 1. 10010110 $= 128 + 16 + 4 + 2 = 150$.

Hexadécimal → binaire. Convertir chaque chiffre hexadécimal en son propre groupe de 4 bits (un nibble).

Exemple : hex F08. $F = 1111$, $0 = 0000$, $8 = 1000$, donc F08 = 1111 0000 1000.

Binaire → hexadécimal. Regrouper les bits en nibbles de 4, en commençant par la droite. Convertir chaque nibble en un chiffre hexadécimal.

Décimal → hexadécimal. La méthode facile consiste d'abord à convertir en binaire, puis en hex.

Ce tableau aide avec les lettres hex :

Les questions Cambridge utilisent des nombres binaires allant jusqu'à 16 bits.

Exemple résolu. Convertir le décimal 100 en binaire sur 8 bits, puis en hexadécimal.

$100 = 64 + 32 + 4$, donc le binaire est 01100100. En divisant en nibbles, 0110 0100 $= 6$ et $4$, donc l'hexadécimal est 64.

Exemple corrigé (hexadécimal → décimal). Convertissez le nombre hexadécimal 2C en décimal. Les valeurs de position en hexadécimal sont $16$ et $1$. 2 vaut $2 \times 16 = 32$ et C vaut $12$, donc 2C $= 32 + 12 = 44$. Vérification par le binaire : 0010 1100 $= 32 + 8 + 4 = 44$.

Pourquoi utiliser l'hexadécimal

L'hex est plus court que le binaire et plus facile à lire et écrire pour les humains. Un chiffre hex remplace 4 chiffres binaires, réduisant ainsi les erreurs. La valeur ne change pas — l'hex est simplement une façon plus courte d'afficher le même binaire.

Les informaticiens utilisent l'hex pour :

• Adresses MAC et adresses IPv6
• codes couleur en HTML (par exemple #FF0000 est rouge)
• adresses mémoire et codes d'erreur
• afficher le contenu de la mémoire (un « vidage mémoire »)

On peut additionner deux nombres binaires sur 8 bits, colonne par colonne de droite à gauche, comme en décimal. Les règles pour une colonne sont :

Quand un report arrive également, $1 + 1 + 1 = 1$ avec un report de 1.

Exemple : additionner 01110110 (118) et 00110000 (48).

  0 1 1 1 0 1 1 0    (118)
+ 0 0 1 1 0 0 0 0    (48)
-------------------
  1 0 1 0 0 1 1 0    (166)

Débordement

Lorsqu'il est interprété comme un entier non signé, un registre de 8 bits contient des valeurs allant de 0 à 255. Si une addition donne un résultat supérieur à 255, la réponse nécessite un 9e bit. Le registre ne peut pas contenir ce bit supplémentaire, il est donc perdu. On appelle cela le débordement (une erreur de débordement). Cela se produit lorsque la valeur dépasse la limite que le registre peut stocker.

Exemple : 11001000 (200) $+$ 01001000 (72) $= 272$. En binaire, cela correspond à 1 00010000, ce qui nécessite 9 bits. Le 1 en position de poids fort ne tiendra pas dans 8 bits, donc la réponse stockée sera fausse.

Un décalage binaire logique déplace tous les bits vers la gauche ou vers la droite d'un certain nombre de positions.

• Les bits qui sortent du registre sont perdus.
• Des zéros sont ajoutés à l'extrémité vide.

Pour un entier non signé, un décalage vers la gauche multiplie par 2 pour chaque position déplacée si aucun bit non nul n'est perdu. Un décalage logique vers la droite donne le résultat entier de la division par 2 pour chaque position ; les bits de droite (les bits de poids faible) sont perdus.

Exemple : décalage vers la gauche de 00110101 (53) de 2 positions.

start:         0 0 1 1 0 1 0 1
left shift 2:  1 1 0 1 0 1 0 0

Le résultat est 11010100 (212), ce qui correspond à $53 \times 4$. Les deux bits les plus à gauche ont été perdus et deux zéros sont entrés sur la droite. Si un 1 est expulsé par la sortie, cette information est définitivement perdue.

Exemple corrigé (décalage à droite). Décalez 10110100 (180) de 3 positions vers la droite. Donnez le résultat en binaire et en décimal, et indiquez l'effet du décalage.

start:          1 0 1 1 0 1 0 0
right shift 3:  0 0 0 1 0 1 1 0

Les trois bits les plus à droite (100) sont perdus et trois zéros entrent à gauche : 00010110 $= 16 + 4 + 2 = 22$. Un décalage de 3 positions vers la droite divise par $2^3 = 8$ : $180 \div 8 = 22.5$, et le décalage ne conserve que la partie entière, $22$. La valeur $0.5$ était portée par le bit 1 perdu.

Exemple corrigé (un décalage à gauche qui échoue). Décalez 01100100 (100) de 2 positions vers la gauche. Le résultat est 10010000 $= 144$, et non $400$ : un 1 a été expulsé à gauche et $400$ est de toute façon trop grand pour 8 bits. Un décalage à gauche ne multiplie correctement que si aucun bit 1 n'est perdu.

Jusqu'à présent, les nombres étaient positifs. Le complément à deux permet à un registre à 8 bits de contenir également des nombres négatifs.

En complément à deux, le bit de gauche (le bit de poids fort, ou MSB) a une valeur de position négative :

-128  64  32  16  8  4  2  1

• Si le MSB (bit de poids fort) est 0, le nombre est zéro ou positif.
• Si le MSB est 1, le nombre est négatif.

Pour rendre un nombre positif négatif : écrivez le binaire positif, inversez chaque bit (0↔1), puis ajoutez 1.

Exemple : rendre $-40$ négatif.

• $+40$ = 00101000
• inverser les bits = 11010111
• ajouter 1 = 11011000

Ainsi $-40$ = 11011000. Vérification en additionnant les valeurs de position : $-128 + 64 + 16 + 8 = -40$.

Pour lire un nombre en complément à deux négatif, il suffit d'additionner les valeurs de position (le MSB compte pour $-128$). La plage d'un nombre en complément à deux sur 8 bits va de $-128$ à $+127$.

Exemple corrigé. Convertissez le nombre en complément à deux 10011010 en décimal. Le bit de poids fort est 1, donc le nombre est négatif : $-128 + 16 + 8 + 2 = -102$. Vérifiez avec l'autre méthode : inversez les bits (01100101) et ajoutez 1 (01100110 $= 102$), donc le nombre est $-102$.

Les ordinateurs stockent le texte en attribuant un numéro à chaque caractère, puis en stockant ce numéro en binaire. L'ensemble des caractères qu'un ordinateur peut utiliser, ainsi que leurs numéros, constituent un ensemble de caractères.

ASCII utilise des codes de caractères sur 7 bits, offrant $N = 2^b = 2^7 = 128$ codes différents. Il inclut les lettres anglaises, les chiffres et les symboles courants ; tous les 128 codes ne sont pas des lettres. Unicode représente une bien plus grande gamme de caractères, y compris différentes langues et des émoticônes.

Essayez — encodez un court message. Cet extrait d'ASCII donne A = 65, B = 66, C = 67 et espace = 32. Écrivez les quatre groupes de 7 bits pour CAB , y compris son dernier espace. Ensuite, décodez les groupes 1000010 1000001 1000011.

Réponse corrigée. Recherchez chaque caractère, puis convertissez son code en binaire :

Ainsi, CAB est 1000011 1000001 1000010 0100000. Le second message se décode en BAC. Un espace a également un code ; il ne s'agit pas d'une absence de données stockées. L'expéditeur et le récepteur doivent utiliser la même correspondance de codes de caractères pour interpréter correctement le message.

Pourquoi une plus grande gamme est importante. ASCII ne peut pas directement représenter un nom chinois. Unicode inclut les caractères chinois ainsi que les caractères anglais et de nombreuses autres langues. Pour la comparaison du programme, expliquez qu'une plus grande gamme nécessite davantage de codes binaires distincts, exigeant donc plus de bits par caractère que le modèle ASCII sur 7 bits.

Essayez — comparez les modèles de stockage indiqués. Stockez les quatre caractères CAB en utilisant (A) 7 bits par caractère et (B) 16 bits par caractère. Supposez que les bits sont empilés sans rembourrage ni informations supplémentaires sur le fichier. Trouvez la taille des données textuelles dans chaque modèle. La valeur sur 16 bits est une hypothèse pour cet exemple et non une règle stipulant que tous les caractères Unicode prennent 16 bits.

Réponse corrigée. Avec le même nombre de caractères, multipliez par le nombre de bits par caractère indiqué :

Le modèle B utilise plus d'espace de stockage pour cet exemple car sa largeur de code déclarée est plus grande. Utilisez la largeur donnée dans une question d'examen. Dans les fichiers réels, l'encodage compte également : UTF-8 stocke les caractères ASCII dans les mêmes octets qu'un fichier ASCII, donc le texte Unicode n'occupe pas toujours plus d'octets. Vous n'avez pas besoin des règles détaillées de UTF-8 pour cette comparaison de programmes.

Une onde sonore est lisse et change constamment. Pour la stocker, l'ordinateur mesure la hauteur de l'onde à des moments réguliers. Cela s'appelle l'échantillonnage, et chaque mesure est un échantillon.

• Le taux d'échantillonnage est le nombre d'échantillons prélevés chaque seconde (mesuré en Hz).
• La résolution d'échantillonnage est le nombre de bits utilisés pour chaque échantillon. La hauteur de l'onde au point d'échantillonnage est son amplitude.

Un taux d'échantillonnage plus élevé et une résolution d'échantillonnage plus élevée offrent un enregistrement plus précis, mais un fichier plus volumineux.

Une image informatique est constituée d'une grille de petits points appelés pixels.

• La résolution est le nombre de pixels dans l'image (par exemple $1920 \times 1080$).
• La profondeur de couleur est le nombre de bits utilisés pour stocker la couleur de chaque pixel.

Une résolution plus élevée et une profondeur de couleur plus grande offrent une image de meilleure qualité, mais un fichier plus volumineux.

La profondeur de couleur détermine le nombre de couleurs différentes que peut prendre chaque pixel : avec $n$ bits, il y a $2^n$ couleurs. Une profondeur de couleur de 1 bit donne 2 couleurs (noir et blanc), 8 bits donnent $2^8 = 256$ couleurs et 24 bits donnent plus de 16 millions de couleurs.

Exemple corrigé. Une image utilise 64 couleurs différentes. Quelle est la plus petite profondeur de couleur possible ? Trouvez le plus petit $n$ tel que $2^n \geqslant 64$ : $2^6 = 64$, soit 6 bits par pixel. Si elle utilisait 65 couleurs, il lui faudrait 7 bits, car 6 bits ne permettent de former que 64 configurations différentes.

Le stockage de données est mesuré en unités ci-dessous. Un demi-octet correspond à 4 bit et un octet à 8 bits ; au-delà du kibioctet, chaque unité est 1024 fois plus grande que la précédente (car $1024 = 2^{10}$ s'adapte au binaire).

Taille de fichier image (en bits) $=$ résolution $\times$ profondeur de couleur $=$ largeur $\times$ hauteur $\times$ profondeur de couleur.

Exemple : une image mesure $1024 \times 1024$ pixels avec une profondeur de couleur de 2 octets ($= 16$ bits).

• bits $= 1024 \times 1024 \times 16 = 16\,777\,216$ bits
• octets $= \div 8 = 2\,097\,152$ octets
• KiB $= \div 1024 = 2048$ KiB
• MiB $= \div 1024 = 2$ MiB

Taille de fichier audio (en bits) $=$ fréquence d'échantillonnage $\times$ résolution de l'échantillon $\times$ durée en secondes.

Ces formules comptabilisent les données non compressées sans en-têtes de fichier. La formule sonore s'applique à un seul canal ; multipliez par le nombre de canaux si une question spécifie plusieurs canaux.

Divisez toujours par 1024 (et non par 1000) pour convertir en KiB, MiB, etc. Donnez votre réponse dans l'unité demandée par la question.

Exemple résolu. Un son est enregistré pendant 30 secondes à un taux d'échantillonnage de 8,000 Hz avec une résolution d'échantillonnage de 16 bits. Calculez la taille du fichier en kibioctets (KiB).

• bits $= 8\,000 \times 16 \times 30 = 3\,840\,000$ bits
• octets $= 3\,840\,000 \div 8 = 480\,000$ octets
• KiB $= 480\,000 \div 1024 \approx 469$ KiB

La compression rend un fichier plus petit. Un fichier plus petit :

• occupe moins d'espace de stockage,
• nécessite moins de bande passante (la quantité de données qu'une connexion peut acheminer),
• prend moins de temps à envoyer (un temps de transmission plus court).

Il existe deux types.

Compression sans perte

La compression sans perte réduit la taille du fichier avec une perte permanente nulle des données. Le fichier d'origine peut être reconstruit exactement.

Une méthode est le codage par plages (RLE). Elle remplace une suite de valeurs répétées par une seule occurrence de la valeur et le nombre de répétitions. Par exemple, WWWWWWWW (8 blancs) est stocké sous la forme « 8 W ». Cette méthode fonctionne bien lorsque les données comportent de nombreuses répétitions.

Exemple corrigé. Une ligne d'une image en noir et blanc est B B B B B W W B B B B B B B B B (16 pixels). Compressez-la avec le codage RLE et indiquez si cela économise de l'espace lorsque chaque nombre et chaque couleur sont stockés dans un octet.

Les plages sont 5 noirs, 2 blancs, 9 noirs ; les données RLE sont donc 5 B 2 W 9 B : 6 octets au lieu de 16 octets pour l'original (un octet par pixel). Cela économise de l'espace car la ligne contient de longues plages. Une ligne qui change de couleur à chaque pixel, B W B W …, deviendrait 1 B 1 W 1 B 1 W …, soit deux fois la taille de l'original : le codage RLE n'est utile que lorsque les données se répètent.

Compression avec perte

La compression avec perte réduit considérablement la taille du fichier en supprimant définitivement certaines données. Les données supprimées ne peuvent pas être récupérées. Par exemple :

• réduction de la résolution ou de la profondeur de couleur d'une image,
• réduction de la fréquence d'échantillonnage ou de la résolution de l'échantillon d'un son.

Utilisez le codage sans perte lorsque vous devez conserver tous les détails (textes et fichiers programmes). Utilisez le codage avec perte pour les photos, la musique et la vidéo, où une légère perte de qualité permet d'obtenir un fichier bien plus petit.

• Convertissez le décimal vers le binaire en soustrayant les valeurs de position (128, 64, 32 …) ; convertissez le binaire vers le décimal en additionnant les valeurs de position contenant un 1.
• Pour convertir en hexadécimal, regroupez le binaire en demi-octets de 4 bits à partir de la droite ; chaque demi-octet correspond exactement à un chiffre hexadécimal.
• Le débordement survient lorsqu'un résultat dépasse la plage de la représentation choisie. Les entiers sans signe sur 8 bits vont de 0 à 255 ; les compléments à deux sur 8 bits vont de −128 à −127.
• Taille de fichier en bits : pour une image, largeur × hauteur × profondeur de couleur ; pour un son, fréquence d'échantillonnage × résolution × secondes. Divisez par 8 pour obtenir des octets, puis par 1024 pour chaque unité supérieure.
• La compression sans perte conserve chaque bit (textes ; codage par longueur de run) ; la compression avec perte supprime définitivement des données (photos, musique) pour obtenir un fichier beaucoup plus petit.