# data[].attributes.attachment_link.readable_text
Nous avons vu comment sont représentés les entiers relatifs au sein d'un ordinateur. Nous allons maintenant voir comment sont représentés les nombres réels, appelés ici nombres flottants.

Représentation de la partie décimale d'un nombre

Partons tout de suite sur un exemple : comment représenter 5,1875 en binaire ?

Il nous faut déjà représenter 5, ça, pas de problème : 101

Comment représenter le ",1875" ?

on multiplie 0,1875 par 2 : 0,1875 x 2 = 0,375. On obtient 0,375 que l'on écrira 0 + 0,375

on multiplie 0,375 par 2 : 0,375 x 2 = 0,75. On obtient 0,75 que l'on écrira 0 + 0,75

on multiplie 0,75 par 2 : 0,75 x 2 = 1,5. On obtient 1,5 que l'on écrira 1 + 0,5 (quand le résultat de la multiplication par 2 est supérieur à 1, on garde uniquement la partie décimale)

on multiplie 0,5 par 2 : 0,5 x 2 = 1,0. On obtient 1,0 que l'on écrira 1 + 0,0 (la partie décimale est à 0, on arrête le processus)

On obtient une succession de "a + 0,b" ("0 + 0,375", "0 + 0,75", "1 + 0,5" et "1 + 0,0"). Il suffit maintenant de "prendre" tous les "a" (dans l'ordre de leur obtention) afin d'obtenir la partie décimale de notre nombre : 0011

Nous avons (101,0011) ₂ qui est la représentation binaire de (5,1875) ₁₀

À faire vous-même 1

Trouvez la représentation binaire de (4,125) ₁₀

Il est possible de retrouver une représentation décimale en base 10 à partir d'une représentation en binaire.

Partons de (100,0101) ₂

Pas de problème pour la partie entière, nous obtenons "4". Pour la partie décimale nous devons écrire : 0 x 2⁻¹ + 1 x 2⁻² + 0 x 2⁻³ + 1 x 2⁻⁴ = 0,3125. Nous avons donc (4,3125) ₁₀

À faire vous-même 2

Trouvez la représentation décimale de (100,001) ₂

À faire vous-même 3

Trouvez la représentation binaire de (0,1) ₁₀

Que remarquez-vous ?

Dans l'exemple ci-dessus, nous remarquons que le processus de "conversion" ne s'arrête pas, nous obtenons : "0,0001100110011...", le schéma "0011" se répète à "l'infini". Cette caractéristique est très importante, nous aurons l'occasion de revenir là-dessus plus tard.

En base dix, il est possible d'écrire les très grands nombres et les très petits nombres grâce aux "puissances de dix" (exemples "6,02.10 ²³" ou "6,67.10⁻¹¹"). Il est possible de faire exactement la même chose avec une représentation binaire, puisque nous sommes en base 2, nous utiliserons des "puissances de deux" à la place des "puissances dix" (exemple "101,1101.2 ¹⁰").

Pour passer d'une écriture sans "puissance de deux" à une écriture avec "puissance de deux", il suffit décaler la virgule : "1101,1001 = 1,1011001.2 ¹¹" pour passer de "1101,1001" à "1,1011001" nous avons décalé la virgule de 3 rangs vers la gauche d'où le "2 ¹¹" (attention de ne pas oublier que nous travaillons en base 2 le "11" correspond bien à un décalage de 3 rangs de la virgule).

Si l'on désire décaler la virgule vers la gauche, il va être nécessaire d'utiliser des "puissances de deux négatives" "0,0110 = 1,10.2⁻¹⁰", nous décalons la virgule de 2 rangs vers la droite, d'où le "-10"

Représentation des flottants dans un ordinateur

La norme IEEE 754 est la norme la plus employée pour la représentation des nombres à virgule flottante dans le domaine informatique. La première version de cette norme date de 1985.

Nous allons étudier deux formats associés à cette norme : le format dit "simple précision" et le format dit "double précision". Le format "simple précision" utilise 32 bits pour écrire un nombre flottant alors que le format "double précision" utilise 64 bits. Dans la suite nous travaillerons principalement sur le format 32 bits.

Que cela soit en simple précision ou en double précision, la norme IEEE754 utilise :

1 bit de signe (1 si le nombre est négatif et 0 si le nombre est positif)

des bits consacrés à l'exposant (8 bits pour la simple précision et 11 bits pour la double précision)

des bits consacrés à la mantisse (23 bits pour la simple précision et 52 bits pour la double précision)

Nous pouvons vérifier que l'on a bien 1 + 8 + 23 = 32 bits pour la simple précision et 1 + 11 + 52 = 64 bits pour la double précision.

Pour écrire un nombre flottant en respectant la norme IEEE754, il est nécessaire de commencer par écrire le nombre sous la forme 1,XXXXX.2 e(avec e l'exposant), il faut obligatoirement qu'il y ait un seul chiffre à gauche de la virgule et il faut que ce chiffre soit un "1". Par exemple le nombre "1010,11001" devra être écrit "1,01011001.2 ¹¹". Autre exemple, "0,00001001" devra être écrit "1,001.2⁻¹⁰¹".

La partie "XXXXXX" de "1,XXXXX.2 e" constitue la mantisse (dans notre exemple "1010,11001" la mantisse est "01011001"). Comme la mantisse comporte 23 bits en simple précision, il faudra compléter avec le nombre de zéro nécessaire afin d'atteindre les 23 bits (si nous avons "01011001", il faudra ajouter 23 - 8 = 15 zéros à droite, ce qui donnera en fin de compte "01011001000000000000000" )

Notre première intuition serait de dire que la partie "exposant" correspond simplement au "e" de "1,XXXXX.2 e" (dans notre exemple "1010,11001", nous aurions "11"). En faite, c'est un peu plus compliqué que cela. En effet, comment représenter les exposants négatifs ? Aucun bit pour le signe de l'exposant n'a été prévu dans le norme IEEE754, une autre solution a été choisie :

Pour le format simple précision, 8 bits sont consacrés à l'exposant, il est donc possible de représenter 256 valeurs, nous allons pouvoir représenter des exposants compris entre (-126) ₁₀ et (+127) ₁₀ (les valeurs -127 et +128 sont des valeurs réservées, nous n'aborderons pas ce sujet ici). Pour avoir des valeurs uniquement positives, il va falloir procéder à un décalage : ajouter systématiquement 127 à la valeur de l'exposant. Prenons tout de suite un exemple (dans la suite, afin de simplifier les choses nous commencerons par écrire les exposants en base 10 avant de les passer en base 2 une fois le décalage effectué) :

Repartons de "1010,11001" qui nous donne 1,01011001.2 ³, effectuons le décalage en ajoutant 127 à 3 : "1,01011001.2 ¹³⁰", soit en passant l'exposant en base 2 : "1,01011001.2 ¹⁰⁰⁰⁰⁰¹⁰". Ce qui nous donne donc pour "1010,11001" une mantisse "01011001000000000000000" (en ajoutant les zéros nécessaires à droite pour avoir 23 bits) et un exposant "10000010" (même si ce n'est pas le cas ici, il peut être nécessaire d'ajouter des zéros pour arriver à 8 bits, ATTENTION, ces zéros devront être rajoutés à gauche).

À noter que pour le format double précision le décalage est de 1023 (il faut systématiquement ajouter 1023 à l'exposant afin d'obtenir uniquement des valeurs positives)

Nous sommes maintenant prêts à écrire notre premier nombre au format simple précision :

Soit le nombre "-10,125" en base 10 représentons-le au format simple précision :

Décalons la virgule : 1010,001 = 1,010001.2³, soit avec le décalage de l'exposant 1,010001.2¹³⁰, en écrivant l'exposant en base 2, nous obtenons 1,010001.2¹⁰⁰⁰⁰⁰¹⁰

Nous avons donc : notre bit de signe = 1 (nombre négatif), nos 8 bits d'exposant = 10000010 et nos 23 bits de mantisse = 01000100000000000000000

Soit en "collant" tous les "morceaux" : 11000001001000100000000000000000

Cette écriture étant un peu pénible, il est possible d'écrire ce nombre en hexadécimal : C1220000

À faire vous-même 4

Déterminez la représentation au format simple précision de (0,25) ₁₀ en binaire et en hexadécimal.

Il est aussi possible de passer d'une représentation au format IEEE 754 à une représentation "classique" en base 10

Soit le nombre flottant au format simple précision : 00111110100000000000000000000000, nous pouvons déjà dire que ce nombre est positif (bit de signe à 0). Les 8 bits suivants (01111101) nous donnent l'exposant décalé : (01111101) ₂ = (125) ₁₀, soit une fois le décalage supprimé, 125 - 127 = -2. Les 23 bits suivants (la mantisse) sont uniquement des zéros, ce qui nous donne en fin de compte : 1,000.2⁻². Ce qui donne, en base 10 également (1,000.2⁻²) ₁₀ soit (0,25) ₁₀.

À faire vous-même 5

Déterminez la représentation au format simple précision de (0,1) ₁₀ en binaire.

Nous avons ici un problème : comme déjà évoqué plus haut, nous nous retrouvons avec une "conversion" qui ne s'arrête jamais (le schéma "0011" se répète à "l'infini"), problème, en simple précision, la mantisse est limitée à 23 bits.

Vous devriez donc obtenir : 00111101110011001100110011001100

À faire vous-même 6

Soit le nombre flottant au format simple précision : 00111101110011001100110011001100. Trouvez la représentation en base 10 de ce nombre.

La réponse à la question posée ci-dessus est (0,099999994) ₁₀, or, en toute logique, nous devrions trouver (0,1) ₁₀. Cette "légère" erreur est logique quand on y réfléchit un peu. N'oubliez qu'à cause de la limitation de la mantisse à 23 bits, nous avons dû "tronquer" notre résultat (de toutes les façons, même avec une mantisse beaucoup plus grande, on aurait aussi eu le problème, car le schéma "0011" se répète à l'infini). Cette représentation avec un nombre limité de bits des nombres flottants est un problème classique en informatique. Cela peut entrainer des erreurs d'arrondi dans les calculs qui peuvent être très gênants si on n'y prend pas garde :

À faire vous-même 7

À l'aide de Spyder, tapez dans la console : 0.1+0.2

En toute logique, nous devrions trouver 0.3 et pourtant la console affiche 0.30000000000000004. Ce problème est directement lié à la limitation du nombre de bits utilisé pour représenter les nombres flottants évoquée ci-dessus. Il existe des "astuces" pour éviter ce genre d'inconvénient, mais ce sujet ne sera pas abordé ici.

À faire vous-même 8

Déterminez la représentation au format simple précision d'un tiers (1/3) en binaire et en hexadécimal.

# data[].attributes.attachment_link.description
Nous avons vu comment sont représentés les entiers relatifs au sein d'un ordinateur. Nous allons maintenant voir comment sont représentés les nombres réels, appelés ici nombres flottants. Partons tout de suite sur un exemple : comment représenter 5,1875 en binaire ? Il nous faut déjà représenter 5, ça, pas de problème : 101 Comment représenter le ",1875" ?

# data[].attributes.body
Chapitre 2 - Entiers relatifs

# data[].attributes.body
Chapitre 3 - flottants

# data[].attributes.attachment_link.readable_text
Nous avons déjà vu comment représenter les entiers positifs, nous allons maintenant nous intéresser aux entiers relatifs.

La première idée qui pourrait nous venir à l'esprit est, sur un nombre comportant n bits, d'utiliser 1 bit pour représenter le signe et n-1 bit pour représenter la valeur absolue du nombre à représenter. Le bit de signe étant le bit dit "de poids fort" (c'est à dire le bit le plus à gauche), ce bit de poids fort serait à 0 dans le cas d'un nombre positif et à 1 dans le cas d'un nombre négatif.

un exemple : on représente l'entier 5 sur 8 bits par 00000101, -5 serait donc représenté par 10000101

À faire vous-même 1

En utilisant la méthode décrite ci-dessus, représentez -15 (représentation sur 8 bits)

Il existe un énorme inconvénient à cette méthode : l'existence de deux zéros, un zéro positif (00000000) et un zéro négatif (10000000) !

Ce problème est, pour plusieurs raisons qui ne seront pas développées ici, rédhibitoire. Nous allons donc devoir utiliser une autre méthode : le complément à deux

Le complément à deux

Avant de représenter un entier relatif, il est nécessaire de définir le nombre de bits qui seront utilisés pour cette représentation (souvent 8, 16 , 32 ou 64 bits)

Prenons tout de suite un exemple : déterminons la représentation de -12 sur 8 bits

Commençons par représenter 12 sur 8 bits (sachant que pour représenter 12 en binaire seuls 4 bits sont nécessaire, les 4 bits les plus à gauche seront à 0) : 00001100

Inversons tous les bits (les bits à 1 passent à 0 et vice versa) : 11110011

Ajoutons 1 au nombre obtenu à l'étape précédente : les retenues sont notées en rouge

La représentation de -12 sur 8 bits est donc : 11110100

Comment peut-on être sûr que 11110100 est bien la représentation de -12 ?

Nous pouvons affirmer sans trop de risque de nous tromper que 12 + (-12) = 0, vérifions que cela est vrai pour notre représentation sur 8 bits.

Dans l'opération ci-dessus, nous avons un 1 pour le 9e bit, mais comme notre représentation se limite à 8 bits, il nous reste bien 00000000.

À faire vous-même 2

En utilisant le complément à 2, représentez -15 (représentation sur 8 bits)

Il faut noter qu'il est facile de déterminer si une représentation correspond à un entier positif ou un entier négatif : si le bit de poids fort est à 1, nous avons affaire à un entier négatif, si le bit de poids fort est à 0, nous avons affaire à un entier positif.

À faire vous-même 3

Représentez sur 8 bits l'entier 4 puis représentez, toujours sur 8 bits, l'entier -5. Additionnez ces 2 nombres (en utilisant les représentations binaires bien évidemment), vérifiez que vous obtenez bien -1.

À faire vous-même 4

Quel est le plus petit entier négatif que l'on peut représenter sur 8 bits ?

À faire vous-même 5

Quel est le plus grand entier positif que l'on peut représenter sur 8 bits ?

Dans le "À faire vous-même 4" vous avez dû normalement trouver 10000000 (soit -128) et 01111111 (soit 127) dans le "À faire vous-même 5". Plus généralement, nous pouvons dire que pour une représentation sur n bits, il sera possible de coder des valeurs comprises entre -2 n-1 et +2 n-1 - 1

À faire vous-même 6

Quelles sont les bornes inférieure et supérieure d'un entier relatif codé sur 16 bits ?

# data[].attributes.attachment_link.title
Représentation binaire d'un entier relatif

# data[].attributes.attachment_link.description
Nous avons déjà vu comment représenter les entiers positifs, nous allons maintenant nous intéresser aux entiers relatifs. La première idée qui pourrait nous venir à l'esprit est, sur un nombre comportant n bits, d'utiliser 1 bit pour représenter le signe et n-1 bit pour représenter la valeur absolue du nombre à représenter.

# data[].attributes.attachment_link.readable_text
Le système décimal

Pour que vous compreniez le fonctionnement du binaire, et des systèmes de comptage en général (plus communément appelés bases), je vais commencer par faire une petite réintroduction à la base 10 que vous connaissez tous.

En effet, tout le monde sait compter en base 10 (décimal). Mais comment ça marche ? Comment est construit notre système ? Pour répondre à cette question à l'apparence simple, oubliez tout et reprenons depuis le début : comment avez-vous appris à compter à l'école ?

Vous penserez peut-être que la base 10 vient du fait qu'on a 10 doigts, mais en tout cas deux choses sont sûres :

Il y a 10 chiffres : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

Avec ces derniers, on peut compter jusqu'à 9.

Et si l'on veut aller au-delà de 9, il faut changer de rang.

Cela signifie que si le rang des unités est plein, il faut passer à celui des dizaines, puis des centaines, milliers et j'en passe.

Par exemple : à 19, le rang des unités est "saturé" (plein), car il contient le chiffre 9, et il n'y a pas (dans la base 10) de valeur plus élevée. Il faut donc incrémenter le rang périphérique puis réinitialiser l'état de celui des unités. Ce qui signifie : j'ai 19, je ne peux pas mettre plus de 9 à droite, donc j'ajoute 1 à celui de gauche et je remets à zéro celui de droite.

Comme je disais tout à l'heure, le nombre entier va être composé de rangs (unités, dizaines, centaines, etc). Chaque rang vaut le rang précédent multiplié par l'indice de la base. Une centaine vaut dix dizaines, et une dizaine vaut 10 unités. Par exemple, dans l'image ci-dessus, on peut voir le nombre 185 ₁₀ (ici, le ₁₀ signifie qu'il s'agit d'un nombre, en base 10). Dans ce nombre, on peut voir trois rangs : centaines, dizaines et unités. Pour n'importe quelle base, la valeur d'un rang est égale à b n, où b est l'indice de la base (ici, 10) et n la position du rang. Ici, les unités ont la position 0, les dizaines la position 1 et les centaines la position 2. Nous pouvons donc écrire :

$185 = 1 * 10^2 + 8 * 10^1 + 5 * 10^0$

Ce que je viens de faire, c'est décomposer 185 en puissance de 10 (unités, dizaines, centaines, etc).

Un nombre est égal à la somme des valeurs de ses rangs, et on peut décomposer n'importe quel nombre en puissance de sa base.

Le binaire

Le binaire, c'est le système de comptage des ordinateurs. Pourquoi le binaire et pas le décimal comme les humains ? Et bien c'est très simple : un ordinateur est composé de circuits électroniques, et donc de composants électriques. Le plus simple pour compter est donc d'utiliser un système en base 2 (le binaire) car on peut représenter ses deux valeurs possibles (0 et 1) par un signal électrique : 1, y'a du courant, 0, y'en a pas (c'est la version simple).

Je vous ai parlé ci-dessus de rangs. En binaire, c'est pareil à la différence qu'on utilise le terme bit, qui est la contraction de "binary digit", littéralement "chiffre binaire". Par exemple, le nombre 10011 occupe 5 bits. Là où tout se complique, c'est que comme je l'ai expliqué, chaque rang en binaire ne peut avoir que deux valeurs (binaire = base 2) différentes : 0 ou 1. Pour la base 10, chaque rang représente une puissance de 10, pour la base 2, chaque rang occupe une puissance de 2. Voici comment compter en binaire jusqu'à 10 :

Retenez juste ceci : entamer le rang suivant quand l'actuel est plein.

À faire vous-même 1

Combien de valeurs peut-on coder avec 1 bit ?

Combien de valeurs peut-on coder avec 2 bits ?

Combien de valeurs peut-on coder avec 3 bits ?

Combien de valeurs peut-on coder avec n bits ?

Comme on a pu le voir, compter jusqu'à 10 ou 20 reste aisé, mais imaginons un instant que je vous demandasse d'écrire 185 en binaire ? Vous allez faire chaque rang, un par un ?

Conversion décimale binaire

Pour l'instant, on n'a compté que jusqu'à 10. Mais pour les plus grands nombres, la méthode précédente peut se révéler fastidieuse

La méthode :

Il existe bien sûr plusieurs méthodes de conversion, mais nous allons étudier la plus simple et la plus rapide. Il s'agit de la méthode euclidienne.

Cette méthode, en plus d'être facile à utiliser en programmation (c'est un algorithme) est une des meilleures lorsqu'il s'agit de traiter les grands nombres.

