reorganisation du cours

algorithmique/cours/algo.txt

@@ -110,10 +110,10 @@ Exemple d'algorithme
     \end{algorithmic}
     \end{algorithm}
 
-Exemple d'algorithme avec deux implémentations
+Exemple d'algorithme avec son implémentation
------------------------------------------------
+---------------------------------------------
 
-Soit l'algorithme de factorielle suivant :
+Soit l'algorithme de factorielle suivant,
 
 .. raw:: latex
 
@@ -123,40 +123,37 @@ Soit l'algorithme de factorielle suivant :
     \Function{factorielle}{$n$}\Comment{La fonction récursive factorielle}
     \BState \emph{parametre} : $n$ entier
     \If{$n = 1$}
-    \BState \emph{Return} : 1
+    \BState \emph{Sortie} : 1
     \Else
-    \BState \emph{Return} : $n * \Call{factorielle}{n-1}$
+    \BState \emph{Sortie} : $n * \Call{factorielle}{n-1}$ \Comment{On appelle la fonction dans l'algorithme lui-même}
     \EndIf
     \EndFunction
     \end{algorithmic}
     \end{algorithm}
 
-
+et son implémentation en python :
-Ou encore, en **pseudocode** (algorithme vague) :
-
-.. function:: factorielle(n:int)
-
-
-::
-
-    begin
-       if n=1
-          return 1
-       else
-          return n * factoriel(n-1)
-       end if
-    end
-
-Implémentation en python :
 
 .. literalinclude:: code/factorielle.py
     :language: python
 
-Implémentation en OCaml :
+En voici une autre implémentation (en OCaml) :
 
 .. literalinclude:: code/factorielle.ml
     :language: ocaml
 
+On remarque que le **pseudocode** (l'algorithme vague) est très proche de
+la syntaxe du python :
+
+.. function:: factorielle(n:int)
+
+::
+
+       if n=1
+          return 1
+       else
+          return n * factorielle(n-1)
+       end if
+
 Qualité d'un algorithme
 -----------------------
 

algorithmique/cours/annexes/exercices.txt

@@ -53,96 +53,43 @@ Séance 3 : Chaînes et fichiers
     + glob.glob
     + Sans doute ces points peuvent être intégrés dans la séance 2.
 
-Séance 4 : Python Objet & Bases de données
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    + Classe
-    + Méthodes
-    + Surcharge d'opérateurs
-
-    + Construire un exemple de classe progressivement
-
-        Idéalement un exemple avec l'utilisation d'une base de données MySQL
-        utiliser `pymysql`
-
-
-
-Deuxième journée : Python Scientifique
---------------------------------------
-
-Séance 5 : Calcul numérique avec Numpy
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    + Lecture fichiers (type structuré)
-
-    + Algèbre de base
-
-    + broadcasting
-
-    + stacking(hstack,vstack,dstack)
-
-    + boucle ou pas boucle einsum vs numba comme exemple
-
-Séance 6 : Graphiques avec Matplotlib
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    + `visite de la grande galerie <http://matplotlib.org/gallery.html>`_
-       et de `la petite galerie <http://www.loria.fr/~rougier/coding/gallery/>`_
-    + construction d'un graphe simple en 2d en ajoutant des éléments
-      graduellement pour enrichir le graphe (légendes, titre, ....)
-
-    + imshow , contouplot
-
-    + 3D ?
-
-Séance 7 : Calcul scientifique avec Scipy
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    + optimisation
-    + intégration, ode
-    + stats
-
 Séance 8 : Cas pratique de mise en oeuvre
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-
 + écrire des instructions conditionnelles avec alternatives,
 + démontrer qu’une boucle se termine effectivement.
 + organisation modulaire des programmes
 + programmation structurée.
 
-
     1. Récupérer des données physiques ouvertes sur le réseau (T°, ...)
-    2. Appliquer un traitement
-    3. Mettre en forme une représentation graphique des données
 
 
-    + **Variables** : notion de type et de valeur d’une  variable, types simples.
++ **Variables** : notion de type et de valeur d’une  variable, types simples.
     Les types simples présentés sont les  entiers, flottants, booléens et chaînes de caractères.
 
-    + **Expressions et instructions simples** :
++ **Expressions et instructions simples** :
     affectation, opérateurs usuels, distinction entre expression et instruction
      Les expressions considérées sont à valeurs numériques, booléennes ou de type chaîne de caractères.
 
-    + **Instructions conditionnelles**:
++ **Instructions conditionnelles**:
     expressions booléennes et opérateurs logiques simples, structurer et comprendre plusieurs
     instruction if. Variantes avec alternative (else).
 
-    Les étudiants devront être capables de niveaux d’alternatives implantées par des instructions conditionnelles imbriquées.
+Les étudiants devront être capables de niveaux d’alternatives implantées par des instructions conditionnelles imbriquées.
 
-    + **Instructions itératives** :
++ **Instructions itératives** :
     boucles for, boucles conditionnelles while.
     Les sorties de boucle (instruction break) peuvent être présentées et se
     justifient uniquement lorsqu’elles contribuent à simplifier notablement la
     programmation sans réelle perte de lisibilité des conditions d’arrêt.
 
-    + **Fonctions** :
++ **Fonctions** :
   notion de fonction (au sens informatique), définition dans le langage utilisé, paramètres (ou arguments) et résultats, portée des variables.
   On distingue les variables locales des variables globales et on décourage l’utilisation des variables globales autant que possible.
 
   La récursivité sera présentée plus tard.
 
-    + **Manipulation de quelques structures de données**:
++ **Manipulation de quelques structures de données**:
     chaînes de caractères (création, accès à un caractère, concaténation), listes (création, ajout
     d’un élément, suppression d’un élément, accès à un élément, extraction d’une partie de liste), tableaux à une ou plusieurs dimensions.
 
@@ -152,21 +99,21 @@ Séance 8 : Cas pratique de mise en oeuvre
     ponctuelle (« bitmap »). Les algorithmes de traitement d’image seront abordés
     plus tard.
 
-    + **Fichiers** :
++ **Fichiers** :
     notion de chemin d’accès, lecture et écriture de données numériques ou de type chaîne de caractères depuis ou vers un fichier.
 
     On encourage l’utilisation de fichiers en tant que supports de données ou de résultats avant divers traitements, par exemple graphiques.
 
 
-    + **Piles**
++ **Piles**
     Algorithmes de manipulation : fonctions 'push' et 'pop'. On utilise des listes
     (ou tableaux à 1 dimension) pour leur implantation.
 
-    + **Récursivité**
++ **Récursivité**
 
     On en présente les avantages et les inconvénients.
 
-    + **Tris** d’un tableau à une dimension de valeurs
++ **Tris** d’un tableau à une dimension de valeurs
     numériques : tri par insertion, tri rapide (ou 'quicksort'),
     tri par fusion. Application à la
     recherche de la médiane d’une liste de nombres.

algorithmique/cours/control.txt

@@ -62,8 +62,10 @@ L'instruction de test
     \begin{algorithm}
     \caption{Exemple d'instruction de test}
     \begin{algorithmic}[1]
-    \Require $quality\gets 0$ ; $a\gets ""$
+    \BState \emph{entrée}: $quality\gets 0$ \Comment{C'est cette valeur qui sera testée}
-    \BState Begin
+    \BState \emph{locale}: $a\gets ""$
+    \BState \emph{sortie}: $a$ \Comment{La sortie est la valeur de $a$}
+    \BState \emph{corps}:
     \If{$quality\ge 9$}
     \State $a\gets perfect$
     \ElsIf{$quality\ge 7$}
@@ -75,7 +77,6 @@ L'instruction de test
     \Else
     \State $a\gets unusable$
     \EndIf
-    \BState End
     \end{algorithmic}
     \end{algorithm}
 

algorithmique/cours/programme.txt

@@ -7,37 +7,6 @@ Qu'est-ce qu'un programme ?
 - Un **programme** est une suite de **phrases** ;
 - Une **phrase** est une **déclaration** ou une **expression** (*statement* en anglais) ;
 
-expression
-
-    Une expression est une valeur caculée du langage, une opération arithmétique
-    qui retourne une valeur du langage (entier, texte, valeur logique...)
-
-Par exemple, la ligne suivante est une expression effectuant une addition::
-
-    5 + 6
-
-Autres exemples d'expressions :
-
-- 5 est une expression de type int
-- 4.5 est une expression de type float
-- 'c' est une expression de type char
-- true est une expression de type bool
-- print ('c') est une expression de type None
-- raw_input est une expression de type string
-
-Exemple de déclarations :
-
-- `a = 1`
-- `b = 'c'`
-
-.. important:: Le signe égal est utilisé de deux manières
-
-               - lors d'une déclaration d'une expression
-               - lorsque deux expressions sont équivalentes
-
-               Suivant les langages, il y a deux symboles différents, ou alors
-               ils sont identiques.
-
 Production d'un programme :
 
 1. on écrit le code source du programme ;
@@ -63,38 +32,76 @@ programme :
 2. communiquer avec des fichiers,
 3. communiquer avec d'autres programmes.
 
-Interaction avec l'utilisateur
+Les expressions
-------------------------------
+~~~~~~~~~~~~~~~
 
-.. FIXME
+expression
 
-- lire et écrire dans un fichier
+    Une expression est une valeur caculée du langage, une opération arithmétique
-- afficher du texte ou un nombre
+    qui retourne une valeur du langage (entier, texte, valeur logique...)
-- lire du texte ou un nombre
-- les prompts
 
+Par exemple, la ligne suivante est une expression effectuant une addition::
 
-La REPL
+    5 + 6
---------
 
-.. glossary::
+Autres exemples d'expressions :
 
-    REPL
+- 5 est une expression de type int
+- 4.5 est une expression de type float
+- 'c' est une expression de type char
+- true est une expression de type bool
+- print ('c') est une expression de type None
+- raw_input est une expression de type string
 
-      Read Eval Print Loop : outil principal de communication avec un programme
+Un autre exemple d'expression :
-      ou avec un système. Exemples : la console python, le prompt OCaml.
 
-    interface
+.. raw:: latex
 
-      outil de communication avec un programme.
+    \begin{algorithm}
+    \caption{Exemple d'expression}
+    \begin{algorithmic}[1]
+    \BState \emph{sortie}: $l$ \Comment{C'est l'expression calculée renvoyée}
+    \ForAll {$v \in V(G)$}
+    \State $l(v) \leftarrow \infty$
+    \EndFor
+    \State $l(u) \leftarrow 0$
+    \Repeat
+    \For {$i \leftarrow 1, n$}
+    \State $min \leftarrow l(v_i)$
+    \For {$j \leftarrow 1, n$}
+    \If {$min > e(v_i, v_j) + l(v_j)$}
+    \State $min \leftarrow e(v_i, v_j) + l(v_j)$
+    \State $p(i) \leftarrow v_j$
+    \EndIf
+    \EndFor
+    \State $l(i) \leftarrow min$
+    \EndFor
+    \State $changed \leftarrow l \not= l’$
+    \State $l \leftarrow l$
+    \Until{$\neg changed$}
+    \end{algorithmic}
+    \end{algorithm}
 
-      - interface texte
+On voit qu'une expression peut-être complexe, dans tous les cas une valeur
-      - interface graphique
+est renvoyée.
 
 Les déclarations
-----------------
+~~~~~~~~~~~~~~~~
 
-Renseigner une variable
+Exemple de déclarations :
+
+- `a = 1`
+- `b = 'c'`
+
+.. important:: Le signe égal est utilisé de deux manières
+
+               - lors d'une déclaration d'une expression
+               - lorsque deux expressions sont équivalentes
+
+               Suivant les langages, il y a deux symboles différents, ou alors
+               ils sont identiques.
+
+Il s'agit de **renseigner** une valeur dans une expression nommée
 
 
 - en javascript :
@@ -182,38 +189,35 @@ Voir aussi :
 
     x1 = e1, x2 = e2, ... xn = en;
 
-Les expressions
+Interaction avec l'utilisateur
----------------
+------------------------------
 
-.. raw:: latex
+Il est possible de communiquer de la manière suivante avec un programme :
 
-    \begin{algorithm}
+- lire et écrire sur l'entrée/sortie standard
-    \caption{Exemple d'expression}
+- lire et écrire dans un fichier
-    \begin{algorithmic}[1]
+- afficher du texte ou un nombre
-    \ForAll {$v \in V(G)$}
+- lire du texte ou un nombre
-    \State $l(v) \leftarrow \infty$
+- manipuler les prompts
-    \EndFor
+
-    \State $l(u) \leftarrow 0$
+La REPL
-    \Repeat
+--------
-    \For {$i \leftarrow 1, n$}
+
-    \State $min \leftarrow l(v_i)$
+.. glossary::
-    \For {$j \leftarrow 1, n$}
+
-    \If {$min > e(v_i, v_j) + l(v_j)$}
+    REPL
-    \State $min \leftarrow e(v_i, v_j) + l(v_j)$
+
-    \State $p(i) \leftarrow v_j$
+      Read Eval Print Loop : outil principal de communication avec un programme
-    \EndIf
+      ou avec un système. Exemples : la console python, le prompt OCaml.
-    \EndFor
+
-    \State $l(i) \leftarrow min$
+    interface
-    \EndFor
+
-    \State $changed \leftarrow l \not= l’$
+      outil de communication avec un programme.
-    \State $l \leftarrow l$
+
-    \Until{$\neg changed$}
+      - interface texte
-    \end{algorithmic}
+      - interface graphique
-    \end{algorithm}
 
-.. FIXME mieux définir une expression
 
-Une expression est une portion de code qui renvoie une valeur
 
 Les fonctions
 -------------