Analyse d’Algorithmes

Slides:



Advertisements
Présentations similaires
Tris.
Advertisements

Algorithmes et structures de données avancés
Portée des variables VBA & Excel
Fonctions & procédures
Introduction à l’Algorithmique
Calculs de complexité d'algorithmes
1 UMLV 1. Introduction 2. Hachage ouvert 3. Hachage fermé 4. Implémentation des fonctions Méthodes de hachage.
Cours n°2M2. IST-IE (S. Sidhom) UE 303 Promo. M2 IST-IE 2005/06 Conception dun système d'information multimédia Architecture trois-tiers : PHP/MySQL &
Système formel Nous avons introduit : signes de variables (x, y, z, …), de constantes (0, 1), d’opérations (+, ), de relations (=, ) Axiomes : ce sont.
et évaluation des compétences
INTRODUCTION.
variable aléatoire Discrète
Les sous-programmes Chapitre n° 5: Objectifs : Activité:
Chapitre II.Rappels mathématiques et complexité
Initiation à la programmation et algorithmique cours 3
Chapitre IV. Structures linéaires (piles, files, listes chaînées)
Les bases de l’Algorithmique
Chapitre V : Cinétique chimique
Conception et analyse des algorithmes
Structures de données linéaires
Récursivité.
Analyse des algorithmes: une introduction
Les algorithmes: complexité et notation asymptotique
IFT-2000: Structures de Données Introduction à lanalyse dalgorithmes Dominic Genest, 2009.
Algorithme de Bellman-Ford
Analyse d’algorithmes
Structures de données IFT Abder Alikacem La classe string Département dinformatique et de génie logiciel Édition Septembre 2009 Département dinformatique.
Introduction à l’algorithmique
Les Fonctions. Définir une fonction Sections de code indépendantes que lon peut appeler à nimporte quel moment et dans nimporte quel ordre. Bout de code.
Semaine #1 INF130 par Frédérick Henri.
Courbes de Bézier.
STRUCTURES DE DONNÉES Maxime CROCHEMORE
IFT 6800 Atelier en Technologies d’information
LIFI-Java 2004 Séance du Jeudi 9 sept. Cours 1. La notion de langage Décrire une tâche à effectuer –programme Écrire à un haut niveau –facile pour lutilisateur.
Efficacité des algorithmes
Chapitre 3 Syntaxe et sémantique.
CSI 1502 Principes fondamentaux de conception de logiciels
Tutorat en bio-informatique Le 21 novembre Exercices 2 et 3 (MAT1400) - solutions Chapitre 11.7, Analyse - concepts et contextes vol. 2 27) Cherchez.
ASI 3 Méthodes numériques pour l’ingénieur
Programmation linéaire en nombres entiers : les méthodes de troncature
Analyse des Algorithmes
Analyse d’algorithmes
ASI 3 Méthodes numériques pour l’ingénieur
L’essentiel du langage C
Animateur : Med HAIJOUBI
1 Notations Asymptotiques Et Complexité Notations asymptotiques : 0 et  Complexité des algorithmes Exemples de calcul de complexité.
LES PILES ET FILES.
Pr ZEGOUR DJAMEL EDDINE Ecole Supérieure d’Informatique (ESI)
O-notation 1. Introduction 2. O-notation 3. Opérations 3.1 Somme 3.2 Produit 4. Règles générales 5. Exemple 6.Analyse des algorithmes récursifs 6.1 Dilatation.
INTRODUCTION.
Rappels de statistiques descriptives
Un survol du language C.
Programmation linéaire en nombres entiers
Les Machines RAM.
2008/ Plan du cours 1.Introduction –Contenu du cours 2.Logique mathématique –Calcul propositionnel –Calcul des prédicats –Logique floue et aide à.
Cours LCS N°4 Présenté par Mr: LALLALI
Introduction au langage C : Structures de contrôle 1 ère année Génie Informatique Dr Daouda Traoré Université de Ségou
MATHÉMATIQUES DISCRÈTES Chapitre 2 (section 2) François Meunier DMI.
2005/2006 Structures de Données Introduction à la complexité des algorithmes.
CPI/BTS 2 Algorithmique & Programmation La récursivité Algo – Prog CPI/BTS2 – M. Dravet – 14/09/2003 Dernière modification: 14/09/2003.
Pour les boucles FOR on a fait intervenir la boucles TANT QUE équivalentes dont on connaît calculer le temps d’exécution. Toutes le procédures de comptage.
MATHÉMATIQUES DISCRÈTES Chapitre 2 (section 1)
8PRO107 Éléments de programmation Les adresses et les pointeurs.
8PRO107 Éléments de programmation Les tableaux. Étude de cas 1 Description du problème : Lire une liste d’entiers et l’afficher d’abord dans le même ordre.
Philippe Gandy - 8 septembre 2015 Basé sur les notes de cours de Daniel Morin et Roch Leclerc.
CSI2510 Structures de données et algorithmes Analyse des algorithmes
Objets et Actions Élémentaires.
CSI25101 Tri Plus efficace. CSI25102 Tri récursif Le tri récursif divise les données de grande taille en deux presque moitiés et est appelé récursivement.
L'exécution d'un programme nécessite l'utilisation des ressources de l'ordinateur : temps de calcul pour exécuter les opérations, et l'occupation de la.
Complexité algorithmique
Transcription de la présentation:

