diff --git a/representation_base/.DS_Store b/representation_base/.DS_Store new file mode 100644 index 0000000..42a8956 Binary files /dev/null and b/representation_base/.DS_Store differ diff --git a/representation_base/README.md b/representation_base/README.md new file mode 100644 index 0000000..fce87f2 --- /dev/null +++ b/representation_base/README.md @@ -0,0 +1,31 @@ +# Représentation de base + +## Pourquoi et comment le monde devient numérique ? + +L'adjectif « __Numérique__ » vient du latin « _numerus_ » (« nombre », « multitude ») et signifie « représentation par nombres ». Il s'oppose au calcul analogique ou littéral (par lettre). + +### Définition + +> Le nom __numérique__ désigne maintenant les technologies de l'information et de la communication. On parlera de numérisation l'opération de transformation vers ces technologies numériques. Dans d'autres langues, nous parlerons de digital. + +Les grandeurs numériques n'existent pas à l'état naturel. Le numérique est une pure invention humaine ! + +La numérisation est le procédé permettant la construction d'une représentation discrète d'un objet du monde réel. Elle consiste donc à coder une information (texte, son, image, force...) sous la forme d'un ensemble de nombres (nous parlerons de forme numérique). Cette opération amène à une convergence des informations qui sont à l'origine totalement différentes. Ces informations pourront être manipulées, traitées, transmises et stockées par un système numérique. + +![données dans un ordinateur](./assets/ordinateur.svg) + +Les données de base sont représentées selon un __codage__ dépendant de leur nature : entiers, flottants, caractères et chaînes de caractères, ... + +### Définition + +> Le __codage de l’information__ concerne les moyens de formaliser l'information afin de pouvoir la manipuler, la stocker ou la transmettre. Il ne s'intéresse pas au contenu mais seulement à la forme et à la taille des informations à coder. + +L'objet de cette séquence est de répondre à la question : __Comment sont codées les données dans une machine ?__ + +Cette séquence se décompose en 5 chapitres : + +- [Chapitre 1 : Représentation d'un entier naturel](./seance_1/) +- [Chapitre 2 : Représentation d'un entier relatif](./seance_2/) +- [Chapitre 3 : Représentation d'un flottant](./seance_3/) +- [Chapitre 4 : Représentation d'un booléen](./seance_4) +- [Chapitre 5 : Représentation d'un texte](./seance_5/) diff --git a/representation_base/assets/10_vers_2.PNG b/representation_base/assets/10_vers_2.PNG new file mode 100644 index 0000000..b5baabb Binary files /dev/null and b/representation_base/assets/10_vers_2.PNG differ diff --git a/representation_base/assets/2_vers_10.PNG b/representation_base/assets/2_vers_10.PNG new file mode 100644 index 0000000..b6091b0 Binary files /dev/null and b/representation_base/assets/2_vers_10.PNG differ diff --git a/representation_base/assets/BO.png b/representation_base/assets/BO.png new file mode 100644 index 0000000..73d0475 Binary files /dev/null and b/representation_base/assets/BO.png differ diff --git a/representation_base/assets/BO_1.PNG b/representation_base/assets/BO_1.PNG new file mode 100644 index 0000000..0babe31 Binary files /dev/null and b/representation_base/assets/BO_1.PNG differ diff --git a/representation_base/assets/Base_quelconque.PNG b/representation_base/assets/Base_quelconque.PNG new file mode 100644 index 0000000..f9bacf9 Binary files /dev/null and b/representation_base/assets/Base_quelconque.PNG differ diff --git a/representation_base/assets/ampoule.PNG b/representation_base/assets/ampoule.PNG new file mode 100644 index 0000000..e0a8501 Binary files /dev/null and b/representation_base/assets/ampoule.PNG differ diff --git a/representation_base/assets/binaire.PNG b/representation_base/assets/binaire.PNG new file mode 100644 index 0000000..8b4f5c6 Binary files /dev/null and b/representation_base/assets/binaire.PNG differ diff --git a/representation_base/assets/exemples.PNG b/representation_base/assets/exemples.PNG new file mode 100644 index 0000000..5fad9d8 Binary files /dev/null and b/representation_base/assets/exemples.PNG differ diff --git a/representation_base/assets/exercice_1.PNG b/representation_base/assets/exercice_1.PNG new file mode 100644 index 0000000..edea3d6 Binary files /dev/null and b/representation_base/assets/exercice_1.PNG differ diff --git a/representation_base/assets/exercice_2.PNG b/representation_base/assets/exercice_2.PNG new file mode 100644 index 0000000..4e77547 Binary files /dev/null and b/representation_base/assets/exercice_2.PNG differ diff --git a/representation_base/assets/gros_boutisme.PNG b/representation_base/assets/gros_boutisme.PNG new file mode 100644 index 0000000..36dc1a2 Binary files /dev/null and b/representation_base/assets/gros_boutisme.PNG differ diff --git a/representation_base/assets/gros_boutisme_2.PNG b/representation_base/assets/gros_boutisme_2.PNG new file mode 100644 index 0000000..f346fbc Binary files /dev/null and b/representation_base/assets/gros_boutisme_2.PNG differ diff --git a/representation_base/assets/interrupteur.PNG b/representation_base/assets/interrupteur.PNG new file mode 100644 index 0000000..9606305 Binary files /dev/null and b/representation_base/assets/interrupteur.PNG differ diff --git a/representation_base/assets/octet.PNG b/representation_base/assets/octet.PNG new file mode 100644 index 0000000..fdde016 Binary files /dev/null and b/representation_base/assets/octet.PNG differ diff --git a/representation_base/assets/ordinateur.svg b/representation_base/assets/ordinateur.svg new file mode 100644 index 0000000..574b9f2 --- /dev/null +++ b/representation_base/assets/ordinateur.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/representation_base/assets/petit_boutisme.PNG b/representation_base/assets/petit_boutisme.PNG new file mode 100644 index 0000000..badeaba Binary files /dev/null and b/representation_base/assets/petit_boutisme.PNG differ diff --git a/representation_base/assets/petit_boutisme_2.PNG b/representation_base/assets/petit_boutisme_2.PNG new file mode 100644 index 0000000..92bef97 Binary files /dev/null and b/representation_base/assets/petit_boutisme_2.PNG differ diff --git a/representation_base/assets/tableau.PNG b/representation_base/assets/tableau.PNG new file mode 100644 index 0000000..f397ecb Binary files /dev/null and b/representation_base/assets/tableau.PNG differ diff --git a/representation_base/assets/tableau_hexa.PNG b/representation_base/assets/tableau_hexa.PNG new file mode 100644 index 0000000..896df12 Binary files /dev/null and b/representation_base/assets/tableau_hexa.PNG differ diff --git a/representation_base/seance_1/.DS_Store b/representation_base/seance_1/.DS_Store new file mode 100644 index 0000000..b6d4062 Binary files /dev/null and b/representation_base/seance_1/.DS_Store differ diff --git a/representation_base/seance_1/TP/.gitkeep b/representation_base/seance_1/TP/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/representation_base/seance_1/TP/README.md b/representation_base/seance_1/TP/README.md new file mode 100644 index 0000000..bf56cc9 --- /dev/null +++ b/representation_base/seance_1/TP/README.md @@ -0,0 +1,140 @@ +# Exercices : Représentation des nombres naturels + + + +## Manipulation + +__Question 1 :__ Écrire une fonction `est_valide(binaire)` qui retourne : + +* **True** si le nombre est valide +* **False** si le nombre est invalide. +Le paramètre de la fonction sera une chaîne de caractères représentant un nombre écrit en base 2. + +``` python +>>> est_valide("100010101") +True +>>> est_valide("1010401034") +False +``` + + + +__Question 2 :__ Écrire une fonction ``est_pair(binaire)`` qui retourne : + +* **True** si le nombre passé en paramètre est pair +* **False** si le nombre passé en paramètre est impair. +Le paramètre de la fonction sera une chaîne de caractères représentant un nombre écrit en base 2. + +```python +>>> est_paire('1001') +False +>>> est_paire('1010') +True +``` + + + +## Conversion Binaire - Décimal + +__Question 3 :__ Écrire une fonction ``deux_puissance(rang)`` qui retourne la puissance de 2 associée au rang passé en paramètre. Vous n'utiliserez pas les fonctions Python déjà existantes. + +``` python +>>> deux_puissance(0) +1 +>>> deux_puissance(1) +2 +>>> deux_puissance(2) +4 +``` + + + +__Question 4 :__ A l'aide des fonctions précédentes, écrire une fonction ``binaire_en_decimal(binaire)`` qui retourne la valeur décimale du nombre passé en paramètre. Le paramètre sera une chaîne de caractères représentant un nombre binaire. On vérifiera que ce nombre binaire est valide. + +``` python +>>> binaire_en_decimal("1") +1 +>>> binaire_en_decimal("1010") +10 +>>> binaire_en_decimal("1001") +9 +``` + + + +## Conversion Décimal - Binaire + +__Question 5 :__ Écrire une fonction ``division_euclidienne(nombre, diviseur)`` qui retourne le quotient et le reste obtenu lorsque l'on divise le paramètre *nombre* par le paramètre *diviseur*. + +``` python +>>> division_euclidienne(6,3) +(2,0) +>>> division_euclidienne(10,4) +(2,2) +>>> reste(6, 0) +None +``` + + + +__Question 6 :__ A l'aide de l'algorithme de la division euclidienne et des fonctions précédentes, écrire une fonction ``decimal_en_binaire(*decimal*)`` qui retourne une chaîne de caractères correspondant à la représentation binaire du nombre passé en paramètre. + + +``` python +>>> decimal_en_binaire(16) +"10000" +>>> decimal_en_binaire(31) +"11111" +``` + + + +## Conversion Décimal - Hexadécimal + +__Question 7 :__ Écrire une fonction ``symbole_hexa(decimal)`` qui retourne le symbole correspondant au paramètre dans la base 16. + +```python +>>> symbole_hexa(1) +"1" +>>> symbole_hexa(10) +"A" +``` + + + +__Question 8 :__ En s'inspirant des questions précédentes, écrire une fonction ``decimal_en_hexa(decimal)`` qui retourne une chaîne de caractères correspondant à la représentation en base 16 du nombre passé en paramètre. + +``` python +>>> decimal_en_hexa(21) +"15" +>>> decimal_en_hexa(2019) +"7E3" +``` + + + +## Conversion Hexadécimal - Décimal + +__Question 9 :__ écrire une fonction ``hexa_en_decimal(hexa)`` qui retourne le nombre correspondant à la représentation en base 10 du nombre passé en paramètre. + +```python +>>> hexa_en_decimal("A") +10 +>>> decimal_en_hexa("E10F") +57615 +``` + + + +## Conversion en base $$n$$ + +__Question 10 :__ En s'inspirant des fonctions 8 et 10, écrire une fonction ``decimal_en_base_n(decimal, base)`` qui retourne une chaîne de caractères correspondant à la représentation en base *n* du nombre passé en paramètre. + +```python +>>> decimal_en_base_n(10,2) +"1010" +>>> decimal_en_base_n(10,16) +"A" +>>> decimal_en_base_n(10,5) +"20" +``` diff --git a/representation_base/seance_1/cours/README.md b/representation_base/seance_1/cours/README.md new file mode 100644 index 0000000..54580c2 --- /dev/null +++ b/representation_base/seance_1/cours/README.md @@ -0,0 +1,228 @@ +# Représentation des entiers naturels + +> **_Contenu_** : Notions introduites pour l’écriture en base 2, en base 16 ainsi que la notion de boulisme.
+> **_Compétences_** : Maitriser le codage d’une information et les différentes représentations de celle-ci + +## Le programme + +
+ + +![bo_1.png](/premiere/representation_base/assets/BO_1.PNG) + + +## Apport de connaissances + +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 et toutes.

+ +

