support de cours algo avancée

algo/AlgoApprofondie/cours/apercu.txt

@@ -4,11 +4,17 @@ Aperçu des algorithmes fondamentaux
 Les algorithmes sont partout. Absolument partout aujourd'hui.
 Il n'est pas un domaine de nos activités qui ne soit liés à tel ou tel algorithme.
 
+Quelques grands thèmes: systèmes cryptographiques, géométrie algorithmique, reconnaissance de motifs, mais aussi les problèmes posés par l’algorithmique parallèle, etc... 
+
 En mathématiques
 -----------------
 
 - l'algèbre (étude des structures de données)
 - l'arithmétique modulaire (théorie des nombres)
+  En mathématiques et plus précisément en théorie algébrique des nombres, 
+  l’arithmétique modulaire est un ensemble de méthodes permettant la résolution de problèmes 
+  sur les nombres entiers. 
+  Ces méthodes dérivent de l’étude du reste obtenu par une division euclidienne.
 - la géométrie (affine, algébrique, invariants topologiques...)
 - les diagrammes (diagrammes de Venn...)
 - les colorisation d'une carte
@@ -77,3 +83,14 @@ Exemple de résolution
 
     \end{algorithmic}
     \end{algorithm}
+
+    
+Algorithmes gloutons
+--------------------
+
+Les algorithmes servant à résoudre les problèmes d’optimisation parcourent en général une
+série d’étapes, au cours desquelles ils sont confrontés à un ensemble de possibilités. Un
+algorithme glouton fait toujours le choix qui semble le meilleur sur le moment, dans l’espoir
+qu’il mènera à la solution optimale globalement.
+
+

algo/AlgoApprofondie/cours/complexite.txt

@@ -0,0 +1,50 @@
+Notion de complexité d'un algorithme
+====================================
+
+définition
+-----------
+
+l’analyse de la complexité d’un algorithme consiste à évaluer les ressources
+consommées par l’algorithme lors de l’exécution
+
+deux critères d’évaluation
+
+- le coût en temps (nombre d’opérations)
+- le coût en espace, (quantité de mémoire)
+
+
+principes de base
+-----------------
+
+Caractériser la quantité de ressources consommées en fonction de la
+taille des données sur lesquelles l’algorithme est appliqué. 
+
+Evaluer le coût exact est difficile, on exprimera donc seulement un
+ordre de grandeur
+
+
+définition mathématique
+-----------------------
+
+
+- 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 croı̂t f(n) lorsque n croı̂t
+- on va montrer que f (n) ne croı̂t 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)
+
+::
+
+    f = O(g) ssi ∃k, ∃n 0 , ∀n, n > n 0 ⇒ f (n) ≤ k.g (n)
+
+
+exemples
+---------
+
+- O(n) : progression linéaire
+- O(n^2) : progression quadratique
+- O(n^p) : progression polynomiale
+- O(p^n ) : progression exponentielle
+- O(log(n)): progression logarithmique

algo/AlgoApprofondie/cours/fonctions.txt

@@ -1,2 +1,82 @@
 .. include:: ../../tronCommun/fonctions.txt
 
+Définitions par filtrage
+--------------------------
+
+Lorsqu'un argument est passé à un ensemble de clauses::
+
+    p1 -> e1 ∣ … ∣ pn -> en
+
+- la première clause qui filtre l'argument est exécutée, les autres sont
+    ignorées.
+- si aucune clause ne filtre l'argument, une exception est levée.
+
+
+Définitions récursives
+-----------------------
+
+En ocaml, `let rec` définit une variable récursive, ie qui utilise la (les) valeur(s) en cours de définition.
+
+Exemples
+--------
+
+::
+
+	let rec f (x) = if x <= 1 then 1 else f(x-1) + f(x-2) ;;
+	let rec g (x) = if x = 0 then 1 else x * g (x-1) ;;
+	let rec h (x, y) = if x = 0 then 1 else h (x-1, h(x,y)) ;;
+	let rec m (x) = if x > 100 then x - 10 else m (m (x+11)) ;;
+
+On peut imprimer leur valeurs pour qques valeurs::
+
+	begin
+	for i = 1 to 15 do
+	   printf "%d " (f (i)) done;
+	   printf "\n"
+	end ;;
+
+f, g sont les fonctions de Fibonacci et factorielles. C'est la même notation que pour les suites récurrentes. Que valent h et m?
+
+La récursivité est très puissante. Invention de Kleene (1935). Théorie des fonctions récursives, comme moyen général de calcul. On peut montrer qu'il existe toujours des fonctions récursives partielles (qui ne terminent pas pour tte valeur de leurs arguments), si on veut un modèle général. La sous théorie des fonctions récursives primitives correspond aux programmes sans boucles, sans appels récursifs, et l'instruction for. Ces programmes terminent toujours. (cf Introduction to Metamathematics, S. Kleene; Recursive Functions Theory and Logic, A. Yasuhara).
+
+Church et les autres logiciens des années 30 ont montré que systèmes de Post, les fonctions récursives de Kleene, les machines de Turing, sont tous équivalentes. Il a émis la thèse suivante: tous les modèles de la calculabilité sont équivalents.
+
+
+
+Fonctions récursives
+---------------------
+
+::
+
+    let rec fact n = if n > 1 then n * fact (n -1) else 1;;
+
+dans le prompt::
+
+    utop # let rec fact n = if n > 1 then n * fact (n -1) else 1;;
+    val fact : int -> int = <fun>
+    counter: 0 }─utop # fact 5;;
+    - : int = 120
+
+et mutuellement récursives::
+
+    let rec ping n = if n > 0 then pong (n - 1) else "ping"
+        and pong n = if n > 0 then ping (n - 1) else "pong";;
+
+
+    # ping 8 ;;
+    - : bytes = "ping"
+    #  ping 15 ;;
+    - : bytes = "pong"
+
+types récursif
+---------------
+
+::
+
+    type 'a liste =
+      Vide
+      | Cellule of 'a * 'a liste;;
+
+
+
+

algo/AlgoApprofondie/cours/index.txt

@@ -1,6 +1,7 @@
 Algorithmique Approfondie
 =========================
 
+
 .. toctree::
     :maxdepth: 2
 
@@ -13,6 +14,7 @@ Algorithmique Approfondie
     control
     donnees
     apercu
+    complexite
     modularite
     modules
     tp

algo/AlgoApprofondie/cours/presentation.txt

@@ -1,15 +1,26 @@
 Avant propos
 ============
 
+
+
 .. include:: ../../tronCommun/presentation.txt
 
 
+.. image:: _static/pascal.jpg
+
+
 Objectifs de ce cours
 ~~~~~~~~~~~~~~~~~~~~~
 
 Il s'agit de :
 
-.. FIXME définir les objectifs
-
-- choisir une représentation appropriée des données,
-- décomposer en sous-problèmes et affinements successifs,
+- choisir une représentation appropriée des données
+- décomposer en sous-problèmes et affinements successifs (programmation dynamique)
+- approfondir les connaissances des structures de données et des algorithmes
+- les appliquer à la résolution de problèmes
+- rappels sur les types abstraits de données
+- rappels sur la complexité des algorithmes
+- abstractions de données et de contrôle
+- utilisation de librairies de bases implémentant quelques algorithmes (tri, itérateur...)
+- choix de collections et structures de données adaptée au design d'un programme
+- structures de données complexes arbres, tables, graphes