From 6ccddf4cc5411ff1bdf0764d56281773bc92bf12 Mon Sep 17 00:00:00 2001
From: gwen <gremond@cadoles.com>
Date: Wed, 5 Apr 2017 10:36:41 +0200
Subject: [PATCH 01/10] =?UTF-8?q?ajout=20des=20principales=20structures=20?=
 =?UTF-8?q?de=20contr=C3=B4les?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 algorithmique/cours/algo.txt      |  97 +++++++++++++---------------
 algorithmique/cours/control.txt   | 101 ++++++++++++++++++++++++++++--
 algorithmique/cours/programme.txt |  18 +++---
 algorithmique/index.txt           |  26 --------
 4 files changed, 147 insertions(+), 95 deletions(-)
 delete mode 100644 algorithmique/index.txt

diff --git a/algorithmique/cours/algo.txt b/algorithmique/cours/algo.txt
index 2b0e255..8640235 100644
--- a/algorithmique/cours/algo.txt
+++ b/algorithmique/cours/algo.txt
@@ -59,60 +59,6 @@ mathématiques dans certains rôles immuables et ignorerait le fait que les
 existants abstraits qui naissent de la structure d'un domaine plus concret
 peuvent à leur tour servir de domaine de base pour la genèse d'autres existants.
 
-
-Types d'algorithmes
--------------------
-
-La boucle
-~~~~~~~~~~
-
-Différents types de boucles (suites récurrentes, goto, boucle for...)
-
-
-.. raw:: latex
-
-   \begin{algorithm}
-   \caption{My algorithm}\label{euclid}
-   \begin{algorithmic}[1]
-   \Procedure{MyProcedure}{}
-   \State $\textit{stringlen} \gets \text{length of }\textit{string}$
-   \State $i \gets \textit{patlen}$
-   \BState \emph{top}:
-   \If {$i > \textit{stringlen}$} \Return false
-   \EndIf
-   \State $j \gets \textit{patlen}$
-   \BState \emph{loop}:
-   \If {$\textit{string}(i) = \textit{path}(j)$}
-   \State $j \gets j-1$.
-   \State $i \gets i-1$.
-   \State \textbf{goto} \emph{loop}.
-   \State \textbf{close};
-   \EndIf
-   \State $i \gets
-   i+\max(\textit{delta}_1(\textit{string}(i)),\textit{delta}_2(j))$.
-   \State \textbf{goto} \emph{top}.
-   \EndProcedure
-   \end{algorithmic}
-   \end{algorithm}
-
-
-.. raw:: latex
-
-	\begin{algorithm}
-	\caption{Euclid's algorithm}\label{euclid}
-	\begin{algorithmic}[1]
-	\Procedure{Euclid}{$a,b$}\Comment{The g.c.d. of a and b}
-	   \State $r\gets a\bmod b$
-	   \While{$r\not=0$}\Comment{We have the answer if r is 0}
-		  \State $a\gets b$
-		  \State $b\gets r$
-		  \State $r\gets a\bmod b$
-	   \EndWhile\label{euclidendwhile}
-	   \State \textbf{return} $b$\Comment{The gcd is b}
-	\EndProcedure
-	\end{algorithmic}
-	\end{algorithm}
-
 L'algorithme comme généralisation de la calculabilité
 ------------------------------------------------------
 
@@ -121,6 +67,49 @@ impose d'élaborer un nouveau mode de description des méthodes de calcul (appel
 susceptible de satisfaire à la fois le critère de sécurité (maîtrise du résultat) et la possibilité
 d'implémenter les calculs sur un ordinateur.
 
+Exemple d'algorithme
+---------------------
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{L'alorithme de Bellman-Kalaba}
+    \begin{algorithmic}[1]
+    \Procedure {BellmanKalaba}{$G$, $u$, $l$, $p$}
+    \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$}
+    \EndProcedure
+    \Statex
+    \Procedure {FindPathBK}{$v$, $u$, $p$}
+    \If {$v = u$}
+    \State \textbf{Write} $v$
+    \Else
+    \State $w \leftarrow v$
+    \While {$w \not= u$}
+    \State \textbf{Write} $w$
+    \State $w \leftarrow p(w)$
+    \EndWhile
+    \EndIf
+    \EndProcedure
+    \end{algorithmic}
+    \end{algorithm}
+
 Qualité d'un algorithme
 -----------------------
 
diff --git a/algorithmique/cours/control.txt b/algorithmique/cours/control.txt
index 53a02ca..c7031f9 100644
--- a/algorithmique/cours/control.txt
+++ b/algorithmique/cours/control.txt
@@ -16,11 +16,11 @@ L'instruction de saut conditionnel
    \If {$i > \textit{stringlen}$} \Return false
    \EndIf
    \State $j \gets \textit{patlen}$
-   \BState \emph{loop}: \Comment{C'est le label (l'étiquette)}
+   \BState \emph{loop}: \Comment{C'est le label (l'étiquette)} \label{etiquette}
    \If {$\textit{string}(i) = \textit{path}(j)$}
    \State $j \gets j-1$.
    \State $i \gets i-1$.
-   \State \textbf{goto} \emph{loop}.
+   \State \textbf{goto} \emph{loop}. \label{goto}
    \State \textbf{close};
    \EndIf
    \State $i \gets
@@ -31,11 +31,16 @@ L'instruction de saut conditionnel
    \end{algorithm}
 
 
-- **Ligne 7**, le bloc `loop` est aussi un **label** (une étiquette), c'est-à-dire
-  une marque posée qu'il est possible de retrouver dans le programme.
-- **Ligne 11**, l'instruction `goto` (aller à ) est un saut.
+.. raw:: latex
 
-D'une manière générale::
+    Ligne \ref{etiquette}, le bloc `loop` est aussi un label (une étiquette),
+    c'est-à-dire une marque posée qu'il est possible de retrouver dans le programme. \\
+
+.. raw:: latex
+
+    Ligne \ref{goto}, l'instruction \texttt{goto} (aller à ) est le saut vers le label. \\
+
+Description générique d'une instruction de saut::
 
   Instruction 1
   Saut Label1
@@ -47,3 +52,87 @@ D'une manière générale::
 .. important:: les sauts conditionnels sont à éviter, même s'ils sont implémentés
                dans le langage cible, car c'est le meilleur moyen d'aboutir à
                du **code spaghetti**.
