292 lines
9.8 KiB
Plaintext
292 lines
9.8 KiB
Plaintext
Algorithmique
|
||
=============
|
||
|
||
Al-Kharezmi, auteur du traité "Kitab al jabr w'al-muqabala", est l'inventeur
|
||
des manipulations algébriques (algèbre = **al jabr**).
|
||
C'est Léonard de Pise, dit Fibonacci, qui emprunta le nom du célèbre
|
||
mathématicien arabe du 9ème siècle, mais l'algèbre existe
|
||
depuis bien plus longtemps (Depuis Babylone, puis ensuite l'Egypte ancienne).
|
||
|
||
.. glossary::
|
||
|
||
|
||
algorithme
|
||
|
||
terme désignant une suite d'opérations constituant un schéma de calcul
|
||
ou de résolution d'un problème. C'est un processus systématique de
|
||
résolution d'un problème permettant de décrire précisément des étapes.
|
||
C'est une suite finie d'instructions permettant de donner la réponse à un
|
||
problème.
|
||
|
||
L'algorithmique est l'étude et la production de règles et de techniques
|
||
qui sont impliquées dans la définition d'algorithmes.
|
||
|
||
Implémentation d'un algorithme
|
||
------------------------------
|
||
|
||
.. glossary::
|
||
|
||
implémentation
|
||
|
||
Adaptation de la méthodologie de calculabilité au calcul effectif
|
||
sur une machine abstraite ou via un langage formel.
|
||
|
||
Il n’y a pas de parcours à sens unique de l’algorithme vers l’implantation.
|
||
La quête d’une implantation efficace nous amène souvent à effectuer
|
||
un retour vers les algorithmes eux-mêmes, et à en modifier des points
|
||
essentiels. L’aspect théorique de réflexion sur les algorithmes,
|
||
et l’aspect pratique de l'implémentation sont donc en symbiose.
|
||
|
||
Un existant émerge de la décomposition structurale d'un
|
||
domaine de base. Le fait essentiel, c'est la genèse des genres de l'existant les
|
||
uns à partir des autres.
|
||
|
||
L'essence d'une forme (un algorithme) se réalise au sein d'une matière qu'elle créée
|
||
(un langage). L'origine d'une matière fait naître les formes (concepts)
|
||
que sa structure dessine.
|
||
|
||
- Notion structurale de non-contradiction
|
||
- Notion extensive de "réalisation dans un champ donné"
|
||
|
||
Deux aspects réciproques : l'essence d'une forme se réalise au sein d'une
|
||
matière qu'elle crée, l'essence d'une matière faisant naître les formes que sa
|
||
structure dessine.
|
||
|
||
Abandonner l'idée trop simpliste de domaines concrets et d'opérations abstraites
|
||
qui posséderaient en eux-mêmes comme une nature de matière et une nature de
|
||
forme ; cette conception tendrait, en effet, à stabiliser les existants
|
||
mathématiques dans certains rôles immuables et ignorerait le fait que les
|
||
existants abstraits qui naissent de la structure d'un domaine plus concret
|
||
peuvent à leur tour servir de domaine de base pour la genèse d'autres existants.
|
||
|
||
L'algorithme comme généralisation de la calculabilité
|
||
------------------------------------------------------
|
||
|
||
L'importance croissante de l'informatique comme outil scientifique
|
||
impose d'élaborer un nouveau mode de description des méthodes de calcul (appelées algorithmes)
|
||
susceptible de satisfaire à la fois le critère de sécurité (maîtrise du résultat) et la possibilité
|
||
d'implémenter les calculs sur un ordinateur.
|
||
|
||
Exemple d'algorithme
|
||
---------------------
|
||
|
||
.. raw:: latex
|
||
|
||
\begin{algorithm}
|
||
\caption{L'alorithme de Bellman-Kalaba}
|
||
\begin{algorithmic}[1]
|
||
\Procedure {BellmanKalaba}{$G$, $u$, $l$, $p$}
|
||
\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$}
|
||
\EndProcedure
|
||
\Statex
|
||
\Procedure {FindPathBK}{$v$, $u$, $p$}
|
||
\If {$v = u$}
|
||
\State \textbf{Write} $v$
|
||
\Else
|
||
\State $w \leftarrow v$
|
||
\While {$w \not= u$}
|
||
\State \textbf{Write} $w$
|
||
\State $w \leftarrow p(w)$
|
||
\EndWhile
|
||
\EndIf
|
||
\EndProcedure
|
||
\end{algorithmic}
|
||
\end{algorithm}
|
||
|
||
Exemple d'algorithme avec son implémentation
|
||
---------------------------------------------
|
||
|
||
Soit l'algorithme de factorielle suivant,
|
||
|
||
.. raw:: latex
|
||
|
||
\begin{algorithm}
|
||
\caption{Algorithme de la factorielle d'un nombre}\label{factorielle}
|
||
\begin{algorithmic}[1]
|
||
\Function{factorielle}{$n$}\Comment{La fonction récursive factorielle}
|
||
\BState \emph{parametre} : $n$ entier
|
||
\If{$n = 1$}
|
||
\BState \emph{Sortie} : 1
|
||
\Else
|
||
\BState \emph{Sortie} : $n * \Call{factorielle}{n-1}$ \Comment{On appelle la fonction dans l'algorithme lui-même}
|
||
\EndIf
|
||
\EndFunction
|
||
\end{algorithmic}
|
||
\end{algorithm}
|
||
|
||
et son implémentation en python :
|
||
|
||
.. literalinclude:: code/factorielle.py
|
||
:language: python
|
||
|
||
En voici une autre implémentation (en OCaml) :
|
||
|
||
.. literalinclude:: code/factorielle.ml
|
||
:language: ocaml
|
||
|
||
On remarque que le **pseudocode** est très proche de
|
||
la syntaxe du python :
|
||
|
||
.. function:: factorielle(n:int)
|
||
|
||
::
|
||
|
||
if n=1
|
||
return 1
|
||
else
|
||
return n * factorielle(n-1)
|
||
end if
|
||
|
||
Qualité d'un algorithme
|
||
-----------------------
|
||
|
||
- correction d'un algorithme
|
||
- complétude d'un algorithme
|
||
|
||
Sémantique
|
||
|
||
Étude du sens, de la signification d'un langage
|
||
Définir la sémantique d’un langage formel consiste à lui donner une
|
||
signification mathématique.
|
||
|
||
Sémantique opérationnelle
|
||
|
||
on définit la sémantique par sa mise en œuvre sur
|
||
une machine abstraite.
|
||
|
||
Sémantique dénotationnelle
|
||
|
||
on associe à chaque construction syntaxique un
|
||
objet mathématique
|
||
|
||
Sémantique axiomatique
|
||
|
||
chaque construction est décrite par la manière dont
|
||
elle transforme des propriétés ou des prédicats.
|
||
|
||
Proposition
|
||
|
||
une proposition est un énoncé qui est soit vrai, soit faux
|
||
|
||
**exemple** : ``2 + 3 = 5``. Proposition vraie.
|
||
|
||
Prédicats
|
||
|
||
Une proposition dont la valeur de vérité dépend de la valeur d’une ou plusieurs variables
|
||
|
||
**Exemple** : ``n est pair`` : vrai pour n = 4 mais faux pour n = 9
|
||
|
||
|
||
Axiome
|
||
|
||
une proposition qui est supposée vraie
|
||
|
||
Un ensemble d’axiomes est consistant s’il n’existe pas de proposition
|
||
dont on peut démontrer qu’elle est à la fois vraie et fausse.
|
||
|
||
Un ensemble d’axiomes est complet si, pour toute proposition, il est
|
||
possible de démontrer qu’elle est vraie ou fausse.
|
||
|
||
Théorème d’incomplétude de Gödel (1931) : tout ensemble
|
||
consistant d’axiomes pour l’arithmétique sur les entiers est
|
||
nécessairement incomplet.
|
||
|
||
**Les concepts de base en algorithmique sont les axiomes**
|
||
|
||
inférence
|
||
|
||
règles d’inférence, règles permettant de combiner des axiomes et des
|
||
propositions vraies pour établir de nouvelles propositions vraies.
|
||
|
||
Démonstration
|
||
|
||
vérification d’une proposition par une séquence de déductions logiques
|
||
à partir d’un ensemble d’axiomes.
|
||
|
||
Lorsque le champ donné (le domaine) ne contient qu'un nombre fini d'individus,
|
||
on peut définir un choix de valeur des variables permettant de vérifier la
|
||
proposition obtenue par la *conjonction* de tous les axiomes du système proposé.
|
||
On dit alors que ce choix *réalise* un système d'axiomes.
|
||
|
||
|
||
Il ne s'agit plus de savoir si la définition entraîne l'existence, mais de
|
||
chercher si la structure d'un système d'axiomes (*règles*) peut donner naissance
|
||
à un champ d'individus qui soutiennent entre eux les relations définies pas les
|
||
axiomes.
|
||
|
||
Concret et abstrait
|
||
--------------------
|
||
|
||
Il est possible qu'un même genre d'existant joue dans un schéma de genèse le
|
||
rôle d'abstrait par rapport à un concret de base, et soit au contraire dans une
|
||
autre genèse le concret de base d'un nouvel abstrait.
|
||
|
||
Une pareille présentation des choses implique un tel renversement par rapport
|
||
aux habitudes de pensée classiques, qu'il faut encore insister sur le sens
|
||
nouveau que reçoivent ici les expressions de "concret" et "d'abstrait".
|
||
|
||
Les systèmes d'axiomes sont souvent conçus comme des structures purement
|
||
formelles, abstraites. Ces structures sont si profondément engagées dans la
|
||
genèse de leurs réalisations, qu'il valait mieux désigner par ces termes les
|
||
structures de base.
|
||
|
||
Un système d'axiome *peut* devenir le concret de base.
|
||
|
||
Ceci permet d'exprimer non seulement l'engagement du concret dans la genèse de
|
||
l'abstrait, mais encore les relations d'imitation qui peuvent exister entre la
|
||
structure de cet abstrait et celle du concret de base.
|
||
|
||
Dans certains cas, la genèse de l'abstrait à partir d'un concret de base
|
||
s'affirme jusqu'à réaliser une imitation de structure entre ces genres
|
||
d'existants qui naissent l'un de l'autre.
|
||
|
||
**C'est pourquoi on représente souvent un algorithme en pseudo-code**,
|
||
c'est-à-dire en fait dans le mode de représentation (issu du langage préféré de la
|
||
personne qui l'exprime) dominant chez la personne qui exprime un algorithme.
|
||
|
||
Comment rendre un algorithme lisible
|
||
------------------------------------
|
||
|
||
- Le bon algorithme utilise des identifiants explicites.
|
||
- Le bon algorithme est structuré.
|
||
- Le bon algorithme est indenté.
|
||
|
||
Complexité d'un algorithme
|
||
--------------------------
|
||
|
||
On peut approximer la complexité des algorithmes.
|
||
C'est utile pour pouvoir comparer des algorithmes.
|
||
|
||
complexité
|
||
|
||
estimer la complexité d'un algorithme, c'est estimer le nombre de calculs qu'il utilise.
|
||
|
||
Si f est la fonction caractérisant exactement le coût d’un algorithme et n
|
||
la taille des données, on s’intéresse à la façon dont augment f(n) lorsque n augmente
|
||
on va montrer que f(n) n'augmente pas plus vite qu’une autre fonction
|
||
g(n). Du point de vue mathématique, on dit que la fonction f est dominée
|
||
asymptotiquement par la fonction g ce qui se note f = O(g)
|
||
|
||
- Complexité temporelle : c’est le nombre d’op«erations effectuées par
|
||
une machine qui exécute l’algorithme.
|
||
|
||
- Complexité spatiale : c’est le nombre de positions mémoire utilisées par
|
||
une machine qui exécute l’algorithme.
|