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,68 +53,15 @@ 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.

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
 -------------