+
+L'instruction de test
+~~~~~~~~~~~~~~~~~~~~~~
+
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{Exemple d'instruction de test}
+    \begin{algorithmic}[1]
+    \Require $quality\gets 0$ ; $a\gets ""$
+    \BState Begin
+    \If{$quality\ge 9$}
+    \State $a\gets perfect$
+    \ElsIf{$quality\ge 7$}
+    \State $a\gets good$
+    \ElsIf{$quality\ge 5$}
+    \State $a\gets medium$
+    \ElsIf{$quality\ge 3$}
+    \State $a\gets bad$
+    \Else
+    \State $a\gets unusable$
+    \EndIf
+    \BState End
+    \end{algorithmic}
+    \end{algorithm}
+
+
+Les boucles
+-----------
+
+.. important:: Toutes les boucles concernent le paradigme de programmation impératif
+               et ne sont pas valides dans le paradigme de programmation fonctionnel
+               (puisque l'ordre d'évaluation importe)
+
+Répéter ... jusqu'à
+~~~~~~~~~~~~~~~~~~~
+
+.. raw:: latex
+
+   \begin{algorithm}
+    \caption{Exemple de répéter ... jusqu'à}
+   \begin{algorithmic}[1]
+   \Require $i \gets 1$ \Comment{déclaration et initialisation de i}
+   \Statex
+   \Repeat \Comment{c'est le label de début du répéter}
+   \State $i \gets \textit{i+1}$
+   \Until{i == 100} \Comment{condition de fin de la boucle}
+   \end{algorithmic}
+   \end{algorithm}
+
+La boucle **pour** (for)
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{Exemple de boucle for}
+    \begin{algorithmic}[1]
+    \Require  $sum\gets 0$
+    \Statex
+    \For{$i\gets 1, n$}
+    \State $sum\gets sum+i$
+    \EndFor
+    \end{algorithmic}
+    \end{algorithm}
+
+La boucle tant que (while)
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{Exemple de boucle while}
+    \begin{algorithmic}[1]
+    \Require $sum\gets 0$
+    \Statex
+    \State $i\gets 1$
+    \While{$i\le n$}
+    \State $sum\gets sum+i$
+    \State $i\gets i+1$
+    \EndWhile
+    \end{algorithmic}
+    \end{algorithm}
diff --git a/algorithmique/cours/programme.txt b/algorithmique/cours/programme.txt
index 6dec7ad..6906a32 100644
--- a/algorithmique/cours/programme.txt
+++ b/algorithmique/cours/programme.txt
@@ -4,8 +4,8 @@ Définition d'un programme
 Qu'est-ce qu'un programme ?
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-- Un programme est une suite de phrases
-- Une phrase est une **déclaration** ou une **expression**.
+- Un programme est une suite de phrases ;
+- Une phrase est une **déclaration** ou une **expression** (*statement* en anglais) ;
 - Le signe "égal" est utilisé lorsqu'une une déclaration ou une expression sont équivalentes
 
 Les déclarations
@@ -68,10 +68,9 @@ Exemples dans la langue française :
 
 .. glossary::
 
-
     affectation
 
-        une affectation, aussi appelée assignation par anglicisme, est une structure qui permet d'attribuer une valeur à une variable.
+        Une affectation, aussi appelée assignation par anglicisme, est une structure qui permet d'attribuer une valeur à une variable.
 
         Il s'agit d'une structure particulièrement courante en programmation impérative, et dispose souvent pour cette raison d'une notation courte et infixée,
         comme ``x = expr`` ou ``x := expr`` ou encore `x <- expr`.
@@ -103,10 +102,9 @@ Les fonctions
 Préliminaire : rappel de théorie de l'information
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Théorie de l'information (Claude Shannon, 1949), théorie de la
-communication
+Théorie de l'information (Claude Shannon, 1949), (ou théorie de la communication)
 
-canal de transmission::
+Canal de transmission::
 
     entrée -> récepteur -> émetteur -> sortie
 
@@ -136,6 +134,7 @@ Description d'une procédure
    \State $a \gets b$
    \State $b \gets z$
    \EndProcedure
+   \State \Call{permuter}{10, 12} \Comment{appel de la procédure}
    \end{algorithmic}
    \end{algorithm}
 
@@ -165,8 +164,9 @@ Appel d'une procédure
 
 ::
 
-    procedure p(x1, ..., xn);
-        var v1,...,vm;
+    >>> procedure p(x1, ..., xn); 
+
+    >>>    var v1,...,vm;
 
 - les variables x1,...,xn sont appelées *paramètres formels* de p
 - les variables v1,...,vm sont appelées *les variables locales* de p
diff --git a/algorithmique/index.txt b/algorithmique/index.txt
deleted file mode 100644
index d22df1d..0000000
--- a/algorithmique/index.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-Introduction à l'algorithmique
-================================
-
-.. index pour générer de l'HTML
-
-
-Contents:
-
-.. toctree::
-    :maxdepth: 2
-
-    fondement
-    langage
-    modularite
-    machine
-
-
-
-
-Indices and tables
-==================
-
-* :ref:`genindex`
-* :ref:`modindex`
-* :ref:`search`
-

From 6de57bca95d26e120b9fdf0204e23e467140ccc5 Mon Sep 17 00:00:00 2001
From: gwen <gremond@cadoles.com>
Date: Thu, 6 Apr 2017 10:36:31 +0200
Subject: [PATCH 02/10] =?UTF-8?q?d=C3=A9finition=20d'une=20fonction?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 algorithmique/cours/algo.txt      |   4 +-
 algorithmique/cours/programme.txt | 127 +++++++++++++++++++++++++-----
 2 files changed, 111 insertions(+), 20 deletions(-)

diff --git a/algorithmique/cours/algo.txt b/algorithmique/cours/algo.txt
index 8640235..687cbf8 100644
--- a/algorithmique/cours/algo.txt
+++ b/algorithmique/cours/algo.txt
@@ -89,10 +89,10 @@ Exemple d'algorithme
     \State $p(i) \leftarrow v_j$
     \EndIf
     \EndFor
-    \State $l’(i) \leftarrow min$
+    \State $l(i) \leftarrow min$
     \EndFor
     \State $changed \leftarrow l \not= l’$
-    \State $l \leftarrow l’$
+    \State $l \leftarrow l$
     \Until{$\neg changed$}
     \EndProcedure
     \Statex
diff --git a/algorithmique/cours/programme.txt b/algorithmique/cours/programme.txt
index 6906a32..692f7b5 100644
--- a/algorithmique/cours/programme.txt
+++ b/algorithmique/cours/programme.txt
@@ -4,9 +4,16 @@ Définition d'un programme
 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) ;
-- Le signe "égal" est utilisé lorsqu'une une déclaration ou une expression sont équivalentes
+- Un **programme** est une suite de **phrases** ;
+- Une **phrase** est une **déclaration** ou une **expression** (*statement* en anglais) ;
+
+.. 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.
 
 Les déclarations
 ----------------
@@ -38,10 +45,13 @@ Renseigner une variable
 
     let a = 1
 
-(**let** : soit `a` la variable... )
+Grâce au mécanisme d'inférence de type dans OCaml, le mot-clef **let**
+signifie ici véritablement l'instanciation d'une valeur au sens
+mathématique du terme : soit `a` l'entier tel que a soit égal à 1...
 
-En OCaml comme dans tous les langages fonctionnels, toutes les "variables"
-(les affectations) sont en fait des **constantes**.
+En OCaml comme dans tous les langages fonctionnels, tout ce que nous avons l'habitude
+d'appeler des "variables" à propos des affectations, sont en fait des **constantes**
+au sens du paradigme impératif de la programmation.
 
 .. important::
 
@@ -96,6 +106,39 @@ Voir aussi :
 
     x1 = e1, x2 = e2, ... xn = en;
 
+Les expressions
+---------------
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{Exemple d'expression}
+    \begin{algorithmic}[1]
+    \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}
+
+.. FIXME mieux définir une expression
+
+Une expression est une portion de code qui renvoie une valeur
+
 Les fonctions
 -------------
 
@@ -150,7 +193,7 @@ instruction
 
 Une procédure ne renvoie pas de valeur, mais provoque un 'effet de bord' (écriture dans une globale, dans un flux sortant etc.).
 
-Une procédure permet de créer une instruction nouvelle qui deviendra une primitive pour le programmeur
+Une procédure permet de créer une instruction nouvelle qui deviendra une primitive pour le programmeur.
 Cela permet de structurer le texte source du programme et améliorer sa
 lisibilité. Cela permet aussi d'appeler plusieurs fois, et à plusieurs endroit
 dans le code, cette primitive.
@@ -162,28 +205,46 @@ Appel d'une procédure
 
 **déclaration de procédure**
 
-::
+.. raw:: latex
 
-    >>> procedure p(x1, ..., xn); 
+   \begin{algorithm}
+   \caption{Procédure de permutation de deux entiers}\label{permutation}
+   \begin{algorithmic}[1]
+   \Procedure{permuter}{$a,b$}{}
+   \BState \emph{parametres}:
+   \State $a: \textit{int}$ \Comment{paramètres formels de la procédure}
+   \State $b: \textit{int}$
+   \BState \emph{locales}:
+   \State $z: \textit{int}$ \Comment{les variables locales de la procédure}
+   \BState \emph{corps}:
+   \State ... \Comment{Le corps de la procedure}
+   \EndProcedure
+   \State \Call{permuter}{10, 12} \Comment{l'appel de la procédure}
+   \end{algorithmic}
+   \end{algorithm}
 
-    >>>    var v1,...,vm;
 
 - les variables x1,...,xn sont appelées *paramètres formels* de p
 - les variables v1,...,vm sont appelées *les variables locales* de p
 
-**appel de procédure**
+les valeurs effectivement passées en paramètres, ici `10, 12`
+sont appelées **paramètres effectifs** de p
 
-::
+signature
 
-    p(e1, ..., en)
+    C'est l'ensemble paramètre formel + resultat de l'appel
 
-les expressions e1,...,en sont appelées paramètres effectifs de p
+fermeture
 
-SYRACUSE
+    L'ensemble procédure + variables locales + signature + parametres effectifs
+    est appelé une **fermeture**. C'est la procédure + son contexte qui permet
+    de l'instancier dans un programme.
 
-Le niveau d’une déclaration (de variable ou de procédure) est le nombre
-de procédures sous lesquelles elle est déclarée. Le programme principal
-a le niveau 0.
+niveau
+
+    Le niveau d’une déclaration (de variable ou de procédure) est le nombre
+    de procédures sous lesquelles elle est déclarée. Le programme principal
+    a le niveau 0.
 
 Description d'une fonction
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -191,3 +252,33 @@ Description d'une fonction
 Une fonction renvoie une valeur et ne modifie pas l'état courant du programme
 en cours d'exécution ni ne réalise d'effets de bord. Elle renvoie
 **toujours** quelque chose (même la valeur ``None`` qui n'est pas rien)
+
+- une procédure peut prendre des paramètres
+- elle modifie l'état courant du système
+
+- Déclaration des paramètes
+- Déclaration du corps
+- Appel de la procédure
+
+.. raw:: latex
+
+   \begin{algorithm}
+   \caption{Exemple de fonction}\label{fonction}
+   \begin{algorithmic}[1]
+   \Function{permuter}{$a,b$}{} \Comment{définition de la fonction}
+   \BState \emph{parametres}: \Comment{déclaration (noms, types) des paramètres formels}
+   \State $a: \textit{int}$
+   \State $b: \textit{int}$
+   \BState \emph{locales}: \Comment{déclaration (noms, types) des valeurs locales}
+   \State $z: \textit{int}$
+   \BState \emph{corps}:
+   \State $z \gets a$
+   \State $a \gets b$
+   \State $b \gets z$
+   \BState \emph{return}: \Comment{La valeur, le résulat renvoyé par la fonction}
+   \EndFunction
+   \State \Call{permuter}{10, 12} \Comment{appel de la fonction}
+   \BState \emph{result}:
+   \State (12, 10) \Comment{Le résultat effectif de la fonction après appel}
+   \end{algorithmic}
+   \end{algorithm}

From 813a09034a5abf5d5b721b0323f40c15cfefd297 Mon Sep 17 00:00:00 2001
From: gwen <gremond@cadoles.com>
Date: Thu, 6 Apr 2017 14:55:36 +0200
Subject: [PATCH 03/10] =?UTF-8?q?diveres=20d=C3=A9finitions=20de=20la=20pr?=
 =?UTF-8?q?ogrammation?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 algorithmique/cours/fondement.txt  | 31 +++++++----
 algorithmique/cours/langage.txt    | 45 +++++++++++++++
 algorithmique/cours/modularite.txt | 89 ++++++++++++++++++++----------
 algorithmique/cours/programme.txt  | 11 +++-
 4 files changed, 133 insertions(+), 43 deletions(-)

diff --git a/algorithmique/cours/fondement.txt b/algorithmique/cours/fondement.txt
index af45b06..e7ce4c1 100644
--- a/algorithmique/cours/fondement.txt
+++ b/algorithmique/cours/fondement.txt
@@ -1,6 +1,15 @@
 Présentation de l'art de programmer
 ====================================
 
+Qu'est-ce que la programmation ?
+--------------------------------
+
+programmation
+
+    Description d’un calcul (traitement) dans
+    un langage compréhensible par la machine
+    (langage de programmation)
+
 Le processus d'abstraction
 --------------------------
 
@@ -18,18 +27,18 @@ explication du fonctionnement d'une machine abstraite de bas niveau, puis en
 allant de plus en plus haut, mais étant sous-entendu qu'il faut rester connecté au
 bas niveau (comprendre comment ça se passe derrière la scène).
 
-Dans ces deux cas, il est sous-entendu qu'on apprend plus de choses et plus rapidement en mettant 
-les mains dans le cambouis, ce qui vrai bien sûr. Mais cela sous-entend qu'un développeur doit 
-rester le nez dans le guidon. Qu'il doit être un expert de son domaine en accumulant des technos 
-sans aucun recul. Bie sûr il se doit d'être un expert du système dans lequel il évolue 
-(connaissance du système d'exploitation, binding avec le C, du ramasse miette (garbage 
-collector), interaction avec les différentes librairies, gestion et optimisation de la mémoire, 
+Dans ces deux cas, il est sous-entendu qu'on apprend plus de choses et plus rapidement en mettant
+les mains dans le cambouis, ce qui vrai bien sûr. Mais cela sous-entend qu'un développeur doit
+rester le nez dans le guidon. Qu'il doit être un expert de son domaine en accumulant des technos
+sans aucun recul. Bie sûr il se doit d'être un expert du système dans lequel il évolue
+(connaissance du système d'exploitation, binding avec le C, du ramasse miette (garbage
+collector), interaction avec les différentes librairies, gestion et optimisation de la mémoire,
 architecture par microservices, threads...) mais il doit aussi être capable de prendre du recul.
 
-L'approche algorithmique (algorithmique de pseudo code, algorithmique algébrique et modulaire) 
-est un véritable moyen pour le programmeur de prendre du recul : elle commence par se placer du 
-côté de l'esprit humain et de ses capacités de compréhension et d'abstraction, elle autorise une 
-pensée rationnelle sur l'art de programmer et permet au programmeur d'effectuer les bons choix, 
+L'approche algorithmique (algorithmique de pseudo code, algorithmique algébrique et modulaire)
+est un véritable moyen pour le programmeur de prendre du recul : elle commence par se placer du
+côté de l'esprit humain et de ses capacités de compréhension et d'abstraction, elle autorise une
+pensée rationnelle sur l'art de programmer et permet au programmeur d'effectuer les bons choix,
 en connaissance de sa discipline.
 
 Le lien est fait ensuite avec le plus bas niveau grâce une implémentation effective
@@ -98,5 +107,3 @@ plus efficace.
   langages ne dépent plus de la machine, et ils implémentent des paradigmes de
   programmation indépendant de l'état de la mémoire de l'ordinateur,
   ils sont indépendant même du système d'exploitation.
-
-
diff --git a/algorithmique/cours/langage.txt b/algorithmique/cours/langage.txt
index ae4b948..4aac45f 100644
--- a/algorithmique/cours/langage.txt
+++ b/algorithmique/cours/langage.txt
@@ -1,6 +1,30 @@
 Les langages de programmation
 =============================
 
+langage
+
+    Un langage de
+    programmation
+    doit permettre d' écrire des
+    programmes de bonne qualité
+
+Un programme doit être :
+
+- correct
+- robuste
+- lisible, bien documenté
+- facile à modifier, extensible
+
+Un langage de programmation doit permettre :
+
+- la programmation structurée
+- la structuration avec les types
+- proposer un mécanisme d’exceptions
+- présenter des caractères de généricité, de polymorphisme et de surcharge
+
+.. important:: La structuration et l'organisation modulaire sert à maintenir de grands programmes,
+               Elles sont une nécessité
+
 Approche historique et chronologique
 -------------------------------------
 
@@ -287,3 +311,24 @@ en retour les langages. On reconnaît aujourd'hui :
 - Le modèle de programmation système et réseau
 - le modèle **Dev Ops** et les méthodes de développement virtualisés
 - les langages présentant des **fonctionnalités agiles**
+
+Conclusion
+-----------
+
+Les langages de haut niveau sont caractérisés par
+des concepts tels que :
+
+- déclaration de valeurs, types, expressions, portée
+- expressions, variables, instructions, structures de contrôle
+- fonctions, procédures, fermetures
+- encapsulation, modules, objets
+
+===========  ============
+Paradigmes   Concepts
+===========  ============
+impératif    variables, procédures, modules
+objets       classes, méthodes, héritage, surcharge
+fonctionnel  fonctions, fermetures, modules
+logique      prédicats, modules
+concurrent   tâche/processus, communication
+===========  ============
diff --git a/algorithmique/cours/modularite.txt b/algorithmique/cours/modularite.txt
index d102a7f..e1ca7b8 100644
--- a/algorithmique/cours/modularite.txt
+++ b/algorithmique/cours/modularite.txt
@@ -1,6 +1,12 @@
 L'organisation d'un programme
 =============================
 
+
+Un langage de programmation doit permettre la programmation structurée.
+
+.. important:: La structuration et l'organisation modulaire sert à maintenir de grands programmes,
+               Elles sont une nécessité
+
 Structuration d'un programme
 -----------------------------
 
@@ -33,6 +39,9 @@ les données. La structuration d'un programme provient des relations entre
 classes, en particulier l'héritage permet de définir une classe par extension
 d'une autre.
 
+En programmation objet, un **programme** est une collection d’objets qui communiquent
+entre eux par **message**, le **résultat** est un message envoyé à un objet particulier
+
 Comparaison entre les deux paradigmes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -55,31 +64,31 @@ Structuration et sûreté d'exécution
 La preuve de programme
 ~~~~~~~~~~~~~~~~~~~~~~
 
-Le niveau maximum de sûreté d'exécution d'un programme est la preuve. Qu'est-ce que la preuve 
-formelle d'un programme ? Selon la définition de Wikipédia, ce sont "des techniques permettant de 
-raisonner rigoureusement, à l'aide de logique mathématique, sur des programmes informatiques ou 
-du matériel électroniques, afin de démontrer leur validité par rapport à une certaine 
-spécification." Bref c'est un raisonnement logique sur un programmme qui permet d'être sûr que le 
+Le niveau maximum de sûreté d'exécution d'un programme est la preuve. Qu'est-ce que la preuve
+formelle d'un programme ? Selon la définition de Wikipédia, ce sont "des techniques permettant de
+raisonner rigoureusement, à l'aide de logique mathématique, sur des programmes informatiques ou
+du matériel électroniques, afin de démontrer leur validité par rapport à une certaine
+spécification." Bref c'est un raisonnement logique sur un programmme qui permet d'être sûr que le
 programme est valide et ne va pas planter.
 
-La preuve de programme est très peu utilisée dans l'industrie, car très coûteuse et très 
-difficile à mettre en place. Elle quand même utilisée, mais dans des secteurs où le risque doit 
-absolument être évacué et où il n'y a aucun droit à l'erreur. Par exemple, le secteur médical 
-(informatique en bloc opératoire), militaire (peu d'informations nous parviennent dans ce 
-domaine), l'aviation civile (le logiciel Astrée pour Airbus), la fusée Ariane (depuis le bug qui 
-avait fait crasher Ariane 5 ces questions sont prises très au sérieux), et le milieu bancaire 
-(surtout le domaine des décisions boursières : un programme chargé de lancer des décisions 
-d'achat ou de vente à la bourse qui comporte un bug peut en quelque centièmes de secondes faire 
-perdre des millions, voire des milliards d'euros à une banque. Le programme ne doit tout simplement pas 
+La preuve de programme est très peu utilisée dans l'industrie, car très coûteuse et très
+difficile à mettre en place. Elle quand même utilisée, mais dans des secteurs où le risque doit
+absolument être évacué et où il n'y a aucun droit à l'erreur. Par exemple, le secteur médical
+(informatique en bloc opératoire), militaire (peu d'informations nous parviennent dans ce
+domaine), l'aviation civile (le logiciel Astrée pour Airbus), la fusée Ariane (depuis le bug qui
+avait fait crasher Ariane 5 ces questions sont prises très au sérieux), et le milieu bancaire
+(surtout le domaine des décisions boursières : un programme chargé de lancer des décisions
+d'achat ou de vente à la bourse qui comporte un bug peut en quelque centièmes de secondes faire
+perdre des millions, voire des milliards d'euros à une banque. Le programme ne doit tout simplement pas
 bugger).
 
 Le model checking
 ~~~~~~~~~~~~~~~~~~
 
-Le model checking, l'analyse statique et l'interprétation abstraite procèdent d'une méthodologie 
-moins lourde de validation des programmes. Ces méthodes analysent exhaustivement l'évolution du 
-système lors de ses exécutions possibles et permetent de dire si globalement, dans un contexte 
-donné, le programme va fonctionner correctement. Encore très lourdes, ces techniques ne sont 
+Le model checking, l'analyse statique et l'interprétation abstraite procèdent d'une méthodologie
+moins lourde de validation des programmes. Ces méthodes analysent exhaustivement l'évolution du
+système lors de ses exécutions possibles et permetent de dire si globalement, dans un contexte
+donné, le programme va fonctionner correctement. Encore très lourdes, ces techniques ne sont
 utilisées que dans un contexte industriel de haute sécurité.
 
 
@@ -89,8 +98,8 @@ Les tests d'acceptation
 C'est sont les tests unitaires et fonctionnels
 
 
-Très utilisés dans l'industrie, les tests unitaires et fonctionnels ne testent que certaines 
-parties du programme et permettent de dire que le programme va marcher grosso-modo à peu près. 
+Très utilisés dans l'industrie, les tests unitaires et fonctionnels ne testent que certaines
+parties du programme et permettent de dire que le programme va marcher grosso-modo à peu près.
 Beaucoup moins coûteux à installer, ce sont des éléments cléfs des méthodes agiles.
 
 
@@ -110,27 +119,27 @@ cher à payer.
 Les méthodologies agiles
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
-La manière dont le code est produit importe énormément. Par exemple, une 
-méthodologie ou le **refactoring** (réécriture de code) est permis et même conseillé 
+La manière dont le code est produit importe énormément. Par exemple, une
+méthodologie ou le **refactoring** (réécriture de code) est permis et même conseillé
 a plus de chance de produire du code organisé.
 
-Les méthodologies agiles produisent en général du code mieux organisé. Ce sont les 
+Les méthodologies agiles produisent en général du code mieux organisé. Ce sont les
 méthodes de travail les plus en vogue aujourd'hui, elles mettent l'accent sur :
 
 - Du logiciel fonctionnel plutôt que de la documentation exhaustive
 - La réponse au changement plutôt que le suivi d'un plan
 - Le logiciel fonctionnel est la principale mesure d'avancement
-- Une attention continue à l'excellence technique et à une bonne 
+- Une attention continue à l'excellence technique et à une bonne
   conception améliore l'agilité
 - La simplicité est essentielle (il est facile de faire, il est
   difficile de faire simple)
 
-Le principe de base de la méthodologie Scrum par exemple est de focaliser l'équipe de façon 
-itérative sur un ensemble de fonctionnalités à réaliser, dans des itérations de durée fixe de une 
-à quatre semaines, appelées **sprints**. Chaque sprint possède un but à atteindre, défini par le 
-responsable de produit, à partir duquel sont choisies les fonctionnalités à implémenter dans ce 
-sprint. Un sprint aboutit toujours sur la livraison d'un produit partiel fonctionnel. Pendant ce 
-temps, le facilitateur a la charge de réduire au maximum les perturbations extérieures et de 
+Le principe de base de la méthodologie Scrum par exemple est de focaliser l'équipe de façon
+itérative sur un ensemble de fonctionnalités à réaliser, dans des itérations de durée fixe de une
+à quatre semaines, appelées **sprints**. Chaque sprint possède un but à atteindre, défini par le
+responsable de produit, à partir duquel sont choisies les fonctionnalités à implémenter dans ce
+sprint. Un sprint aboutit toujours sur la livraison d'un produit partiel fonctionnel. Pendant ce
+temps, le facilitateur a la charge de réduire au maximum les perturbations extérieures et de
 résoudre les problèmes non techniques de l'équipe.
 
 
@@ -143,3 +152,23 @@ Les Outils de linting (validation)
 
 Exemple en python : pylint
 
+Les modules
+-----------
+
+Il s'agit de décomposer un grand programme en
+morceaux (**modules**) connectés entre eux par des **interfaces** bien
+définies.
+
+Ces modules doivent être aussi indépendants que possible.
+
+module
+
+    ensemble de ressources  liées sémantiquement
+
+interface
+
+    mode d’emploi du module
+
+Les interfaces
+
+- principe de masquage des informations (partie publique, partie secrète)
diff --git a/algorithmique/cours/programme.txt b/algorithmique/cours/programme.txt
index 692f7b5..52d57ff 100644
--- a/algorithmique/cours/programme.txt
+++ b/algorithmique/cours/programme.txt
@@ -154,6 +154,9 @@ Canal de transmission::
 Description d'une procédure
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+En programmation impérative, un programme est une suite d’instructions qui font
+évoluer l’état mémoire, le résultat est dans l’état final de la mémoire.
+
 - une procédure peut prendre des paramètres
 - elle modifie l'état courant du système
 
@@ -258,7 +261,13 @@ en cours d'exécution ni ne réalise d'effets de bord. Elle renvoie
 
 - Déclaration des paramètes
 - Déclaration du corps
-- Appel de la procédure
+- Appel de la fonction
+
+En programmation fonctionnelle, programme est un ensemble de définitions de fonctions,
+un résultat est l'application d’une fonction à une structure de données effective.
+
+- composant de base : la fonction
+- opération de base : l’application
 
 .. raw:: latex
 

From 936de04ce4715841a8717070b0ff25b66188774b Mon Sep 17 00:00:00 2001
From: gwen <gremond@cadoles.com>
Date: Thu, 6 Apr 2017 16:57:22 +0200
Subject: [PATCH 04/10] algorithme factorielle

---
 algorithmique/cours/algo.txt            | 49 +++++++++++++++++++++++++
 algorithmique/cours/code/factorielle.ml | 17 +++++++++
 algorithmique/cours/code/factorielle.py | 12 ++++++
 3 files changed, 78 insertions(+)
 create mode 100644 algorithmique/cours/code/factorielle.ml
 create mode 100644 algorithmique/cours/code/factorielle.py

diff --git a/algorithmique/cours/algo.txt b/algorithmique/cours/algo.txt
index 687cbf8..2624431 100644
--- a/algorithmique/cours/algo.txt
+++ b/algorithmique/cours/algo.txt
@@ -110,6 +110,55 @@ Exemple d'algorithme
     \end{algorithmic}
     \end{algorithm}
 
+Exemple d'algorithme avec deux implémentations
+-----------------------------------------------
+
+Soit l'algorithme de factorielle suivant :
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{Algorithme de la factorielle d'un nombre}\label{factorielle}
+    \begin{algorithmic}[1]
+    \Function{factorielle}{$n$}\Comment{La fonction récursive factorielle}
+    \BState \emph{parametre} : $n$ entier
+    \If{$n = 1$}
+    \BState \emph{Return} : 1
+    \Else
+    \BState \emph{Return} : $n * \Call{factorielle}{n-1}$
+    \EndIf
+    \EndFunction
+    \end{algorithmic}
+    \end{algorithm}
+
+
+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 :
+
+.. literalinclude:: code/factorielle.ml
+    :language: ocaml
+
+
+
 Qualité d'un algorithme
 -----------------------
 
diff --git a/algorithmique/cours/code/factorielle.ml b/algorithmique/cours/code/factorielle.ml
new file mode 100644
index 0000000..5065a2c
--- /dev/null
+++ b/algorithmique/cours/code/factorielle.ml
@@ -0,0 +1,17 @@
+let rec fact = function
+    |1 -> 1
+    | n -> n * fact (n-1) ;;
+
+let print_fact n =
+  Printf.printf "factorielle %i = %i\n" n (fact n)
+
+let main () = 
+  begin 
+    print_fact 5 ;
+    print_newline () ;
+    exit 0 ;
+  end
+
+let _ = main ()
+
+
diff --git a/algorithmique/cours/code/factorielle.py b/algorithmique/cours/code/factorielle.py
new file mode 100644
index 0000000..734719f
--- /dev/null
+++ b/algorithmique/cours/code/factorielle.py
@@ -0,0 +1,12 @@
+def factorielle(n):
+    if (n > 1):
+       r  = n*factorielle(n-1)
+    else:
+        r = 1
+    return r
+
+def print_fact(n):
+    print "factorielle {} = {}\n".format(5, factorielle(5))
+
+if __name__ == '__main__':
+    print_fact(5)

From 0685998e20070737780f0bad9c6b72ef13c55774 Mon Sep 17 00:00:00 2001
From: gwen <gremond@cadoles.com>
Date: Fri, 7 Apr 2017 15:28:36 +0200
Subject: [PATCH 05/10] =?UTF-8?q?pr=C3=A9sentation=20du=20cours=20et=20ava?=
 =?UTF-8?q?nt=20propos?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 algorithmique/cours/index.txt                 |  2 +-
 .../{abstract.txt => cours/presentation.txt}  | 28 ++++++++-----------
 2 files changed, 13 insertions(+), 17 deletions(-)
 rename algorithmique/{abstract.txt => cours/presentation.txt} (51%)

diff --git a/algorithmique/cours/index.txt b/algorithmique/cours/index.txt
index 51d3dc5..7c23c16 100644
--- a/algorithmique/cours/index.txt
+++ b/algorithmique/cours/index.txt
@@ -4,6 +4,7 @@ Introduction à l'algorithmique
 .. toctree::
     :maxdepth: 2
 
+    presentation
     fondement
     langage
     modularite
@@ -12,4 +13,3 @@ Introduction à l'algorithmique
     control
     machine
     annexes/index
-
diff --git a/algorithmique/abstract.txt b/algorithmique/cours/presentation.txt
similarity index 51%
rename from algorithmique/abstract.txt
rename to algorithmique/cours/presentation.txt
index 52d472c..ce046cb 100644
--- a/algorithmique/abstract.txt
+++ b/algorithmique/cours/presentation.txt
@@ -1,13 +1,13 @@
-Initiation à l'algorithmique et présentation de la programmation
-================================================================
+Avant propos
+-------------
 
-**Présentation du cours**
+**Présentation de ce cours**
 
 - L'accent est mis sur l'approche **algorithmique scientifique**, dite algorithmique
   algébrique. L'algorithmique est un sous-domaine de l'algèbre et des
   approches modulaires (arithmétique modulaire...)
 
-- Le point de vue mathématique étant assez exigeant, aucun formalisme fort de
+- Le point de vue mathématique étant assez exigeant, **aucun formalisme fort** de
   l'algorithmique mathématique ne sera présenté. Aucun symbole mathématique donc, et
   seulement du pseudo-code.
   L'approche mathématique forte utilisant le formalisme mathématique de
@@ -15,22 +15,18 @@ Initiation à l'algorithmique et présentation de la programmation
   des grandes écoles.
 
 - L'algorithmique présentée ici est donc délibérément pseudo-scientifique mais en revanche
-  ouverte au multi-paradigme. En général l'évocation d'un algorithme en pseudo code est toujours
+  ouverte au **multi-paradigme**. En général l'évocation d'un algorithme en pseudo code est toujours
   réducteur car limité au style de programmation le plus à la mode actuellement, c'est-à-dire le
-  style impératif. Nous présenterons un éventail des plus grands paradigmes de programmation
-  existants. Nous nous limiterons à la programmation impérative, fonctionnelle, modulaire,
-  générique et objet. Nous envisagerons les structures de données et les structures de contrôle
+  **style impératif**. Nous présenterons un éventail des plus grands paradigmes de programmation
+  existants. Nous nous limiterons à la **programmation impérative, fonctionnelle, modulaire,
+  générique et objet**. Nous envisagerons les structures de données et les structures de contrôle
   spécifiques à chacun des styles évoqués.
 
-- Et parce qu'un honnête programmeur doit avoir une vue d'ensemble de l'état de son art,
+- Et parce qu'un honnête programmeur doit avoir une vue d'ensemble de **l'état de son art**,
   nous évoquerons un panorama des différents langages existants -- historiques et contemporains --
   en les comparants les uns aux autres.
 
 - Durant tout le cours, nous souhaitons proposer une pédagogie par l'exemple, et nous nous
-  limiterons l'exposé à deux langages : principalement le Python3 pour la programmation
-  impérative, modulaire et objet, mais nous évoquerons aussi certains exemples en langage OCaml
-  à propos de la programmation fonctionnelle et générique.
-
-
-- Introduire certains domaines et résultats importants de
-  l’informatique théorique
+  limiterons l'exposé à deux langages d'implémentation des algorithmes : le **Python** pour la programmation
+  impérative, modulaire et objet, et nous évoquerons aussi certains exemples en langage **OCaml**
+  à propos de la programmation fonctionnelle, modulaire et générique.

From 95231a42530d58928f0d32ba296b4a04270c0d0d Mon Sep 17 00:00:00 2001
From: gwen <gremond@cadoles.com>
Date: Fri, 7 Apr 2017 17:22:05 +0200
Subject: [PATCH 06/10] =?UTF-8?q?d=C3=A9finition=20des=20actions=20d'un=20?=
 =?UTF-8?q?programme?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 algorithmique/cours/fondement.txt  | 39 ++++++++++++++++++++
 algorithmique/cours/index.txt      |  1 -
 algorithmique/cours/machine.txt    | 27 --------------
 algorithmique/cours/modularite.txt |  2 +-
 algorithmique/cours/programme.txt  | 57 ++++++++++++++++++++++++++++++
 5 files changed, 97 insertions(+), 29 deletions(-)
 delete mode 100644 algorithmique/cours/machine.txt

diff --git a/algorithmique/cours/fondement.txt b/algorithmique/cours/fondement.txt
index e7ce4c1..15e6ce4 100644
--- a/algorithmique/cours/fondement.txt
+++ b/algorithmique/cours/fondement.txt
@@ -107,3 +107,42 @@ plus efficace.
   langages ne dépent plus de la machine, et ils implémentent des paradigmes de
   programmation indépendant de l'état de la mémoire de l'ordinateur,
   ils sont indépendant même du système d'exploitation.
+
+Qu'est-ce qu'une machine ?
+---------------------------
+
+Une machine, ce truc apparemment si complexe, est en fait
+un assemblage de bric et de brac.
+
+L'assemblage des connecteurs permet de simuler un additionneur,
+en prenant en compte les propriétés de **reste euclidien**
+de l'addition.
+
+La structure électronique est composée de :
+
+- un ordonnanceur.
+- le stockage d'un **état**.
+- une pile d'instruction
+
+.. glossary::
+
+    adressage
+
+        Dès lors qu'on dispose de ces bases électronique au dessus du processeur,
+        un langage d'assemblage est possible, c'est le langage de calcul sur les registres.
+
+    registre
+
+        machines ont un espace mémoire et un espace de calcul (registres)
+
+Un ordinateur, c'est très très stupide, mais ça permet de disposer de :
+
+- une mémoire très grande et ordonnée,
+- une capacité à effectuer inlassablement des tâches répétitives
+- une grande rapidité de calcul
+
+Apprendre à programmer, c'est-à-dire être capable de
+contrôler la machine.
+
+.. important:: Apprendre à programmer, c'est-à-dire apprendre à penser de manière structurée,
+               pour pouvoir accessoirement ensuite communiquer avec une machine.
diff --git a/algorithmique/cours/index.txt b/algorithmique/cours/index.txt
index 7c23c16..8fc94b1 100644
--- a/algorithmique/cours/index.txt
+++ b/algorithmique/cours/index.txt
@@ -11,5 +11,4 @@ Introduction à l'algorithmique
     algo
     programme
     control
-    machine
     annexes/index
diff --git a/algorithmique/cours/machine.txt b/algorithmique/cours/machine.txt
deleted file mode 100644
index b0e9c77..0000000
--- a/algorithmique/cours/machine.txt
+++ /dev/null
@@ -1,27 +0,0 @@
-Machine abstraite
------------------
-
-une machine, ce truc apparemment si complexe, est en fait 
-un assemblage de bric et de brac. 
-
-l'assemblage des connecteurs permet de simuler un additionneur, 
-en prenant en compte les propriétés de **reste euclidien**
-de l'addition. 
-
-la structure électronique est composée de :
-
-- un ordonnanceur. 
-- le stockage d'un **état**.
-- une pile d'instruction
-
-dès lors qu'on dispose de ces bases électronique au dessus du processeur,
-un langage d'assemblage est possible, c'est le langage de calcul sur les registres. 
-
-l'adressage mémoire
-
-
-registre
-
-    machines ont un espace mémoire et un espace de calcul (registres)
-     
-      
diff --git a/algorithmique/cours/modularite.txt b/algorithmique/cours/modularite.txt
index e1ca7b8..ccc8091 100644
--- a/algorithmique/cours/modularite.txt
+++ b/algorithmique/cours/modularite.txt
@@ -1,4 +1,4 @@
-L'organisation d'un programme
+Introduction à la modularité
 =============================
 
 
diff --git a/algorithmique/cours/programme.txt b/algorithmique/cours/programme.txt
index 52d57ff..c2789ca 100644
--- a/algorithmique/cours/programme.txt
+++ b/algorithmique/cours/programme.txt
@@ -7,6 +7,21 @@ 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) ;
 
+Exemple de déclarations :
+
+- `a = 1`
+- `b = 'c'`
+
+Exemple 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
+
+
 .. important:: Le signe égal est utilisé de deux manières
 
                - lors d'une déclaration d'une expression
@@ -15,6 +30,48 @@ Qu'est-ce qu'un programme ?
                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 ;
+2. on demande au compilateur de le traduire en code machine : c'est la compilation du programme ;
+3. on demande à la machine d'effectuer le code machine : c'est l'exécution du programme.
+
+.. important::
+
+    L'introduction à la compilation et les différentes phases de la compilation
+    d'un programme sont des sujets qui ne seront pas traités dans ce cours.
+
+Dans un programme de base, il y a deux fichiers :
+
+1. un fichier contenant le code : c'est le source du programme.
+2. un fichier contenant le code machine : c'est l'exécutable.
+
+Que peut faire un programme lorsqu'il est exécuté ?
+Le programme doit communiquer. S'il reste isolé, il ne pourra pas
+produire quoi que ce soit. Voici les trois moyens de communication qu'a un
+programme :
+
+1. communiquer avec l'utilisateur,
+2. communiquer avec des fichiers,
+3. communiquer avec d'autres programmes.
+
+La REPL
+--------
+
+.. glossary::
+
+    REPL
+
+      Read Eval Print Loop : outil principal de communication avec un programme
+      ou avec un système. Exemples : la console python, le prompt OCaml.
+
+    interface
+
+      outil de communication avec un programme.
+
+      - interface texte
+      - interface graphique
+
 Les déclarations
 ----------------
 

From 86dec2211336bc8a79ac15bdeb097646865918a4 Mon Sep 17 00:00:00 2001
From: gwen <gremond@cadoles.com>
Date: Mon, 10 Apr 2017 12:25:40 +0200
Subject: [PATCH 07/10] presentation du cours d'algo

---
 algorithmique/cours/annexes/agile.txt     |   4 +-
 algorithmique/cours/annexes/exercices.txt | 175 ++++++++++++++++++++++
 algorithmique/cours/annexes/index.txt     |   2 +-
 algorithmique/cours/presentation.txt      |  24 ++-
 algorithmique/cours/programme.txt         |  28 +++-
 5 files changed, 224 insertions(+), 9 deletions(-)
 create mode 100644 algorithmique/cours/annexes/exercices.txt

diff --git a/algorithmique/cours/annexes/agile.txt b/algorithmique/cours/annexes/agile.txt
index 43dd756..5884c11 100644
--- a/algorithmique/cours/annexes/agile.txt
+++ b/algorithmique/cours/annexes/agile.txt
@@ -1,5 +1,5 @@
-Les méthodes  agile
-===================
+La planification  agile
+========================
 
 Le mode itératif
 -----------------
diff --git a/algorithmique/cours/annexes/exercices.txt b/algorithmique/cours/annexes/exercices.txt
new file mode 100644
index 0000000..a5050a0
--- /dev/null
+++ b/algorithmique/cours/annexes/exercices.txt
@@ -0,0 +1,175 @@
+Première journée : Le langage Python
+-------------------------------------
+
++------------------------------------------------------+------------------------------------------------------------------------+
+| Contenus                                             | Précisions et commentaires                                             |
++======================================================+========================================================================+
+| Recherche dans une liste, recherche du maximum dans  |                                                                        |
+| une liste de nombres, calcul de la moyenne et de la  |                                                                        |
+| variance.                                            |                                                                        |
++------------------------------------------------------+------------------------------------------------------------------------+
+| Recherche d’un mot dans une chaîne de caractères.    | On se limite ici à l’algorithme "naïf", en estimant sa complexité.     |
++------------------------------------------------------+------------------------------------------------------------------------+
+
+
+Séance 1 : Un apercu des possibles utilisations de Python
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
++ Objectif de la formation
+
++ les outils de travail avec Python
+    + éditeur de texte + IPython (commandes intéractives + `%run`)
+    + environnement de développement intégré (ex. Spyder)
+    + Notebook IPython (proche de Maple/Mathematica)
+
+
+Séance 2 : Éléments de base du langage
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- structures de données
+    + (),[],{}
+    + listes en compréhension
+
+- éléments du langage
+        boucles, conditions, fonctions, itérateur, map , enumerate
+
+- Exemple en algorithmique de base
+
+::
+
+    In [1]: def tri1():
+
+    %timeit l1.sort()
+
+Séance 3 : Chaînes et fichiers
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    + traitement des chaines de caractères
+        + s.replace()
+        + s1 + s2
+    + un exemple de regexp simple
+    + type de fichiers
+        + mode d'accès
+    + 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.
+        Les types simples présentés sont les  entiers, flottants, booléens et chaînes de caractères.
+
+    + **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**:
+        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.
+
+    + **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** :
+      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**:
+        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.
+
+        On met en évidence le fait que certaines opérations d’apparence simple cachent
+        un important travail pour le processeur.  On met à profit la structure de
+        tableau d’entiers à deux dimensions pour introduire la notion d’image
+        ponctuelle (« bitmap »). Les algorithmes de traitement d’image seront abordés
+        plus tard.
+
+    + **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**
+        Algorithmes de manipulation : fonctions 'push' et 'pop'. On utilise des listes
+        (ou tableaux à 1 dimension) pour leur implantation.
+
+    + **Récursivité**
+
+        On en présente les avantages et les inconvénients.
+
+    + **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.
+
+        On étudie et on compare ces algorithmes de tri du point de vue des complexités temporelles dans le meilleur et dans le
+        pire cas.
diff --git a/algorithmique/cours/annexes/index.txt b/algorithmique/cours/annexes/index.txt
index 5101b23..566502a 100644
--- a/algorithmique/cours/annexes/index.txt
+++ b/algorithmique/cours/annexes/index.txt
@@ -4,6 +4,6 @@ Annexes
 .. toctree::
     :maxdepth: 2
 
+    exercices
     agile
     scrum
-
diff --git a/algorithmique/cours/presentation.txt b/algorithmique/cours/presentation.txt
index ce046cb..ab7873b 100644
--- a/algorithmique/cours/presentation.txt
+++ b/algorithmique/cours/presentation.txt
@@ -1,7 +1,8 @@
 Avant propos
--------------
+============
 
-**Présentation de ce cours**
+Introduction
+~~~~~~~~~~~~
 
 - L'accent est mis sur l'approche **algorithmique scientifique**, dite algorithmique
   algébrique. L'algorithmique est un sous-domaine de l'algèbre et des
@@ -30,3 +31,22 @@ Avant propos
   limiterons l'exposé à deux langages d'implémentation des algorithmes : le **Python** pour la programmation
   impérative, modulaire et objet, et nous évoquerons aussi certains exemples en langage **OCaml**
   à propos de la programmation fonctionnelle, modulaire et générique.
+
+Objectifs de ce cours
+~~~~~~~~~~~~~~~~~~~~~
+
+Il s'agit de :
+
+- maîtriser  et concevoir un algorithmes de base,
+- choisir une représentations appropriée des données,
+- décomposer en sous-problèmes et affinements successifs,
+- organiser les modules ou fonctions.
+
+Le développement raisonné d’algorithmes et leur implantation
+permet d'acquérir les qualités suivantes :
+
++   Analyser et modéliser un problème,
++   Spécifier,
++   Exprimer, une problématique, une solution ou un algorithme,
++   Traduire un algorithme dans un langage de programmation,
++   Concevoir un algorithme répondant à un problème précisément posé.
diff --git a/algorithmique/cours/programme.txt b/algorithmique/cours/programme.txt
index c2789ca..ca3d11a 100644
--- a/algorithmique/cours/programme.txt
+++ b/algorithmique/cours/programme.txt
@@ -7,12 +7,17 @@ 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) ;
 
-Exemple de déclarations :
 
-- `a = 1`
-- `b = 'c'`
+expression
 
-Exemple d'expressions :
+    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
@@ -21,6 +26,10 @@ Exemple d'expressions :
 - 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
 
@@ -55,6 +64,17 @@ programme :
 2. communiquer avec des fichiers,
 3. communiquer avec d'autres programmes.
 
+Interaction avec l'utilisateur
+------------------------------
+
+.. FIXME
+
+- lire et écrire dans un fichier
+- afficher du texte ou un nombre
+- lire du texte ou un nombre
+- les prompts
+
+
 La REPL
 --------
 

From 44c153b95c7e9f59129c47a09b30566c49665586 Mon Sep 17 00:00:00 2001
From: gwen <gremond@cadoles.com>
Date: Mon, 10 Apr 2017 12:36:16 +0200
Subject: [PATCH 08/10] reorganisation (ordonnancement) du cours

---
 algorithmique/cours/algo.txt       | 8 ++------
 algorithmique/cours/index.txt      | 2 +-
 algorithmique/cours/langage.txt    | 2 +-
 algorithmique/cours/modularite.txt | 7 ++-----
 algorithmique/cours/programme.txt  | 2 --
 5 files changed, 6 insertions(+), 15 deletions(-)

diff --git a/algorithmique/cours/algo.txt b/algorithmique/cours/algo.txt
index 2624431..c34c830 100644
--- a/algorithmique/cours/algo.txt
+++ b/algorithmique/cours/algo.txt
@@ -157,8 +157,6 @@ Implémentation en OCaml :
 .. literalinclude:: code/factorielle.ml
     :language: ocaml
 
-
-
 Qualité d'un algorithme
 -----------------------
 
@@ -283,7 +281,5 @@ C'est utile pour pouvoir comparer des algorithmes.
 
 complexité
 
-	estimer la complexité d'unalgorithme,
-    c'est-à-dire estimer le nombre de calculs qu'il utilise.
-
-analyse de complexité
+	estimer la complexité d'un algorithme,
+  c'est-à-dire estimer le nombre de calculs qu'il utilise.
diff --git a/algorithmique/cours/index.txt b/algorithmique/cours/index.txt
index 8fc94b1..00ce3dc 100644
--- a/algorithmique/cours/index.txt
+++ b/algorithmique/cours/index.txt
@@ -7,8 +7,8 @@ Introduction à l'algorithmique
     presentation
     fondement
     langage
-    modularite
     algo
     programme
     control
+    modularite
     annexes/index
diff --git a/algorithmique/cours/langage.txt b/algorithmique/cours/langage.txt
index 4aac45f..0302694 100644
--- a/algorithmique/cours/langage.txt
+++ b/algorithmique/cours/langage.txt
@@ -5,7 +5,7 @@ langage
 
     Un langage de
     programmation
-    doit permettre d' écrire des
+    doit permettre d'écrire des
     programmes de bonne qualité
 
 Un programme doit être :
diff --git a/algorithmique/cours/modularite.txt b/algorithmique/cours/modularite.txt
index ccc8091..13920c0 100644
--- a/algorithmique/cours/modularite.txt
+++ b/algorithmique/cours/modularite.txt
@@ -167,8 +167,5 @@ module
 
 interface
 
-    mode d’emploi du module
-
-Les interfaces
-
-- principe de masquage des informations (partie publique, partie secrète)
+    mode d’emploi du module, avec en plus un principe de masquage
+    des informations (partie publique, partie secrète)
diff --git a/algorithmique/cours/programme.txt b/algorithmique/cours/programme.txt
index ca3d11a..6507b40 100644
--- a/algorithmique/cours/programme.txt
+++ b/algorithmique/cours/programme.txt
@@ -7,7 +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
@@ -261,7 +260,6 @@ En programmation impérative, un programme est une suite d’instructions qui fo
    \end{algorithmic}
    \end{algorithm}
 
-
 effet de bord
 
     toute modification de la mémoire ou modification d'un support externe

From 9fb80c6b48e5c35b8fef690d07780033a422f724 Mon Sep 17 00:00:00 2001
From: gwen <gremond@cadoles.com>
Date: Mon, 10 Apr 2017 17:47:40 +0200
Subject: [PATCH 09/10] reorganisation du cours

---
 algorithmique/cours/algo.txt              |  43 +++---
 algorithmique/cours/annexes/exercices.txt | 133 ++++++------------
 algorithmique/cours/control.txt           |   7 +-
 algorithmique/cours/programme.txt         | 160 +++++++++++-----------
 4 files changed, 146 insertions(+), 197 deletions(-)

diff --git a/algorithmique/cours/algo.txt b/algorithmique/cours/algo.txt
index c34c830..f561d77 100644
--- a/algorithmique/cours/algo.txt
+++ b/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}
 
