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

Production d'un programme :

1. on écrit le code source du programme ;
2. on demande au compilateur de le traduire en code machine : c'est la compilation du programme ;
3. on demande à la machine d'effectuer le code machine : c'est l'exécution du programme.

.. important::

    L'introduction à la compilation et les différentes phases de la compilation
    d'un programme sont des sujets qui ne seront pas traités dans ce cours.

Dans un programme de base, il y a deux fichiers :

1. un fichier contenant le code : c'est le source du programme.
2. un fichier contenant le code machine : c'est l'exécutable.

Que peut faire un programme lorsqu'il est exécuté ?
Le programme doit communiquer. S'il reste isolé, il ne pourra pas
produire quoi que ce soit. Voici les trois moyens de communication qu'a un
programme :

1. communiquer avec l'utilisateur,
2. communiquer avec des fichiers,
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 (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::

    5 + 6

Expressions à partir de types de base
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Autres exemples d'expressions :

- 5 est une expression de type int
- 4.5 est une expression de type float
- 'c' est une expression de type char
- true est une expression de type bool
- print ('c') est une expression de type None
- raw_input est une expression de type string

Expressions à partir de types produits
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Les types construits permettent de structurer l’information.

- les produits (n-uplets)

.. code-block:: ocaml

    # type complexe = float * float ;;

- les produits nommés (enregistrements)

.. code-block:: ocaml

    # type adresse = { rue : string ; ville : string ; cp : int};;
    # type fiche = {
    nom : string ;
    prenom : string ;
    adresse : adresse ;
    date naissance : int * int * int ;
    tel fixe : string ;
    portable : string
    };;
    # let v1 = { a = 1 ; b = false ; c = 'r'};;

-  les sommes (constructeurs)

.. code-block:: ocaml

    # type couleur = Pique | Coeur | Carreau | Trefle;;
    # let v = (Pique , Coeur);;
    val v : couleur * couleur = (Pique , Coeur)

.. code-block:: ocaml

    type nombre =
    Ent of int | Reel of float | Cplx of float × float
    Ent, Reel, Cplx sont les constructeurs du type.

On voit qu'une expression peut-être complexe, mais dans tous les cas une valeur
est renvoyée.

- les types séquences (listes)

.. code-block:: ocaml

    # 4::1::5::8::1::[];;
    - : int list = [4 ;1 ;5 ;8 ;1]

Algorithme de la longeur d'une liste
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

.. code-block:: ocaml

    # let rec longueur l =
    match l with
    [] -> 0
    | ::s -> 1 + (longueur s);;

Cette fonction est prédéfinie en Ocaml : `List.length`


Algorithmes de tri
~~~~~~~~~~~~~~~~~~~

On désigne par "tri" l'opération consistant à ordonner un ensemble d'éléments en fonction de clés sur lesquelles est définie une relation d'ordre.

Les algorithmes de tri ont une grande importance pratique.
Ils sont fondamentaux dans certains domaines (exemples : map-reduce en database non relationnelle).

L'étude du tri est également intéressante en elle-même, c'est un des domaines de l'algorithmique très étudié et connu.

Algorithme de tri par insertion
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Cet algorithme de tri suit de manière naturelle la structure récursive des
listes. Soit l une liste à trier :
- si l est vide alors elle est déjà triée
- sinon, l est de la forme x::s et on trie récursivement la suite s et on obtient une liste triée s’
  on insert x au bon endroit dans s’ et on obtient une liste triée

Description de l'algorithme

- la fonction inserer permet d’insérer un élément x dans une liste l
- si la liste l est triée alors x est inséré au bon endroit

.. code-block:: ocaml

    # let rec inserer x l =
    match l with
    [] -> [x]
    | y::s -> if x<=y then x::l else y::(inserer x s);;
    val inserer : ’a -> ’a list -> ’a list
    # inserer 5 [3 ;7 ;10];;
    - : int list = [3 ; 5 ; 7 ; 10]

Algorithme de tri rapide
~~~~~~~~~~~~~~~~~~~~~~~~

soit une liste l à trier :

- si l est vide alors elle est triée
- sinon, choisir un élément p de la liste (le premier par exemple)
  nommé le **pivot**
- partager l en deux listes g et d contenant les autres éléments de l
  qui sont plus petits (resp. plus grands) que la valeur du pivot p
- trier récursivement g et d, on obtient deux listes g’ et d’ triées

.. code-block:: ocaml
    :caption: fonction de partage d'une liste

    #let rec partage p l =
    match l with
    [] -> ([] , [])
    |x::s -> let g,d = partage p s in
    if x<=p then (x::g , d) else (g , x::d) ;;
    val partage : ’a -> ’a list -> ’a list * ’a list = <fun>
    # partage 5 [1 ;9 ;7 ;3 ;2 ;4];;
    - : int list * int list = ([1 ; 3 ; 2 ; 4], [9 ; 7])

.. code-block:: ocaml
    :caption: algorithme de tri rapide

    # let rec tri rapide l =
    match l with
    [] -> []
    | p::s -> let g , d = partage p s in
    (tri rapide g)@[p]@(tri rapide d) ;;
    val tri rapide : ’a list -> ’a list = <fun>
    # tri rapide [5 ; 1 ; 9 ; 7 ; 3 ; 2 ; 4];;
    - : int list = [1 ; 2 ; 3 ; 4 ; 5 ; 7 ; 9]


Les listes chaînées
~~~~~~~~~~~~~~~~~~~~

.. code-block:: ocaml

    typedef struct list{
    int elt ;
    struct list* suivant ;
    } ;

Les déclarations
-----------------

Un autre exemple d'expression :

.. raw:: latex

    \begin{algorithm}
    \caption{Exemple d'expression}
    \begin{algorithmic}[1]
    \BState \emph{sortie}: $l$ \Comment{C'est l'expression calculée renvoyée}
    \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}

Exemple de déclarations :

- `a = 1`
- `b = 'c'`

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

Il s'agit de **renseigner** une valeur dans une expression nommée

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

- Les déclarations de types primitifs et conversions de type
- Les 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;

Interaction avec l'utilisateur
------------------------------

Il est possible de communiquer de la manière suivante avec un programme :

- lire et écrire sur l'entrée/sortie standard
- lire et écrire dans un fichier
- afficher du texte ou un nombre
- lire du texte ou un nombre
- manipuler les prompts

La REPL (boucle d'interaction)
-------------------------------

.. glossary::

    REPL

      Read Eval Print Loop : outil principal de communication avec un programme
      ou avec un système. Exemples : la console python, le prompt OCaml.

    interface

      outil de communication avec un programme.

      - interface texte
      - interface graphique

**Exemples de REPL**

Le prompt python::

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

    Python 2.7.12 (default, Nov 19 2016, 06:48:10)
    Type "copyright", "credits" or "license" for more information.

    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.

    In [1]:

Le prompt OCaml (utop)::

        Type #utop_help for help about using utop.

        ─( 09:21:24 )─< command 0 >──
        utop #
        # let x = 1 in x + 2;;
        - : int = 3
        # let y = 1 + 2;;
        val y : int = 3
        # y * y;;
        - : int = 9