Voici la méthode :

On prend le nombre en base 10 (forme normale).

On le divise par 2 et on note le reste de la division (soit 1 soit 0)

On refait la même chose avec le quotient précédent, et on met de nouveau le reste de côté.

On réitère la division, jusqu'à ce que le quotient soit 0.

Le nombre en binaire apparaît alors : il suffit de prendre tous les restes de bas en haut.

Et l'exemple :

À faire vous-même 2

Convertir $42_{10}$ en base 2

Conversion binaire décimale

Je vous rassure tout de suite : c'est plus simple dans ce sens-là que dans l'autre.

Prenons un nombre au hasard, tel que 11010011. Il s'étale sur 8 rangs, et comme dit précédemment, chaque rang correspond à une puissance de deux.
Le premier rang (en partant de la droite) est le rang 0, le second est le 1, etc.

Pour convertir le tout en décimale, on procède de la manière suivante : on multiplie par 2 ⁰ la valeur du rang 0, par 2 ¹ la valeur du rang 1, par 2 ² la valeur du rang 2, [...], par 2 ¹⁰ la valeur du rang 10, etc.

Après ça, il ne reste plus qu'à remplacer les puissances de 2 par leurs valeurs et de calculer la somme : ( Attention à bien partir de la droite !)
$11010011_{binaire} = 1*1 + 1*2 + 0*4 + 0*8 + 1*16 + 0*32 + 1*64 + 1*128 = 211_{décimal}$