Analyse d’Algorithmes Structures de données IFT-2000 Analyse d’Algorithmes Input Algorithme Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini.

Temps d’exécution Les algorithmes transforment des objets en entrée en des objets en sortie. Le temps d’exécution d’un algorithme croît en fonction de la taille des entrées. Le temps d’exécution en moyenne est souvent difficile à déterminer. Nous nous intéresserons au pire cas dans le temps d’exécution. Facile à analyser Crucial dans les applications dans le domaine des jeux, des finances et de la robotique par exemple.

Études Expérimentales Écrire un programme implémentant un algorithme Exécuter le programme avec différentes tailles des données en entrée. Utiliser une fonction, comme la fonction prédéfinie clock(), pour avoir une mesure des temps d’exécution. Tracer les résultats.

Limitation des expériences Il est nécessaire d’implémenter l’algorithme, ce qui peut être difficile. Les résultats peuvent ne pas être indicatifs du temps d’exécution d’autres entrées non inlcuses dans l’expérience. Pour comparer deux algorithmes, le même environnement de programmation (matériel et logiciel) doit être utilisé.

Analyse théorique Utiliser une description de haut niveau de l’algorithme au lieu de l’implémenter. Caracteriser le temps d’exécution comme une fonction de la taille des entrées, n. Tenir compte de toutes les possibilités comme entrée. Nous permet d’évaluer la vitesse d’un algorithme independemment de l’environnement.

Pseudocode Algorithme arrayMax(A, n) Input tableau A de n entiers description haut niveau de l’algorithme Plus structuré qu’une prose en français! Moins detaillé qu’un programme Exemple: trouver l’élément max dans un tableau Algorithme arrayMax(A, n) Input tableau A de n entiers Output l’élément maximum de A currentMax  A[0] for i  1 to n  1 do if A[i]  currentMax then currentMax  A[i] return currentMax

Pseudocode Structures de contrôle Declaration d’une méthode if … then … [else …] while … do … repeat … until … for … do … L’indentation remplace les accolades Declaration d’une méthode Algorithme method (arg [, arg…]) Input … Output … Appel Methode/Fonction var.method (arg [, arg…]) Valeur retournée return expression Expressions Assignation (comme  en C, C++, Java) Test d’égalité (comme  en C, C++, Java) n2 Exposant et autres formats mathématiques permis

Le modèle “Random Access Machine” (RAM) Le CPU Une banque de cellules de mémoire illimitée, chacune peut contenir un nombre arbitraire de caractères 1 2 Les cellules de mémoire sont adressables, leur accès prend une unité de temps

Operations primitives Instructions de base exécutées par un algorithme Ont leur correspondant en pseudocode Independants d’un langage de programmation Leurs définitions exactes ne sont pas importantes On considère qu’elles prennent un temps constant dans le modèle RAM Exemples: Evaluation d’une expression Assigner une valeur à une variable Indexation dans un tableau Appeler une methode Retourner d’une méthode

Compter les opérations primitives En inspectant le pseudocode, nous pouvons determiner le nombre maximum d’opérations primitives exécutées par l’algorithme, comme une fonction de la taille des entrées Algorithme arrayMax(A, n) currentMax  A[0] 2 # operations for i  1 to n  1 do 2 + n if A[i]  currentMax then 2(n  1) currentMax  A[i] 2(n  1) { incrémenter le compteur i } 2(n  1) return currentMax 1 Total 7n  1

