Topic outline

  • Section 1 : Organisation 2019-2020

    Lady Ada Lovelace
    Volumes horaires
    •  5 séances de cours de 1h15mn (6,25h)
    • 10 séances de TD de 1h15mn (12,5h)
    •  5 séances de TP de 2h45mn (13,75h)
    •  1 contrôle de 1h30

    Enseignants - Adresses électroniques


    Cours
    • Groupes 2MIC A+B+C+D  et 2FASnum : Patrick Esquirol

    Travaux Dirigés
      • 2MIC_A :
      • 2MIC_B : Rafael Bailón-Ruiz
      • 2MIC_C : 
      • 2MIC_D : Rafael Bailón-Ruiz
      • 2FAS_NUM : Patrick Esquirol
      Travaux Pratiques
      • 2MIC_A :
      • 2MIC_B :
      • 2MIC_C : 
      • 2MIC_D : Rafael Bailón-Ruiz et Frederic Chatrie
      • 2FAS_NUM : Patrick Esquirol

      Etudiants
      Feuilles d'émargement 2019-2020 à télécharger (à venir)
      • 2MIC_A :
      • 2MIC_B :
      • 2MIC_C : 
      • 2MIC_D :
      • 2FAS_NUM

      • Section 2 : Compétences et connaissances visées - Annales

        Voir ici la liste des connaissances et des compétences que vous êtes censés posséder à la fin de cet enseignement.
        Utilisez cette liste pour évaluer vos acquis et repérer vos points faibles.
        Revoyez vos TD et TP en conséquence.

        Si certains problèmes de compréhension résisent, n'hésitez pas à contacter vos enseignants de cours/td/tp (voir emails ci-dessus). Réglez ces problèmes bien avant le contrôle ...

        Annale 2016-2017

        Annale 2017-2018

        • Section 3 : Support de cours et polycop de TD et TP

          • La présentation utilisée en cours (.pptx .pdf) utilisé en cours.
          • Les sujets (pdf) de TD et TP.
          • Section 4 : Exercices d'auto-formation

            Exercices sur les tableaux
            Enoncés ici
            Essayez d'abord de faire ces exercices seul. Chercher l'algorithme et vérifier ensuite en faisant un programme. En cas de problème rencontré, envoyez votre travail en cours à vos enseignants ou prenez contact avec eux (aux inter-cours). Certains de ces exercices peuvent être utilisés pour le contrôle en fin d'année ...

            Quizz Ada sur les pointeurs et les listes simplement chaînées

            Quelle condition doit-on écrire en Ada pour savoir si une liste est vide ?

            Que doit-on vérifier impérativement au début d'un sous-programme qui accède aux éléments d'une liste ?

            Quelle instruction permet systématiquement d'empiler un nouvel élément en tête d'une liste quelconque ?

            Comment parcourir une liste pour appliquer le même traitement à chacun de ses éléments ?

            Comment se positionner sur le dernier élément d'une liste non vide ?

            Réponses  du quizz  ici

            Sujets d'exercices non corrigés sur les listes

            Exercice commenté sur la construction d'une liste

            On désire créer une liste L contenant les éléments 1,2,3 (dans cet ordre) à l'aide d'une liste simplement chaînée L au moins de 4 façons différentes :

            méthode 1- créer 3 listes L1, L2, L3 à une seule cellule chacune contenant respectivement 1, 2 et 3, puis les relier correctement entre elles.

            méthode 2- créer une liste L contenant 1, aller à la fin pour ajouter la deuxième cellule (2), aller encore à la fin pour ajouter la dernière cellule (3).

            méthode 3- créer une liste en empilant les éléments : d'abord le 3 , puis le 2, puis le 1.

            méthode 4- on généralise : on veut paramétrer la méthode 3 pour pouvoir créer des listes du type 1, 2, 3, ... , Nb).
            Exercice sur la conversion d'un tableau en liste

            Partant d'un tableau, par exemple une chaîne de caractères (on rappelle qu'un String est en fait un tableau de caractères), T = "kayak" = ('k', 'a', 'y', 'a', 'k'),

            écrire une fonction de conversion d'un tableau en liste. L'ordre des éléments dans la liste doit être le même que l'ordre des éléments dans le tableau.

            L = 'k' -> 'a' ->  'y' -> 'a' -> 'k'

            solution ici

            Exercice commenté sur les listes circulaires
            1 Etant donné une liste L, écrire un sous-programme qui la rend circulaire (le dernier élément doit avoir le premier comme suivant).       -> solution 1
            2 Ecrire un algorithme qui permet d'afficher une liste circulaire.
            3 Ecrire un algorithme qui indique si un entier donné appartient à une liste circulaire.
            4 Ecrire un algorithme qui permet d'insérer un entier dans une liste circulaire. La liste doit rester circulaire après insertion.
            5 Ecrire un algorithme qui permet d'enlever la première occurrence rencontrée d'un entier donné dans une liste circulaire (les autres occurrences ne sont pas affectées). La liste doit rester circulaire après la suppression. L'algorithme doit lever une exception si la liste ne contenait aucune occurrence de l'entier à enlever.
            Solutions 2 et 4


            • Section 5 : Quelques ressources Ada utiles

              Get_line
              Les sous-programmes d'entrée sortie de types Character et String du paquetage Ada.Text_Io (Ada 2005) sur ce lien.On voit notamment qu'il existe en Ada une fonction Get_Line qui retourne un chaîne (string) dont la longueur est fixée dynamiquement (à l'exécution). Pour dimensionner cette chaîne il faut donc utiliser un bloc declare ...begin ... end  et affecter cette chaîne dès sa déclaration :

              ... declare

                  S : String:= Get_Line;   -- S est dimensionnée par le résultat de la fonction Get_Line

                  begin

                      ...

                      put(S'length);  -- si on veut connaître la taille de S, on utilise l'attribut S'length

                      put(S);

                      ...

                  end;         --declare

              ...

              Tri à bulles

              Un document utile pour le TD2 : un programme Ada effectuant le test d'un tri à bulles d'un tableau d'entiers

              Attention il faut extraire seulement le sous-programme de tri et vérifiez la conformité du type de tableau (modifier au besoin la déclaration du type Tab_Chiffres pour qu'il soit adapté à votre programme).

              Toute la syntaxe Ada (ou presque) en 1 page !!
              Les polycops de 1ere année de Didier Le Botlan :
              Formulaire d'aide à la conception d'un algorithme
              Fichiers texte en Ada
              • Le paquetage Tortue

                Le terme "Tortue" est né en 1950 avec les premiers robots construits par le neurophysiologiste William Grey Walter. Une tortue graphique est un petit robot qui se déplace dans un espace 2D avec un stylo et une gomme qu'on peut abaisser ou lever pour tracer sur le sol des segments de différentes couleurs ou les effacer. Pour simuler à l'écran la commande de la tortue, un ensemble de primitives graphiques (ex : tracer un segment de longueur donnée, tourner d'un angle donné ...etc) a été implanté dans les langages Logo (Seymour Papert, MIT) et également Pascal. Ces langages ont favorisé l'apprentissage ludique de l'algorithmique et de la programmation dans les années 80, donnant la possibilité de réaliser des figures géométriques de plus en plus complexes. La popularité de Logo tenait en grande partie à sa tortue graphique, bien qu'il soit un langage fonctionnel général et puissant (comme Caml et Lisp). Une petite communauté de programmeurs continue à promouvoir la tortue et Logo , voir par exemple : http://el.media.mit.edu/logo-foundation/what_is_logo/logo_programming.html,     https://turtleacademy.com/). Le paquetage Ada "Tortue" reprend les idées essentielles du concept initial. Il propose une fenêtre graphique dans laquelle on peut piloter une seule tortue à l'aide de primitives de déplacement et de dessin de segments.Pour pouvoir utiliser le paquetage Tortue :

                1. Placer une clause with Tortue; dans son programme
                2. Compiler à partir d'Emacs.
                3. Vérifier que l'option "utiliser le compilateur préfiguré Insa" est bien cochée dans le menu Ada/Options

                Si le menu Emacs ne propose pas cette option (nouveaux entrants en 2ème année Insa)

                1. Fermer Emacs
                2. Aller dans le répertoire /home/commetud/1ere Annee/ADA/Setup.
                3. Lancer le programme setup-exe
                4. Re-ouvrir Emacs et vérifier que l'option "utiliser le compilateur préfiguré Insa" est bien cochée dans le menu Ada/Options

                Pour connaître les spécifications du paquetage Tortue (types et sous-programmes utilisables), aller dans le répertoire /home/commetud/1ere Annee/ADA/Acteurs/GAda et ouvrir le fichier tortue.ads.

                Attention : vérifier qu'aucun fichier tortue.ads ou tortue.adb n'existe dans le répertoire de votre programme ; si de tels fichiers existent, les effacer.


                Primitives de dessin en Ada

                • Ouvrir_Fenetre     : procédure pour créer la fenêtre de dessin  (pour la fermeture, cliquer sur la croix (χ) en haut à droite de la fenêtre de dessin ou appuyer sur le bouton "Fermer" de la fenêtre d'entrée-sortie. Il faut toujours appeler cette procédure avant de commencer un nouveau dessin.
                • Largeur_Ecran      :  fonction retournant la largeur de la fenêtre de dessin
                • Hauteur_Ecran      : fonction retournant la hauteur de la fenêtre de dessin
                Le repère du dessin a pour origine le point de coordonnées (0,0) situé en bas à gauche de la fenêtre de dessin. Initialement la tortue
                • est placée au centre de le fenêtre de dessin
                • est orientée vers le haut
                • a un crayon baissé (prêt à dessiner si la tortue se déplace
                Il y a 2 procédures de déplacement (en ligne droite), l'une en indiquant le point d'arrivée (location absolue) l'autre en indiquant la longueur à parcourir (localisation relative).
                • Aller_A(X,Y)          : procédure qui fait aller la tortue au point de coordonnées (X,Y) en suivant un segment de droite (dessine ce segment si le crayon est baissé)
                • Avancer(Long)      : procédure qui fait avancer la tortue d'un segment de longueur Long (float) depuis sa position actuelle (dessine un segment si le crayon est baissé)
                Il y a 3 procédures pour modifier l'orientation de la tortue (la direction dans laquelle elle va avancer) :
                • Tourner_Droite(A) : procédure qui fait tourner la tourner la tortue d'un angle A (degres) dans le sens des aiguille d'une montre par rapport à son orientation courante.
                • Tourner_Gauche(A) : procédure qui fait tourner la tourner la tortue d'un angle A (degres) dans le sens inverse des aiguille d'une montre par rapport à son orientation courante.
                • Reculer(Long)       : procédure qui fait reculer la tortue d'un segment de longueur Long (float) depuis sa position actuelle (dessine un segment si le crayon est baissé)
                Enfin il y a 2 procédures pour lever ou baisser le crayon et une pour changer sa couleur.
                • Lever_Crayon        : procédure qui fait lever le crayon. Permet à la tortue de se déplacer sans laisser de trace
                • Baisser_Crayon     : procédure qui fait baisser le crayon. Dès que la tortue se déplace, un trait apparait
                • Regler_Couleur( (R,V,B) ) : procédure qui change la couleur du crayon ; le type couleur T_Couleur est un triplet d'entiers représentant respectivement les intensités de Rouge,Vert et Bleu en synthèse soustractive.

                Si on veut créer des variables ou des constantes de type T_Couleur  il faut placer une clause

                  with Gada.Graphics dans son programme.

                Exemple de couleurs constantes :

                Rappel : les couleurs en synthèse additive :

                Synthese Additive RVB

                • Trucs , astuces

                  Edition de programmes sous Linux avec Emacs

                  • Comment coloriser un programme Ada ?

                  voir ce tutorial

                  • Comment indenter correctement un programme Ada ?

                  voir ce tutorial

                  • Eléments de solution des TD et TP

                    TD1 et TP1 (Kaprekar) :
                    La méthode de conception d'algorithmes est basée sur les étapes suivantes :

                    1 Créer un programme principal et réaliser une analyse descendante du problème à résoudre : mettre en évidence tous les sous-programmes qui interviennent dans le programme principal. Ecrire le corps de ce programme principal en --commentaires

                    2 Spécifier chaque sous-programme, c-à-d indiquer :
                    • si c'est une procédure ou une fonction
                    • son nom
                    • les paramètres, le type et le mode de passage de chacun : choisir entre in (par valeur en lecture seulement), out (par adresse en écriture seulement) ou in out (par adresse en lecture puis écriture)

                    Vérifier chaque spécification (compilation)

                    4 Recenser les tests unitaires qui permettront de valider complètement (tous les cas possibles) une fois son corps réalisé.
                    3 Terminer le codage du corps du programme principal et vérifier la correction des appels aux sous-programmes  (compiler) en faisant l'hypothèse (abstraction) que les sous-programmes existent et fonctionnent correctement.
                    3 Pour développer le corps de chaque sous-programme écrire d'abord son algorithme en utilisant des
                    commentaires AVANT de le coder, puis développer un après l'autre chaque ss-programme et appliquer les tests unitaires prévus. Corriger toutes les erreurs d'un sous-programme avant de passer au suivant. Au besoin pour pouvoir compiler et corriger les erreurs de syntaxe d'un sous-programme X qui appelle un autre sous-programme Y non encore développé, développer un "bouchon" de Y (coder un traitement minimal, par exemple l'instruction "null;" pour une procédure et l'instruction "return [Valeur bidon ou par défaut]" pour une fonction .
                    TD2 (Facebook)
                    • Dimensionnement dynamique du tableau avec un bloc declare/begin/end : version 1
                    • Dimensionnement dynamique du tableau à l'aide d'un appel de fonction : version 2
                    • Dimensionnement dynamique du tableau et creation d'un ss-programme intermédiaire (Traiter_Amis)  : version 3
                    • Un algorithme de tri d'entiers : le tri par sélection
                    • Un algorithme de recherche en table
                    TP2 (Recherche d'un mot dans une chaîne)
                    TD3 (Récursivité)
                    TP3 (Récursivité)

                    TD4 (Pointeurs et listes chaînées)
                    TP4 (Pointeurs et listes chaînées)