-
-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 :
+et son 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
 -----------------------
 
diff --git a/algorithmique/cours/annexes/exercices.txt b/algorithmique/cours/annexes/exercices.txt
index a5050a0..af41f52 100644
--- a/algorithmique/cours/annexes/exercices.txt
+++ b/algorithmique/cours/annexes/exercices.txt
@@ -53,123 +53,70 @@ 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.
-        Les types simples présentés sont les  entiers, flottants, booléens et chaînes de caractères.
++ **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** :
-        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.
++ **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**:
-        expressions booléennes et opérateurs logiques simples, structurer et comprendre plusieurs
-        instruction if. Variantes avec alternative (else).
++ **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** :
-        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.
++ **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** :
-      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.
++ **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.
+  La récursivité sera présentée plus tard.
 
-    + **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.
++ **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.
 
-        On met en évidence le fait que certaines opérations d’apparence simple cachent
-        un important travail pour le processeur.  On met à profit la structure de
-        tableau d’entiers à deux dimensions pour introduire la notion d’image
-        ponctuelle (« bitmap »). Les algorithmes de traitement d’image seront abordés
-        plus tard.
+    On met en évidence le fait que certaines opérations d’apparence simple cachent
+    un important travail pour le processeur.  On met à profit la structure de
+    tableau d’entiers à deux dimensions pour introduire la notion d’image
+    ponctuelle (« bitmap »). Les algorithmes de traitement d’image seront abordés
+    plus tard.
 
