Initiation à Algorithmique et programmation en ADA

1. Initiation à Algorithmique et programmation en ADA

2. Infos pratiques • Organisation du semestre : • Cours/TDs • Les TDs sont réalisés en binôme et notés. • Un partiel en janvier. • Bibliographie : • Programmer en ADA95 par John Barnes, 2ième édition, Vuibert, ISBN 2-7117-8651-X • http://crb.univ-littoral.fr/coursada/index.htm

3. L’algorithmique • Définition : • Un algorithme est une suite d’instructions qui une fois exécutée, conduit à un résultat donné. • Exemple : • Fabriquer un brownie : • 1 Préparer la pâte • 2 Faire fondre le chocolat • 3 Mélanger le chocolat et la pâte • 4 Faire cuire 35 minutes • Les instructions sont séquentielles, elle se suivent et doivent être réalisées l’une après l’autre

4. L’algorithmique • Il est possible de raffiner l’algorithme afin qu’il soit plus explicite : • Faire fondre le chocolat : • 2.1 Placer le chocolat dans un récipient • 2.2 Placer le récipient dans une casserole avec de l’eau bouillante • 2.3 Attendre que le chocolat soit fondu • Réaliser un algorithme pour un ordinateur consiste à raffiner suffisamment l’algorithme afin qu’il soit compréhensible pour la machine.

5. Le pseudo-code • Définition • Le pseudo-code est une façon de décrire un algorithme sans référence à un langage de programmation en particulier • Exemple : Programme Daboville Tantque Gérard n’est pas fatigué ramer FinTantque Remarquez l’indentation Pour rendre le code plus lisible

6. Les arbres programmatiques • Il est possible de représenter le programme précédent sous la forme d’un arbre programmatique Début Si Gérard n’est pas fatigué FAUX VRAI Ramer Fin

7. Architecture des ordinateurs Mémoire centrale • Unité Centrale • Lecture de l’instruction • Exécution de l’instruction • Mise à jour de la mémoire Le programme en langage machine, logé en mémoire, est exécuté par le processeur

8. Les différents langages • Ajoutons 5 à la valeur d’une case mémoire • En langage machine : • 80 06 00 00 05 • En assembleur : • Add [I],0x05 • En ADA : • I:=I+5;

9. Le langage machine/assembleur • Avantages • Très rapide à l’exécution, car au plus près de la machine • Adapté au développement de petits programmes critiques tels que : • Les drivers • Des parties du noyau des SE • Inconvénients • Peu lisible -> source d’erreurs • Inadapté au développement de programmes de grandes tailles, au développement par plusieurs équipes • ………

10. Les langages évolués • Exemples • ADA, C/C++, Java, …. • Avantages • Adaptés à la réalisation de gros projets grâce à : • Un style « plus humain » des programmes • L’abstraction des données (par exemple I) • …. • Inconvénients • Plus lent que l’assembleur • …..

11. L ’ADA • Historique : • Commande du département Américain de la défense nationale (DoD) • Hommage à Augusta Ada Byron, comtesse de Lovelace (1815-1852), assistante de Charles Babbage qui travaillait sur sa machine analytique mécanique. Dans un sens très réel, elle est donc le premier programmeur du monde !

12. La compilation • Position du problème : • L’ordinateur ne comprend que le langage machine • D’où la nécessité de traduire les autres langages en langage machine. C’est le processus de compilation. • En 2 phases : • La compilation elle-même qui est la traduction du programme en langage machine • L’édition de liens : qui est l’ajout des éventuelles librairies pour former au final l’exécutable (le .exe sous windows)

13. Entrée / SortiedeDonnées

14. Les variables • Définition : • Une variable correspond à un emplacement précis de la mémoire • En ADA, les variables ont : • Un identificateur : un nom • Un type : entier, nombre réel, chaîne de caractères,… • Une valeur : le contenu de la case • Exemple : I:Integer:=2; • Déclaration d’une variable I de type integer (entier) et dont la valeur est 2.

15. Les variables Mémoire centrale I L’ordinateur choisit une case mémoire pour stocker notre variable. Le langage ADA fait que l’on peut référencer la variable via son identificateur : I

16. Les variables • En ADA, il faut déclarer une variable avant de pouvoir s’en servir. Le choix de l’identificateur doit respecter certaines règles : • Uniquement des lettres majuscules/minuscules, • Le trait bas • Les chiffres de 0 à 9 • Et il faut commencer par une lettre. • Exemple : « Surface :Float; » • Attention, l’ADA ne fait pas de distinction entre les majuscules et les minuscules. On dit qu’il est insensible à la casse.

17. Les variables • Les identificateurs suivants sont corrects : • X1 • Variable_X_12 • Les identificateurs suivants sont incorrects : • 12x (on commence par un chiffre) • Revenu&recette (un caractère non permis dans l’identificateur : le « & »)

