« Introduction à la complexité et sa formalisation » : différence entre les versions

De Wiki du LAMA (UMR 5127)
Aller à la navigation Aller à la recherche
Aucun résumé des modifications
Aucun résumé des modifications
Ligne 25 : Ligne 25 :


<pre>
<pre>
1. type nat = Z | S of nat
1. type nat = Z | S of nat
2. let one = S Z
2. let one = S Z
3. let two = S (S Z) (* etc.. *)
3. let two = S (S Z) (* etc.. *)
</pre>

On programme ensuite une fonction identité simple :

<pre>
1. let id1 n = n
</pre>

Et une fonction identité qui inspecte son argument, puis le reconstruit :

<pre>
1. let rec id2 n = match n with
2. | Z -> Z
3. | S p -> S (id2 p)
</pre>
</pre>



Version du 25 avril 2025 à 14:19

Étudiant : ALBRECHT Maël

Tuteur : HIRSCHOWITZ Tom

Introduction

Lorsque nous créons de grands programmes, l'optimisation de ceux-ci est importante pour diminuer le temps d'exécution et la longueur de ceux-ci. Pour cela, nous allons donc nous intéresser au principe de complexité.

Complexité

La complexité permet de mesurer l'efficacité des fonctions. La complexité dépend de différents critères tel que par exemple :

  • le temps de calcul séquentiel , c'est a dire le temps qui es mis pour exécuter toute les instructions une par une.
  • le temps de calcul parallèle , c'est a dire le temps qui es mis pour exécuter toute les instructions avec plusieurs processeur donc avec des opération exécuté en simultané.
  • l'esapace disque nécessaire a ces opération qui peut donc ralonger le temps d'execution d'une opérations.
  • ainsi que beaucoup d'autre paramètre...


Pour illustrer cela nous allons utiliser deux fonctions « identité » comme exemple.

On commence donc par définir un type d'entier unaires.

1.   type nat = Z | S of nat
2.   let one = S Z
3.   let two = S (S Z) (* etc.. *)

On programme ensuite une fonction identité simple :

1.   let id1 n = n

Et une fonction identité qui inspecte son argument, puis le reconstruit :

1.   let rec id2 n = match n with
2.   | Z -> Z
3.   | S p -> S (id2 p)

Langages utilisés

OCaml

Agda (Calf)

Tri en OCaml

Trie par insertion en OCaml

Trie par fusion en OCaml

Complexité en Agda/Calf

Deux fonctions « identité »

Conclusion