-    + **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.
++ **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.
+    On encourage l’utilisation de fichiers en tant que supports de données ou de résultats avant divers traitements, par exemple graphiques.
 
 
-    + **Piles**
-        Algorithmes de manipulation : fonctions 'push' et 'pop'. On utilise des listes
-        (ou tableaux à 1 dimension) pour leur implantation.
++ **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.
+    On en présente les avantages et les inconvénients.
 
-    + **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.
++ **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.
 
-        On étudie et on compare ces algorithmes de tri du point de vue des complexités temporelles dans le meilleur et dans le
-        pire cas.
+    On étudie et on compare ces algorithmes de tri du point de vue des complexités temporelles dans le meilleur et dans le
+    pire cas.
diff --git a/algorithmique/cours/control.txt b/algorithmique/cours/control.txt
index c7031f9..76f6558 100644
--- a/algorithmique/cours/control.txt
+++ b/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 Begin
+    \BState \emph{entrée}: $quality\gets 0$ \Comment{C'est cette valeur qui sera testée}
+    \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}
 
diff --git a/algorithmique/cours/programme.txt b/algorithmique/cours/programme.txt
index 6507b40..5326280 100644
--- a/algorithmique/cours/programme.txt
+++ b/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
-- afficher du texte ou un nombre
-- lire du texte ou un nombre
-- les prompts
+    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::
 