+ 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 ? + +### La numération décimale (base 10) + +Dans la vie courante et dans beaucoup de domaines, nous utilisons la numération décimale. Elle repose à l’origine sur nos dix doigts : les dix symboles – chiffres – permettent de représenter tous les nombres. +
+La position des chiffres est primordiale dans cette représentation (numération de position) : il y a quelques années déjà, vous avez appris ce qu’étaient les unités (colonne de droite), les dizaines, les centaines, etc… + +Bref, 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. Le nombre en est ainsi décomposé.
+ +Ainsi, on peut écrire 4138 comme 4 * 1000 + 1 * 100 + 3 * 10 + 8 * 1 +→ On remarque les égalités suivantes : 1000 = 103 ; 100 = 10² ; 10 = 101 ; 1 = 100 + +Donc 4138 peut s’écrire : 4 * 103 + 1 * 102 + 3 * 101 + 8 * 100
+→où 10 est appelé BASE de cette numération (ici décimale)
+→où chaque chiffre (compris entre 0 et 9) est soit celui des unités, dizaines, etc… + +![exercice_1.png](/premiere/representation_base/assets/exercice_1.PNG) + +✏ *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 codage binaire (base 10) + +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_**.
Un bit a deux états stables. +En électronique, il est facile d'obtenir un système présentant deux états stables distincts. Prenons l'exemple +d'un interrupteur + +![interrupteur.png](/premiere/representation_base/assets/interrupteur.PNG) + +![exemples.png](/premiere/representation_base/assets/exemples.PNG) + +Ainsi, pour coder une information qui peut ne prendre que deux états stables, la numération binaire est la +plus adaptée. +
+**Remarque** : étant donné que les symboles 0 et 1 sont communs à beaucoup de bases de numération (en +l’occurrence 2 et 10), nous adoptons les notations suivantes. + +(1011)b ou 1011(en base 2) ou encore (1011)2 pour la base binaire
+(101)d ou 101(en base 10) ou encore (101)10 pour la base dix + +#### Comment trouver la représentation en base deux d'un entier naturel donné en base dix + +→ Méthode des divisions successives
+Exemple: (11)d = (?)b + +![10_vers_2.png](/premiere/representation_base/assets/10_vers_2.PNG) + +(11)d => (1011)b + +
+ + +✏ Comment représenter des informations complexes ? ✏ + +

  • Avec 1 bit, nous pouvons coder 2 informations. +
  • Avec 2 bits, nous pouvons coder 4 informations différentes (2²) + +Si nous généralisons un peu : avec **_k_** bits, nous pouvons coder **_2k_** informations différentes + +### À faire vous-même + +Compléter le tableau suivant afin de coder les 8 premiers entiers naturels (entiers positifs ou nul) + +![tableau.png](/premiere/representation_base/assets/tableau.PNG) + +### À faire vous-même + +1. Convertir 42(10) en base 2 : 101010 +2. Convertir 104(10) en base 2 : 1101000 + +
    + +### Qu'est-ce qu'un octet ? + +Un octet ((**byte** en anglais) est un regroupement de 8 bits. +On parle aussi de mot. Il permet de coder 28 = 256 mots différents. +Si nous codons des entiers naturels, nous coderons les nombres 0 à 255. Dans la littérature, un regroupement de 4 bits est appelé un quartet (cela nous servira plus tard). + +![octet.png](/premiere/representation_base/assets/octet.PNG) + +### Unités de mesure + +Il est très courant en informatique de mesurer la capacité mémoire d'un disque dur, de la RAM d'un ordinateur ou d'un débit de données Internet avec une unité de mesure exprimée comme un multiple d'octets. Ces multiples sont traditionnellement des puissances de 10 et on utilise les préfixes "kilo", " méga", etc. pour les nommer. Le tableau ci-dessous donne les principaux multiples utilisés dans la vie courante. + +| Nom | Symbole | Valeur | +| :--------------- |:---------------: | -----:| +| Kilooctet | ko | 103 octets | +| Mégaoctet | Mo | 103 ko | +| Gigaoctet | Go | 103 Mo | +| Teraoctet | To | 103 Go | + +> Remarque : Historiquement, les multiples utilisés en informatique étaient des puissances de 2. Pour ne pas confondre l'ancienne et la nouvelle notation, on utilise des symboles différents pour représenter ces multiples. + +| Nom | valeur | Nombre d'octeets | +| :--------------- |:---------------: | -----:| +| Kio | 210 octets | 1024 | +| Mio | 210Kio |1048576| +| Gio | 210Mio |1073741824| +| Tio | 210Gio |1099511627776| + +### À faire vous-même + +> Faisons la conversion de la base 2 vers la base 10 --> Passer de (0 1 1 0 1 1 0 1)b = (….......)d + +Méthode : +
  • Ecrire le nombre binaire dans le tableau de correspondance
    +
  • Faire la somme des valeurs des rangs pour lesquels la valeur du bit vaut 1. + +![2_vers_10.png](/premiere/representation_base/assets/2_vers_10.PNG) + +Somme : ............ + +---------------------------- + +### Le système hexadécimal (base 10) + +

    + La représentation en binaire n'est pas pratique à nous humain pour travailler (longueur de l'information importante, difficile à écrire et à lire sans faire d'erreur...). +

    + Pour cela, nous travaillons avec la base hexadécimale. Le système hexadécimal permet de réduire la longueur des mots et facilite leur manipulation : +L'écriture d'un nombre binaire en base hexadécimale est aisée. + + +Ce système comporte seize symboles : +- les dix chiffres du système décimal (0 à 9) +- et les six premières lettres de l’alphabet (A à F)
    +
    +Ce sera donc un système en **base 16**. + +✏ Pour l'ordinateur, ça ne change rien, il travaille toujours en binaire. ✏ + +### À faire vous-même + +> Compléter la colonne binaire + +![binaire.png](/premiere/representation_base/assets/binaire.PNG) + +> Passer de la base décimale à la base hexadécimale
    Écrire le nombre 63650 (10) en base 16 + +![exercice_2.png](/premiere/representation_base/assets/exercice_2.PNG) + +> Faisons la conversion de la base 16 vers la base 10, écrire le nombre 2A3 (16) en base décimale + +Méthode : +

  • Ecrire le nombre hexadécimal dans le tableau de correspondance en positionnant le chiffre correspondant à chacun des rangs. +
  • Faire la somme des produits des chiffres avec la pondération correspondante. + +![tableau-hexa.png](/premiere/representation_base/assets/tableau_hexa.PNG) + +> Passer du code binaire au code hexadécimal + +**_Première méthode_** : opérer en deux étapes. +
  • passer du binaire au décimal dans un premier temps +
  • passer ensuite du décimal à l’hexadécimal
    + +Exemple : vérifier que 10110111101 (2) = 1469 (10) = 5BD + + +**_Deuxième méthode_** : plus rapide, elle consiste à découper le nombre binaire en quartets (mots de 4 bits), à partir de la droite, puis à remplacer chaque quartet par le symbole hexadécimal correspondant. + +Exemple : 10110111101 (2) = 101 1011 1101 en binaire découpé en quartet + = 5 B D en hexadécimal + +------------------------------------ + +### Passer d'une base quelconque à une autre + +Pour passer d'une base à une autre, on passera par la base 10 car c'est sur cette base qu'on maîtrise le mieux les opérations de base. + +Exemple : (944)10 → ( 12234)5 + +![base_quelconque.png](/premiere/representation_base/assets/Base_quelconque.PNG) + +------------------------- + +### Le boutisme + +La représentation des entiers naturels sur des mots de 2, 4 ou 8 octets se heurte au problème de l'ordre dans lequel ces octets sont organisés en mémoire. Ce problème est appelé le boutisme (ou endianness en anglais). + +Prenons l'exemple d'un mot de 2 octets (16 bits) comme 5BC9. Il y a deux organisations possibles d'un tel mot en mémoire : + +
  • Le gros boutisme (ou ou « mot de poids fort en tête » ou big endian en anglais), qui consiste à placer l'octet de poids fort en premier, c'est à dire à l'adresse mémoire la plus petite. + +![gros_boutisme.png](/premiere/representation_base/assets/gros_boutisme.PNG) + +> Quelques architectures respectant cette règle : _les processeurs Motorola 68000, les SPARC (Sun Microsystems) ou encore les System/370 (IBM)_. De plus, tous les protocoles TCP/IP communiquent en gros-boutiste. Il en va de même pour le protocole PCI Express. + +
  • Le petit boutisme (ou little endian en anglais), qui au contraire place l'octet de poids faible en premier. + +![petit_boutisme.png](/premiere/representation_base/assets/petit_boutisme.PNG) + +> Les processeurs x86 ont une architecture petit-boutiste. Celle-ci, au prix d'une moindre lisibilité du code machine par le programmeur, simplifiait la circuiterie de décodage d'adresses courtes et longues en 1975, quand un 8086 avait 29 000 transistors. Elle est d'influence pratiquement nulle aujourd’hui. + +Généralisons pour 4 octets. Ainsi, le mot 5BC96AF sera représenté de la manière suivante : +en **gros boutisme** + +![gros_boutisme_2.png](/premiere/representation_base/assets/gros_boutisme_2.PNG) + +en **petit boutisme** + +![petit_boutisme_2.png](/premiere/representation_base/assets/petit_boutisme_2.PNG) + +La représentation petit ou gros boutisme est en principe transparente à l'utilisateur car cela est géré au niveau du système d'exploitation. Cette représentation prend de l'importance quand on accède aux octets soit en mémoire, soit lors d'échanges d'informations sur un réseau. + + +```python + +``` diff --git a/representation_base/seance_1/evaluation/README.md b/representation_base/seance_1/evaluation/README.md new file mode 100644 index 0000000..e69de29 diff --git a/representation_base/seance_1/exercices/README.md b/representation_base/seance_1/exercices/README.md new file mode 100644 index 0000000..8837442 --- /dev/null +++ b/representation_base/seance_1/exercices/README.md @@ -0,0 +1,63 @@ +# Convertisseur + +Certaines oeuvres (film, livre, série...) contiennent un nombre dans leur titre. L'objectif est d'écrire les nombres en base 2, ce qui donne une toute autre lecture des titres... + +Exemple : Terminator $`2`$ $`\rightarrow`$ Terminator $`\overline{10}^2`$ + +## Titre de films + +- Les **4** Fantastiques +- Le **6**ème sens +- Blanche neige et les **7** nains +- Alien : Le **8**ème Passager +- Fast and Furious **9** +- **12** hommes en colère +- Vendredi **13** +- **21** Jump street +- Les **101** dalmatiens +- OSS **117** : Le Caire, nid d'espions +- **2001** : L'Odysée de l'espace +- **127** Heures +- **300** +- **28** jours plus tard +- Les **Quatre Cents** Coups + +## Titre de livres + +- Entretien avec **un** vampire, d'Anne rice +- L'homme **bicentenaire**, Isaac Asimov +- Les **Trois** Mousquetaires, Alexandre Dumas +- Les **Quatre** Filles du docteur March, Louisa May Alcott +- Blanche-Neige et les **sept** nains, Frères Grimm +- **Cinquante** nuances de Grey, E.L. James +- Le Tour du monde en **80** jours, Jules Verne +- **99** francs, Frédéric Beigbeder +- Fahrenheit **451**, Ray Bradbury +- Les **Mille et Une** Nuits +- **1984**, Georges Orwell +- Ils étaient **dix**, Agatha Christie +- **Vingt mille** lieues sous les mers + +## Expressions + +- Être unis comme les **cinq** doigts de la main +- L’art de faire du **neuf** avec du vieux +- Chercher **midi** à **quatorze** heures + +## Recette + +Une recette de cuisine demande de la précision. + +La recette suivante permet de fabriquer de délicieux __chocolats fourrés au beurre de cacahuètes__...Seulement, toutes les quantités sont exprimées en une base différente de la base décimale. + +_Reconstituer la recette en convertissant toutes les quantités en décimal_. + +Pour $`\overline{100}^2`$ personnes, soit $`\overline{30}^8`$ biscuits. + +1. Mixer $`\overline{41}^{16}`$g de biscuits sablés pour les réduire en poudre +2. Dans un saladier, mélanger cette poudre avec $`\overline{175}^8`$g de sucre glace et $`\overline{1\text{E}}^{16}`$g de beurre de cacahuètes. Bien mélanger pour obtenir une pâte. +3. Faire fondre $`\overline{\text{F}0}^{16}`$g de chocolat pâtissier. +4. Dans des caissettes en aluminium, étaler un peu de chocolat fondu (environ $`\overline{100}^2`$g) puis placer un morceau de pâte, et recouvrir de chocolat fondu. +5. Répéter l'opération avec les ingrédients restants. +6. Mettre au réfrigérateur pendant environ $`\overline{1010}^2`$ minutes puis servir. + diff --git a/representation_base/seance_2/.gitkeep b/representation_base/seance_2/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/representation_base/seance_2/README.md b/representation_base/seance_2/README.md new file mode 100644 index 0000000..306f4ef --- /dev/null +++ b/representation_base/seance_2/README.md @@ -0,0 +1,127 @@ +# Représentation des entiers relatifs + +## Attendus + +| Contenus | Capacités attendues | +| :--: | :-- | +| Représentation binaire d’un entier relatif | Évaluer le nombre de bits nécessaires à l’écriture en base 2 d’un entier, de la somme ou du produit de deux nombres entiers.
    Utiliser le complément à 2 | + +## Contexte + +Pour comprendre le fonctionnement du binaire, nous allons nous intéresser dans le un premier temps à la représentation des entiers positifs en base 10. +Quelque soit la base utilisée, le fonctionnement est identique et les méthodes de conversion sont similaires. + +## Pré-requis + +### La valeur absolue d'un nombre + +La valeur absolue d'un nombre réel est sa valeur numérique sans tenir compte de son signe. Elle est notée $`|n|`$. + +- Si $`n > 0`$, alors $`|n| = n`$ +- Si $`n < 0`$, alors $`|n| = `$ opposé de $`n`$ + +### Les bits significatifs + +### L'addition binaire + +Les opérations ci dessous manipulent des nombres représentés en binaire, codés sur un (1) bit. + +```math +\begin{align*} +0 + 0 &= 0 \\ +1 + 0 &= 1 \\ +0 + 1 &= 1 \\ +1 + 1 &= 0 \rightarrow \textit{Mais on reporte la retenue sur le bit de poids supérieur} +\end{align*} +``` + +### La soustraction + +Les opérations ci dessous manipulent des nombres représentés en binaire, codés sur quatre (4) bit. + +```math +\begin{align*} +0110 - 0011 &= 0011 \\ +1011 - 10 &= 1001 \\ +10 - 101 &= ? \\ +\end{align*} +``` + +**_À votre avis, que donne cette dernière opération ?_** + +## 1. La représentation binaire signée + +La première méthode utilisée pour représenter des entiers négatifs est de réserver un bit qui déterminera le signe. Il restera donc p - 1 bits pour la représentation de la valeur absolue. + +Le bit de signe choisi est le bit le poids fort. Par convention, on définira : · + +- $`1`$ pour représenter un nombre négatif +- $`0`$ pour représenter un nombre positif + +Avant de représenter un entier, il faut aussi définir le nombre de bits qui seront utilisés, souvent 4, 8, 16, 32 ou 64 bits. + +Prenons un exemple avec l'entier $`5`$ sur 8 bits : + +```math +\begin{align*} +5_{10} & = 0000\ 0101_2 \\ +-5_{10} & = 1000\ 0101_{2} +\end{align*} +``` + +Cependant cette méthode possède un inconvénient majeur : + +Les opérations "classiques" avec 2 nombres binaires ne fonctionnent plus ! C'est pour ces raisons que nous allons utiliser une nouvelle méthode : **le complément à deux**. + +Par ailleurs, on peut observer qu'il existe dorénavant deux manières de notation du nombre zéro (0) : + +- $`0000\ 0000 = +0`$ +- $`1000\ 0000 = -0`$ + +## 2. Le complément à 2 + +Le **complément à 2** est la méthode de représentation d'un entier négatif. + +Cette méthode se décompose en quatre (4) étapes : + +1. Représenter la valeur absolue de l'entier relatif sur $`p`$ bits +2. Inverser tous les bits (les 1 deviennent des 0 et vice versa) +3. Ajouter un (1) au nombre obtenu à l'étape précédente +4. Le résultat de cette dernière opération est donc la représentation sur $`p`$ bits de l'entier relatif. + +**Travail à faire** + +> Calculer l'entier -5 en appliquant le complément à 2 sur 8 bits. + +Vérifions que la représentation par le complément à 2 satisfait la règle vue précédemment. + +Exemple avec les entiers 13 et -13 : + +```math +\begin{align} +& & \: 0 \: 0 \: 0 \: 0 \: 1 \: 1 \: 0 \: 1 \\ ++ & & \: 1 \: 1 \: 1 \: 1 \: 0 \: 0 \: 1 \: 1 \\ +\hline += & & 1 \: 0 \: 0 \: 0 \: 0 \: 0 \: 0 \: 0 \: 0 +\end{align} +``` + +Dans l'opération ci-dessus, nous avons un 1 pour le 9ième bit, mais comme notre représentation se limite à 8 bits, il nous reste bien $`(00000000)_2`$. + +> 1. Représenter sur 8 bits l'entier 4 puis représenter, toujours sur 8 bits, l'entier -5. +> 2. Additionner ces 2 nombres, vérifier que vous obtenez bien -1. + +**Question pour vous** + +- Quel est le plus petit entier négatif que l'on peut représenter sur huit (8) bits ? +- Et quel est le le plus grand ? + +/!\ Remarque /!\ : + +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`$ . + +Sachant que dans le langage C, les entiers signés sont codés sur 32 bits, dont un (1) pour le signe, quelles sont les valeurs minimale et maximale des entiers que l'on peut représenter ? + +En Python, la taille des entiers est arbitraire (donc non fixe), ainsi les valeurs minimale et maximale des entiers ne dépend que de la quantité de mémoire disponible sur votre machine. + +Néanmoins, on dispose de la bibliothèque _numpy_ qui permet de forcer une représentation sur 8 bits, par exemple, à l'aide de la fonction *int8* diff --git a/representation_base/seance_2/exercices/.gitkeep b/representation_base/seance_2/exercices/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/representation_base/seance_2/exercices/README.md b/representation_base/seance_2/exercices/README.md new file mode 100644 index 0000000..054865c --- /dev/null +++ b/representation_base/seance_2/exercices/README.md @@ -0,0 +1,16 @@ +- 10924 : Point le plus profond, située au fond de l’océan Pacifique, la fosse des Mariannes. En 2020, le submersible Fendouzhe a plongé à cette profondeur et a observé des traces de pollution humaine (bouteille et sac en plastique) https://www-francetvinfo-fr.cdn.ampproject.org/c/s/www.francetvinfo.fr/meteo/climat/video-un-submersible-chinois-au-coeur-des-eaux-les-plus-profondes-de-la-terre_4192715.amp + +- 26 : Ours polaire +- 109 : Orque +- 273 : Grand requin blanc +- 332 : Point le plus profond atteint par un homme en plongé sous-marine (Ahmed Gabr in 2014) +- 1024 : Début de la Midnight zone. Aucun rayon solaire n'est capable d'atteindre cette profondeur +- 1596 : Hydrothermal vents are formed from seawater passing through extremely hot volcanic rocks. They release heavy metals that are toxic to most animals. But even in those extreme conditions specialized life finds a way to survive. +- 3005 : Cuvier's Beaked Whales are the deepest diving mammals. +- 3688 : Profondeur moyenne des océans +- 3800 : On April 14th, 1912 the Titanic sank to its final resting place at a depth of 3,800 meters. +- 4000 : The Abyssal Zone +- 6000 : The Hadal Zone. More people have been to the Moon than the Hadal Zone. +- 6227 : The USS Johnston sank in WWII and is the deepest shipwreck ever found. +- 8848 : Équivalent de l'altitude du mont Everest +- 10225 : Hadal Amphipod diff --git a/representation_base/seance_2/tp/.gitkeep b/representation_base/seance_2/tp/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/representation_base/seance_2/tp/README.md b/representation_base/seance_2/tp/README.md new file mode 100644 index 0000000..142bada --- /dev/null +++ b/representation_base/seance_2/tp/README.md @@ -0,0 +1,59 @@ +# Exercices : Représentation des nombres relatifs + + + +## Complément à deux + +__Question 1 :__ Écrire une fonction ``valeur_absolue(nombre)`` qui retourne la valeur absolue du nombre passé en paramètre. + +```python +>>> valeur_absolue(7) +7 +>>> valeur_absolue(-6) +6 +``` + + + +__Question 2 :__ Écrire une fonction ``inverse(binaire)`` qui retourne une nouvelle chaîne de caractères qui correspond à l'inverse de la chaîne passée en paramètre. + +Le paramètre de la fonction sera une chaîne de caractères représentant un nombre écrit en base 2. + +``` python +>>> inverse("1010") +"0101" +>>> inverse("10110011") +"01001100" +``` + + + +__Question 12 :__ Écrire une fonction ``addition_binaire(binaire1,binaire2)`` qui additionne et retourne le résultat des 2 nombres représentés en base 2. Vous vous aiderez de la table d'addition vu dans le cours. + +```python +>>> addition_binaire("1001","0001") +"1010" +>>> addition_binaire("0001","0001") +"0010" +``` + + + +__Question 13 :__ En utilisant les fonctions précédentes, écrire une fonction ``complement_a_2(decimal, nombre_bit)`` qui retourne la représentation en complément à 2 du nombre donné en paramètre. + +``` python +>>> complement_a_deux(-12, 8) +"11110100" +>>>> complement_a_deux(7,8) +"00000111" +``` + + +__Question 14 :__ En utilisant le principe inverse, écrire une fonction ``complement_a_2_vers_decimal(binaire)`` qui retourne la valeur du nombre représenté en complément à 2 passé en paramètre. Vous aurez besoin d'écrire une fonction qui effectue la soustraction de 2 nombres binaires. + +``` python +>>> complement_a_2_vers_decimal("1111") +-1 +>>>> complement_a_2_vers_decimal('0111") +7 +``` diff --git a/representation_base/seance_3/README.md b/representation_base/seance_3/README.md new file mode 100644 index 0000000..8c8cf36 --- /dev/null +++ b/representation_base/seance_3/README.md @@ -0,0 +1,157 @@ +# Codage des décimaux : les flottants + +## Attendus + +| Contenus | Capacités attendues | +| :--: | :-- | +| Représentation approximative des nombres réels : notion de nombre flottant | Calculer sur quelques exemples la représentation de nombres réels : 0.1, 0.25 ou 1/3. | + +## Petit rappel : la base 10 + +Intéressons nous à l'écriture d'un nombre décimal en base 10, comme par exemple 223,25 + +### Codage de la partie entière + +Nous savons tous ici, en base 10, que 223 se compose de : + +- 3 unités, +- 2 dizaines +- 2 centaines. + +Cela vient de la série de divisions ci-dessous, sur laquelle les restes fournissent le nombre d'unités (3), de dizaines (2) et de centaines (2 aussi) + +![partie entière base 10](assets/div1base10.jpg) + +On écrit alors $`223 = 2 \times 100 + 2 \times 10 + 3 \times 1`$​ : c'est sa décomposition en base 10 + +### Codage de la partie décimale + +Pour la partie décimale, 0.25, en base dix également, on a l'habitude de lire 2 dixièmes et 5 centièmes. Cela vient cette fois de multiplication par 10 : + +* $`0,25 \times 10 = 2.5`$ : la partie entière indique le nombre de dixièmes (2) et la partie décimale restante est 0,5 + +* $`0,5 \times 10 = 5`$ : la partie entière indique le nombre de centièmes (5) et il n'y a plus de partie décimale à _explorer_. + +On vient de voir que $`0,25 = 2 \times \frac{1}{10} + 5 \times \frac{1}{100}`$ + +Ainsi on peut écrire : $`223,25 = 2 \times 100 + 2 \times 10 + 3 + 2 \times \frac{1}{10} + 5 \times \frac{1}{100}`$ + +En **notation scientifique**, on obtient : $`223,25= 2,2325 \times 10²`$​ + +**Définition** + +> La __notation scientifique__ est une façon de représenter les nombres décimaux. Elle consiste à exprimer le nombre sous la forme $`\pm a\times 10^{n}`$, où $`\pm`$ est appelé signe, $`a`$ est un nombre décimal de l'intervalle $`[1 ; 10[`$ appelé __mantisse (ou significande)__ et $`n`$ est un entier relatif appelé __exposant__. + +## En base 2 + +### Codage de la partie entière + +Pour la partie entière, c'est exactement le même principe mais en divisant cette fois par 2 : + +![partie entière base 10](assets/div1base2.jpg) + +On écrit alors : $`223 = 1 \times 2⁰ + 1 \times 2¹ + 1 \times 2² +1 \times 2³ + 1 \times 2⁴ + 0 \times 2⁵ + 1 \times 2⁶ +1 \times 2⁷`$ : C'est sa décomposition en base 2. + +Ainsi $`223 = 11111011_2`$ + +### Codage de la partie décimale + +Pour la partie décimale, on procède comme en base 10 mais en multipliant par 2 au lieu de multiplier par 10 : + +- $`0,25 \times 2 = 0,5`$​​ : la partie entière vaut **0**, la partie décimale restante est 0.5 +- $`0,5 \times 2 = 1,0`$ : la parie entière vaut **1**. il n'y a plus rien après la virgule donc nous avons terminé + +On vient de voir que $`0.25 = 0 \times 2^{-1} + 1 \times 2^{-2}`$ : c'est sa décomposition en base 2 + +Ainsi, on peut écrire : + +* $`123,25 = 11011111,01_2`$ +* En notation scientifique en base 2 : $`123,25 = 1,111101110_2 \times 2 ^7`$ + +**Travail à faire** + +> Trouvez l'écriture scientifique en base 2 des nombres décimaux ci-dessous : +> +> * 8,5 +> * 12,125 + +## Problème... + +Cherchons maintenant l'écriture scientifique de 0,1 en base 2. + +* $`0,1 \times 2 = 0,2`$ : partie entière **0** , la partie décimale restante est 0,2 +* $`0,2 \times 2 = `$ + +**!! SPOILER plus bas, ne défilez pas avant d'avoir trouvé ! !!** + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +**Conclusion :** + +**On ne peut coder de façon exacte le nombre 0,1 en base 2.** + +**Et ce n'est pas le seul dans ce cas : la plupart des décimaux sont dans le même cas !** + +**On est donc contraint de faire une approximation !!** + +Allons un peu dans la console de Thonny : + +```Python +>>> 0.1 + 0.1 + 0.1 == 0.3 +??? +``` + +Ce n'est pas une erreur ou un bug de Python mais la conséquence d'une approximation liée au codage en base 2 : + +```python +>>> 0.1 + 0.1 + 0.1 +??? +``` + +> **Il n'est pas possible de coder un nombre décimal en valeur exacte en base 2**. +> +> **On obtient une approximation du nombre décimal, et non le nombre en lui même.** +> +> **Cette approximation est appelée _nombre en virgule flottante_ et correspond au type _float_ en Python.** + +## IEEE-754 + +Voir https://www.youtube.com/watch?v=mtizhxkB-Zw&ab_channel=Wandida%2CEPFL + +A compléter + +________ + +Inspiré de Mieszczak Christophe CC BY SA diff --git a/representation_base/seance_3/assets/div1base10.jpg b/representation_base/seance_3/assets/div1base10.jpg new file mode 100644 index 0000000..8cd40d8 Binary files /dev/null and b/representation_base/seance_3/assets/div1base10.jpg differ diff --git a/representation_base/seance_3/assets/div1base2.jpg b/representation_base/seance_3/assets/div1base2.jpg new file mode 100644 index 0000000..e75a7e7 Binary files /dev/null and b/representation_base/seance_3/assets/div1base2.jpg differ diff --git a/representation_base/seance_3/exercices/PATRIOT/CORRECTION.md b/representation_base/seance_3/exercices/PATRIOT/CORRECTION.md new file mode 100644 index 0000000..cab350f --- /dev/null +++ b/representation_base/seance_3/exercices/PATRIOT/CORRECTION.md @@ -0,0 +1,125 @@ +# Missile Patriot + +![An MIM-104 Patriot missile is test fired](./assets/missile.jpeg) +Source : Department of Defense. American Forces Information Service. Defense Visual Information Center. + +## Pré-requis + +Avoir programmer : + +- une fonction qui prend un nombre de secondes et affiche au format (hh:mm:ss) +- une fonction qui calcule le PGCD de 2 entiers + +## Corrigé + +Le micro-contrôleur de l’antimissile *Patriot* stocke la valeur $`\frac{1}{10}`$ en ne conservant que 23 bits pour la partie décimale (codage en virgule fixe). + +Il calcule le temps écoulé depuis son démarrage en multiples de $`\frac{1}{10}`$ème de seconde. + +1. Écrire $`\frac{1}{10}`$ en binaire, en conservant au moins 30 chiffres binaires après la virgule. + + ```math + \begin{aligned} + & 0,1 \times 2 = \textcolor{red}{0},2 \\ + & \left.\begin{aligned} + 0,2 \times 2 & = \textcolor{red}{0},4 \\ + 0,4 \times 2 & = \textcolor{red}{0},8 \\ + 0,8 \times 2 & = \textcolor{red}{1},6 \\ + 0,6 \times 2 & = \textcolor{red}{1},2 \\ + 0,2 \times 2 & = \textcolor{red}{0},4 \\ + 0,4 \times 2 & = \textcolor{red}{0},8 \\ + 0,8 \times 2 & = \textcolor{red}{1},6 \\ + 0,6 \times 2 & = \textcolor{red}{1},2 \\ + 0,2 \times 2 & = \textcolor{red}{0},4 \\ + \end{aligned}\right\rbrace \textit{suivi de 2 fois} + \end{aligned} + ``` + + Soit $`0,1 = 0,00011001100110011001100110011_2`$ + +2. Sachant que les registres du *Patriot* ne conservent que 23 bits après la virgule, quelle est, en base 10, la valeur qui est codée effectivement à la place de $`\frac{1}{10}`$ ? + + La représentation binaire de 0,1 sur 23 bits est $`0,00011001100110011001100_2`$. Le nombre $`n`$ associé correspond à : + + ```math + \begin{aligned} + n & = 0 \times 2^{-1} + 0 \times 2^{-2} + 0 \times 2^{-3} + 1 \times 2^{-4} + \dots + 0 \times 2^{-23}\\ + & = 2^{-4} + 2^{-5} + 2^{-8} + 2^{-9} + 2^{-12} + 2^{-13} + 2^{-16} + 2^{-17} + 2^{-20} + 2^{-21} \\ + & = \frac{1}{2^4} + \frac{1}{2^5} + \frac{1}{2^8} + \frac{1}{2^9} + \frac{1}{2^{12}} + \frac{1}{2^{13}} + \frac{1}{2^{16}} + \frac{1}{2^{17}} + \frac{1}{2^{20}} + + \frac{1}{2^{21}}\\ + & = \frac{2^{17}}{2^{17} \times 2^4} + \frac{2^{16}}{2^{16} \times 2^5} + \frac{2^{13}}{2^{13} \times 2^8} + \frac{2^{12}}{2^{12} \times 2^9} + \frac{2^9}{2^9 \times 2^{12}} + \frac{2^8}{2^8 \times 2^{13}} + \frac{2^5}{2^5 \times 2^{16}} + \frac{2^4}{2^4 \times 2^{17}} + \frac{2}{2\times2^{20}} + \frac{1}{2^{21}}\\ + & = \frac{2^{17} + 2^{16} + 2^{13} + 2^{12} + 2^9 + 2^8 + 2^5 + 2^4 + 2 + 1}{2^{21}} \\ + & = \frac{131072 + 65536 + 8192 + 4096 + 512 + 256 + 32 + 16 + 2 + 1}{2097152} \\ + & = \frac{209715}{2097152} \\ + & \simeq 0.09999990463256836 + \end{aligned} + ``` + +3. Quelle est l’erreur approximative commise sur la représentation de $`\frac{1}{10}`$ ? + + L'erreur approximative sur la représentation de $`\frac{1}{10}`$ : + + ```math + \begin{aligned} + \epsilon & = \frac{1}{10} - n\\ + & = \frac{1}{10} - \frac{209715}{2097152} \\ + & = \frac{2097152 - 2097150}{20971520} \\ + & = \frac{2}{20971520} \\ + & = \frac{1}{10485760} \\ + & \simeq 0.000000095 + \end{aligned} + ``` + +4. Combien de signaux d’horloge le *Patriot* reçoit-il en 100 h de fonctionnement ? + + Le nombre de signaux d'horloges $`s`$ que reçoit un missile _Patriot_ en 100h de fonctionnement : + + ```math + \begin{aligned} + s & = \textit{nombre de signaux par seconde} \times \textit{nombre de secondes en } 100h \\ + & = 10 \times 60 \times 60 \times 100 \\ + & = 3600000 + \end{aligned} + ``` + +5. En tenant compte de l’erreur calculée à la question 3., quel est le décalage de l’horloge du *Patriot* par rapport à l’heure réelle au bout de 100h ? + + Le décalage de l'horloge $`d`$ du missile _Patriot_ au bout de 100h de fonctionnement : + + ```math + \begin{aligned} + d & = \textit{nombre de signaux d'horloges sur } 100h \times \textit{erreur approximative de la représentation d'un } \frac{1}{10} \\ + & = s \times \epsilon \\ + & = 3600000 \times \frac{1}{10485760} \\ + & = 360000 \times \frac{1}{1048576} \\ + & = \frac{360000}{1048576} \\ + & = \frac{5625}{16384} \\ + & \simeq 0,34 s + \end{aligned} + ``` + +6. Sachant qu’un missile se déplace à une vitesse d’environ 1 676 m/s, à quelle erreur de position en mètres correspond le décalage d’horloge d’un *Patriot* ayant fonctionné 100 h sans interruption ? + + Soient : + + - $`v`$, la vitesse du missile, 1676m/s, + - $`d`$, le décalage de l'horloge calculée à la question 5, + - $`e`$, l'erreur de position d'un missile _Patriot_, ayant fonctionné 100h, est : + + ```math + \begin{aligned} + e & = v \times d \\ + & = 1676 \times \frac{5625}{16384} \\ + & = \frac{9427500}{16384} \\ + & = \frac{2356875}{4096} \\ + & \simeq 575,40 m + \end{aligned} + ``` + +7. Conclure, sachant que, pour atteindre sa cible un *Patriot* doit l’approcher à moins de 500 m. + + La question 6 nous a permis de calculer l'erreur de position du missile _Patriot_ ayant fonctionné pendant 100h. Le décalage d'un tel missile est supérieur à la distance d'approche finale de 500m. En conclusion, le missile _Patriot_ n'atteint pas sa cible. + +N.B : + +- En 1991, pendant la guerre du Golfe, un anti-missile _Patriot_ manque l’interception d’un missile Scud. Bilan : 28 soldats morts. +- Si au lieu de tronquer $`\frac{1}{10}`$ on avait arrondi au plus proche : $`0,00011001100110011001101_2`$ alors l’erreur aurait été de 0,000000024 au lieu de 0,000000095 soit environ 140 m au lieu de 575 ! diff --git a/representation_base/seance_3/exercices/PATRIOT/ENONCE.md b/representation_base/seance_3/exercices/PATRIOT/ENONCE.md new file mode 100644 index 0000000..c312104 --- /dev/null +++ b/representation_base/seance_3/exercices/PATRIOT/ENONCE.md @@ -0,0 +1,26 @@ +# Missile Patriot + +![An MIM-104 Patriot missile is test fired](./assets/missile.jpeg) +Source : Department of Defense. American Forces Information Service. Defense Visual Information Center. + +## Pré-requis + +Avoir programmé : + +- une fonction qui prend un nombre de secondes et l'affiche au format (hh:mm:ss) +- une fonction qui calcule le PGCD de 2 entiers +- une fonction qui indique si une fraction de 2 entiers est irréductible (i.e dont le PGCD est égal à 1) + +## Énoncé + +Le micro-contrôleur de l’antimissile *Patriot* stocke la valeur $`\frac{1}{10}`$​ en ne conservant que 23 bits pour la partie décimale (codage en virgule fixe). + +Il calcule le temps écoulé depuis son démarrage en multiples de $`\frac{1}{10}`$ème de seconde. + +1. Écrire $`\frac{1}{10}`$ en binaire, en conservant au moins 30 chiffres binaires après la virgule. +2. Sachant que les registres du *Patriot* ne conservent que 23 bits après la virgule, quelle est, en base 10, la valeur qui est codée effectivement à la place de $`\frac{1}{10}`$ ? +3. Quelle est l’erreur approximative commise sur la représentation de $`\frac{1}{10}`$ ? +4. Combien de signaux d’horloge le *Patriot* reçoit-il en 100 h de fonctionnement ? +5. En tenant compte de l’erreur calculée à la question 3., quel est le décalage de l’horloge du *Patriot* par rapport à l’heure réelle au bout de 100h ? +6. Sachant qu’un missile se déplace à une vitesse d’environ 1 676 m/s, à quelle erreur de position en mètres correspond le décalage d’horloge d’un *Patriot* ayant fonctionné 100 h sans interruption ? +7. Conclure, sachant que, pour atteindre sa cible un *Patriot* doit l’approcher à moins de 500 m. diff --git a/representation_base/seance_3/exercices/PATRIOT/assets/missile.jpeg b/representation_base/seance_3/exercices/PATRIOT/assets/missile.jpeg new file mode 100644 index 0000000..caecced Binary files /dev/null and b/representation_base/seance_3/exercices/PATRIOT/assets/missile.jpeg differ diff --git a/representation_base/seance_3/exercices/README.md b/representation_base/seance_3/exercices/README.md new file mode 100644 index 0000000..f67a939 --- /dev/null +++ b/representation_base/seance_3/exercices/README.md @@ -0,0 +1,43 @@ +## Exercice 1 + +Écrire, en Python, une fonction `approximation` , prenant en entrée : +- deux paramètre `a` et `b`, les flottants à comparer), +- un paramètre `precision`, un entier donnant le nombre de chiffres après la virgule souhaitée entre 0 et 16 + +* Cette fonction reverra `True` si $`|a - b|< 10^{-precision}`$​ et `False` sinon. +* Documenter la fonction +* Créer plusieurs DocTests renvoyant soit True soit False. + +_Remarque : On utilisera la fonction valeur absolue : [`abs` ](https://www.w3schools.com/python/ref_func_abs.asp)_ + +Si nous avons besoin de comparer des flottants, on utilisera donc cette fonction. + +## Exercice : 2 + +Ecrire, en Python, une fonction `pythagore` prenant en entrée 3 flottants `a`, `b`, `c` et renvoie `True` si le triangle de dimension `a`, `b`et `c`est rectangle et `False` sinon. + +_Attention : On ne sait pas lequel de `a`, `b` ou `c` est le plus grand côté ! Il faudra donc étudier tous les cas possibles !` + +- Documenter la fonction +- Créer plusieurs DocTests renvoyant soit True soit False. + +## Exercice : 3 + +Écrire, en Python, une fonction `f` prenant en entrée un paramètre `x`, un flottant. Cette fonction renverra $x^3 + 3 * x^2 +3 * x +1$ + +Écrire, en Python, une fonction `g` prenant en entrée un paramètre `x`, un flottant. Cette fonction renverra $(x + 1)^3$ + +Écrire en Python une fonction `egalite` prenant en entrée 2 paramètres `f` et `g`, deux fonctions Python renvoyant des valeurs flottantes. Elle devra : + +- Comparer approximativement, avec une précision de 10 chiffres après la virgule, les fonctions `f` et `g` en prenant aléatoirement 1000 valeurs de `x` dans l'intervalle [-10, 10]. +- Si une des comparaisons est fausse, alors la fonction renverra `False` +- Si toutes les comparaisons sont vraie, alors la fonction renverra `True` + + + +_Remarque : Évidemment, il s'agit de comparaison **approximative**. Si les deux fonctions sont égales 1000 fois à $`10^{-10}`$ près, il y a de fortes chances qu'elles sont égales... mais ce n'est pas une certitude !_ + +Modifier et `f` pour qu'elle renvoie $`x²`$ et `g` pour qu'elle renvoie $`x² + 10^{⁻11}`$. + +- les deux fonctions sont-elles égales ? +- qu'en dit la fonction `egalite` ? diff --git a/representation_base/seance_4/PYTHON.md b/representation_base/seance_4/PYTHON.md new file mode 100644 index 0000000..967f81d --- /dev/null +++ b/representation_base/seance_4/PYTHON.md @@ -0,0 +1,163 @@ +# Type Booléen en Python + +## Valeur et Type + +En Python, les booléens sont `True` et `False`, ils sont du type `bool` + +```python +>>> True +True +>>> print(type(True)) + +>>> False +False +>>> print(type(False)) + +``` + +## Comparaison + +Les opérateurs de comparaison courants sont identiques à ceux des mathématiques mais ATTENTION, il ne faut pas confondre l’égalité et l’affectation + +Python + +```python +>>> variable = 5 # une affectation +>>> 5 == 8 # une égalité (qui est fausse) +False +``` + +**Le résultat d’une comparaison est toujours un booléen** + +## Comparaisons des nombres + +| Comparaison | Symbole | Exemple | Résultat | +| ----------------- | ------- | ------------- | -------- | +| Égalité | `==` | `1 + 2 == 3` | `True` | +| Différence | `!=` | `1 + 2 != 3` | `False` | +| Supérieur | `>` | `4 > 3` | `True` | +| Inférieur | `<` | `2.2 < 2 * 3` | `True` | +| Supérieur ou égal | `>=` | `5 >= 6` | `False` | +| Inférieur ou égal | `<=` | `8 <= 3` | `False` | + +## Appartenance à une structure + +On peut tester qu’un élément appartient à une structure avec le mot clé `in` + +```python +>>> "a" in "bonjour" # False +False +>>> "bon" in "bonjour" # True +True +>>> 1 in [2, 3, 4] # False +False +``` + +# Opérations sur les booléens + +Les opérateurs sur les booléens sont de deux types : + +- opérateur unaire : prend *un* booléen et en renvoie *un*. +- opérateur binaire : prend *deux* booléens et en renvoie *un*. + +## Opérateur unaire : la négation + +### La négation: `not` + +C’est le seul opérateur *unaire*, il donne le contraire de ce qu’on lui passe. + +```python +>>> not True # s'évalue à False +False +>>> not False # s'évalue à True +True +``` + +## Opérateur binaire : le OU, noté `or` + +**Il est vrai si l’un des deux booléens est vrai.** + +```python +>>> False or False +False +>>> False or True +True +>>> True or False +True +>>> True or True +True +``` + +## Opérateur binaire : le ET, noté `and` + +**Il est vrai si les deux booléens sont vrais.** + +```python +>>> False and False +False +>>> False and True +False +>>> True and False +False +>>> True and True +True +``` + +## Opérateur binaire : le XOR noté `^` + +**Il est vrai si EXACTEMENT un des deux booléens est vrai** + +```python +>>> False ^ False +False +>>> False ^ True +True +>>> True ^ False +True +>>> True ^ True +False +``` + +## Python et les booléens + +Python permet de comparer n’importe quoi à un booleen. + +Par exemple, une chaîne de caractère vide est évaluée à `False`.` + +```python +>>> bool(1) +True +>>> bool(0) +False +>>> bool("") +False +>>> bool("abc") +True +>>> bool([]) +False +>>> bool([1, 2]) +True +``` + +- 0 est faux, les autres entiers sont vrais, +- une structure vide est fausse, les autres sont vraies. + +## Complément : `None` et l’identité `is` + +Python propose la valeur `None` (rien) qui est fréquement utilisé pour représenter l’absence d’une valeur. + +Étant le seul objet du type `NoneType`, on peut tester son *identité* avec `is` : + +```python +>>> 1 is None +False +>>> "abc" is None +False +>>> None is None +True +>>> a = 5 +>>> a is None +False +``` + +On verra plus tard qu’une _fonction_ qui ne se termine par `return ...` renvoie néanmoins `None`. \ No newline at end of file diff --git a/representation_base/seance_4/README.md b/representation_base/seance_4/README.md new file mode 100644 index 0000000..b80481b --- /dev/null +++ b/representation_base/seance_4/README.md @@ -0,0 +1,243 @@ +# Codage des booléens + +## Attendus + +| Contenus | Capacités attendues | +| :--: | :-- | +| Valeurs booléennes : 0,1. Opérateurs booléens : and, or, not.
    Expressions booléennes | Dresser la table d’une expression booléenne | + +## Définition + +De nombreux dispositifs électroniques, électromécanique, (mécanique, électrique, pneumatique, etc....) fonctionnement en TOUT ou RIEN. + +Ceci sous-entend qu'ils peuvent prendre 2 états. + +Exemples : + +- Arrêt / Marche +- Enclenché / Déclenché +- Vrai / Faux +- Ouvert / Fermé +- Avant / Arrière +- Conduction / Blocage + +Un système présentera un fonctionnement __logique combinatoire__ si l'état à un instant $`t`$ des variables de sortie ne dépend que de l'état des variables d'entrée au même instant $`t`$. + +## Variable logique + +Une variable logique ne peut prendre que 2 états: + +| État Vrai | État Faux | +| :--: | :--: | +| Oui | Non | +| True | False | +| 1 | 0 | +| Haut | Bas | +| High | Low | + +Pour ces raisons, il est beaucoup plus avantageux d'employer un système mathématique n'utilisant que 2 valeurs numériques. + +Par convention, on utilise les valeurs 0 / 1 pour représenter les états d'une variable logique. + +La variable binaire est aussi appelée variable __booléenne__. (De George Boole, mathématicien anglais 1815 - 1864) + +## Fonction logique + +Une fonction $`S`$ (exemple: allumer une lampe) peut comporter $`n`$ variables logiques. +Pour chacune de ces combinaisons, la fonction peut prendre une valeur 0 ou 1. +Nous obtenons $`2^n`$ combinaisons pour ces $`n`$ variables. + +### Table de vérité + +On représente l'ensemble valeurs d'entrées et sorties par une table de vérité : + +- À chaque variable d'entrée correspond une colonne, +- À chaque ligne, une valeur d'état possible, +- Une colonne de sortie contient la valeur de l'état de l'opération. + +Exemple : + +```math +\begin{aligned} +S = 1 \text{ si} \left\{ +\begin{array}{l} + a = 0 \text{ et } b = 1 \\ + a = 0 \text{ et } b = 0 \\ + a = 1 \text{ et } b = 0 + \end{array} +\right. +\end{aligned} +``` + +| $`a`$ | $`b`$ | $`S`$ | +| :--: | :--: | :--: | +| 0 | 1 | 1 | +| 0 | 0 | 1 | +| 1 | 1 | 0 | +| 1 | 1 | 0 | +| 1 | 0 | 1 | + +### Opérateurs logiques + +#### Opérateur NON + +On associe à une variable binaire quelconque $`a`$ son complément, noté $`\overline{a}`$ + +```math +\begin{aligned} +S = 1 \text{ ssi } a = 0 +\end{aligned} +``` + +La table de vérité de l'opérateur NON : + +| $`a`$ | $`S = \overline{a}`$ | +| :--: | :--: | +| 0 | 1 | +| 1 | 0 | + +#### Opérateur ET + +L'état 1 est obtenu lors de l’action simultanée sur les 2 variables $`a`$ et $`b`$. L'opérateur est noté $`\land`$ + +```math +\begin{aligned} +S & = 1 \text{ ssi } a = 1 \text{ et } b = 1 \\ + & = a \land b +\end{aligned} +``` + +La table de vérité de l'opérateur ET : + +| $`a`$ | $`b`$ | $`S = a \land b`$ | +| :--: | :--: | :--: | +| 0 | 0 | 0 | +| 0 | 1 | 0 | +| 1 | 0 | 0 | +| 1 | 1 | 1 | + +##### Propriétés + +```math +\begin{aligned} + a \land a & = a \\ + a \land 1 & = a \\ + a \land \overline{a} & = 0 \\ + a \land 0 & = 0 +\end{aligned} +``` + +#### Opérateur OU + +L'état 1 est obtenu lors de l’action simultanée sur l'une des 2 variables ou les 2. L'opérateur est noté $`\lor`$ + +```math +\begin{aligned} +S = 1 \text{ si} \left\{ +\begin{array}{l} + a = 0 \text{ ou } b = 1 \\ + a = 1 \text{ ou } b = 0 \\ + a = 1 \text{ ou } b = 1 + \end{array} +\right. +\end{aligned} +``` + +La table de vérité de l'opérateur OU : + +| $`a`$ | $`b`$ | $`S = a \lor b`$ | +| :--: | :--: | :--: | +| 0 | 0 | 0 | +| 0 | 1 | 1 | +| 1 | 0 | 1 | +| 1 | 1 | 1 | + +##### Propriétés + +```math +\begin{aligned} + a \lor a & = a \\ + a \lor 1 & = 1 \\ + a \lor \overline{a} & = 1 \\ + a \lor 0 & = a +\end{aligned} +``` + +### Algèbre de Boole + +#### Définition + +Système algébrique constitué de l'ensemble $`\{0, 1\}`$, muni des 3 opérateurs de base NON, ET, OU. + +#### Propriétés + +- __Associativité__ : Comme avec les opérations habituelles, certaines parenthèses sont inutiles. Exemple : $`( a \land b ) \land c = a \land (b \land c) = a \land b \land c`$ +- __Commutativité__ : L'ordre est sans importance. Exemple : $`a \land b = b \land a`$ +- __Distributivité__ : Exemple : $`a \lor ( b \land c ) = ( a \lor b ) \land ( a \lor c )`$ +- __Idempotence__ : Exemple : $`a \land a \land a \land \dots \land a = a`$ + +### Forme canonique + +Combinaison des variables de la fonction via les opérateurs de base de l’__algèbre de Boole__. + +La fonction $`S`$ définie par : + +```math +\begin{aligned} +S = 1 \text{ si} \left\{ +\begin{array}{l} + a = 0 \text{ et } b = 1 \\ + a = 0 \text{ et } b = 0 \\ + a = 1 \text{ et } b = 0 + \end{array} +\right. +\end{aligned} +``` + +$`S`$ s'écrit sous sa forme canonique : $`S= (\overline{a} \land b) \lor (\overline{a} \land \overline{b}) \lor (a \land \overline{b})`$ + +### + +## Exercices + +### Établir des tables de vérité + +**Travail à effectuer** : Écrire les tables de vérité des expressions booléennes suivantes : + +1. $`S(a, b) = \overline{a} \land b`$ +2. $`S(a, b) = b \lor (a \land b)`$ +3. $`S(a, b) = a \land (a \lor b)`$ +4. $`S(a, b, c) = (\overline{a} \land b) \lor (a \land c)`$ +5. Communication = Émetteur ET Récepteur +6. Décrocher = (Sonnerie ET Décision de répondre) OU décision d'appeler +7. Bac = Avoir la moyenne OU (NON Avoir la moyenne ET rattrapage) + +### Équivalence d'expressions booléennes + +1. Montrer que $`(a \land b) = \overline{\overline{a} \lor \overline{b}}`$ +2. Montrer que $`(a \lor b) = \overline{\overline{a} \land \overline{b}}`$ + +N.B : Deux expressions booléennes sont équivalentes si leurs tables de vérité le sont. + +Autrement dit, si pour toutes les entrées des tables de vérité, l'ensemble des valeurs de sorties de ces mêmes tables sont équivalentes alors les expressions booléennes sont équivalentes. + +### Déterminer une expression booléenne + +| a | b | ssi(a, b) | +| :--: | :--: | :--: | +| 0 | 0 | __1__ | +| 0 | 1 | __0__ | +| 1 | 0 | __0__ | +| 1 | 1 | __1__ | + +**Travail à effectuer** : Trouver l'expression booléenne, notée ssi(a, b) à partir de la table de vérité ci-dessus. + +### Loi de De Morgan + +Les __lois de De Morgan__ sont des identités entre propositions logiques. Elles ont été formulées par le mathématicien britannique Augustus De Morgan (1806-1871). + +1. $`\overline{(a \lor b)} = \overline{a} \land \overline{b}`$ +2. $`\overline{(a \land b)} = \overline{a} \lor \overline{b}`$ + +**Travail à effectuer** : Démontrer ces 2 lois. + diff --git a/representation_base/seance_4/exercices/README.md b/representation_base/seance_4/exercices/README.md new file mode 100644 index 0000000..c6e2b7e --- /dev/null +++ b/representation_base/seance_4/exercices/README.md @@ -0,0 +1,42 @@ +# TD : Logique combinatoire + +## Algèbre de Boole + +Q1. Simplifier les équations suivantes à l'aide des théorèmes de l'algèbre de Boole : + +1. $`S = (\overline{a} \lor b) \land (a \lor b)`$ +2. $`S = \overline{a} \land b \land \overline{c} \lor \overline{a} \land b \land c \lor a \land b \land \overline{c} \lor a \land b \land c`$ +3. $`S = a \land b \land c \lor b \land c \lor b \land \overline{b}`$ +4. $`S = (a \lor \overline{a} \land b) \land \overline{( a \lor b )} \lor b \land \overline{c} \lor b \land c`$ + +## Logigrammes + +Q2. Établir les logigrammes réalisant les équations suivantes : + +5. $`S = a \lor b \land \overline{c}`$​ +6. $`S = \overline{(\overline{a} \land b \lor c) \land \overline{d}}`$ +7. $`S = a \land (\overline{b} \lor c)`$ + +Q3. Établir l'équation des sorties S3 et S4 du logigramme suivant : + +![Logigramme](./assets/exercice_2_q3.svg) + +Q4. Établir la table de vérité de S3 et de S4 en fonction de l'état des variables d'entrée : + +Q5. Compléter le chronogramme de la sortie S3 ci-dessous : + +![Logigramme](./assets/exercice_2_q5.svg) + +## Étude du fonctionnement d'une perçeuse + +On considère une perceuse actionnée par un moteur $`M`$. Le moteur ne peut tourner que si l’interrupteur $`C`$ est actionné et si toutes les conditions de sécurité suivantes sont respectées : + +- La protection de sécurité $`P`$ est en place +- Le courant de surcharge $`I`$ n’est pas dépassé + +Outre ces conditions normales de fonctionnement, une clé $`K`$ permet de faire tourner le moteur sans aucune condition de sécurité. + +Q6. En supposant que chaque variable $`C, P, I`$ et $`K`$ vaut 1 lorsque la condition de fonctionnement est respectée, donner la table de vérité du moteur $`M`$. + +Q7. Donner l’équation et le logigramme. + diff --git a/representation_base/seance_4/exercices/README_2.md b/representation_base/seance_4/exercices/README_2.md new file mode 100644 index 0000000..61ff726 --- /dev/null +++ b/representation_base/seance_4/exercices/README_2.md @@ -0,0 +1,74 @@ +# TD : Logique combinatoire + +## Exercice 1 + +Q1. En utilisant les propriétés de l’algèbre de Boole, simplifier les équations logiques suivantes : + +1. $`S = a \land(a \lor \overline{b})`$ +2. $`S = (\overline{a} \lor b) \land (\overline{a} \lor \overline{b})`$ +3. $`S = a \lor (\overline{a} \land \overline{b})`$ +4. $`S = a \land (\overline{a} \lor b)`$ + +## Exercice 2 + +Q2. Faire le logigramme des fonctions suivantes en utilisant que des portes logiques à 2 entrées : + +1. $`S = a\land b \lor \overline{b} \land c`$ +2. $`S = \overline{(a \lor b) \land c}`$ +3. $`S = \overline{(a \lor \overline{b}) \land (d \lor \overline{c})}`$​ + +## Exercice 3 + +Q3. Pour le logigramme suivant, donner l’équation logique de la sortie $`S`$​​ en fonction des entrées $`a, b`$ et $`c`$​​​ : + +![Logigramme](./assets/exercice_3.svg) + +Q4. Simplifier l’équation logique $`S`$. + +Q5. Dessiner le nouveau logigramme simplifié de l’équation logique $`S`$. + +## Exercice 4 + +Q6. Pour le logigramme suivant, donner l’équation logique de la sortie $`T`$ en fonction des entrées $`a, b, c`$ et $`d`$ : + +Q7. Simplifier l’équation logique $`T`$. + +Q8 : Dessiner le nouveau logigramme simplifié de l’équation logique $`T`$. + +## Exercice 5 + +Q9. À partir de la table de vérité ci-dessous, déterminer l’équation logique $`S`$. + +| $`a`$ | $`b`$ | $`c`$ | $`S`$ | +| :--: | :--: | :--: | :--: | +| 0 | 0 | 0 | __1__ | +| 0 | 0 | 1 | __1__ | +| 0 | 1 | 0 | __1__ | +| 0 | 1 | 1 | __0__ | +| 1 | 0 | 0 | __0__ | +| 1 | 0 | 1 | __0__ | +| 1 | 1 | 0 | __1__ | +| 1 | 1 | 1 | __0__ | + +Q10. Simplifier l'équation logique $`S`$ + +Q11. Compléter les chronogrammes ci-dessous. + +![Logigramme](./assets/exercice_5.svg) + +## Exercice 6 + +Un parking souterrain est géré grâce à un gardien et à partir de capteurs de détection de véhicules. +Un capteur $`p`$ dans le sol détectera la présence d'un véhicule à l'entrée du parking ($`p = 1`$). +Un capteur $`h`$ en hauteur détectera la présence d'un véhicule de plus de 2 mètres ($`h = 1`$). Pour une hauteur supérieure à 2 mètres l'entrée dans le parking est interdite. +De plus, le gardien du parking aura la possibilité de fermer un contact $`g`$ ($` g = 1`$) si le parking est plein, pour ne pas autoriser l'entrée de véhicules supplémentaires. +L'autorisation de pénétrer sera visualisée sur un feu bicolore : + +- Si le feu est vert la barrière s'ouvrira et le véhicule pourra +- Si le feu est rouge la barrière restera fermée + +Q12. Donnez la table de vérité du système. Pour les combinaisons matériellement impossibles, le feu rouge restera allumé. + +Q13. En déduire les équations Logiques de "Vert" et "Rouge". + +Q14. Réalisez le schéma à l’aide de portes logiques diff --git a/representation_base/seance_4/exercices/assets/exercice_2_q3.svg b/representation_base/seance_4/exercices/assets/exercice_2_q3.svg new file mode 100644 index 0000000..c6fb2b1 --- /dev/null +++ b/representation_base/seance_4/exercices/assets/exercice_2_q3.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/representation_base/seance_4/exercices/assets/exercice_2_q5.svg b/representation_base/seance_4/exercices/assets/exercice_2_q5.svg new file mode 100644 index 0000000..99ec3cb --- /dev/null +++ b/representation_base/seance_4/exercices/assets/exercice_2_q5.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/representation_base/seance_4/exercices/assets/exercice_3.svg b/representation_base/seance_4/exercices/assets/exercice_3.svg new file mode 100644 index 0000000..0025d41 --- /dev/null +++ b/representation_base/seance_4/exercices/assets/exercice_3.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/representation_base/seance_4/exercices/assets/exercice_5.svg b/representation_base/seance_4/exercices/assets/exercice_5.svg new file mode 100644 index 0000000..523fd4f --- /dev/null +++ b/representation_base/seance_4/exercices/assets/exercice_5.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/representation_base/seance_4/tp/README.md b/representation_base/seance_4/tp/README.md new file mode 100644 index 0000000..c5c203a --- /dev/null +++ b/representation_base/seance_4/tp/README.md @@ -0,0 +1,109 @@ +# Mystère + +## Description + +L'idée de ce TP est de manipuler les expressions booléennes. + +Pour cela, vous allez devoir programmer des fonctions booléennes. + +A chaque fonction `mystere` suivante, sont données des doctests. +Ces doctests correspondent aux valeurs des tables de vérités. + +## Consignes + +Recopier le bloc de code suivant dans un fichier `mystere.py` + +Vous devez écrire le corps de la fonction sous la forme d'une expression booléenne, dont les variables correspondent aux paramètres d'entrée fournis. + +```python +def mystere1(a): + ''' + >>> mystere1(True) + False + >>> mystere1(False) + True + ''' + pass + +def mystere2(a, b): + ''' + >>> mystere2(True, True) + True + >>> mystere2(True, False) + True + >>> mystere2(False, True) + True + >>> mystere2(False, False) + False + ''' + pass + +def mystere3(a, b): + ''' + >>> mystere3(True, True) + False + >>> mystere3(True, False) + True + >>> mystere3(False, True) + True + >>> mystere3(False, False) + False + ''' + pass + +def mystere4(a, b): + ''' + >>> mystere4(True, True) + False + >>> mystere4(True, False) + False + >>> mystere4(False, True) + False + >>> mystere4(False, False) + True + ''' + pass + +def mystere5(a, b): + ''' + >>> mystere5(True, True) + True + >>> mystere5(True, False) + False + >>> mystere5(False, True) + False + >>> mystere5(False, False) + True + ''' + pass + +def mystere6(a, b): + ''' + >>> mystere6(True, True) + False + >>> mystere6(True, False) + True + >>> mystere6(False, True) + False + >>> mystere6(False, False) + False + ''' + pass + +def mystere7(a, b): + ''' + >>> mystere7(True, True) + False + >>> mystere7(True, False) + True + >>> mystere7(False, True) + False + >>> mystere7(False, False) + True + ''' + pass + +if __name__ == '__main__': + import doctest + doctest.testmod(verbose=False) +``` \ No newline at end of file diff --git a/representation_base/seance_5/README.md b/representation_base/seance_5/README.md new file mode 100644 index 0000000..fe9d510 --- /dev/null +++ b/representation_base/seance_5/README.md @@ -0,0 +1,283 @@ +# Représentation d'un texte en machine + +## Attendus + +| Contenus | Capacités attendues | +| :--: | :-- | +| Représentation d’un texte en machine.
    Exemples des encodages ASCII, ISO-8859-1, Unicode | Identifier l’intérêt des différents systèmes d’encodage.
    Convertir un fichier texte dans différents formats d’encodage. | + +## Contexte + +![Martine écrit en UTF-8](https://www.apprendre-en-ligne.net/bloginfo/images/humour/geek_martine-ecrit-en-utf-8.jpg) + +Source : http://www.retourdemartine.free.fr/ + + +Prenons l'alphabet courant `A`, `B`, `C`, ... `Z` et plaçons le dans un tableau. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    ABCDEFGHIJKLMNOPQRSTUVWXYZ
    + +Regardons les indices associés à chaque lettre. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    012345678910111213141516171819202122232425
    ABCDEFGHIJKLMNOPQRSTUVWXYZ
    + +À un indice correspond une lettre et à une lettre est associée un et un seul indice. + +## Définition + +En généralisant à l'ensemble des caractères (`,`, `é`, `%`, ...), un caractère peut être représenté par un entier, donc avoir une représentation binaire en machine. + +___Définition___ + +> L'entier associé à un caractère est appelé ___point de code___ de ce caractère (0 est le point de code de `A`. 25 le point de code de `Z`.) + +___Définition___ + +> On parle ainsi d'___encodage de caractères___ : mécanisme qui gère les points de code en octets dans la mémoire de l’ordinateur, puis lit les octets à nouveau en points de code. + +Il a existé et existe plusieurs encodages. + +## Encodage ASCII + +En 1960, l'organisation internationale de normalisation (ISO) décide de créer la norme ASCII (American Standard Code for Information Interchange). + +À chaque caractère est associé un nombre binaire sur 7 bits. + +![Table ASCII](https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/ASCII-Table.svg/738px-ASCII-Table.svg.png) + +Source : Wikipédia + +Comme vous pouvez le constater dans le tableau ci-dessus, au "A" majuscule correspond le code binaire $`(1000001)_2`$ $`(65)_{10}`$ ou $`(41)_{16}`$ + +___Question___ + +> Combien de points de code (et donc de caractères) peuvent être représentés grâce à l'encodage ASCII ?" + +___Solution___ + +> Avec 7 bits, on peut coder $`2^7`$ points de code, donc 128 caractères. + +___Travail à effectuer___ + +> 1. Quel est le point de code et la représentation en binaire, du caractère `a` ? +> 2. Comment grâce à la représentation, en binaire, peut-on savoir si une lettre est en majuscule ou minuscule ? + +___Solution___ + +> 1. Le caractère `a` a pour point de code 97, soit $`(1100001)_2`$. +> 2. Le bit de rang 5 est égal à : +> - 1 si la lettre est en minuscule, +> - 0 si la lettre est en majuscule. + +La norme ASCII convient bien à la langue anglaise, mais pose des problèmes dans d'autres langues, par exemple le français. + +En effet, l'ASCII ne prévoit pas d'encoder les lettres accentuées. + +## Encodage ISO-8859-1 + +Cette norme reprend les mêmes principes que l'ASCII, mais les points de code associés à chaque caractère sont codés sur 8 bits. + +___Question___ + +> Combien de points de code (et donc de caractères) peuvent être représentés grâce à l'encodage ISO-8859-1 ? + +___Soution____ + +> Sur 8 bits, on peut représenter $`2^8`$ points de code, soit 256 caractères... 2 fois plus que l'encodage ASCII. + +Cette norme va être principalement utilisée dans les pays européens puisqu'elle permet d'encoder les caractères utilisés dans les principales langues européennes (la norme ISO-8859-1 est aussi appelée "latin1" car elle permet d'encoder les caractères de l'alphabet dit "latin"). + +Problème, il existe beaucoup d'autres langues dans le monde qui n'utilisent pas l'alphabet dit "latin", par exemple le chinois ou le japonais ! D'autres normes ont donc dû voir le jour. + +Des changements de configuration sont nécessaires pour afficher un texte dans l'encodage adéquat. + +## Encodage Unicode + +Pour éviter ces problèmes, en 1991, une nouvelle norme a vu le jour : Unicode. + +Unicode a pour ambition de rassembler tous les caractères existant afin qu'une personne utilisant Unicode puisse, sans changer la configuration de son traitement de texte, à la fois lire des textes en français ou en japonais. + +Unicode est une table qui regroupe tous les caractères existant au monde. Unicode accepte plusieurs systèmes de codage : UTF-8, UTF-16, UTF-32. + +Le plus utilisé, notamment sur le Web, est UTF-8. + +### Nombre s'octets en UTF-8 + +Pour encoder les caractères Unicode, UTF-8 utilise un nombre variable d'octets (jusque 4) : + +- Les caractères de numéro 0 à 127 sont codés sur un octet dont le bit de poids fort est toujours nul, +- Les caractères de numéro supérieur à 127 sont codés sur plusieurs octets. +- Dans ce cas, les bits de poids fort du premier octet forment une suite de 1 de longueur égale au nombre d'octets utilisés pour coder le caractère, les octets suivants ayant 10 comme bits de poids fort. + + + + + + + + + + + + +
    Définition du nombre d'octets utilisés
    Représentation binaire en UTF-8Signification
    0xxxxxxx1 octet codant 1 à 7 bits
    110xxxxx 10xxxxxx2 octets codant 8 à 11 bits
    1110xxxx 10xxxxxx 10xxxxxx3 octets codant 12 à 16 bits
    11110xxx 10xxxxxx 10xxxxxx 10xxxxxx4 octets codant 17 à 21 bits
    + +### Méthode pour obtenir la représentation binaire en UTF-8 d'un caractère + +1. Représenter le point de code associé au caractère en binaire +2. En fonction du nombre de bits, définir le nombre d'octets nécessaires pour une représentation en UTF-8 +3. Découper les blocs de bits en autant d'octets nécessaires. + +Exemple : le caractère `A` a pour point de code 65 dans la table Unicode. + +1. Représentation binaire de 65 : 100 0001 +2. 7 bits sont nécessaires $`\rightarrow`$​ 1 octet nécessaire pour le représenter en UTF-8
    • +3. Représentation en UTF-8 : 01000001 ou $`(41)_{16}`$ + +Exemple : le caractère œ a pour point de code 339 dans la table Unicode. + +1. Représentation binaire de 339 : 1 0101 0011 +2. 9 bits sont nécessaires $`\rightarrow`$ 2 octets nécessaires pour le représenter en UTF-8 +3. l'octet de poids faible codant les 6 bits de poids faible, l'octet poids fort codant les 3 bits de poids forts +4. Représentation en UTF-8 : 1100101 10010011 ou $`(\text{C}5\,93)_{16}`$ + +___Travail à effectuer___ + +> 1. Quelle est la représentation binaire du caractère `b` (point de code : 98) en UTF-8 ? +> 2. Quel est le point de code représenté par $`(\text{C}2\,80)_{16}`$ en UTF-8 ? + +___Solution___ + +> 1. Le point de code 98 a comme représentatio binaire : $`(1100010)_`$ +> - 7 bits sont nécessaires ⇒ 1 octet nécessaire pour le réprésenter en UTF-8 +> - Représentation en UTF-8 : 01100010 ou $`(62)_{16}`$ +> 2. $`(\text{C}2\,80)_{16} = (11000010\,10000000)_{16}`$ + +Le point de code est représenté par les bits 11000010 10000000. Soit $`(10000000)_2 = (128)_{10}`$ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    Exemples de codage UTF-8
    Point de codeCaractèreReprésentation binaire UTF-8
    66B01000010
    233é11000011 10101001
    8364€11100010 10000010 10101100
    119070𝄞11110000 10011101 10000100 10011110
    + +___Observation___ + +Dans toute chaîne de caractères UTF-8, on remarque que : + +- tout octet de bit de poids fort nul code un caractère ASCII sur un octet, +- tout octet de bits de poids fort valant 11 est le premier octet d'un caractère codé sur plusieurs octets, +- tout octet de bits de poids fort valant 10 est à l'intérieur d'un caractère codé sur plusieurs octets. diff --git a/representation_base/seance_5/debranche/README.md b/representation_base/seance_5/debranche/README.md new file mode 100644 index 0000000..e067c50 --- /dev/null +++ b/representation_base/seance_5/debranche/README.md @@ -0,0 +1,42 @@ +# Activité débranchée : Codage des caractères + +## Contexte + +L'histoire de la communication est aussi ancienne que l'histoire de l'humanité. Depuis les origines, l'homme a eu besoin de communiquer. Pour cela il mit au point des codes, des alphabets et des langages. Parole, gestes de la main, signaux de fumée, tam-tam, document écrit… tout était bon pour véhiculer le message. + +Dès la préhistoire, les hommes ont commencés à communiquer notamment grâce à l'art rupestre. + +Les peintures rupestres pouvaient permettre de marquer un territoire d'habitation ou de chasse ou transmettre des pensées, une façon de voir le monde et ce qu'il l'entoure. + +![Photographie de peintures d'animaux dans la grotte de Lascaux](./assets/lascaux.jpeg) + +Photographie de peintures d'animaux dans la grotte de Lascaux, Source : Wikimedia + +Le __codage des caractères__ est une convention qui permet, à travers un codage connu de tous, de transmettre de l'information textuelle, là où aucun support ne permet l'écriture scripturale et sa transmission. + +Cela consiste à représenter chaque caractère, par un motif visuel, un motif sonore, ou une séquence abstraite. + +## Objectifs + +L'objectif de ce TD est d'étudier des codages ancestraux de l'ère de la mécanisation et de la numérisation des communications. + +4 codages sont étudiés : + +- [L'alphabet de Chappe](./chappe/), +- [Le code morse](./morse/), +- [Le code Baudot](./baudot), +- [Le code BCD](./bcd). + +## Consignes + +- Par groupe, vous devez étudier les documents relatifs au codage, +- Individuellement : (20 minutes) + - Coder votre nom et âge, + - Coder une phrase de votre choix de 10-15 caractères, + - L'échanger à un autre membre, + - Décoder la phrase transmise +- Collectivement, répondre aux questions suivantes (10 minutes) : + - Époque du codage + - Principe de fonctionnement : nombre de caractères codés, mécanisme pour coder un caractère + - Avantages / inconvénients +- A la fin du temps imparti, un élève du groupe présente au reste de la classe les réponses aux questions traitées. (5 minutes) diff --git a/representation_base/seance_5/debranche/assets/lascaux.jpeg b/representation_base/seance_5/debranche/assets/lascaux.jpeg new file mode 100644 index 0000000..f172220 Binary files /dev/null and b/representation_base/seance_5/debranche/assets/lascaux.jpeg differ diff --git a/representation_base/seance_5/debranche/baudot/description.pdf b/representation_base/seance_5/debranche/baudot/description.pdf new file mode 100644 index 0000000..cc0c79f Binary files /dev/null and b/representation_base/seance_5/debranche/baudot/description.pdf differ diff --git a/representation_base/seance_5/debranche/baudot/table.pdf b/representation_base/seance_5/debranche/baudot/table.pdf new file mode 100644 index 0000000..2cea24d Binary files /dev/null and b/representation_base/seance_5/debranche/baudot/table.pdf differ diff --git a/representation_base/seance_5/debranche/bcd/description.pdf b/representation_base/seance_5/debranche/bcd/description.pdf new file mode 100644 index 0000000..02f187c Binary files /dev/null and b/representation_base/seance_5/debranche/bcd/description.pdf differ diff --git a/representation_base/seance_5/debranche/bcd/table.pdf b/representation_base/seance_5/debranche/bcd/table.pdf new file mode 100644 index 0000000..38b3a99 Binary files /dev/null and b/representation_base/seance_5/debranche/bcd/table.pdf differ diff --git a/representation_base/seance_5/debranche/chappe/description.pdf b/representation_base/seance_5/debranche/chappe/description.pdf new file mode 100644 index 0000000..e4e4577 Binary files /dev/null and b/representation_base/seance_5/debranche/chappe/description.pdf differ diff --git a/representation_base/seance_5/debranche/morse/description.pdf b/representation_base/seance_5/debranche/morse/description.pdf new file mode 100644 index 0000000..de971b8 Binary files /dev/null and b/representation_base/seance_5/debranche/morse/description.pdf differ diff --git a/representation_base/seance_5/debranche/morse/table.svg b/representation_base/seance_5/debranche/morse/table.svg new file mode 100644 index 0000000..d385bda --- /dev/null +++ b/representation_base/seance_5/debranche/morse/table.svg @@ -0,0 +1,204 @@ + + + + + +Code morse international + +1. Un tiret est égal à trois points. +2. L’espacement entre deux éléments d’une même lettre est égal à un point. +3. L’espacement entre deux lettres est égal à trois points. +4. L’espacement entre deux mots est égal à sept points. + + + + + + + + + + + + + + + + + + + + + + + + + + + +U +V +W +X +Y +Z + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +A +B +C +D +E +F +G +H +I +J +K +L +M +N +O +Q +P +R +S +T + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1 +2 +3 +4 +5 +6 +7 +8 +9 +0 + + + + diff --git a/representation_base/seance_5/td/CORRECTION.md b/representation_base/seance_5/td/CORRECTION.md new file mode 100644 index 0000000..010cbc8 --- /dev/null +++ b/representation_base/seance_5/td/CORRECTION.md @@ -0,0 +1,206 @@ +# TD - Le Li�vre et la Tortue + +## Contexte + +2 fichiers `lièvre-iso-8859-1.html` et `lièvre-utf8.html` contiennent le même texte : la fable du lièvre et de la tortue de Jean de La Fontaine. + +![Couverture](./assets/couverture.jpg) +Source : Wikipédia + +Si on ouvre ces 2 fichiers dans un navigateur Web, des symboles étranges apparaissent, rendant la lecture inconfortable. + +Ce TD a pour but de comprendre l'origine de ce phénomène. + +Cette séance se découpe en 2 parties : +- La première consiste à explorer et découvrir la problématique d'encodage, +- La deuxième consiste à manipuler la représentation des chaines de caractères en python. + +Les parties doivent être traitées dans l'ordre. + +# Pré-Requis + +Avoir l'extension [Set Character Encoding](https://chrome.google.com/webstore/detail/set-character-encoding/bpojelgakakmcfmjfilgdlmhefphglae) installée sur votre poste. + +# Partie 1 - Exploration et découverte + +Cette partie vise à vous faire comprendre le problème d'encodage par différentes observations, calculs et manipulations à réaliser. + +A la fin de cette partie, vous devez répondre à un questionnaire et le valider avec votre professeur. + +En cas de réussite, vous pouvez aborder la partie 2. + +## Table d'encodage et calcul de la représentation binaire + +### ISO-8859-1 + +Voici la table d'encodage ISO-8859-1 : + +![Table de codage](./assets/iso-8859-1.png) + +Exemple : la point de code du caractère `A` est 41 (ligne 4x et colonne x1). + +***Observation 1.*** Sachant que l'encodage ISO-8859-1 représente les points de code sur 1 octet. Quelle est la représentation binaire du caractère `A` ? + +Le point de code du caractère `A` est $`41_{16}`$ soit $`0100\,0001`$ en binaire. + +***Observation 2.*** Quelle est le point de code du caractère `<` ? Quelle est sa représentation binaire ? + +Le point de code du caractère `<` est $`3C_{16}`$ soit $`0011\,1100`$ en binaire. + +***Observation 3.*** Quelle est la point de code du caractère `à`? Quelle est sa représentation binaire ? + +Le point de code du caractère `à` est $`E0_{16}`$ soit $`1110\,0000`$ en binaire. + +***Observation 4.*** Étant donné le mot binaire $`(10101001)_2`$, quel caractère représente-il ? Quel est celui associé au mot binaire $`(11110100)_2`$ ? + +- $`(10101001)_2 = \text{A}9_{16}`$, soit le point de code lié au caractère `©`. +- $`(11110100)_2 = \text{F}4_{16}`$, soit le point de code lié au caractère `ô`. + +### Unicode UTF-8 + +La table d'encodage de l'UTF-8 est plus conséquente que celle de l'encodage ISO-8859-1. Le site https://unicode-table.com/fr permet d'obtenir les correspondances entre les caractères, leur point de code ainsi que leur représentation binaire UTF-8. + +Exemple : le caractère `©` a le point de code U+00A9 (U+ symbolise le fait que l'encodage est Unicode), soit le 169ème point de code ($`(A9)_{16} = (169)_{10}`$) dans la table d'encodage. + +***Observation 5.*** En vous référant au cours sur l'encodage UTF-8, calculez la représentation binaire UTF-8 de ce caractère. + +La représentation binaire du point de code est $`(10101001)_2`$, qui nécessite 8 bits. + +Selon la règle de codage UTF-8, 2 octets sont nécessaires pour représenter en binaire UTF-8 le caractère, sous la forme : $`110XXXXX\,10XXXXXX`$ où X représente les bits de la représentation binaire du point de code. + +La représentation binaire UTF-8 est : $`11000010\,10101001`$. + +***Observation 6.*** Cherchez le point de code et la représentation binaire du caractère ♧. + +Le point de code du caractère ♧ est 2667. La représentation binaire du point de code est : $`2667_{16} = 0010\,0110\, 0110\,0111_2`$, qui nécessite 16 bits. + +Selon la règle de codage UTF-8, 3 octets sont nécessaires pour représenter en binaire UTF-8 le caractère, sous la forme : $`1110XXXX\,10XXXXXX\,10XXXXXX`$ où X représente les bits de la représentation binaire du point de code. + +La représentation binaire UTF-8 est : $`11100010\,10011001\,10100111`$. + +***Observation 7.*** Cherchez le point de code et le caractère associés à la représentation binaire $`(11100010\,10000100 \,10111100)_2`$. + +La représentation binaire UTF-8 du caractère est sur 3 octets, sous la forme $`1110XXXX\,10XXXXXX\,10XXXXXX`$ où X représente les bits de la représentation binaire du point de code. + +La représentation binaire du point de code est : $`0010\,0001\, 0011\,1100_2`$, Soit $`213C_{16}`$. + +Le caractère associé est : ℼ. + +## Effet visuel du problème d'encodage + +***Observation 8.*** Ouvrez dans votre navigateur Web les fichiers `lièvre-iso-8859-1.html` et `lièvre-utf8.html`. +Quelles différences constatez-vous ? + +Des caractères bizarres apparaissent. + +***Observation 9.*** Dans l'explorateurs de fichiers, comparez la taille de ces 2 fichiers (en octets). Quelles différences constatez-vous ? + +- ISO-8859-1 : 1385 octets, +- UTF-8 : 1418 octets. + +***Observation 10.*** Dans votre navigateur Web, en faisant clic droit sur le page `lièvre-iso-8859-1.html`, changer la valeur de `Set Encoding character` avec les autres valeurs que celle sélectionnée. Que constatez-vous ? + +***Observation 11.*** Dans votre navigateur Web, en faisant clic droit sur le page `lièvre-utf8.html`, changer la valeur de `Set Encoding character` avec les autres valeurs que celle sélectionnée. Que constatez-vous ? + +Les caractères bizarres disparaissent au profit d'accents. + +## Analyse de la représentation binaire d'un fichier texte + +Nous allons utiliser un éditeur hexadécimal de texte en ligne https://www.onlinehexeditor.com/, il permet de visualiser le contenu réel d'un fichier texte, i.e les mots binaires (en héxadécimal) qui représentent les caractères. + +***Observation 12.*** Dans votre navigateur Web, rendez-vous sur la page https://www.onlinehexeditor.com/ et ouvrez les 2 fichiers `lièvre-iso-8859-1.html` et `lièvre-utf8.html` en cliquant sur `open file`. Quelles différences constatez-vous ? + +***Observation 13.*** Au vu des observations précédentes, comment expliquez-vous que votre navigateur affiche : +- `LiÚvre` au lieu de `lièvre` quand on ouvre le fichier `lièvre-utf8.html` avec un encodage iso-8859-1 ? +- `t�moignage` au lieu de `témoignage` quand on ouvre le fichier `lièvre-iso-8859-1.html` avec un encodage UTF-8 ? + +## Questionnaire + +Q1. le caractère `à` a toujours la même représentation en mémoire quelque soit l'encodage utilisé ? + +A. Vrai +B. Faux [X] + +Q2. Dans la table d'encodage Unicode, le caractère `Ô` est le : + +A. 212ème [X] +B. 213ème +C. $`(D4)_{16}`$ème [X] +D. Il n'existe dans la table d'encodage Unicode + +Q3. En UTF-8, les caractères sont représentés sur : + +A. 1 octet +B. 2 octets +C. 7 bits +D. un nombre variable entre 1 et 4 octets [X] + +Q4. En cas de problème d'affichage visuel d'un texte, quelle(s) est(sont) la(les) solution(s) selon vous ? + +A. s'assurer que l'encodage du fichier et le même que celui qui sert à l'affichage [X] +B. modifier le fichier pour corriger les erreurs +C. appeler son professeur pour qu'il corrige le problème +D. modifier l'encodage de la visualisation [X] + +Q5. Soit le point de code U+00D4, cela vous indique que : + +A. l'encodage est Unicode et la représentation binaire du caractère est $`(01001101)_2`$ +B. l'encodage est Unicode et la représentation binaire du caractère est $`(11000011 \,10010100)_2`$ [X] +C. l'encodage est Unicode et le caractère associé est la lettre Ô [X] +D. l'encodage est ISO-8859-1 et la représentation binaire du caractère est $`(01001101)_2`$ + +Q6. Quand une application traite un fichier encodé en iso-8859-1 : + +A. Elle traite octet par octet [X] +B. Elle traite un nombre variable d'octets +C. calcule la position en fonction de la valeur de l'octet et affiche le caractère associé [X] +D. affiche les caractères en fonction de la table d'encodage Unicode + +## Partie 2 - Manipulation en Python + +***Q1.*** Dans un interpréteur Python, exécutez successivement les instructions `chr(212)` et `chr(169)`. Qu'en déduisez-vous sur la spécification de la fonction `chr`? + +```python +>>> chr(212) +'Ô' +>>> chr(169) +'©' +``` + +`chr` donne le caractère associé au point de code passé en paramètre. + +***Q2.*** Dans un interpréteur Python, exécutez successivement les instructions `ord('©')` et `ord('à')`. Qu'en déduisez-vous sur la spécification de la fonction `ord`? + +```python +>>> ord('©') +169 +>>> ord('à') +224 +``` + +`ord` donne le point de code du caractère passé en paramètre. + +***Q3.*** Écrire une fonction `binaire_utf8`, qui prend en paramètre un point de code Unicode sous la forme d'un entier et renvoie la représentation binaire UTF-8 du caractère associé, sous la forme d'une liste d'octet (un octet est une liste de bits). (Aide : Vous pouvez réutiliser les fonctions de conversion en binaire des précédentes séances ainsi que la méthode vu en cours) + +```python +def binaire_utf8(code): + binaire_code = binaire(code) + if len(binaire_code) < 8: + return binaire_code + elif 8 <= binaire_code < 12: + return '110' + binaire_code[:5] + '10' + binaire_code[5:] + elif 12 <= binaire_code < 17: + return '1110' + binaire_code[:4] + '10' + binaire_code[4:10] + '10' + binaire_code[10:] + elif 17 <= binaire_code: + return '11110' + binaire_code[:3] + '10' + binaire_code[3:9] + '10' + binaire_code[9:15] + '10' + binaire_code[15:] +``` + +***Q4.*** Écrire une fonction `str_to_utf8`, qui prend en paramètre une chaine de caractère et renvoie la représentation binaire UTF-8, en hexadécimal, de l'ensemble des caractères de la chaine. Exécutez votre fonction sur la chaine `Rien ne sert de courir ; il faut partir à point. Le Lièvre et la Tortue en sont un témoignage.` Comparez le résultat obtenu avec celui de l'observation 12. + +```python +def str_to_utf8(chaine): + l = [] + for caractere in chaine: + l.append(hexadecimal(binaire_utf8(ord(caractere)))) + return l +``` diff --git a/representation_base/seance_5/td/ENONCE.md b/representation_base/seance_5/td/ENONCE.md new file mode 100644 index 0000000..573cdc9 --- /dev/null +++ b/representation_base/seance_5/td/ENONCE.md @@ -0,0 +1,133 @@ +# TD - Le Li�vre et la Tortue + +## Contexte + +2 fichiers `lièvre-iso-8859-1.html` et `lièvre-utf8.html` contiennent le même texte : la fable du lièvre et de la tortue de Jean de La Fontaine. + +![Couverture](./assets/couverture.jpg) +Source : Wikipédia + +Si on ouvre ces 2 fichiers dans un navigateur Web, des symboles étranges apparaissent, rendant la lecture inconfortable. + +Ce TD a pour but de comprendre l'origine de ce phénomène. + +Cette séance se découpe en 2 parties : +- La première consiste à explorer et découvrir la problématique d'encodage, +- La deuxième consiste à manipuler la représentation des chaines de caractères en python. + +Les parties doivent être traitées dans l'ordre. + +# Pré-Requis + +Avoir l'extension [Set Character Encoding](https://chrome.google.com/webstore/detail/set-character-encoding/bpojelgakakmcfmjfilgdlmhefphglae) installée sur votre poste. + +# Partie 1 - Exploration et découverte + +Cette partie vise à vous faire comprendre le problème d'encodage par différentes observations, calculs et manipulations à réaliser. + +A la fin de cette partie, vous devez répondre à un questionnaire et le valider avec votre professeur. + +En cas de réussite, vous pouvez aborder la partie 2. + +## Table d'encodage et calcul de la représentation binaire + +### ISO-8859-1 + +Voici la table d'encodage ISO-8859-1 : + +![Table de codage](./assets/iso-8859-1.png) + +Exemple : la point de code du caractère `A` est 41 (ligne 4x et colonne x1). + +***Observation 1.*** Sachant que l'encodage ISO-8859-1 représente les points de code sur 1 octet. Quelle est la représentation binaire du caractère `A` ? + +***Observation 2.*** Quelle est le point de code du caractère `<` ? Quelle est sa représentation binaire ? + +***Observation 3.*** Quelle est la point de code du caractère `à`? Quelle est sa représentation binaire ? + +***Observation 4.*** Étant donné le mot binaire $`(10101001)_2`$, quel caractère représente-il ? Quel est celui associé au mot binaire $`(11110100)_2`$ ? + +### Unicode UTF-8 + +La table d'encodage de l'UTF-8 est plus conséquente que celle de l'encodage ISO-8859-1. Le site https://unicode-table.com/fr permet d'obtenir les correspondances entre les caractères, leur point de code ainsi que leur représentation binaire UTF-8. + +Exemple : le caractère `©` a le point de code U+00A9 (U+ symbolise le fait que l'encodage est Unicode), soit le 169ème point de code ($`(A9)_{16} = (169)_{10}`$) dans la table d'encodage. + +***Observation 5.*** En vous référant au cours sur l'encodage UTF-8, calculez la représentation binaire UTF-8 de ce caractère. Qu'observez-vous par rapport à l'observation 8 ? + +***Observation 6.*** Cherchez le point de code et la représentation binaire du caractère ♧. + +***Observation 7.*** Cherchez le point de code et le caractère associés à la représentation binaire $`(11100010\,10000100 \,10111100)_2`$. + +## Effet visuel du problème d'encodage + +***Observation 8.*** Ouvrez dans votre navigateur Web les fichiers `lièvre-iso-8859-1.html` et `lièvre-utf8.html`. +Quelles différences constatez-vous ? + +***Observation 9.*** Dans l'explorateurs de fichiers, comparez la taille de ces 2 fichiers (en octets). Quelles différences constatez-vous ? + +***Observation 10.*** Dans votre navigateur Web, en faisant clic droit sur le page `lièvre-iso-8859-1.html`, changer la valeur de `Set Encoding character` avec les autres valeurs que celle sélectionnée. Que constatez-vous ? + +***Observation 11.*** Dans votre navigateur Web, en faisant clic droit sur le page `lièvre-utf8.html`, changer la valeur de `Set Encoding character` avec les autres valeurs que celle sélectionnée. Que constatez-vous ? + +## Analyse de la représentation binaire d'un fichier texte + +Nous allons utiliser un éditeur hexadécimal de texte en ligne https://www.onlinehexeditor.com/, il permet de visualiser le contenu réel d'un fichier texte, i.e les mots binaires (en héxadécimal) qui représentent les caractères. + +***Observation 12.*** Dans votre navigateur Web, rendez-vous sur la page https://www.onlinehexeditor.com/ et ouvrez les 2 fichiers `lièvre-iso-8859-1.html` et `lièvre-utf8.html` en cliquant sur `open file`. Quelles différences constatez-vous ? + +***Observation 13.*** Au vu des observations précédentes, comment expliquez-vous que votre navigateur affiche : +- `LiÚvre` au lieu de `lièvre`quand on ouvre le fichier `lièvre-utf8.html` avec un encodage iso-8859-1 ? +- `t�moignage` au lieu de `témoignage`quand on ouvre le fichier `lièvre-iso-8859-1.html` avec un encodage UTF-8 ? + +## Questionnaire + +Q1. le caractère `à` a toujours la même représentation en mémoire quelque soit l'encodage utilisé ? + +A. Vrai +B. Faux + +Q2. Dans la table d'encodage Unicode, le caractère `Ô` est le : + +A. 212ème +B. 213ème +C. $`(D4)_{16}`$ème +D. Il n'existe dans la table d'encodage Unicode + +Q3. En UTF-8, les caractères sont représentés sur : + +A. 1 octet +B. 2 octets +C. 7 bits +D. un nombre variable entre 1 et 4 octets + +Q4. En cas de problème d'affichage visuel d'un texte, quelle(s) est(sont) la(les) solution(s) selon vous ? + +A. s'assurer que l'encodage du fichier et le même que celui qui sert à l'affichage +B. modifier le fichier pour corriger les erreurs +C. appeler son professeur pour qu'il corrige le problème +D. modifier l'encodage de la visualisation + +Q5. Soit le point de code U+00D4, cela vous indique que : + +A. l'encodage est Unicode et la représentation binaire du caractère est $`(01001101)_2`$ +B. l'encodage est Unicode et la représentation binaire du caractère est $(11000011 \,10010100)_2$ +C. l'encodage est Unicode et le caractère associé est la lettre Ô +D. l'encodage est ISO-8859-1 et la représentation binaire du caractère est $`(01001101)_2`$ + +Q6. Quand une application traite un fichier encodé en iso-8859-1 : + +A. Elle traite octet par octet +B. Elle traite un nombre variable d'octets +C. calcule la position en fonction de la valeur de l'octet et affiche le caractère associé +D. affiche les caractères en fonction de la table d'encodage Unicode + +## Partie 2 - Manipulation en Python + +***Q1.*** Dans un interpréteur Python, exécutez successivement les instructions `chr(212)` et `chr(169)`. Qu'en déduisez-vous sur la spécification de la fonction `chr`? + +***Q2.*** Dans un interpréteur Python, exécutez successivement les instructions `ord('©')` et `ord('à')`. Qu'en déduisez-vous sur la spécification de la fonction `ord`? + +***Q3.*** Écrire une fonction `binaire_utf8`, qui prend en paramètre un point de code Unicode sous la forme d'un entier et renvoie la représentation binaire UTF-8 du caractère associé, sous la forme d'une liste d'octet (un octet est une liste de bits). (Aide : Vous pouvez réutiliser les fonctions de conversion en binaire des précédentes séances ainsi que la méthode vu en cours) + +***Q4.*** Écrire une fonction `str_to_utf8`, qui prend en paramètre une chaine de caractère et renvoie la représentation binaire UTF-8, en hexadécimal, de l'ensemble des caractères de la chaine. Exécutez votre fonction sur la chaine `Rien ne sert de courir ; il faut partir à point. Le Lièvre et la Tortue en sont un témoignage.` Comparez le résultat obtenu avec celui de l'observation 12. diff --git a/representation_base/seance_5/td/assets/couverture.jpg b/representation_base/seance_5/td/assets/couverture.jpg new file mode 100644 index 0000000..fda2fb5 Binary files /dev/null and b/representation_base/seance_5/td/assets/couverture.jpg differ diff --git a/representation_base/seance_5/td/assets/iso-8859-1.png b/representation_base/seance_5/td/assets/iso-8859-1.png new file mode 100644 index 0000000..fe127f6 Binary files /dev/null and b/representation_base/seance_5/td/assets/iso-8859-1.png differ