À faire vous-même 3

Convertir $10011001_2$ en base 10

L'hexadécimal

Le binaire, c'est bien pratique : on peut coder des nombres uniquement avec des 0 et des 1. C'est bien pour les signaux électriques et tout le bazar, mais dans la vie de tous les jours c'est pas bien facile d'utilisation. On utilise couramment la base 10. Le problème c'est qu'en informatique, tout est basé sur le binaire, et étant une base d'indice 2, c'est plus aisé d'encoder les informations sur un nombre multiple de 2. On utilise donc souvent la base 16, appelé système hexadécimal (hexa = 6, déci = 10, 16 = 6 + 10) car 16 est un multiple de 2, et qu'il permet de représenter 8 bits avec seulement 2 chiffres. Ça paraît simple, mais il y a un autre problème : en base 10, on utilise 10 chiffres. En base 2 (binaire) on utilise seulement 2 chiffres : 0 et 1. Mais du coup, en base 16, il faut 16 chiffres. OK, 0 1 2 3 4 5 6 7 8 9.. quoi après ? On prend des lettres de l'alphabet.
Ce qui donne :
0 1 2 3 4 5 6 7 8 9 A B C D E F On peut établir une liste de correspondances entre la base 10 et la base 16 (voire même la base 2) :

Binaire (base 2)

