définition d'une fonction

This commit is contained in:
gwen 2017-04-06 10:36:31 +02:00
parent 6ccddf4cc5
commit 6de57bca95
2 changed files with 111 additions and 20 deletions

View File

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

View File

@ -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 dune 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 dune 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}