définition d'une fonction

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

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}