Décimal (base 10)

Hexadécimal (base 16)

Comme vous pouvez le voir, le plus grand chiffre en hexadécimal est $F$, et il correspond à $15$ en décimal et $1111$ en binaire : F est donc encodé sur 4 bits ($F_{hex} = 1111_{bin}$, 4 chiffres binaires = 4 bits).

Pour convertir un nombre binaire en base 16, on regroupe les bits 4 à 4, chaque groupe donnant un chiffre hexadécimal. À l'inverse, passer d'un numbre hexadécimal à sa représentation binaire se fait en remplaçant chaque chiffre pour son équivalent sur 4 bits. Ainsi, $11011001_2 = 1101\ 1001_2 = D9_{16}$, tandis que $7F_{16} = 0111\ 1111_2 = 01111111_2$. Attention, si le nombre binaire de départ n'a pas un nombre de bits multiple de 4, il faut ajouter des zéros en tête (ce qui ne change pas sa valeur) afin de pouvoir les regrouper 4 par 4.

À faire vous-même 4

Convertir $101111011001_2$ en base 16

À faire vous-même 5

Convertir $111011_2$ en base 16

À faire vous-même 6

Convertir $1A3E_{16}$ en base 2

Convertir un nombre décimal en hexadécimal

Pour convertir un nombre décimal en hexadécimal, la méthode est similaire au binaire, sauf que cette fois on divise par 16.