Estimation du temps d’exécution L’algorithme arrayMax exécute 7n  1 opérations primitives dans le pire cas. Définissons: a = le temps que prend par la plus rapide des opérations primitives b = le temps que prend la plus lente des opérations primitives Soit T(n) le temps dans le pire cas de arrayMax. On peut alors écrire : a (7n  1)  T(n)  b(7n  1) Ainsi, le temps d’exécution T(n) est bornée par deux fonctions linéaires

Taux de croissance du temps d’exécution Changer l’environnement (matériel/logiciel) Affecte T(n) par un facteur constant, mais Ne doit pas altérer le taux de croissance de T(n) Le taux de croissance linéaire du temps d’exécution T(n) est une propriété intrinsèque de l’algorithme arrayMax

Taux de croissance Taux de croissance des fonctions: Linéaire  n Quadratique  n2 Cubique  n3 Dans le diagramme log-log, la pente d’une droite correspond au taux de croissance de la fonction.

Facteurs constants Le taux de croissance n’est pas affecté par facteurs constants ou des termes de plus bas ordres Exemples 102n + 105 est une fonction linéaire 105n2 + 108n est une fonction quadratique 1E+24 Quadratique 1E+22 Quadratique 1E+20 Linéaire 1E+18 Linéaire 1E+16 ) n 1E+14 ( T 1E+12 1E+10 1E+8 1E+6 1E+4 1E+2 1E+0 1E+0 1E+2 1E+4 1E+6 1E+8 1E+10 n

Notation “Grand-Oh” Soit les fonctions f(n) et g(n), nous dirons que f(n) est en O(g(n)) s’ils existent c et n0, des constantes positives, tel que f(n)  cg(n) pour n  n0 Exemple: 2n + 10 est en O(n) 2n + 10  cn (c  2) n  10 n  10/(c  2) prendre c = 3 and n0 = 10

Exemple “Grand-Oh” Exemple: la function n2 n’est pas en O(n) n2  cn Les 2 inégalités ne peuvent être satisfaites si c doit être une constante

Autres Exemples “Grand-Oh” 7n-2 est en O(n) besoin de c > 0 and n0  1 tel que 7n-2  c•n pour n  n0, Ceci est vrai pour c = 7 et n0 = 1 3n3 + 20n2 + 5 3n3 + 20n2 + 5 is O(n3) besoin de c > 0 et n0  1 tel que 3n3 + 20n2 + 5  c•n3 pour n  n0, ceci est vrai pour c = 4 et n0 = 21 3 log n + log log n 3 log n + log log n is O(log n) besoin de c > 0 et n0  1 tel que 3 log n + log log n  c•log n pour n  n0, ceci est vrai pour c = 4 et n0 = 2

“Grand-Oh” et le taux de croissance La notation “big-Oh” donne une borne supérieure au taux de croissance de la fonction Dire que “f(n) est en O(g(n))” signifie que le taux de croissance de f(n) n’est pas supérieur que le taux de croissance de g(n) Nous pouvons utiliser la notation “big-Oh” pour comparer des fonctions par rapport à leur taux de croissance f(n) is O(g(n)) g(n) is O(f(n)) g(n) croît plus Oui Non f(n) croît plus Même croissance

Règles du “Grand-Oh” Si f(n) est un polynôme de degrés d, f(n) est alors en O(nd), i.e., négliger les termes de plus bas degrés négliger les coefficients constants Utiliser la petite possible classe de fonctions Dire “2n est en O(n)” au lieu de “2n est en O(n2)” Utiliser la plus simple expression de la classe Dire “3n + 5 est en O(n)” au lieu de “3n + est en O(3n)”

Analyse asymptotique L’analyse asymptotique d’un algorithme determine le temps d’exécution dans la notation ”big-Oh” Pour appliquer l’analyse asymptotique Il faut trouver le nombre d’opérations primitives exécutées dans le pire cas en focntion de la taille des entrées Exprimer par la suite cette fonctiond ans la notation “big-Oh” Exemple: Nous avons determiné que l’algorithme arrayMax execute au plus 7n  1 operations primitives Nous dirons que l’algorithme arrayMax “s’exécute en un temps O(n) ” Depuis que les facteurs constants et les termes de plus bas ordres sont négligés, nous pouvons les négliger également lorsque nous compterons les opérations primitives

Calcul des moyennes de prefix Nous allons illustrer l’anlayse asymptotique avec deux algorithmes pour le calucl des moyennes de prefix La i-ème moyenne prefix d’un tableau X est la moyenne des (i + 1) premiers éléments de X: A[i] = (X[0] + X[1] + … + X[i])/(i+1) Calculer le tableau A des moyennes prefix d’un autre tableau X a des applications dans l’analyse financière

Moyennes prefix (Quadratique) L’algorithme suivant calcule les moyennes prefix en un temps quadratique en appliquant la definition Algorithm prefixAverages1(X, n) Input tabelau X de n entiers Output tableau A des moyennes prefix de X #opérations A  nouveau tableau de n entiers n for i  0 to n  1 do n s  X[0] n for j  1 to i do 1 + 2 + …+ (n  1) s  s + X[j] 1 + 2 + …+ (n  1) A[i]  s / (i + 1) n return A 1

Progression arithmétique Le temps de calcul de prefixAverages1 est O(1 + 2 + …+ n) La somme des n premiers entier est n(n + 1) / 2 Voici une simple preuve visuelle Ainsi, l’algorithme prefixAverages1 s’exécute en un temps de l’ordre O(n2)

Moyennes prefix (Linéaire) L’algorithme suivant calcule les moyennes prefix en un temps linéaire en considérant les sommes courantes Algorithm prefixAverages2(X, n) Input tableau X de n entiers Output tableau A des moyennes prefix de X #opérations A  nouveau tableau of n entiers n s  0 1 for i  0 to n  1 do n s  s + X[i] n A[i]  s / (i + 1) n return A 1 L’algorithme prefixAverages2 s’exécute en un temps en O(n)

Les Maths que vous devez réviser Sommations (Sec. 1.3.1) Logarithmes et Exposants (Sec. 1.3.2) Techniques de preuves (Sec. 1.3.3) Probabilité de base (Sec. 1.3.4) propriétés des logarithmes: logb(xy) = logbx + logby logb (x/y) = logbx - logby logbxa = alogbx logba = logxa/logxb propriétés des exponentiels: a(b+c) = aba c abc = (ab)c ab /ac = a(b-c) b = a logab bc = a c*logab

Famille du “Grand-Oh” big-Omega f(n) est (g(n)) s’il existe une constante c > 0 et un entier constant n0  1 tel que f(n)  c•g(n) for n  n0 big-Theta f(n) est (g(n)) s’ils existent des constantes c’ > 0 et c’’ > 0 et un entier constant n0  1 tel que c’•g(n)  f(n)  c’’•g(n) for n  n0 little-oh f(n) est o(g(n)) si, pour toute constante c > 0, il existe un entier constant n0  0 tel que f(n)  c•g(n) pour n  n0 little-omega f(n) est (g(n)) si, pour toute constante c > 0, il existe un entier constant n0  0 tel que f(n)  c•g(n) pour n  n0

Intuition pour la notation asymptotique Big-Oh f(n) est O(g(n)) si f(n) est asymptotiquement inférieure ou égale à g(n) big-Omega f(n) est (g(n)) si f(n) est asymptotiquement supérieure ou égale à g(n) big-Theta f(n) est (g(n)) si f(n) est asymptotiquement égale à g(n) little-oh f(n) est o(g(n)) si f(n) est asymptotiquement strictement inférieur que g(n) little-omega f(n) est (g(n)) si f(n) est asymptotiquement strictement supérieure que g(n)

Exemple Utilisation de la famille du “Grand-Oh” 5n2 est (n2) f(n) est (g(n)) s’il existe une constante c > 0 et un entier constant n0  1 tel que f(n)  c•g(n) pour n  n0 prendre c = 5 and n0 = 1 5n2 est (n) f(n) est (g(n)) s’il existe une constante c > 0 et un entier constant n0  1 tel que f(n)  c•g(n) pour n  n0 prendre c = 1 and n0 = 1 5n2 est (n) f(n) est (g(n)) si, pour toute constante c > 0, il existe un entier constant n0  0 tel que f(n)  c•g(n) pour n  n0 besoin 5n02  c•n0  pour un c donné, le n0 qui satisfait cela est n0  c/5  0