-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
-      ou avec un système. Exemples : la console python, le prompt OCaml.
+Un autre exemple d'expression :
 
-    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
-      - interface graphique
+On voit qu'une expression peut-être complexe, dans tous les cas une valeur
+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}
-    \caption{Exemple d'expression}
-    \begin{algorithmic}[1]
-    \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}
+- lire et écrire sur l'entrée/sortie standard
+- lire et écrire dans un fichier
+- afficher du texte ou un nombre
+- lire du texte ou un nombre
+- manipuler les prompts
+
+La REPL
+--------
+
+.. glossary::
+
+    REPL
+
+      Read Eval Print Loop : outil principal de communication avec un programme
+      ou avec un système. Exemples : la console python, le prompt OCaml.
+
+    interface
+
+      outil de communication avec un programme.
+
+      - interface texte
+      - interface graphique
 
-.. FIXME mieux définir une expression
 
-Une expression est une portion de code qui renvoie une valeur
 
 Les fonctions
 -------------

From 26c756a914665056cb248e7e04959b3fe01bf9fa Mon Sep 17 00:00:00 2001
From: gwen <gremond@cadoles.com>
Date: Tue, 11 Apr 2017 11:18:17 +0200
Subject: [PATCH 10/10] reorganisation du cours

---
 algorithmique/cours/control.txt   |   4 +-
 algorithmique/cours/index.txt     |   1 +
 algorithmique/cours/programme.txt | 177 +++++-------------------------
 3 files changed, 30 insertions(+), 152 deletions(-)