À faire vous-même 7

Convertir $1387_{10}$ en base 16

Convertir un nombre hexadécimal en décimal

Le principe est le même que pour la conversation "binaire en décimal" sauf qu'au lieu d'utiliser des $2^n$ on utilise des $16^n$ :

exemple :

$12B7_{16} = 1\times16^3 + 2\times16^2 + 11\times16^1 + 7\times16^0 = 1\times4096 + 2\times256 + 11\times16 + 7 = 4096 + 512 + 176 + 7 = 4791$

Vous avez remarqué que quand on trouve un B dans le nombre écrit en hexadécimal, on le remplace par un 11 dans le calcul. C'est exactement la même chose quand on trouve :

un A, on le remplace par un 10

un C, on le remplace par un 12

un D, on le remplace par un 13

un E, on le remplace par un 14

un F, on le remplace par un 15

À faire vous-même 8

Convertir $1B87_{16}$ en base 10

Généralisation pour une base $b$

Nous avons vu ci-dessus comment convertir un nombre en base 10 en un nombre en base 16. Pour convertir un nombre $n$ (en base 10) en sa représentation en base $b$, il faut suivre l'algorithme suivant :

On appelle $D$ la liste des chiffres (le résultat).

Tant que $n > 0$

Faire la division euclidienne de $n$ par $b$.

Ajouter le reste à $D$

Mettre le quotient dans $n$

Inverser l'ordre de $D$

Soit $x$ la représentation du nombre en base 10, $r$ la représentation du nombre en base $b$, $r$ étant écrit en utilisant $n$ chiffres : $c_{0}$, $c_{1}$...$c_{n-1}$, nous avons :

$r = c_{n-1}c_{n-2}\ldots c_{2}c_{1}c_{0}$

$x = \sum\limits_{i=0}^{n-1} c_i b^i = c_{n-1}b^{n-1} + c_{n-2}b^{n-2} + \ldots + c_{2}b^{2} + c_{1}b^{1} + c_{0}b^{0}$

# data[].attributes.attachment_link.description
Pour que vous compreniez le fonctionnement du binaire, et des systèmes de comptage en général (plus communément appelés bases), je vais commencer par faire une petite réintroduction à la base 10 que vous connaissez tous. En effet, tout le monde sait compter en base 10 (décimal). Mais comment ça marche ?

# data[].attributes.body
Chapitre 1
Chapitre 2 - Entier positif

# data[].attributes.attachment_link.readable_text
Note

Le code JavaScript de ce convertisseur a été mis à jour le 11/12/2016. La version originale (compatible avec Internet Explorer 5) est toujours disponible.

copyright © 2005‑2021 Sébastien Guillon - HTML - CSS

# data[].attributes.attachment_link.description
Le code JavaScript de ce convertisseur a été mis à jour le 11/12/2016. La version originale (compatible avec Internet Explorer 5) est toujours disponible. copyright © 2005‑2021 Sébastien Guillon - HTML - CSS

# data[].attributes.attachment_link.description
Convert the binary number into the corresponding hexadecimal number.

# data[].attributes.attachment_link.readable_text
Binary Bingo Practice
(Decimal to Binary)

