algo programmation structurée

This commit is contained in:
gwen 2017-04-30 08:44:43 +02:00 committed by Benjamin Bohard
parent 428dc25db2
commit 11c43df090
4 changed files with 232 additions and 50 deletions

View File

@ -1,4 +1,4 @@
Introduction à la modularité
La programmation structurée
=============================
Un langage de programmation doit permettre la programmation structurée.
@ -21,54 +21,8 @@ Si on ne prend pas garde au bon découpage des programmes en modules indépendan
on se retrouve rapidement débordé par un grand nombre de variables,
et il devient quasiment impossible de réaliser un programme correct.
La modularité
~~~~~~~~~~~~~
Les données et les traitements sont regroupés au sein d'une même entité à deux
facettes : d'un côté le code proprement dit, de l'autre son interface. La
communication entre modules s'effectue via leur interface. La description d'un
type peut être masquée en n'apparaissant pas dans l'interface du module. Ces
types de données abstraits facilitent les modifications d'implantation à
l'intérieur d'un module sans affecter les autres modules qui s'en servent. De
plus, les modules peuvent être paramétrés par d'autres modules augmentant
ainsi leur réutilisabilité.
Le paradigme objet
~~~~~~~~~~~~~~~~~~
Les descriptions des traitements et des données sont regroupées dans des
entités appelées **classes**; un objet est une instance (valeur) d'une classe.
La communication entre objets est réalisée par envoi de message, l'objet
receveur détermine à l'exécution (liaison retardée) le traitement
correspondant au message. En cela, la programmation objet est dirigée par
les données. La structuration d'un programme provient des relations entre
classes, en particulier l'héritage permet de définir une classe par extension
d'une autre.
En programmation objet, un **programme** est une collection dobjets qui communiquent
entre eux par **message**, le **résultat** est un message envoyé à un objet particulier
Comparaison entre les deux paradigmes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Il y a dualité entre ces deux modèles.
- On ne peut pas augmenter les composants d'un type dans un module (pas
d'extensibilité des données), mais on peut ajouter de nouveaux traitements
(extensibilité des traitements) sur ces données.
- En objet, on peut ajouter des sous-classes à une classe (extensibilité des
données) pour traiter des nouveaux cas, mais on ne peut pas ajouter de nouveaux
traitements visibles de la classe ancêtre (pas d'extensibilité des traitements).
**La combinaison des deux paradigmes offre de nouvelles extensibilités pour les
traitements et les données.**
Sûreté d'exécution
--------------------
La programmation raisonnée
~~~~~~~~~~~~~~~~~~~~~~~~~~
---------------------------
Un **programme** est le codage d'un algorithme dans un langage de programmation.
La programmation consiste à modéliser un problème du monde réel sous une forme
@ -198,3 +152,49 @@ et l'implémentation effective de l'algorithme
config_save_values(c, MODNAME)
return True
return False
Les deux grands paradigmes
---------------------------
La modularité
~~~~~~~~~~~~~~
Les données et les traitements sont regroupés au sein d'une même entité à deux
facettes : d'un côté le code proprement dit, de l'autre son interface. La
communication entre modules s'effectue via leur interface. La description d'un
type peut être masquée en n'apparaissant pas dans l'interface du module. Ces
types de données abstraits facilitent les modifications d'implantation à
l'intérieur d'un module sans affecter les autres modules qui s'en servent. De
plus, les modules peuvent être paramétrés par d'autres modules augmentant
ainsi leur réutilisabilité.
Le paradigme objet
~~~~~~~~~~~~~~~~~~
Les descriptions des traitements et des données sont regroupées dans des
entités appelées **classes**; un objet est une instance (valeur) d'une classe.
La communication entre objets est réalisée par envoi de message, l'objet
receveur détermine à l'exécution (liaison retardée) le traitement
correspondant au message. En cela, la programmation objet est dirigée par
les données. La structuration d'un programme provient des relations entre
classes, en particulier l'héritage permet de définir une classe par extension
d'une autre.
En programmation objet, un **programme** est une collection dobjets qui communiquent
entre eux par **message**, le **résultat** est un message envoyé à un objet particulier
Comparaison entre les deux paradigmes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Il y a dualité entre ces deux modèles.
- On ne peut pas augmenter les composants d'un type dans un module (pas
d'extensibilité des données), mais on peut ajouter de nouveaux traitements
(extensibilité des traitements) sur ces données.
- En objet, on peut ajouter des sous-classes à une classe (extensibilité des
données) pour traiter des nouveaux cas, mais on ne peut pas ajouter de nouveaux
traitements visibles de la classe ancêtre (pas d'extensibilité des traitements).
**La combinaison des deux paradigmes offre de nouvelles extensibilités pour les
traitements et les données.**

View File

@ -1,5 +1,5 @@
Les modules
============
La programmation modulaire
===========================
Il s'agit de décomposer un grand programme en
morceaux (**modules**) connectés entre eux par des **interfaces** bien
@ -240,3 +240,72 @@ obtenir un nouveau module :
.. code-block:: ocaml
module M = F (Titi) (Toto)
Signatures, type abstrait et langage de modules
=================================================
Contrainte de type par signature
------------------------------------
::
module M =
struct
type t = int * int * int ;;
let make d m y = d, m, y ;;
end ;;
let d = M.make 8 5 8 ;;
module type S =
sig
type t ;;
val make : int -> int -> int -> t ;;
end ;;
module MS = (M:S) ;;
MS.make 5 1 2 ;;
Type et signature
------------------
::
# module type A = sig
val a: int -> int
end ;;
module type A = sig val a : int -> int end
# module B = struct
let a x = x + 1 ;;
end;;
module B : sig val a : int -> int end
# module C = (B:A) ;;
module C : A
# C.a 2 ;;
- : int = 3
#
Module auquel on impose une signature
-----------------------------------------
::
module type DATE = sig
type t
val make: int -> t
val get_year: t -> int
val get_month: t -> int
end ;;
module MR = struct
type t = int * int
let make x y = (x, y)
let get_month (x, y) = x
let get_year (x, y) = y
end ;;
module date = (MR:DATE) ;;

View File

@ -352,6 +352,17 @@ Il est possible de communiquer de la manière suivante avec un programme :
- lire (du texte, un nombre...)
- interagir avec les prompts
.. code-block:: ocaml
let x = read_int () in
let signe =
if x >= 0
then " positif "
else " négatif " in
print_string signe
.. ifconfig:: exercice
**Exercice** : écrire un algorithme qui demande le prénom d'une personne

102
algorithmique/markup.txt Normal file
View File

@ -0,0 +1,102 @@
markup
========
exercices
---------
.. ifconfig:: exercice
**Exercice** :
.. ifconfig:: correction
**Correction** :
sphinx
-----------
.. function:: spam(eggs)
ham(eggs)
Spam or ham the foo.
The function :func:`spam` does a similar thing
http://www.sphinx-doc.org/en/stable/markup/code.html
http://www.sphinx-doc.org/en/stable/domains.html
latex
--------------
s'il faut mettre du latex :
https://www.jujens.eu/posts/2014/Aug/13/rapport-rst-sphinx/
(pour le preamble)
.. role:: latex(raw)
:format: latex
----
sudo apt-get install texlive-full
You need to remove
\usepackage{algorithmicx}
and use the following in your preamble:
\usepackage{algorithm}% http://ctan.org/pkg/algorithms
\usepackage{algpseudocode}% http://ctan.org/pkg/algorithmicx
.. raw:: latex
\begin{algorithm}
\caption{My algorithm}\label{euclid}
\begin{algorithmic}[1]
\Procedure{MyProcedure}{}
\State $\textit{stringlen} \gets \text{length of }\textit{string}$
\State $i \gets \textit{patlen}$
\BState \emph{top}:
\If {$i > \textit{stringlen}$} \Return false
\EndIf
\State $j \gets \textit{patlen}$
\BState \emph{loop}:
\If {$\textit{string}(i) = \textit{path}(j)$}
\State $j \gets j-1$.
\State $i \gets i-1$.
\State \textbf{goto} \emph{loop}.
\State \textbf{close};
\EndIf
\State $i \gets
i+\max(\textit{delta}_1(\textit{string}(i)),\textit{delta}_2(j))$.
\State \textbf{goto} \emph{top}.
\EndProcedure
\end{algorithmic}
\end{algorithm}
.. raw:: latex
\begin{algorithm}
\caption{Euclid's algorithm}\label{euclid}
\begin{algorithmic}[1]
\Procedure{Euclid}{$a,b$}\Comment{The g.c.d. of a and b}
\State $r\gets a\bmod b$
\While{$r\not=0$}\Comment{We have the answer if r is 0}
\State $a\gets b$
\State $b\gets r$
\State $r\gets a\bmod b$
\EndWhile\label{euclidendwhile}
\State \textbf{return} $b$\Comment{The gcd is b}
\EndProcedure
\end{algorithmic}
\end{algorithm}