diff --git a/Progression.xlsx b/Progression.xlsx new file mode 100644 index 0000000..b303bdb Binary files /dev/null and b/Progression.xlsx differ diff --git a/algorithmes/avances/README.md b/algorithmes/avances/README.md index 1e54aab..0ef91d1 100644 --- a/algorithmes/avances/README.md +++ b/algorithmes/avances/README.md @@ -1,6 +1,6 @@ > En informatique, on retrouve fréquemment des problèmes d'optimisation comme par exemple le problème du **rendu de monnaie**. Les algorithmes gloutons sont utilisés pour résoudre ce type de problème. -### Le Programme +## Le Programme diff --git a/architecture/2018-12-hw-sw.pdf b/architecture/2018-12-hw-sw.pdf new file mode 100644 index 0000000..fb47196 Binary files /dev/null and b/architecture/2018-12-hw-sw.pdf differ diff --git a/architecture/M999.zip b/architecture/M999.zip new file mode 100644 index 0000000..dca1dbf Binary files /dev/null and b/architecture/M999.zip differ diff --git a/architecture/M999/README.pdf b/architecture/M999/README.pdf new file mode 100755 index 0000000..86606c2 Binary files /dev/null and b/architecture/M999/README.pdf differ diff --git a/architecture/M999/assets/M999-instructions-2.md b/architecture/M999/assets/M999-instructions-2.md new file mode 100755 index 0000000..5b63a4d --- /dev/null +++ b/architecture/M999/assets/M999-instructions-2.md @@ -0,0 +1,39 @@ +--- +title: M999 - jeu d'instructions 2 +author: Philippe BODDAERT +--- + +# 1. Contexte + +Le processeur M999 est doté d'un jeu d'instructions. + +Une instruction est un mot de 3 chiffres, appelé _opcode_, correspondant à une opération à effectuer par le processeur. + +Le premier chiffre de l'opcode détermine le type de l'opération (copie, opération arithmétique, saut d'instruction ...). + +Les deux derniers chiffres indiquent, selon le type de l'opération, une adresse mémoire, un registre, un sous-type d'opération... + +# 2. Jeu d'instructions + +| op0 | op1 op2 | instruction à réaliser | +| ----- | --------- | ------------------------------------------------------------ | +| 0 | _addr_ | copie le mot mémoire d’adresse _addr_ dans le registre A | +| 1 | _addr_ | copie le mot mémoire d’adresse _addr_ dans le registre B | +| 2 | _addr_ | copie le contenu du registre R dans le mot mémoire d'adresse _addr_ | +| 3 | 0 0 | ajoute les valeurs des registres A et B, produit le résultat dans R | +| 3 | 0 1 | soustrait la valeur du registre B à celle du registre A, produit le résultat dans R | +| 3 | 0 2 | divise la valeur du registre A par 2, le quotient est placé dans R, le reste dans B | +| 3 | 0 3 | multiplie la valeur du registre A par 2, le résultat est placé dans R | +| 3 | 9 9 | ne fait rien | +| 4 | _rs_ _rd_ | copie la valeur du registre source _rs_ dans le registre destination _rd_ | +| 5 | _addr_ | branche en _addr_ (PC reçoit la valeur _addr_) | +| 6 | _addr_ | branche en _addr_ si la valeur du registre R est strictement positive | + +Les registres (_rs_, _rd_) sont désignés par les valeurs suivantes : + +valeur | registre +:------: | :--------: +0 | A +1 | B +2 | R + diff --git a/architecture/M999/assets/M999-instructions.md b/architecture/M999/assets/M999-instructions.md new file mode 100755 index 0000000..0bee697 --- /dev/null +++ b/architecture/M999/assets/M999-instructions.md @@ -0,0 +1,36 @@ +--- +title: M999 - jeu d'instructions +author: Philippe BODDAERT +--- +# 1. Contexte + +Le processeur M999 est doté d'un jeu d'instructions. + +Une instruction est un mot de 3 chiffres, appelé _opcode_, correspondant à une opération à effectuer par le processeur. + +Le premier chiffre de l'opcode détermine le type de l'opération (copie, opération arithmétique, saut d'instruction ...). + +Les deux derniers chiffres indiquent, selon le type de l'opération, une adresse mémoire, un registre, un sous-type d'opération... + +# 2. Jeu d'instructions + +| op0 | op1 op2 | instruction à réaliser | +| ----- | --------- | ------------------------------------------------------------ | +| 0 | _addr_ | copie le mot mémoire d’adresse _addr_ dans le registre A | +| 1 | _addr_ | copie le mot mémoire d’adresse _addr_ dans le registre B | +| 2 | _addr_ | copie le contenu du registre R dans le mot mémoire d'adresse _addr_ | +| 3 | 0 0 | ajoute les valeurs des registres A et B, produit le résultat dans R | +| 3 | 0 1 | soustrait la valeur du registre B à celle du registre A, produit le résultat dans R | +| 3 | 9 9 | ne fait rien | +| 4 | _rs_ _rd_ | copie la valeur du registre source _rs_ dans le registre destination _rd_ | +| 5 | _addr_ | branche en _addr_ (PC reçoit la valeur _addr_) | +| 6 | _addr_ | branche en _addr_ si la valeur du registre R est strictement positive | + +Les registres (_rs_, _rd_) sont désignés par les valeurs suivantes : + +valeur | registre +:------: | :--------: +0 | A +1 | B +2 | R + diff --git a/architecture/M999/assets/exemple.png b/architecture/M999/assets/exemple.png new file mode 100755 index 0000000..84df360 Binary files /dev/null and b/architecture/M999/assets/exemple.png differ diff --git a/architecture/M999/assets/m999.png b/architecture/M999/assets/m999.png new file mode 100755 index 0000000..02b3d9e Binary files /dev/null and b/architecture/M999/assets/m999.png differ diff --git a/architecture/M999/assets/multiplication_russe.jpeg b/architecture/M999/assets/multiplication_russe.jpeg new file mode 100755 index 0000000..98272da Binary files /dev/null and b/architecture/M999/assets/multiplication_russe.jpeg differ diff --git a/architecture/M999/assets/multiplication_russe_2.jpeg b/architecture/M999/assets/multiplication_russe_2.jpeg new file mode 100755 index 0000000..d0ea355 Binary files /dev/null and b/architecture/M999/assets/multiplication_russe_2.jpeg differ diff --git a/architecture/os/assets/Linux_bash.png b/architecture/os/assets/Linux_bash.png new file mode 100644 index 0000000..f8c8f10 Binary files /dev/null and b/architecture/os/assets/Linux_bash.png differ diff --git a/architecture/von_Neumann/M99.md b/architecture/von_Neumann/M99.md new file mode 100644 index 0000000..427e736 --- /dev/null +++ b/architecture/von_Neumann/M99.md @@ -0,0 +1,194 @@ +## Le processeur **papier** : **M99** + +Pour étudier le fonctionnement d'une machine de Von Neumann, nous allons travailler sur du papier ! + +Cette machine est issue des travaux de Philippe Marquet et Martin Quinson github.com/InfoSansOrdi/M999, enseignants chercheurs en informatique. + +![M99](../assets/m99.png) + +Le M99 est une machine dotée de 100 cases mémoire (la grille en haut de la feuille), et d'un processeur (en bas de la feuille). + +On peut diviser ce processeur en trois (3) parties distinctes : + +- La mémoire + - Composée de 100 cases "***mots mémoire"*** de 3 chiffres (valeur de 000 à 999). + - Ces espaces sont accessibles par des adresses codées sur 2 chiffres. Cette mémoire va contenir données et instructions. + +Le processeur dispose de deux registres généraux nommés A et B, et d'un registre accumulateur/résultat nommé R. Ces registres sont de 3 chiffres, mais au contraire de la mémoire, ils ont un signe. Ils peuvent donc contenir des valeurs comprises entre -999 et 999. + +Le processeur dispose aussi d'un quatrième registre nommé PC (Program Counter). C'est le pointeur d'instruction, contenant l'adresse mémoire de la prochaine instruction à exécuter. Lorsqu'on utilise le M99, on peut noter le numéro de l'instruction à exécuter dans la case prévue à cette effet, mais en pratique, il est plus simple de le matérialiser avec un "pion" situé sur une des cases de la grille mémoire, ou même de suivre avec son doigt. + +## Unité arithmétique et logique + +L'unité arithmétique et logique – UAL – est en charge d'effectuer les calculs. Les opérandes et résultats sont dans les registres, A et B pour les opérandes, R pour le résultat. + +## Unité de commande + +L'unité de commande pilote l'ordinateur. Son cycle de fonctionnement comporte 3 étapes : + +1. charger l'instruction depuis la case mémoire pointée par PC vers la zone dédiée dans l'UAL (la case sous le registre PC). Incrémenter ensuite le PC. +2. décoder l'instruction : à partir des 3 chiffres codant l'instruction, identifier quelle est l’opération à réaliser en utilisant le pense-bête à droite de l'UAL. +3. exécuter l'instruction. + +## Jeu d'instruction + +| code | mnémonique | instruction à réaliser | +| ----- | --------------------------------------- | ------------------------------------------------------------ | +| 0 x y | `STR xy` | copie le contenu du registre R dans le mot mémoire d'adresse *xy* | +| 1 x y | `LDA xy` | copie le mot mémoire d’adresse *xy* dans le registre A | +| 2 x y | `LDB xy` | copie le mot mémoire d’adresse *xy* dans le registre B | +| 3 x y | `MOV x y` | copie registre Rx dans Ry (R0: R; R1: A; R2: B) | +| 4 - - | **opérations arithmétique et logiques** | | +| 4 0 0 | `ADD` | ajoute les valeurs des registres A et B, produit le résultat dans R | +| 4 0 1 | `SUB` | soustrait la valeur du registre B à celle du registre A, produit le résultat dans R | +| . . . | etc | … | +| 5 x y | `JMP x y` | branche en *xy* (PC reçoit la valeur *xy*) | +| 6 x y | `JPP x y` | branche en *xy* si la valeur du registre R est positive | +| 7 x y | `JEQ x y` | saute une case (PC += 2) si la valeur du registre R est égale à *xy* | +| 8 x y | `JNE x y` | saute une case (PC += 2) si la valeur du registre R est différent de *xy* | + +Notez que pour JEQ et JNE, on a `PC += 2` si la condition est respectée car l'opération saute une case (PC++) après l'étape de chargement par l'unité de commande (PC++). + +### Boot et arrêt + +La machine démarre avec la valeur nulle comme pointeur d'instruction (PC=0) et elle s'arrête si le pointeur d'instruction vaut 99. + +On peut donc utiliser le mnémonique `HLT` comme synonyme de `JMP 99`. + +### Entrées/sorties + +Les entrées/sortries sont "mappées" en mémoire: Écrire le mot mémoire 99 écrit sur le terminal, tandis que les valeurs saisies sur le terminal seront lues dans le mot mémoire 99. + +# Exercice 1 + +Objectifs: + +- prise en main du M99 +- comprendre l'encodage des opcode dans la mémoire +- comprendre le cycle fetch/decode/execute + +## Q1: Que fait le programme chargé à l'adresse 0 ? + +Pour répondre, il faut appliquer le cycle fetch/decode/exec aux données qui sont dans les premières adresses de la mémoire. Traduire les valeurs numériques en mémoire est nécessaire. + +``` +00: LDA 10 // Charge le contenu de la case 10 dans le registre A +01: LDB 11 // Charge le contenu de la case 11 dans le registre B +02: SUB // R := A - B +03: JPP 7 // Si R > 0 alors PC := 7 +04: MOV B R // B := A +05: STR 99 // Copie R en 99, c'est-à-dire, affiche R à l'écran +06: JMP 99 // Arrête le programme +07: MOV A R // A := B +08: STR 99 // Copie R en 99, donc affiche R à l'écran +09: JMP 99 // Arrête le programme +10: 123 // Utilisé seulement comme une donnée, sans signification +11: 42 // Utilisé seulement comme une donnée, sans signification +``` + +Donc au final, ce programme affiche 123, car 123 > 42. + +## Q2: Que fait le programme débutant à l'adresse 13? + +``` +13: LDA 99 // Charge une entrée utilisateur dans A +14: MOV A R // R := A +15: STR 10 // Copie l'entrée utilisateur en 10 +16: LDA 99 // Charge une entrée utilisateur dans A +17: MOV A R // R := A +18: STR 11 // Copie l'entrée utilisateur en 11 +19: JMP 0 // Branche l'exécution sur 0 +``` + +Donc au final, ce programme demande deux entrées à l'utilisateur avant d'exécuter le programme précédent (qui affichera le plus grand d'entre eux). + +## Q3: Écrire un programme affichant le minimum de deux entrées clavier + +On peut l'écrire à partir de l'adresse 20 en mémoire, et on n'a pas besoin d'écrire ce qu'on lit en mémoire puisqu'on l'utilise immédiatement. + +``` +20: 199; LDA 99 // input A +21: 299; LDB 99 // input B +22: 401; SUB +23: 610; JPP 27 // JMP 27 si R>0, ie si A>B +24: 320; MOV A R // Copie A dans R +25: 099; STR 99 // Affiche A +26: 599; JMP 99 // Halt +27: 320; MOV B R // Copie B dans R +28: 099: STR 99 // Affichage B +29: 599: JMP 99 // Halt +``` + +# Exercice 2 + +Objectifs: + +- Modifier un programme en assembleur +- Voir l'intérêt d'un compilateur, et d'un langage de haut niveau + +## Q1: Que fait le programme débutant à l'adresse 40 (pour les entrées 5 et 2)? + +Il calcule le produit des deux entrées et affiche le résultat + +## Q2: Peut-on raccourcir ce programme ? + +On peut passer à 21 cases en stockant x et y dans les cases 40 et 41 car on n'a plus besoin de ce code une fois qu'on l'a exécuté. + +Il faut ensuite déplacer les cases 61 et 62 (qui sont respectivement la valeur 1 et le résultat) dans les cases 59 et 60. Cette opération est plus simple en *nommant les variables*, c'est à dire en écrivant par exemple "LDB un" à la place de "LDB 61" dans la case 51. + +On peut même tomber à 19 cases en utilisant une ruse: au lieu d'énumérer les trois opérations nécessaires pour afficher le contenu de A avant de s'arrêter, on branche vers l'endroit du programme 1 qui fait cela (JMP 04). + +Notez que réutiliser les bouts d'un autre programme en sautant au milieu de son code est considéré comme "très sale" par la plupart des programmeurs. En pratique on ne veut absolument jamais faire quelque chose d'aussi dangereux avec de vrais programmes car cela les rend difficile à lire et à comprendre. On ne fait pas des programmes que pour la machine, mais aussi (surtout) pour que d'autres humains les comprennent. + +``` + 56: 310: MOV A R -> 56: 504: JMP 04 + 57: 099: STR 99 + 58: 599: HLT +``` + +## Q3: Corrigez ce programme quand la seconde entrée vaut 0 + +En effet, notre programme calcule par exemple 5*0 = 5 car il ajoute x au résultat dans tous les cas. Pour corriger, il faut d'abord vérifier s'il y a besoin d'ajouter x et ensuite seulement le faire. + +La première solution est d'ajouter un JMP juste avant la boucle pour entrer au bon endroit de la boucle (sur le décrément de y). Mais cela fait un code spagetti assez désagréable. + +La seconde solution est de réécrire le corps de boucle pour faire le décrément du compteur avant l'addition au résultat, au prix de légères contortions pour sortir de la boucle au bon moment + +``` + 46: 162: LDA res -> 46: 162: LDA y + 47: 259: LDB x 47: 261: LDB un + 48: 400: ADD 48: 401: SUB + 49: 062: STR res 49: 899: JNE 99 // on suppose que -1 overflow en 99 + 50: 160: LDA y 50: 556: JMP fin // Sort de la boucle + 51: 261: LDB un 51: 162: LDA res + 52: 401: SUB 52: 259: LDB x + 53: 060: STR y 53: 400: ADD + 54: 646: JPP 46 54: 062: STR res + 55: 546: JMP 46 // Retour début boucle + 56: 162: LDA res + 57: 504: JMP 04 // Utilise la fin du prog 1 +``` + +L'instruction de la ligne 49 est assez discutable. Son objectif est de tester si R==-1, mais on n'a pas de nombres négatifs dans la mémoire. On suppose donc ici qu'un nombre négatif en registre sera traduit en son complément à 100 à l'usage. C'est assez réaliste de ce que font les vrais ordinateurs. + +Au final, les deux solutions sont assez diffiles à relire: soit on commence la première boucle en sautant au milieu, soit on sort de la dernière boucle en sautant depuis le milieu. C'est quand même plus simple d'utiliser un langage de haut niveau et un compilateur :) + +# Lien à l'informatique + +Le M99 est un ordinateur en papier, assez simple à utiliser avec seulement un crayon, mais il a été pensé pour être relativement réaliste des vrais ordinateurs. + +- La mémoire d'un vrai ordinateur est également découpée en mots mémoires, chacun étant doté d'une adresse unique. En général, les vrais ordinateurs utilisent des mots de 1 octet (8 bits). Les ordinateurs 32bits peuvent avoir jusqu'à 2³² mots (soit un peu plus de 4Go de mémoire) tandis que les ordinateurs 64bits peuvent en avoir jusqu'à 2⁶⁴ en théorie (18 Exaoctets, 18.10¹⁸ octets). + +- Les vrais processeurs ont également des registres afin de gérer au mieux le problème de la barrière mémoire. Ils ont également des caches pour optimiser les échanges entre la mémoire et le CPU. Là où lire en mémoire peut demander une centaine de cycles CPU, lire en cache prend entre 10 et 30 cycles. Le M99 n'a pas de caches pour simplifier. + +- Les vrais programmes sont également écrits sous forme d'opcodes en mémoire des vrais ordinateurs, avec le préfixe indiquant l'opération tandis que le sufixe indique les opérandes. Le jeu d'opérations élémentaires disponibles varie beaucoup d'un processeur à l'autre. + + Pour le M99, nous avons choisi d'utiliser des mots mémoires de trois positions décimales, ce qui contraint fortement le nombre d'instructions disponibles. Ces contraintes sont parfaitement réalistes de celles que doivent résoudre les fabriquants de CPU. Ajouter des instructions simplifie l'écriture de programmes efficaces, mais complique grandement le processeur, qui devient plus cher et plus énergivore. + + Les processeurs de la famille RISC (reduced instruction set CPU) visent la simplicité et n'offrent que peu d'instructions tandis que ceux de la famille CISC (complex instruction set CPU) offrent des opérations optimisées plus rares, comme des opérations vectorielles. + + Il serait faux de dire que l'une des familles est vraiment préférable à l'autre. Il s'agit plutôt de deux compromis différents entre complexité du processeur et complexité des programmes. Les processeurs des téléphones portables sont souvent des RISC (par exemple du constructeur ARM) tandis que ceux des ordinateurs sont souvent des CISC (par exemple des constructeurs Intel ou AMD). + +- Gérer les entrées/sorties au travers d'adresses particulières de l'espace d'adressage du bus mémoire est parfaitement réaliste. En revanche, il est rare d'avoir plusieurs périphériques à la même adresse et on aurait pu séparer les lectures du clavier et les écritures à l'écran dans des zones mémoire différentes. De plus, nous avons ignoré toute la synchronisation qu'un vrai processeur doit faire pour échanger avec les périphériques, souvent bien plus lent. + +# \ No newline at end of file diff --git a/architecture/von_Neumann/MEMOIRE.md b/architecture/von_Neumann/MEMOIRE.md index f7b0ef3..494929c 100644 --- a/architecture/von_Neumann/MEMOIRE.md +++ b/architecture/von_Neumann/MEMOIRE.md @@ -51,4 +51,17 @@ Le temps d'accès est le même, peu importe la cellule : on parle alors de ***RA -![mémoire](../assets/memoire.png) \ No newline at end of file +![mémoire](../assets/memoire.png) + + + + + +---------- + +Auteur : Florian Mathieu + +Licence CC BY NC + +Licence Creative Commons
Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International. + diff --git a/architecture/von_Neumann/TURING.md b/architecture/von_Neumann/TURING.md new file mode 100644 index 0000000..7da33d6 --- /dev/null +++ b/architecture/von_Neumann/TURING.md @@ -0,0 +1,57 @@ +## Machine de Turing + +Cette machine est constituée : + +- D' un **ruban infini** divisé en cases consécutives. Chaque case contient un symbole d'un *alphabet*. L'alphabet contient un symbole spécial appelé « symbole blanc », et un ou plusieurs autres symboles. Le ruban est supposé être de longueur infinie vers la gauche ou vers la droite, en d'autres termes la machine doit toujours avoir assez de longueur de ruban pour son exécution. On considère que les cases du ruban contiennent par défaut le « symbole blanc » . + +- Une **tête de lecture/écriture** (ci-dessous le **`V`**) qui peut lire et écrire les symboles sur le ruban, et se déplacer vers la gauche ou vers la droite du ruban + +- Un **registre d'état** qui mémorise l'état courant de la machine de Turing. Le nombre d'états possibles est toujours fini, et il existe un état spécial appelé « état de départ » qui est l'état initial de la machine avant son exécution. + +- Une **table d'actions** qui indique à la machine quel symbole écrire sur le ruban, comment déplacer la tête de lecture (vers la droite ou la gauche), et quel est le nouvel état, en fonction du symbole lu sur le ruban et de l'état courant de la machine. Si aucune action n'existe pour une combinaison donnée d'un symbole lu et d'un état courant, la machine s'arrête. + + + +**Exemple : voici l'algorithme permettant d'ajouter 1 à un nombre binaire.** + +Choisissez un nombre binaire et écrivez le à droite de la tête de lecture (par exemple 101). + +| | | | | | | | | | | V | | | | | | | | | | +| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | +| | | | | | | | | | | | 1 | 0 | 1 | | | | | | | + +Réalisez pas à pas l'algorithme ci-dessous : + +- la machine lit chaque case de gauche à droite jusqu'à tomber sur une case vide. Il y a alors deux cas possibles: + - Si la dernière case mémorisée dans le registre d'état est un 0 alors la machine se décale d'une case à gauche et écrit 1 puis retourne dans sa position initiale. . + - Si la dernière case est un 1, la machine se décale d'une case à gauche et : + - si cette case vaut 1, elle écrit 0 puis se décale à gauche et recommence le point précédent. + - si cette case vaut 0 ou est vide, elle écrit 1 puis retourne à sa position initiale. + +*Etape 1* : la machine va à droite jusqu'à la première case vide. + +| | | | | | | | | | | | | | | V | | | | | | +| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | +| | | | | | | | | | | | 1 | 0 | 1 | | | | | | | + +*Etape 2* : la dernière case lue est ... donc ... + +| | | | | | | | | | | | | | V | | | | | | | +| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | +| | | | | | | | | | | | 1 | 0 | 0 | | | | | | | + +*Etape 4* : ... + +| | | | | | | | | | | | | V | | | | | | | | +| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | +| | | | | | | | | | | | 1 | 1 | 0 | | | | | | | + +*Etape 5* : ... + +| | | | | | | | | | | V | | | | | | | | | | +| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | +| | | | | | | | | | | | 1 | 1 | 0 | | | | | | | + +Vous trouverez [sur ce site](http://zanotti.univ-tln.fr/turing/turing.php) un simulateur d'une machin de de Turing si vous souhaitez aller plus loin. + +ll faut garder à l'esprit que la machine de Turing est un modèle universel de calcul et qu'elle peut calculer tout ce que n'importe quel ordinateur physique peut calculer (aussi puissant soit-il). In­ver­sement, ce qu'elle ne peut pas calculer ne peut l'être non plus par un ordinateur. Elle résume donc de manière saisissante le concept d'*ordinateur* et constitue un support idéal pour raisonner autour de la notion d'*algorithme* de *calcul* ou de *démonstration*. En terminale, nous étudierons plus en détail le concept de calculabilité. \ No newline at end of file diff --git a/assets/CC-BY-SA.svg b/assets/CC-BY-SA.svg new file mode 100644 index 0000000..9b0c0be --- /dev/null +++ b/assets/CC-BY-SA.svg @@ -0,0 +1,9 @@ + +]> + + Creative Commons “Attribution-Share Alike” license icon + + + + + diff --git a/données_en_table/Exercices/CORRECTION.md b/données_en_table/Exercices/CORRECTION.md index ba179e5..bc80fb6 100644 --- a/données_en_table/Exercices/CORRECTION.md +++ b/données_en_table/Exercices/CORRECTION.md @@ -187,4 +187,13 @@ Ainsi que celle- ci : - \ No newline at end of file + + +---------- + +Auteur : Florian Mathieu + +Licence CC BY NC + +Licence Creative Commons
Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International. + diff --git a/données_en_table/Exercices/README.md b/données_en_table/Exercices/README.md index 7af23fa..8760713 100644 --- a/données_en_table/Exercices/README.md +++ b/données_en_table/Exercices/README.md @@ -225,3 +225,12 @@ Ainsi que celle- ci : + +------------ + +Auteur : Florian Mathieu + +Licence CC BY NC + +Licence Creative Commons
Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International. + diff --git a/données_en_table/FUSION.md b/données_en_table/FUSION.md index 4e6624e..c00b1a4 100644 --- a/données_en_table/FUSION.md +++ b/données_en_table/FUSION.md @@ -51,3 +51,13 @@ def fusion(table_1, table_2, cle_1, cle_2=None): return table_finale ``` + + +-------------- + +Auteur : Florian Mathieu + +Licence CC BY NC + +Licence Creative Commons
Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International. + diff --git a/données_en_table/MANIPULATION.md b/données_en_table/MANIPULATION.md index f05a1a2..70399f7 100644 --- a/données_en_table/MANIPULATION.md +++ b/données_en_table/MANIPULATION.md @@ -128,3 +128,11 @@ Quel est le résultat affiché ? +--------- + +Auteur : Florian Mathieu + +Licence CC BY NC + +Licence Creative Commons
Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International. + diff --git a/données_en_table/README.md b/données_en_table/README.md index 514e2b3..536a45d 100644 --- a/données_en_table/README.md +++ b/données_en_table/README.md @@ -160,3 +160,15 @@ def vers_csv(nom, ordre): return None ``` + + + + +---------- + +Auteur : Florian Mathieu + +Licence CC BY NC + +Licence Creative Commons
Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International. + diff --git a/knn/README.md b/knn/README.md index ad9ab4d..c9873e8 100644 --- a/knn/README.md +++ b/knn/README.md @@ -47,3 +47,27 @@ Il devrait donc se trouver dans zone. On peut alors trouver ses cinq ou six plus ### Formulation de l'algorithme + + + + + + + + + + + + + + + + +-------------- + +Auteur : Florian Mathieu + +Licence CC BY NC + +Licence Creative Commons
Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International. + diff --git a/representation_construits/Evaluation.pdf b/representation_construits/Evaluation.pdf new file mode 100644 index 0000000..2c04953 Binary files /dev/null and b/representation_construits/Evaluation.pdf differ diff --git a/~$Progression.xlsx b/~$Progression.xlsx new file mode 100644 index 0000000..5a93205 Binary files /dev/null and b/~$Progression.xlsx differ