ajout des principales structures de contrôles

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

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
+.. raw:: latex
-  une marque posée qu'il est possible de retrouver dans le programme.
-- **Ligne 11**, l'instruction `goto` (aller à ) est un saut.
 
-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}

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
+- Un programme est une suite de phrases ;
-- Une phrase est une **déclaration** ou une **expression**.
+- 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
+Théorie de l'information (Claude Shannon, 1949), (ou théorie de la communication)
-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);
+    >>> procedure p(x1, ..., xn); 
-        var v1,...,vm;
+
+    >>>    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

algorithmique/index.txt

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