reorganisation du cours

algorithmique/cours/control.txt

@@ -1,5 +1,5 @@
-Structures de contrôle
+Les tructures de contrôle
-======================
+==========================
 
 L'instruction de saut conditionnel
 ----------------------------------

algorithmique/cours/index.txt

@@ -9,6 +9,7 @@ Introduction à l'algorithmique
     langage
     algo
     programme
+    fonctions
     control
     modularite
     annexes/index

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
+        ─( 09:21:24 )─< command 0 >──
-évoluer l’état mémoire, le résultat est dans l’état final de la mémoire.
+        utop #
-
-- 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}