18. Les variables • Deux types essentiels : • Les entiers : Integer en ADA, pour stocker des variables qui sont par nature entières. (un nombre d’objets, un compteur,…) • Les flottants : Float en ADA, pour stocker des nombres réels. (les coordonnées x et y d’un point, le résultat d’une division,…) • Remarque n°1 : il est possible de déclarer plusieurs variables simultanément, par exemple : « X1,X2 :Integer ; » • Remarque n°2 : Les types en ADA possèdent des attributs : • Integer ’First désigne la plus petite valeur possible du type Integer • Integer ’Last désigne la plus grande valeur possible du type Integer • Attention à la notation des constantes en ADA : • 23 est nécessairement un nombre de type Integer • 23.0 est nécessairement un nombre de type Float

19. Les variables • Les opérateurs classiques s’appliquent sur ces types : • Les 4 opérations de base. Attention 3/2 donne 1, mais 3.0/2.0 donne 1.5 car la première opération se fait sur des entiers et la deuxième sur les flottants. • ** pour l’exponentiation • Abs pour la valeur absolue • Exemple : I,J:Integer; K:Integer:=4; … I:=K*4; J:=K*I+78**2;

20. Les variables • Opérateurs réservés aux entiers : • rem pour le reste de la division entière. La division euclidienne tronque vers zéro. Cela signifie que la valeur absolue du résultat est toujours la même que celle obtenue en divisant les valeurs absolues des opérandes : • 7/3 = 2 donc 7 rem 3 = 1 • -7/3 = -2 donc –7 rem 3 = -1 • mod pour le modulo arithmétique usuel. Pour b positif, a mod b est toujours dans l’intervalle [0;b-1] et pour b négatif, a mod b est toujours dans l’intervalle [b+1;0] • 11 mod  5 donnera 1  • (- 11) mod  5 donnera 4  • 11 mod (–5) donnera -4

21. Les variables • Opérateurs réservés aux flottants : • sqrt pour la racine carrée : • sqrt(4.0) donne 2.0 • cos, sin, tan, log, ... • Attention à l’ordre de priorité des opérateurs, ne pas hésiter à utiliser les parenthèses : • 2+3*4=14 !

22. Les variables • Attention bis : On ne peut pas mélanger différents types dans une opération. • Exemple : I,J:Float; K:Integer; …. I:=J*2.0; --OK I:=J*K; --illégal • Il faut effectuer une conversion de type, en plaçant le type devant la variable, par exemple : I:=J*Float(K);

23. L’affectation • Définition : • L’affectation consiste à donner une valeur à une variable • Exemple : • En pseudo-code : I  3 J  I+4 • En ADA : I:=3; J:=I+4; • A la fin, I:=3 et J:=7. • Conclusion « := » est le symbole d’affectation en ADA.

24. Structure général d’un programme ADA with Ada.Text_Io; use Ada.Text_Io; procedure Mon_Programme is I:Integer:=3; J,K:Float; begin I:=I+5; K:=3; J:=3*K-7; end Mon_Programme; Déclaration des packages utilisés Déclaration des variables Corps de la procédure

25. Sortie de données • La sortie de données à l’écran s ’effectue via l’instruction « Put », par exemple : Put(« Bonjour le monde  »); Put(45); Put(4.1); Put(I);

26. Put(Integer) • Attention, il faut inclure la directive suivante avant de pouvoir utiliser Put avec les Integer : with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; • Put possède un argument supplémentaire (qui vaut 8 par défaut), la taille minimale des nombres : Put(4,3); affiche : _ _ 4, mais Put(4,4); affiche : _ _ _ 4.

27. Put(Float) • Attention, il faut inclure la directive suivante avant de pouvoir utiliser Put avec les Float : with Ada.Float_Text_Io; use Ada.Float_Text_Io; • Put possède 3 arguments supplémentaires : • Put(X,N1,N2,N3); avec : • X : le nombre à afficher • N1 : le nombre de chiffres avant la virgule • N2 : le nombre de chiffres après la virgule • N3 : le nombre de chiffres de l ’exposant

28. Autre commande • « New_Line » pour passer à la ligne : New_Line; passe une ligne New_Line(4); passe 4 lignes

29. Entrée de données • L ’entrée de données se fait via l’instruction « Get ». Elle s’utilise de la même façon que « Put ». • Exemple : with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; ….. I:Integer; … Get(I);

30. Autre commande • Get pioche dans le tampon clavier les données dont il a besoin et laisse les autres : On tape 12 28 44 Get(I) va affecter la valeur 12 à la variable I et le tampon deviendra : 28 44 • Pour palier à ce fonctionnement, il est possible de vider le tampon en utilisant l’instruction « Skip_Line »

31. Les structures alternatives

32. Les booléens • Définition : • Le type booléen (boolean en ADA) correspond à une variable pouvant prendre uniquement 2 valeurs : VRAI ou FAUX (True ou False). Le nom est en hommage à George Boole qui développa l’algèbre de Boole. • Exemple : Test: boolean; ….. Test:=True;