Rules: You'll have 300 seconds to get BINGO. Your score does not reset, so you accumulate points by playing more games. You score a certain number of points for getting BINGO (the amount differs depending on the difficulty setting). You will also get 1 point for each correct conversion while you'll lose 10 points for each wrong guess. Your score cannot drop below zero. The goal is to accumulate as many points as possible as not only to foster a better understanding of binary/decimal conversion, but also to gain the respect and admiration of your peers.

# data[].attributes.attachment_link.title
Kevin's Number Conversion Practice through Bingo

# data[].attributes.attachment_link.description
Binary Bingo Practice (Decimal to Binary) Rules: You'll have 300 seconds to get BINGO. Your score does not reset, so you accumulate points by playing more games. You score a certain number of points for getting BINGO (the amount differs depending on the difficulty setting).

# data[].attributes.body
Chapitre 5 - encodage des textes

# data[].attributes.attachment_link.readable_text
Objectifs : - Représenter physiquement un circuit logique. - Utiliser la logique de boole. - Définir les opérations logiques fondamentales.

Exercice 1 : Montrez la table de vérité du circuit suivant :

Exercice 2 : Quelle est la fonction logique réalisée par le circuit de la figure suivante :

Exercice 3 : Quelle est la fonction logique réalisée par le circuit de la figure suivante :

Exercice 4 : Utilisez l'algèbre de Boole pour simplifier les équations logiques suivantes :

Exercice 5 : Utilisez la table de Karnaugh pour simplifier l'équation logique suivante :

Exercice 6 : On dispose de 2 nombres binaires x et y à 3 bits chacun tels que x = [x2x1x0] et y = [y2y1y0]. On veut concevoir un circuit qui fait la comparaison entre ces 2 nombres de telle sorte que la sortie S soit égale à " 1 "si dans l'ordre on a : x2:x1:x0 = y2:y1:y0 et à " 0 " autrement.

Exercice 7 : On désire effectuer la somme OU logique du contenu de deux registres A et B de 4 bits chacun selon l'équation suivante :

C'est-à-dire que le résultat du contenu de A OU du contenu de B sera stocké dans le registre B. Chaque bit du registre A est désigné par : Ai et chaque bit du registre B est désigné par : BiEn utilisant des bistables asynchrones R-S :

1. établir la table d'état contenant les colonnes Ai et Bi au temps t, Bi au temps t+1 et les entrées du bistable R-S.
2. l'expression logique du circuit.
3. le schéma logique du circuit.

Exercice 9 : On demande de simplifier une fonction logique s définie par sa forme canonique et sa table de vérité telle que :

Exercice 8 : On demande de simplifier une fonction logique s définie par sa forme canonique et sa table de vérité telle que :

Le circuit logique et la table de vérité sont :

Le circuit réalisé la fonction ET telle que :

Le circuit réalisé la fonction OU telle que :

Solution de l'exercice 4 :

Solution de l'exercice 6 :

Les combinaisons possibles pour x et y sont de 23 = 8, c'est-à-dire :

A chaque combinaison de x peut correspondre n'importe laquelle des huit combinaisons de y.
De plus, pour chaque bit xi il existe 2 combinaisons possibles de bits de y et inversement, de telle sorte que la solution par rapport à la comparaison bit par bit est :

ce qui donne l'équation logique suivante :

Comme chaque entrée est à 3 bits (bit 20, bit 21 et bit 22), et que chaque paire de bits est décrite par l'équation (1), alors le circuit cherché est le suivant :
1. La table d'état est :
Il est évident que ce circuit n'est pas optimal et qu'une simplification s'impose.
L'équation (1) peut être simplifiée en ajoutant, sans rien changer à l'équation, deux zéros ainsi :

L'équation (2) donne un circuit qui ne nécessite que 7 éléments au lieu des 16 du circuit non simplifié tel que :

(0/1) veut dire que l'on peut indifféremment choisir soit 0 soit 1.

2. les expressions logiques du circuit sont :

ce qui nous donne, pour chaque bit i,le schéma suivant :

3. le schéma logique complet du circuit est :

1. Simplification par voie algébrique :
le théorème d'idempotence permet d'écrire :

2. Simplification par la méthode de Karnaugh :

On reproduit la table de vérité dans une table, appelée table de Karnaugh, telle que :

On remarque que les 4 cases de la table de Karnaugh correspondent aux 4 lignes de la table de vérité. La simplification consiste à encercler tout ensemble de cases remplies de 1, adjacentes sur la même ligne ou la même colonne.

Dans notre exercice, on trouve deux ensembles (ligne y = 1 et colonne x = 1) de cases qui recouvrent complétement les parties affectées aux variables x et y.
Ainsi, on peut déduire que la solution est s = x + y.

Solution de l'exercice 9 :

La table de Karnaugh est :

Ainsi, on peut déduire que la solution est :

# data[].attributes.attachment_link.title
Exercices circuit logique, table de vérité et table de Karnaugh

# data[].attributes.attachment_link.description
Objectifs : - Représenter physiquement un circuit logique. - Utiliser la logique de boole. - Définir les opérations logiques fondamentales.

# data[].attributes.attachment_link.readable_text
Sachant que A, B et C sont des variables booléennes. Démontrer que :

Exercice 2 - Analyse et synthèse de circuits

L'implémentation d'une fonction logique Z relativement complexe repose sur un XOR de deux autres fonctions X et Y comme indiqué sur le schéma suivant :

1) En considérant que les portes XOR et XNOR à N entrées ont un coût 2N, calculer le coût des fonctions X, Y et Z telles qu'elles ont été implémentées.

