formations/algorithmique/cours/programme.txt

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

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

Renseigner une variable


- en javascript :

.. code-block:: javascript

    var b = "blabla" ;

- en python :

.. code-block:: python

    b = "blabla"

- en java :

.. code-block:: java

    String b = "A";

- en OCaml :

.. code-block:: ocaml

    let a = 1

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

    Par voie de conséquence, le symbole ``=`` est utilisé à la fois pour la définition des objets et pour le test d'égalité.
    Pour les autres langages, on utilise `==` ou bien `===` (javascript) car
    le `=` est sémantiquement déjà utilisé...

Toutes ces notation, apparemment anodines, correspondent donc à des paradigmes de programmation

Lorsqu'on ne déclare pas les types des symboles déclarés, c'est que soit

- le typage est faible
- le typage est dynamique (calcul du type en fonction du contenu de la
  variable)
- le typage est statique et fort mais ça ne se voit pas
  (var le système les calcule automatiquement par inférence de type)

Assigner, allouer, affecter une chose à quelqu'un ou à une autre chose.

Exemples dans la langue française :

- Le traitement que le budget **alloue** à ces fonctionnaires.
- Un système d'exploitation multitâche alloue le travail du processeur aux processus en attente, pour un bref laps de temps, à leur tour.

.. glossary::

    affectation

        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`.
        Dans certains langages, le symbole est considéré comme un opérateur d'affectation,
        et la structure entière peut alors être utilisée comme une expression.
        D'autres langages considèrent une affectation comme une instruction et ne permettent pas cet usage.

Voir aussi :

- Déclarations de types primitifs et conversions de type
- Types de base::

        Octets (8 bits) byte
        Entiers courts (16 bits) short
        Entiers (32 bits) int
        Entiers longs (64 bits) long
        Réels (32 bits) float
        Réels longs (64 bits) double
        Caractères (16 bits) char
        Booléens boolean

- Déclarations par lots::

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

Préliminaire : rappel de théorie de l'information
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Théorie de l'information (Claude Shannon, 1949), (ou théorie de la communication)

Canal de transmission::

    entrée -> récepteur -> émetteur -> sortie

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

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