33. Les booléens • De nouveaux opérateurs sur les entiers et les flottants : « a = b » prend la valeur True si a est égal à b « a /= b » prend la valeur True si a est différent de b «  a > b » prend la valeur True si a est supérieur à b «  a >= b » prend la valeur True si a est supérieur ou égal à b Idem pour « < »

34. Les booléens • Exemple : Test:Boolean; A,B:Integer; …. A:=3; B:=4; ….. Test:=A<=B; .. A la fin du programme Test prend la valeur True.

35. Les booléens • Les opérateurs réservés aux booléens : • « not » l’opérateur unitaire qui change True en False • « and » l’opérateur binaire : et logique. Le résultat est True uniquement si les 2 opérandes valent True • « or » l’opérateur binaire : ou logique. Le résultat est True si l’un ou l’autre des opérandes vaut True, et False si les 2 opérandes sont False • « xor » l’opérateur binaire : ou exclusif. Le résultat est True si l’un des 2 opérandes (mais pas les 2) vaut True. On peut aussi le considérer comme l’opérateur donnant True uniquement quand les 2 opérandes sont différents.

36. Les booléens • Exemple : T1,T2:Boolean:=True; ….. T1:=not T2; (T1 vaut False) T2:=T1 or T2; (T2 vaut True) T2:=T1 and T2; (T2 vaut False) T2:=(2<3) or T1; (T2 vaut True)

37. La structure « if » • Définition : • Elle permet au programme de prendre des décisions, par exemple en pseudo-code : A3 Lire B Si A<B alors Ecrire « A est inférieur à B » Sinon Ecrire « B est inférieur à A » Fin Si

38. La structure « if » • Le même exemple en ADA : A:=3; Get(B); if A<B then Put(« A est inférieur à B »); else Put(« B est inférieur à A »); end if;

39. Les différentes formes du « if » • La plus simple : ifconditionthen instructions …. end if; • Avec un else : ifconditionthen instructions …. else instructions …. end if;

40. Les différentes formes du « if » • Avec un ou plusieurs elsif : ifcond1then instructions …. elsifcond2then instructions …. elsifcond3then instructions …. …. else instructions …. end if;

41. Les « if » imbriqués • Les instructions placés au sein des parties du « if » peuvent être quelconques. On peut par conséquent insérer une deuxième structure « if » à l’intérieur de la première, par exemple : ifa/=0then ifb**2-4*a*c>0then instructions …. end if; else instructions …. end if;

42. La structure « case » • Celle-ci peut remplacer avantageusement une série de elsif dans certains cas particuliers. case variable is when valeur1 => instructions; …. when valeur2 => null; when valeur3..valeur4 => instructions; …. …. when others => instructions; end case; • Explications : • Quand la variable prend la valeur « valeur1 » alors c’est uniquement les instructions correspondantes à cette valeur qui sont exécutées. La troisième condition est une plage de valeurs entre valeur3 et valeur4. Enfin, others, correspond au comportement par défaut si aucune condition n’est réalisée.

43. Les structures répétitives

44. L’instruction « loop » • La forme la plus simple des structures répétitives est l’instruction loop, exemple : loop instructions… end loop; • Il est possible de sortir de la boucle en utilisant le mot-clé « exit ». Par exemple : loop instructions… if a/=0 then exit; end if; end loop;

45. L’instruction « loop » • La structure « if cond then exit ...» est si commune qu’elle possède une notation particulière : « exit whencond ». Ainsi on peut écrire : loop instructions…. exit whencond; instructions…. end loop;

46. L’instruction « while » • Si le test a effectuer pour sortir de la boucle doit se faire au début de celle-ci, on peut alors utiliser une construction avec « while », dont voici la syntaxe : while cond loop instructions…. end loop; • En pseudo-code, on écrira : Tantquecond instructions… Fin Tantque • Remarque : l’instruction est répétée tant que la condition est VRAI

47. L’instruction « for » • Le nombre de répétitions d’une même suite d’instructions est souvent connu. On utilisera dans ce cas une structure « for ». • La syntaxe est la suivante : for X inV1..V2loop instructions…. end loop; • Dans cette exemple, la variable X va prendre toutes les valeurs entre V1 et V2 puis la répétition va se terminer. • Remarque 1 : Dans ce cas précis, il n’est pas nécessaire de déclarer la variable X avant son utilisation.

48. L’instruction « for » • Remarque 2 : V1 est obligatoirement inférieur à V2. Si l’on veut parcourir la plage de valeurs dans le sens contraire, il faut ajouter « reverse » à l’entête : for I in reverse 14..45 loop Put(I); end loop; • Le programme précédent va afficher les nombres de 45 à 14 dans cet ordre. • En pseudo-code on écrira : Pour I allant de 45 à 14 Ecrire I Fin Pour

49. Les tableauxPremière partie

50. Définition • Un tableau est une structure permettant de stocker un ensemble de variables du même type. • Par exemple : Supposons la nécessité de stocker les notes d’une classe à une épreuve. On déclare alors un tableau de dimension la taille de la classe, puis on y stocke les notes. • La note N°4 est 6