Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

UNIVERSITÉ DU QUÉBEC À CHICOUTIMI Module d’ingénierie. ATELIER DE PROGRAMMATION

UNIVERSITÉ DU QUÉBEC À CHICOUTIMI Module d’ingénierie. ATELIER DE PROGRAMMATION 3 TESTS, BOUCLES ET FONCTIONS Omar Noui, Ph. D. Chargé de cours au département d’informatique et mathématique. TABLE DES MATIERES Table des matières............................................................................................... 2 1. Introduction : ................................................................................................ 3 2. Intéraction Utilisateur-machine: ................................................................. 4 2.1. Options d’affichage : ............................................................................... 4 2.2. Entrée d’informations : .......................................................................... 6 3. Expressions logiques : .................................................................................. 8 4. Structures de contrôle : .............................................................................. 10 4.1. Test if : ................................................................................................ 10 4.2. Boucle while : .................................................................................... 12 4.3. Boucle for : .......................................................................................... 14 4.4. Commande break : .............................................................................. 16 5. Les fonctions : ............................................................................................. 17 6. Exemples du cours : ................................................................................... 22 6.1. Méthode du point fixe :......................................................................... 22 6.2. Factorisation de Cholesky : .................................................................. 25 Références : ........................................................................................................ 27 1. INTRODUCTION : Dans cet atelier, nous allons présenter les outils de base de la programmation sur Octave. Premièrement, nous allons exposer les différentes commandes permettant de faciliter l’interaction utilisateur- machine. Ensuite, nous allons présenter les outils permettant d’écrire et de manipuler des expressions logiques (booléennes). Par la suite, nous allons exposer les syntaxes des différentes structures de contrôles (tests, boucles…) en illustrant par des exemples simples et d’autres plus élaborés. Ensuite, nous allons expliquer comment créer des fonctions personnalisées sur Octave. Finalement, nous allons présenter des exemples d’algorithmes en analyse numérique en donnant des explications sur toutes les étapes de leur élaboration. 2. INTÉRACTION UTILISATEUR-MACHINE: Dans cette section nous allons présenter quelques commandes permettant une interaction entre l’utilisateur et le logiciel. Dans un programme, il est possible par exemple d’afficher à l’utilisateur un message d’erreur ou de lui demander de rentrer manuellement la valeur d’une variable. 2.1. Options d’affichage : Il existe plusieurs commandes qui permettent d’afficher des informations ou des messages à l’utilisateur. Voici quelques-unes : a) Commande disp : Contrairement au fait d’écrire seulement le nom de la variable, cette commande n’affiche que son contenu. Voici un exemple illustrant l’affichage sans et avec la commande disp : Le résultat dans la fenêtre de commandes s’affiche comme suit : Il est possible d’utiliser cette commande pour afficher un contenu quelconque sans qu’il soit affecté à une variable. b) Commande printf : C’est une commande permettant d’afficher le contenu d’une ou plusieurs variables de manière plus élaborée. Par exemple, il est possible de spécifier le nombre de décimales à afficher ou de retourner un nombre sous la notation scientifique et plus encore. Le premier argument de la commande peut contenir une chaîne de caractères. Dans chaque emplacement où on veut afficher le contenu d’une variable, on met le symbole % suivit du format d’affichage de ce contenu. Les arguments suivants sont les variables que l’on veut placer saisies dans l’ordre d’affichage. Voici quelques possibilités de formats possibles : %i Affiche le contenu de la variable comme entier (integer) %f Affiche le contenu de la variable comme nombre réel à virgule flottante (float) %e Affiche le contenu de la variable en notation scientifique en utilisant un exposant %s Affiche le contenu de la variable comme chaîne de caractère (string) %% Affiche le symbole de pourcentage % \n Précise qu’il faut retourner à la ligne à ce niveau. %8f Spécifie qu’il faut utiliser 8 colonnes pour l’affichage du contenu en virgule flottante %10.8f Spécifie qu’il faut utiliser 10 colonnes pour l’affichage du nombre avec 8 décimales L’exemple suivant montre comment utiliser les différentes options et syntaxes proposées pour cette commande. Notons que la commande de la ligne 7 doit être écrite sur la même ligne (le retour à la ligne a été effectué seulement pour pourvoir faire la capture d’écran). Le résultat de la commande s’affiche ainsi : c) Commandes warning et error : Ces deux commandes permettent d’afficher un message d’avertissement (ou d’erreur). La différence entre les deux est que error arrête l’exécution du reste du script. Ce qui n’est pas le cas avec warning. Le message d’erreur peut être écrit de la même façon que la commande printf en suivant les mêmes règles. Ceci nous permet d’inclure le contenu des variables en cas de besoin. Dans l’exemple qui suit, nous avons utilisé les deux commandes dans le même script : Remarquons que les deux messages sont terminés par \n(retour à la ligne). Ceci nous permet d’éviter qu’Octave affiche un autre message d’erreur. La commande exécutée sera affichée de la façon suivante : On peut facilement remarquer que le programme a continué son exécution après la commande warning. Cependant, la ligne 7 n’a pas été exécutée puisqu’elle vient après la commande error. 2.2. Entrée d’informations : Dans plusieurs situations, on peut créer un programme qu’un autre utilisateur devra utiliser. Dans ce cas, on peut programmer un script ou une fonction où l’utilisateur devra entrer les valeurs de certaines variables manuellement. Pour se faire, on utilise la commande input. Une fois la valeur est saisie par l’utilisateur, elle sera attribuée à une variable spécifique pour être utilisée dans le programme. Voici un script qui permet de rentrer manuellement un nombre d’heures et le convertir en minutes : On demande à l’utilisateur de rentrer un nombre d’heures que nous attribuant à la variable x. Puis, on lui retourne la valeur en minute en utilisant printf. Dans la fenêtre de commandes, on voit apparaître la phrase : « Entrez un nombre d’heures ». L’utilisateur écrit le nombre d’heures qu’il souhaite convertir (par exemple 31) et puis sur le bouton « Enter ». Le programme convertit ensuite le nombre d’heures en minutes et utilise la commande printf pour retourner la chaîne de caractère avec la réponse comme le montre l’image ci-dessous. Il est possible de vérifier si l’utilisateur a entré une valeur ou qu’il a seulement cliqué sur « Enter » sans entrer aucune information. Pour se faire, on peut utiliser la commande isempty(nom_de_la_variable). Il est aussi possible d’ajouter un arrêt d’exécution d’un script à un emplacement spécifique en ajoutant la commande pause à l’emplacement où on veut que le programme s’arrête. L’utilisateur devra cliquer sur « Enter » pour continuer l’exécution. 3. EXPRESSIONS LOGIQUES : Les expressions logiques (ou booléennes), sont des énoncés mathématiques dont on peut répondre par vrai (1) ou faux (0). En programmation, on a souvent besoin de ce type d’expression pour définir une condition d’application d’un test ou une condition d’arrêt d’une boucle. Octave reconnaît ces expressions comme étant de type logical. En général, ces expressions sont sous forme d’égalité, d’inégalité ou une composition d’expressions. Il est possible de vérifier si une expression est logique en effectuant le test islogical(expr). Ce dernier affiche 1 si oui, sinon il affiche 0. Le tableau suivant présente différents symboles utilisés dans des expressions logiques : x==y eq(x,y) Teste si x est égale à y. x~=y ne(x,y) Teste si x est différent de y. x<y lt(x,y) Teste si x est inférieur strictement que y. x<=y le(x,y) Teste si x est inférieur ou égal à y. x>y gt(x,y) Teste si x est supérieur strictement que y. x>=y ge(x,y) Teste si x est supérieur ou égal à y. Pour que ces expressions soient logiques, il faut que les variables x et y soient affectées par une valeur. Sinon, le logiciel ne pourra pas décider si l’expression est vraie ou fausse. Notons, que deux méthodes sont proposées pour chaque teste. Le tableau ci-dessous donne les différentes opérations logiques que nous pouvons effectuer sur des expressions booléennes : ~expr Effectue la négation de l’expression, c.-à-d. inverser sa valeur de vérité. (Si expr est vraie alors sa négation est fausse et vice versa). expr1 & expr2 and(expr1,expr2) Effectue l’opération du « ET » logique entre les deux expressions, c.-à-d. que pour que le résultat soit vrai, il faut que les deux expressions soient vraies. expr1 | expr2 or(expr1,expr2) Effectue l’opération du « OU » logique entre les deux expressions, c.-à-d. que pour que le résultat soit vrai, il faut que soit l’une, soit l’autre, soit les deux soient vraies. xor(expr1,expr2) Effectue l’opération du « OU exclusif » entre les deux expressions, c.-à-d. que le résultat et vrai l’une ou l’autre et vrai mais pas les deux au même temps. L’exemple suivant illustre les différentes opérations et commandes vues dans cette section : Le lecteur prendra soin de vérifier les réponses dans la ligne de commandes dans la figure ci-dessous : 4. STRUCTURES DE CONTRÔLE : Les structures de contrôle sont des instructions spéciales qui permettent d’exécuter des opérations de manières itératives (boucles) ou sous des conditions (tests). Les structures de contrôle sont la base de la programmation d’algorithmes en analyse numérique. Il est important de comprendre leur fonctionnement et de les utiliser d’une manière appropriée. 4.1. Test if : C’est une structure qui permet d’exécuter des instructions seulement si une ou des conditions sont satisfaites. Le tableau suivant présente les syntaxes possibles de ce test ainsi que leur traduction : if condition instruction 1 else instruction 2 endif (ou end) Si condition (expr logique) est vraie alors on exécute le bloc d’instructions 1. Sinon on exécute le bloc d’instructions 2. if condition 1 instruction 1 elseif condition 2 instruction 2 ⋮ elseif condition n-1 uploads/Industriel/ atelier-3-octave.pdf