diff --git a/algorithmique/cours/control.txt b/algorithmique/cours/control.txt
index 76f6558..0208fc3 100644
--- a/algorithmique/cours/control.txt
+++ b/algorithmique/cours/control.txt
@@ -1,5 +1,5 @@
-Structures de contrôle
-======================
+Les tructures de contrôle
+==========================
 
 L'instruction de saut conditionnel
 ----------------------------------
diff --git a/algorithmique/cours/index.txt b/algorithmique/cours/index.txt
index 00ce3dc..a4cdce6 100644
--- a/algorithmique/cours/index.txt
+++ b/algorithmique/cours/index.txt
@@ -9,6 +9,7 @@ Introduction à l'algorithmique
     langage
     algo
     programme
+    fonctions
     control
     modularite
     annexes/index
diff --git a/algorithmique/cours/programme.txt b/algorithmique/cours/programme.txt
index 5326280..2fad8ef 100644
--- a/algorithmique/cours/programme.txt
+++ b/algorithmique/cours/programme.txt
@@ -2,7 +2,7 @@ Définition d'un programme
 ==========================
 
 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) ;
@@ -33,12 +33,13 @@ programme :
 3. communiquer avec d'autres programmes.
 
 Les expressions
-~~~~~~~~~~~~~~~
+----------------
 
 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...)