Coût de X(A, B, C, D) =
Coût de Y(A, B, C, D) =
Coût de Z(A, B, C, D) =

2) Trouver l'expression disjonctive simplifiée de X au moyen de la table de Karnaugh.
Évaluer son coût minimal.

X = ____________________________________________________________________

3) Trouver l'expression conjonctive simplifiée de Y au moyen de la table de Karnaugh.
Évaluer son coût minimal.

Y = ____________________________________________________________________

4) Trouver l'expression conjonctive simplifiée de Z en vous basant sur les résultats précédents.
Évaluer le coût minimal de cette implémentation.

Z = ____________________________________________________________________

Considérant le circuit suivant implémentant la fonction X :

1) Trouver l'expression algébrique de X sous la forme d'un produit de sommes :

2) Donner la table de Karnaugh à variable inscrite de X sans simplifier (inscrire D) :

3) Dessiner dans la zone en pointillés le circuit permettant d'obtenir X en sortie

Soit la table de vérité de la fonction logique F(A,B,C,D) :

1) Retranscrire les maxterms de la fonction F sous forme binaire en soulignant les maxterms facultatifs - exemple : 1110 pour

F(A,B,C,D) =

2) Procéder par la méthode Quine-McCluskey pour simplifier la fonction F(A,B,C,D) et identifier les impliqués premiers

Impliqués premiers sous forme binaire :

3) Utiliser la table suivante pour identifier les impliqués essentiels de F(A,B,C,D)

4) Les impliqués essentiels couvrent-ils l'ensemble des maxterms ? Si oui, donner l'expression conjonctive simplifiée de la fonction F(A,B,C,D). Autrement, suggérer une solution et donner l'expression conjonctive simplifiée de la fonction F(A,B,C,D) ainsi obtenue.

5) Confirmer votre résultat en utilisant une table de Karnaugh

Exercice 2 - Analyse et synthèse de circuits

1) En considérant que les portes XOR et XNOR à N entrées ont un coût 2N, calculer le coût des fonctions X, Y et Z telles qu'elles ont été implémentées.

Coût de X(A, B, C, D) = (3+1) + (2+2) = 8
Coût de Y(A, B, C, D) = (3+1) + (2+2) = 8
Coût de Z(A, B, C, D) = 8 + 8 + 2?2 = 20

3) Trouver l'expression conjonctive simplifiée de Y au moyen de la table de Karnaugh.
Évaluer son coût minimal.

4) Trouver l'expression conjonctive simplifiée de Z en vous basant sur les résultats précédents. Évaluer le coût minimal de cette implémentation.

5) Dessinez le circuit optimisé.

Exercice 3 - Circuits avec mux/démux

1) Trouver l'expression algébrique de X sous la forme d'un produit de sommes :

2) Donner la table de Karnaugh à variable inscrite de X sans simplifier (inscrire D) :

3) Dessiner dans la zone en pointillés le circuit permettant d'obtenir X en sortie

Exercice 4 - Quine-McCluskey

1) Retranscrire les maxterms de la fonction F sous forme binaire en soulignant les maxterms facultatifs :

2) Procéder par la méthode Quine-McCluskey pour simplifier la fonction F(A,B,C,D) et identifier les impliqués premiers

3) Utiliser la table suivante pour identifier les impliqués essentiels de F(A,B,C,D)

5) Confirmer votre résultat en utilisant une table de Karnaugh

# data[].attributes.attachment_link.title
Exercices algèbre de boole, circuits logiques et la méthode Quine-McCluskey

# data[].attributes.attachment_link.description
Sachant que A, B et C sont des variables booléennes. Démontrer que : Exercice 2 - Analyse et synthèse de circuits L'implémentation d'une fonction logique Z relativement complexe repose sur un XOR de deux autres fonctions X et Y comme indiqué sur le schéma suivant : 1) En considérant que les portes XOR et XNOR à N entrées ont un coût 2N, calculer le coût des fonctions X, Y et Z telles qu'elles ont été implémentées.

# data[].attributes.attachment_link.readable_text
Sachant que A, B, C et D sont des variables booléennes.

a) En utilisant exclusivement l'algèbre booléene, démontrez que :

b) En utilisant la décomposition de Shannon, démontrez que :

c) En utilisant une technique de votre choix, démontrez que le circuit suivant a toujours sa sortie fausse :

Exercice 2 - Analyse et synthèse de circuits

L'implantation d'une fonction logique Z relativement complexe repose sur un NOR de deux autres fonctions FX et FY comme indiqué sur le schéma suivant :

1) La fonction FX est spécifiée par sa table de vérité :

Trouver l'expression disjonctive simplifiée de X au moyen de la table de Karnaugh.
Évaluez son coût minimal et dessinez votre meilleur circuit

2) La fonction FY a déjà été réalisée par un apprenti. Elle fonctionne bien mais le patron prétend que le circuit coûte trop cher pour rien. Faites l'analyse de cette fonction et proposez votre meilleur circuit en comparant les versions disjonctive et conjonctive.

c) Votre patron vous demande de porter un regard critique sur la première implantation de FY. Qu'allez-vous lui dire ?

3) Sachant que finalement, seule la valeur de Z importe, proposez votre meilleur circuit pour implanter Z(A,B,C,D)

Exercice 3 - Quine-McCluskey

Soit la table de vérité de la fonction logique F(A,B,C,D) :

1) Retranscrire les minterms de la fonction F sous forme binaire en soulignant les minterms facultatifs - exemple : 0110 pour

2) Procéder par la méthode Quine-McCluskey pour simplifier la fonction F(A,B,C,D) et identifier les impliquants premiers

3) Utiliser la table suivante pour identifier les impliquants essentiels de F(A,B,C,D)

4) Utilisez la méthode de Petrick simplifiée (après élimination des impliquants essentiels) pour trouver toutes les solutions (les moins chères) possibles. Écrivez chaque solution sous sa forme algébrique (disjonctive).

5) Confirmez votre résultat en utilisant une table de Karnaugh

En utilisant un décodeur (3 bits de sélection A, B et C) et une seule porte logique à deux entrées par fonction, implantez les fonctions F1, F2, F3 et F4

En utilisant un multiplexeur (4 vers 1, 2 bits de sélection) et une seule porte logique, implantez la fonction suivante :
a) En utilisant exclusivement l'algèbre booléene, démontrez que :
Suggestion : utilisez la réduction sur les variables C et D

On calcule les formes canoniques disjonctives des deux expressions :

Après distribution et commutation, on obtient les deux mêmes expressions.

b) Par Shannon, sur la variable A, il vient :

Par Shannon sur la variable B, il vient :

c) En utilisant une technique de votre choix, démontrez que le circuit suivant a toujours sa sortie fausse :
Soit X, la sortie du XNOR(B,C), il vient, par Shannon sur la variable X :

2) La fonction FY a déjà été réalisée par un apprenti. Elle fonctionne bien mais le patron prétend que le circuit coûte trop cher pour rien. Faites l'analyse de cette fonction et proposez votre meilleur circuit en comparant les versions disjonctive et conjonctive. c) Votre patron vous demande de porter un regard critique sur la première implantation de FY. Qu'allez-vous lui dire ?

Exercice 2 - Analyse et synthèse de circuits

1) Trouver l'expression disjonctive simplifiée de X au moyen de la table de Karnaugh.
Évaluez son coût minimal et dessinez votre meilleur circuit

C'était une bonne idée d'utiliser la forme conjonctive. Toutefois, deux erreurs ont été commises :

1) 3 impliqués alors que 2 auraient suffi
2) L'utilisation de portes NOR aurait été moins couteuse
3) Sachant que finalement, seule la valeur de Z importe, proposez votre meilleur circuit pour implanter Z(A,B,C,D)
Conclusion, le patron avait raison, le circuit coute (2+2)+(3+2)+(3+2)+(3+2), soit 19 à la place de 9.

Dessinez le circuit optimisé.

2) Procéder par la méthode Quine-McCluskey pour simplifier la fonction F(A,B,C,D) et identifier les impliquants premiers

3) Impliquants essentiels : 0X1X
Soient 4 solutions optimales avec 3 impliquants premiers (+ l'impliquant essentiel)
5) Confirmez votre résultat en utilisant une table de Karnaugh

# data[].attributes.attachment_link.title
Exercices algèbre de boole et circuits logiques

# data[].attributes.attachment_link.description
Sachant que A, B, C et D sont des variables booléennes.

# data[].attributes.body
Chapitre 6

# data[].attributes.attachment_link.readable_text
mytuple = ("apple", "banana", "cherry")

Tuple

Tuples are used to store multiple items in a single variable.

Tuple is one of 4 built-in data types in Python used to store collections of data, the other 3 are List, Set, and Dictionary, all with different qualities and usage.

A tuple is a collection which is ordered and unchangeable.

Tuples are written with round brackets.

Tuple Items

Tuple items are ordered, unchangeable, and allow duplicate values.

Tuple items are indexed, the first item has index [0], the second item has index [1] etc.

Ordered

When we say that tuples are ordered, it means that the items have a defined order, and that order will not change.

Unchangeable

Tuples are unchangeable, meaning that we cannot change, add or remove items after the tuple has been created.

Allow Duplicates

Since tuples are indexed, they can have items with the same value:

Tuple Length

To determine how many items a tuple has, use the len() function:

Create Tuple With One Item

To create a tuple with only one item, you have to add a comma after the item, otherwise Python will not recognize it as a tuple.

Example

One item tuple, remember the comma:

Try it Yourself "

Tuple Items - Data Types

Tuple items can be of any data type:

Example

String, int and boolean data types:

Try it Yourself "

A tuple can contain different data types:

Example

A tuple with strings, integers and boolean values:

Try it Yourself "

type()

From Python's perspective, tuples are defined as objects with the data type 'tuple':

The tuple() Constructor

It is also possible to use the tuple() constructor to make a tuple.

Python Collections (Arrays)

There are four collection data types in the Python programming language:

List is a collection which is ordered and changeable. Allows duplicate members.

Tuple is a collection which is ordered and unchangeable. Allows duplicate members.

Set is a collection which is unordered, unchangeable*, and unindexed. No duplicate members.

Dictionary is a collection which is ordered** and changeable. No duplicate members.

*Set items are unchangeable, but you can remove and/or add items whenever you like.

**As of Python version 3.7, dictionaries are ordered. In Python 3.6 and earlier, dictionaries are unordered.

When choosing a collection type, it is useful to understand the properties of that type. Choosing the right type for a particular data set could mean retention of meaning, and, it could mean an increase in efficiency or security.

# data[].attributes.attachment_link.description
W3Schools offers free online tutorials, references and exercises in all the major languages of the web. Covering popular subjects like HTML, CSS, JavaScript, Python, SQL, Java, and many, many more.