+    qui retourne une valeur (entier, texte, valeur logique...).
+    C'est donc une suite sémantiquement correcte de **valeurs de base** et **d'opérateurs**
 
 Par exemple, la ligne suivante est une expression effectuant une addition::
 
@@ -86,7 +87,7 @@ On voit qu'une expression peut-être complexe, dans tous les cas une valeur
 est renvoyée.
 
 Les déclarations
-~~~~~~~~~~~~~~~~
+-----------------
 
 Exemple de déclarations :
 
@@ -103,7 +104,6 @@ Exemple de déclarations :
 
 Il s'agit de **renseigner** une valeur dans une expression nommée
 
-
 - en javascript :
 
 .. code-block:: javascript
@@ -217,156 +217,33 @@ La REPL
       - interface texte
       - interface graphique
 
+**Exemples de REPL**
 
+Le prompt python::
 
-Les fonctions
--------------
+      Python 2.7.12 (default, Nov 19 2016, 06:48:10)
+      [GCC 5.4.0 20160609] on linux2
+      Type "help", "copyright", "credits" or "license" for more information.
+      >>>
+      >>> dir()
+      ['__builtins__', '__doc__', '__name__', readline', 'rlcompleter']
+      >>>
+Le prompt ipython::
 
-Préliminaire : rappel de théorie de l'information
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Python 2.7.12 (default, Nov 19 2016, 06:48:10)
+    Type "copyright", "credits" or "license" for more information.
 
-Théorie de l'information (Claude Shannon, 1949), (ou théorie de la communication)
+    IPython 2.4.1 -- An enhanced Interactive Python.
+    ?         -> Introduction and overview of IPython's features.
+    %quickref -> Quick reference.
+    help      -> Python's own help system.
+    object?   -> Details about 'object', use 'object??' for extra details.
 
-Canal de transmission::
+    In [1]:
 
-    entrée -> récepteur -> émetteur -> sortie
+Le prompt OCaml (utop)::
 
-Description d'une procédure
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        Type #utop_help for help about using utop.
 
-En programmation impérative, un programme est une suite d’instructions qui font
-évoluer l’état mémoire, le résultat est dans l’état final de la mémoire.
-
-- une procédure peut prendre des paramètres
-- elle modifie l'état courant du système
-
-- Déclaration des paramètes
-- Déclaration du corps
-- Appel de la procédure
-
-.. raw:: latex
-
-   \begin{algorithm}
-   \caption{Procédure de permutation de deux entiers}\label{permutation}
-   \begin{algorithmic}[1]
-   \Procedure{permuter}{$a,b$}{}
-   \BState \emph{parametres}:
-   \State $a: \textit{int}$
-   \State $b: \textit{int}$
-   \BState \emph{locales}:
-   \State $z: \textit{int}$ \Comment{Une variable intermédiaire est nécessaire}
-   \BState \emph{corps}:
-   \State $z \gets a$
-   \State $a \gets b$
-   \State $b \gets z$
-   \EndProcedure
-   \State \Call{permuter}{10, 12} \Comment{appel de la procédure}
-   \end{algorithmic}
-   \end{algorithm}
-
-effet de bord
-
-    toute modification de la mémoire ou modification d'un support externe
-
-instruction
-
-  commande ou phrase en mesure de modifier l'état du programme ou de la machine hôte
-	(allocation mémoire, support externe, disque, écran...)
-
-Une procédure ne renvoie pas de valeur, mais provoque un 'effet de bord' (écriture dans une globale, dans un flux sortant etc.).
-
-Une procédure permet de créer une instruction nouvelle qui deviendra une primitive pour le programmeur.
-Cela permet de structurer le texte source du programme et améliorer sa
-lisibilité. Cela permet aussi d'appeler plusieurs fois, et à plusieurs endroit
-dans le code, cette primitive.
-
-Appel d'une procédure
-~~~~~~~~~~~~~~~~~~~~~
-
-(ex: pseudo-pascal)
-
-**déclaration de procédure**
-
-.. raw:: latex
-
-   \begin{algorithm}
-   \caption{Procédure de permutation de deux entiers}\label{permutation}
-   \begin{algorithmic}[1]
-   \Procedure{permuter}{$a,b$}{}
-   \BState \emph{parametres}:
-   \State $a: \textit{int}$ \Comment{paramètres formels de la procédure}
-   \State $b: \textit{int}$
-   \BState \emph{locales}:
-   \State $z: \textit{int}$ \Comment{les variables locales de la procédure}
-   \BState \emph{corps}:
-   \State ... \Comment{Le corps de la procedure}
-   \EndProcedure
-   \State \Call{permuter}{10, 12} \Comment{l'appel de la procédure}
-   \end{algorithmic}
-   \end{algorithm}
-
-
-- les variables x1,...,xn sont appelées *paramètres formels* de p
-- les variables v1,...,vm sont appelées *les variables locales* de p
-
-les valeurs effectivement passées en paramètres, ici `10, 12`
-sont appelées **paramètres effectifs** de p
-
-signature
-
-    C'est l'ensemble paramètre formel + resultat de l'appel
-
-fermeture
-
-    L'ensemble procédure + variables locales + signature + parametres effectifs
-    est appelé une **fermeture**. C'est la procédure + son contexte qui permet
-    de l'instancier dans un programme.
-
-niveau
-
-    Le niveau d’une déclaration (de variable ou de procédure) est le nombre
-    de procédures sous lesquelles elle est déclarée. Le programme principal
-    a le niveau 0.
-
-Description d'une fonction
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Une fonction renvoie une valeur et ne modifie pas l'état courant du programme
-en cours d'exécution ni ne réalise d'effets de bord. Elle renvoie
-**toujours** quelque chose (même la valeur ``None`` qui n'est pas rien)
-
-- une procédure peut prendre des paramètres
-- elle modifie l'état courant du système
-
-- Déclaration des paramètes
-- Déclaration du corps
-- Appel de la fonction
-
-En programmation fonctionnelle, programme est un ensemble de définitions de fonctions,
-un résultat est l'application d’une fonction à une structure de données effective.
-
-- composant de base : la fonction
-- opération de base : l’application
-
-.. raw:: latex
-
-   \begin{algorithm}
-   \caption{Exemple de fonction}\label{fonction}
-   \begin{algorithmic}[1]
-   \Function{permuter}{$a,b$}{} \Comment{définition de la fonction}
-   \BState \emph{parametres}: \Comment{déclaration (noms, types) des paramètres formels}
-   \State $a: \textit{int}$
-   \State $b: \textit{int}$
-   \BState \emph{locales}: \Comment{déclaration (noms, types) des valeurs locales}
-   \State $z: \textit{int}$
-   \BState \emph{corps}:
-   \State $z \gets a$
-   \State $a \gets b$
-   \State $b \gets z$
-   \BState \emph{return}: \Comment{La valeur, le résulat renvoyé par la fonction}
-   \EndFunction
-   \State \Call{permuter}{10, 12} \Comment{appel de la fonction}
-   \BState \emph{result}:
-   \State (12, 10) \Comment{Le résultat effectif de la fonction après appel}
-   \end{algorithmic}
-   \end{algorithm}
+        ─( 09:21:24 )─< command 0 >──
+        utop #