Cours de Programmation Appliquée à la Chimie J.Y. Raty jyraty@ulg.ac.be 3/47 Tel:04/3663747 Gsm: 0495/334473

Environnement But du cours Programmation en calcul scientifique Esprit critique et logique dans la programmation Utile au chimiste Ouverture vers la simulation numérique Expériences virtuelles Tout se trouve-t-il dans le commerce ? Adaptibilité Environnement Langage : Fortran 90 (C++) Systèmes : Windows/Unix Terminal : PC/X Ordinateur : Machine Calcul (calcul.ulg.ac.be) Travail : Interactif Avec/ sans fichier Avec/ sans usage de librairie Transfert -> PC (présentation/graphisme)

T.P (2 séries) Plan du cours numériques (peu) non-numériques 30’ Introduction et rappels 1h00 Structure de programmation 4h Langage FORTRAN 90 5h Algorithmes numériques (peu) non-numériques 3h Simulations numériques 1h30 Commentaires et exercices T.P (2 séries) 1 Initiation 2 Exercice algorithme classique 3 Sous-routine, Librairie 4 Simulation 5 Simulation, transfert->PC (analyse/graphisme)

Cours 1 Généralités Structures de programmation Informatique – Programmation Ordinateur Représentations des nombres en mémoire Structures de programmation Mini – langage + Schematique Déclaration, variables, boucles, conditions…

Définitions Programmation “Moyen utilisés pour passer de concepts humains vers une représentation electronique (mécanique) exécutable par une machine” Informatique “Science du traitement rationnel de l’information considérée comme le support des connaissances humaines et des communications” Notion de MULTITUDE : des données à traîter répétition des mêmes operations

Programmation Que veut-on résoudre ? Formulation du problème Problème : - données, paramètres - résultats Formulation du problème formules mathématiques formulation logique envisager toutes les situations possibles Traduction en schéma logique Algorithmique Prise en compte des données, paramètres Sortie des résultats Lire tout ! Pas dans le programme ! Contraintes : rapidité d’exécution volume des transferts mémoire -> processeur (CPU) précision voulue usage de support externe ( librairie math, graphique) portabilité (ANSI + extensions constructeurs bigendian, little endian…)

Quelques définitions 1 bit : 0 ou 1 1 octet = 8 bits 1 mot : 4 octets 1 1 mot : 4 octets 1 kilooctet (kilobyte, KB) = 1024 octets /= Kb Digital (0/1) vs Analogique (continu) 1 kilooctet (kilobyte, KB) = 1024 octets

Représentation des nombres et précision 4.1. Base Définition : nombre utilisé pour élaborer un système d'énumération. Au-delà de ce nombre, on ajoute une rangée supplémentaire. Base 2 : seule base utilisable dans un ordinateur (cf. supra à la définition du bit). Exemple : écrire 37 dans cette base 37 = 32 + 4 + 1 = 25 + 22 + 2° . L'ordre des puissances de 2 est... 26 25 24 23 22 21 2° . La représentation de 37 sera dès lors :...0100101 . Base 10 : celle que nous utilisons habituellement. Base 16 : base hexadécimale. Son utilisation, notamment dans les adresses, repose sur le fait qu'un octet peut se diviser en deux demi-octets (2x4 bits). Chaque demi- octet pouvant prendre 16 valeurs différentes (24). Hexadécimale :0123456789 A B C D E F Décimale : 0123456789 10 11 12 13 14 15.

4.2. Représentation des nombres dans un ordinateur Nombre d’octets dépend du constructeur… Nombre entier : la représentation se fait en base 2 pour les nombres entiers positifs et en base 2-le complément pour les nombres entiers négatifs. Une représentation habituelle se fait en 4 octets, soit 32 bits. Un bit, celui de gauche, est réservé au signe. Dès lors, nous en déduisons que 0 sera représenté par 31 bits nuls (-1) sera représenté par 31 bits un le nombre de nombres entiers positifs sera égal à 231 -1 = 2147483647 le nombre de nombres entiers négatifs sera égal à 231 le plus grand entier positif est égal à 2147483647 le plus grand entier négatif est égal à - 2147483648 les non signés (> 0) utilisent 32 bits 1 … 1 bit Signe 31 bits pour nombre

Exemples : 127.48 -> 0.12748 x 10 3 , 0.00348 -> 0.348 x 10 -2 . Nombre réel ou flottant :, le constructeur décide du nombre total d'octets pour représenter le nombre réel et au sein de ce nombre total, de la répartition pour la représentation d'une part de l'exposant et d'autre part de la mantisse. Exemples : 127.48 -> 0.12748 x 10 3 , 0.00348 -> 0.348 x 10 -2 . la partie décimale s'appelle la mantisse, toujours comprise entre 0 et 1, la puissance de 10 s'appelle l'exposant. Une représentation courante est donnée par un mot de 4 octets (simple précision) : 1 octet exposant, 3 octets mantisse - Le domaine limité (exemple : de 10-77 à 1077) - la précision est pour ce choix de l'ordre de 10 -6 . Les nombres réels sont donc des objets discrets. Intervalle fini entre des nombres réels adjacents, la grandeur de cet intervalle est donnée par la précision de la représentation. Une réduction de l'intervalle peut être obtenue en allouant à la représentation du nombre réel un nombre plus élevé d'octets (8 octets donneront une précision d'environ 10-14). 1 1

Et les lettres ? Table de correspondance ‘ ASCII’

5.1 Niveaux de Langage La compréhension d'un langage pour l'homme et celle pour la machine varie en sens inverse. Plus il se rapproche du langage humain, plus il est incompréhensible par l'ordinateur et vice-versa. Les trois niveaux principaux sont : Langage machine ou binaire : langage de base pour un ordinateur car reposant sur l'état physique ; passage ou absence de courant. Langage d'assemblage : langage basé sur des mnémoniques alphabétiques. Un programme spécial appelé Assembleur traduit les instructions en langage machine. Langages de programmation : relativement aisé à comprendre par l'utilisateur. Sa traduction en langage binaire se fait soit par un interpréteur : programme écrit en langage machine et décodant le programme soumis ligne par ligne en simultanéité avec la prise des données. Il fournit de suite la (les) faute(s) d'exécution s'il y a lieu. Sa performance est médiocre au niveau de l'exécution. Soit par un compilateur : programme traduisant en langage binaire l'ensemble du code soumis et l'arrangeant pour une exécution optimale. La traduction est dissociée de l'exécution.

Choix du langage… Functionality F77 C C++ F90 Numerical robustness Data parallelism Data abstraction Objected oriented programming Functional programming Average 2 3 4 3,4 3,2 1 2,2 1,2 Ref : J. Wagener, Fortran 90 and Computation Sciences.

Architecture de l’ordinateur ‘Hardware’ Logiciel = software Système d’exploitation = OS (Linux, Windows, MacOS) msec Nano-sec (GHz) Le ‘bus’ limite la rapidité du tout…

Structures de programmation Affectation Action : prend le résultat d'une opération ou le contenu de la mémoire correspondant au membre de droite sans le modifier pour le placer dans la mémoire correspondant au membre de gauche en remplacement de ce qui existe. Exemples :   l'opération algébrique a = b x 2.5 + d sera représentée par a  6*2.5+d incrémenter une variable x d'une unité : x  x+1. le contenu de la mémoire affectée à x est augmenté d'une unité et le résultat replacé au même endroit. Elever au carré x  x * x

Affectation suite variables a , b : réelles a  a+b b  a-b a  a-b Exemple tordu : échange du contenu de deux zones de mémoire avec seulement 2 variables… variables a , b : réelles a  a+b b  a-b a  a-b Faire 3 variables au tableau puis

Conversion 1.2. Conversion C C C Action : transfère la valeur d'une variable ou d'une expression (algébrique ou caractère) d'un type donné vers une variable ou une expression d'un autre type.   Exemples : a) Déclare ; m, n : Entier Déclare ; x,y,z : Réel m x/y+z b) Déclare ; x : Réel Déclare ; zz : Complexe zz x Il y aura affectation de x à la partie réelle de zz et zéro à sa partie imaginaire.  ATTENTION conversion réel vers entier…. C C

Opérateurs Addition + Soustraction - Multiplication * Puissance ** Division / concaténation (de caractères) -concat-­ Exemples : x <- (a+b)*c y <- (a+b)**0.5/42. titre <- sous-titre-concat-paragraphe

Vrai pour logic1 et Faux pour logic2 Opérateurs logiques De relation entre variables ou expressions réelles, entières, caractères Représentation : = , < , <= , > , >= , < > Action : ces opérateurs comparent deux variables entre elles et fournissent un résultat logique. Déclare rien Déclare ; S1, S2, y, z: Réel Déclare ; logic1, logic2 : Booléen Type ; (pi  3.1415) (Supposons qu'après acquisition des données, nous ayons y=5., z=3.) S1  pi*y*y S2  pi*z*z logic1  S1 > S2 logic2  - S1<=S2 Vrai pour logic1 et Faux pour logic2

Opérateurs logiques De relation entre variables ou expressions logiques Représentation : et , ou , non, ou exclusif. Action : ces opérateurs fournissent un résultat logique suite à une comparaison entre deux variables ou expressions logiques ou à une action sur une variable ou expression logique.   Déclare ; l1, l2, l3, l4, l5, l6 : Booléen (Supposons que les valeurs suivantes soient affectées à I1, I2, I3 : I1  Vrai, I2 <- Faux, I3 <- Vrai) I4  I1 et I3 I5  I1 et I2 I6  I1 ou I3 (Nous trouverons Vrai pour I4, Faux pour I5, Vrai pour I6) I4  non I1 I5  non (I1 et I2) I6  I1 et (non 12) (Résultat : Faux pour I4, Vrai pour I5, Vrai pour I6).

Déclarations Toutes les variables doivent être déclarées 3.1. Déclaration de non existence  Représentation : Déclare ; Rien  Action : stipule au compilateur qu'aucune variable n'existe.   3.2. Déclaration explicite Représentation : Déclare ; Liste des variables : Type Action : stipule que les variables reprises dans la liste appartiennent au type donné. Elle définit la nature des informations représentées par la variable, son genre d'encodage binaire et dès lors sa précision et ses limites et enfin les opérations autorisées sur cette variable.  - Entier (INTEGER), court, normal ou long - Flottant ou Réel (MAL), normal, double, quadruple - Complexe (COMPLEX) composé de deux flottants et pouvant être normal ou double - Booléen (ou logique) - Caractère (type non numérique) pour une variable représentant un ensemble de caractères et dont la longueur est à spécifier - Pointeur (voir le sous-chapitre C dédié à cette variable) - Structure ou objet personnalisé.

3.3. Déclaration implicite Représentation : Déclare ; genre de variables ; Type. Action : stipule que toutes les variables reprises dans le genre mentionné font partie du type donné. Exemple : Déclare ; Toutes les variables commençant par C; Complexe. 3.4. Déclaration de dimension Représentation : Dimension ; Variable 1(Début : Fin), Variable 2 (Début : Fin, Début : Fin). Action : prévient le compilateur de réserver à l'exécution du programme une zone mémoire adéquate pour la Variable 1,... Début indique la numérotation du premier élément de la variable et Fin la numérotation du dernier élément. Note : cette déclaration s'adresse, bien évidemment, aux vecteurs et matrices multidimensionnelles. Fin doit être supérieur à début. Exemples : Dimension ; x(-15:-7), y(36:43, 0:8) Dimension ; racine (1:120).

Lecture/Ecriture 4.1. Structure de lecture Représentation : Lire (endroit, comment) Var 1, Var 2, ... Action : au moment de l'exécution, le programme va lire, à l'emplacement spécifié par endroit suivant la présentation décrite par comment, les valeurs à affecter à Var 1, Var 2, ... Note : la nomenclature des variables porte le nom de liste. L'affectation des valeurs aux membres de la liste est toujours impérative. L'instruction de lecture peut remplacer l'affectation. 4.2. Structure d'écriture Représentation : écrire (endroit, comment) Var 1, Var 2,... Déclare; rayon, aire: Réel Type;(pi  3.14159) Ecrire(écran,format standard) 'entrer un rayon' Lire(clavier,format standard)rayon aire  pi*rayan*rayon Ecrire(écran,format standard) 'aire du cercle=', aire

Structures de répétition 1) Répétition avec indice   Représentation : Pour x variant de m à n , par pas de dx répéter Action 1 Action 2 Fin répétition x Déclare Rien Déclare ; l, J, K : Entier Déclare ; x,y, : Réel J <- 0 X <- 0. K <- 5 Pour I allant de -5 à +8 par pas de 1 répéter J <- J+1 x <- K*l+x y <- x+2*I Fin répétition 1 Ecrire (Disque, libre) J, x, y. Le résultat sera J=21, x=105. et y=121. La variable-indice passe effectivement par la borne 8. Toutefois, la valeur de 1 après l'instruction Fin de répétition 1 sera de 9. boucles, loop

Imbrication

2) Répétition conditionnelle   Un groupe d'action peut être répété tant qu'une condition est vérifiée. Cette condition est une expression logique qui ne prend que deux valeurs : Vrai ou Faux. Tant que Condition répéter Action 1… …Action N Fin répétition conditionnelle  autre : Répéter   …Action N Tant que Condition. Différence entre les 2 ?

Choix a) Si Condition alors Action 1 Fin Condition  2.1. Alternative simple   La question est unique et la réponse peut être simple ou alternative. a) Si Condition alors Action 1 Fin Condition b) Si Condition alors Action 1 sinon Action 2 Action : si la Condition est Vraie, l'ordinateur réalise alors les actions 7 et suivantes dans les deux cas ; si la Condition est Faux, dans le cas a), il ne se passe rien ; dans le cas b), il réalise les actions 2 et suivantes. a <- 5.28 b <- 10.4 Si (a < b) alors c = a+b sinon c = a-b Fin condition La valeur de c sera de 15.68.

2.2. Alternative multiple Les questions pouvant être multiples et enchaînées, les conditions vont s'imbriquer selon un arbre. Si Condition 1 alors Action 1 Sinon Condition 2 alors Action 2 Sinon Action 3 Fin des Conditions

Saut d’instruction Normalement, les instructions s’enchaînent en séquence mais on peut rompre la séquence par un saut Aller vers Adresse 1 Adresse 2 Action 1 Action N Adresse 1 Action N+1

Appel à un sous-programme Un sous-programme ou module est un programme possédant un nom qui permet à tout autre programme (ou à tout autre sous-programme) de l'appeler afin de lui faire exécuter une certaine tâche. Deux types de variables : * la variable locale : celle qui est définie uniquement entre l'ouverture et la fermeture d'un ensemble ou d'un sous- ensemble ; * la variable globale : celle qui est commune à un ensemble et un (des) sous­ensemble(s) appelé(s) par l'ensemble ou à des sous-ensemble(s) s'appelant l'un l'autre. Représentation : Appel Nom-Sous-programme (Variable 1, Variable 2, ..., Variable N). Action : à l'appel de Nom-sous-programme, on exécute une tâche donnée décrite par ce sous-programme en ayant au préalable défini les valeurs des Variable 1, Variable 2,...qui lui sont nécessaires pour l'exécution. Au retour, on reçoit les nouveaux résultats par d'autres variables (par exemple : Variable N-1, Variable N) ou par les mêmes variables qui ont servi à l'entrée. L'ensemble des variables transitant du programme appelant vers le sous­programme s'appelle la liste. La valeur attribuée à Variable 1 passera à la Variable 1' du sous-programme. - Si le résultat (ou un des résultats) revient via Nom-sous-programme, alors le sous-programme est appelé Fonction. Nom-Sous- Programme (Variable1 ', Variable2', . . . , VariableN') Déclaration de variables locales et/ou globales Action 1 Action M Fin

Sommation et multiplication d'une série de termes Premiers algorithmes Sommation et multiplication d'une série de termes où yi représente : - soit un élément de tableau - soit une grandeur évaluée à chaque bouclage et dépendant évidemment de la variable-indice i (##) Dans les deux cas, l'indice i est un entier. On peut également spécifier un incrément différent de 1 à i.   Déclare ; Rien Déclare ; S, P, x, y: Réel Déclare ; i, M : entier S  0. (Initialisation - Important !) P  1. Pour i allant de 1 à M répéter (L'incrément de i n'est pas indiqué) Action 1 y  résultat des opérations fonction de i x  résultat des opérations fonction de i S  S+y P  P*x Fin répétition i ##

Cours 2 Langage F90 Programme 1 Algorithme ( Mini-langage) : Commentaires – Constante – Variable – Déclaration – Tableau (allocation statique – dynamique) – Opérations - Conversions Programme 1 Erreurs de compilation Erreurs d’exécution Underflow / Overflow Algorithme ( Mini-langage) : Sommation avec poids alternés

Premiers programmes Edition - Compilation – Linkage – Exécution Notions : Entiers – Réels – Complexes Simple-Double precision Underflow-Overflow Tableaux

Why ?…part 1. Synthèse de diamants : dans l’espace, par détonation… Besoin de modélisation Simulation : 3 nanomètres et ‘Buckydiamonds’ JYR et Giulia Galli, Nature Materials 2 (2003)

Etapes de la réalisation d’un prg (f90) Program voici Implicit none … 1) Edition du texte (source) -> mon_programme.f90 2) Compilation et production fichier objet -> mon_programme.o 011000101010100101000101010101010111100010000 011000101010100101000101010101010111100010000 3) Linkage et production fichier exécutable -> mon_programme.exe 00101010101111100011101010010000011

Structure prg testint_A Déclare : rien Déclare ; I,J,K : entiers I  758358974 J  2100000000 K  I + J Ecrit (écran, libre) I, J, K Fin

Structure prg testint_B Déclare : rien Déclare ; A1,A2,A3 : réel simple précision A1 0.23E+15 A2  0.47E+25 A3  A1*A2 Ecrit (écran, libre) A1, A2, A3 A1  0.23E-39 A2  0.47E-25 A3  A1*A2 Fin

Structure prg testint_C Déclare : rien Déclare ; A(4,5),B(4,5) : tableaux de complexes A  1.+ 3. * i Ecrit (écran, libre) A B conjugue(A) Ecrit (écran, libre) B Fin

Structure prg testint_D Déclare ; rien Déclare ;B1,B2,B3,B4 :réel double précision B1  0.44562314521 D 108 B2  0.98 D 200 B3  B1*B2 Ecrit (écran, libre) B1, B2, B3 B4  3.6 D 300 B3  B1*B4 Ecrit (écran, libre) B1, B4 Fin

1) Edition du Fichier SOURCE : testint.f IMPLICIT NONE ! 1) Premiere partie : déclarations !-------------------------------------- REAL:: A1,A2,A3 ! reels simple précision (4octets) REAL*8 :: B1,B2,B3,B4 ! reels double précision (8octets) INTEGER :: I,J,K ! entiers simple précision COMPLEX A(4,5),B(4,5) !A et B sont de TABLEAUX de 4*5 complexes simple prec. ! ! 2) Instructions à exécuter - somme d'entiers !----------------------------------------------- I=758358974 ! maximum 2147483647 J=2100000000 K=I+J ! I+J donne un OVERFLOW (en fait, n'importe quoi...) WRITE(6,'(3(A,I12,2X),/)') ' I=',I,' ;J=',J,' ;K=I+J=',K ! 3) Produits de reels - simple precision -> E !------------------------------------------------ A1=0.23E+15 ! +14 est le maximum pour la multiplication avec A2 (INF pour 10**39) A2=0.47E+25 ! +25 A3=A1*A2 ! OVERFLOW WRITE(6,'(3(A,E12.5,2X),/)')' A1=',A1,' ;A2=',A2,' ;A3=A1*A2= ',A3 ! 4) Illustration UNDERFLOW !------------------------------ A1=0.23E-39 ! -39 est le minimum A2=0.47E-25 ! -25 A3=A1*A2 WRITE(6,'(3(A,E12.5,2X),/)')' A1=',A1,' ;A2=',A2,' ;A3=A1*A2=' c ,A3 A=1.+ (0.,1.)*3. WRITE(6,'("Table A :",/,5(F3.1,1X,F4.1,3X),/)') A B=CONJG(A) WRITE(6,'("B = CONJUG(A) :",/,5(F3.1,1X,F4.1,3X),/)') B ! 5) Operations en Double precision -> D !------------------------------------------- B1=0.44562314521D108 B2=0.98D200 B3=B1*B2 ! valeur exposant maximum 308 - OUF WRITE(6,'(3(A,D19.12,1X),/)')' B1=',B1,' ;B2=',B2,' ;B3=B1*B2=',B3 B4=3.6D300 B3=B1*B4 WRITE(6,'(3(A,D19.12,1X))')' B1=',B1,' ;B4=',B4,' ;B3=B1*B4',B3 END 1) Edition du Fichier SOURCE : testint.f 2) Compilation/Link du Fichier SOURCE vers testint.exe 3) Exécution : testint.exe

Algorithme : sommation alternée (ex : Simpson) 10000 termes = 30000 opérations (2*10000 + 10000) Ok, mais …..maladroit, inélégant Mieux, mais trop d’opérations ! 10000 termes = 20002 opérations (10000 +10000 +2) 10000 termes = 10006 opérations (5000+1) + (5000+1) +1 + 1 +1 +1 Représentation idéale pour notre prg:::

Structure Déclare ; Rien Déclare; S, S1, S2, h, x, binf, bsup : Réel Déclare ; i, n : Entier h  (bsup – binf)/(n-1) S1  0 S2  0 x  binf Pour i allant de 2 à n-1 par pas de 2 répéter x  x+h S1  S1 + f(x) S2  S2 + f(x) Fin répétition i S  h/3. * ( 4.*S1 + 2*S2 + f(binf) – f(bsup) ) Fin binf bsup 1 2 3 n-1 n f1 fn

Cours 3 Langage F90 Programmes 2-3-3bis Algorithme : Rappel formule : Opérations sur “character” Boucles : Do, Do while, implicites Conditions : if, if then, if then else Operations sur tableaux Programmes 2-3-3bis Types de variables, Boucles Algorithme : Intégration par Monte Carlo  prg 4 Rappel formule : Integration méthode de Gauss

Why ?…part 2. Hydrogen sous haute pression Fusion ? Stanimir Bonev, Giulia Galli et al. Nature 7009 (2003) Besoin de modélisation Simulation : H est superfluide si la fusion se passe avec P > 900kbar

Programme 2 : Types de Variables Editer le fichier exe1.f Compiler vers exe1.exe Exécuter exe1.exe Notions : PARAMETER – DIMENSION – Allocation dynamique CHARACTER – lectures - écritures Remarque : exécute 2 fois -> les nombres ‘aléatoires’ ne le sont pas …

Programme 3 : Boucles DO sans conditions Edition de exe2.f Compilation (+link) vers exe2.exe Execution de exe2.exe Notions : DO-ENDDO, IF-ENDIF RESHAPE, CYCLE, EXIT, STOP

Programme 3B : Boucles DO sans conditions Edition de exe2bis.f Compilation (+link) vers exe2bis.exe Exécution de exe2bis.exe Notions : CASE,WHERE, FORALL

Boucle implicite Forme Exemple (A(I),I=1,5,2) Write(*,*)(A(I),I=1,5,2) -> écrit les valeurs de A(1), A(3), A(5)

Programme 4 : DO WHILE Exécuter Notions : ! Conversion d'un entier en un character ! Conversion d'un nombre entier en un nombre "caractere" (ici à 14 positions) IMPLICIT NONE CHARACTER*1 C2(14) INTEGER NUM,NUM2,I,K CHARACTER*1 :: C(0:9)=(/'0','1','2','3','4','5','6','7','8','9'/) WRITE(6,*)' Donner un nombre entier inferieur a 2147000000' READ(5,*) NUM C2='*' ! identification à 14 étoiles K=0 NUM2=NUM DO WHILE (NUM/=0) I=NUM-(NUM/10)*10 C2(14-2-K)=C(I) ! laisser 2 étoiles à droite du nombre K=K+1 NUM=NUM/10 ENDDO WRITE(6,'(14A,3X,I15)') C2,NUM2 PAUSE;END Notions : Conversion entier -> charactère

Sommation avec signe alterné avec i variable entière.   Déclare; Rien Déclare ; i, M; Signe : Entier Déclare; y, S : Réel S  0 (Initialisation de la Somme) Signe  +1 (Initialisation du signe. Attention, s'assurer que l'initialisation donne bien au premier tour le signe indiqué par la formule) Pour i allant de, 1 à M répéter (L'incrément de i est ici 1) Signe  Signe*(-1) …Action y  résultat des opérations S  S + Signe * y Fin répétition i

Algorithme : Recherche de maximum et de minimum Représentation (cas discret) :   Déclare Rien Déclare ; a, Max, Min : Réel Déclare ; Imax, Imin, i : Entier Dimension ; a(0:100) (L'ensemble discret de valeurs ou les valeurs de la fonction continue calculées sur des points donnés du domaine ont été affectés aux éléments du tableau a). (On suppose que les points sont numérotés de 0 à 100. Généralisation immédiate). Max  a(0) Min  a(0) Imax  0 Imin  0 Pour i allant de 1 à 100 par pas de 1 répéter Si (a(i) > Max) alors Max  a(i) Imax  i Fin condition Si (a(i) < Min) alors Min  a(i) Imin  i fin répétition i

Application 1 : Intégration d’une fonction Méthode des Trapèzes et de Monte Carlo f(x2) x_max f(x_max) f(x1) Aire2 Z_al F(z_al) Aire1 x0 x1 x2 x3 x4 xN Tirs aléatoires : # coups ‘In’ / # coups total

Nombres pseudo-aléatoires Pseudo (utilise un algorithme basé sur le contenu d’une adresse mémoire, par exemple horloge…) Integer :: iseed Iseed =… Call srand(iseed) A = rand() B = rand() Génère une quantite de nombres pseudo (selon la valeur de iseed) et retient la position du 1er 00101111 00101011 00101001 00100011 Lit la valeur et place l’index sur le suivant Attention : peut varier d’un compilateur à l’autre (ran, random_number etc…)

F(x)=a*x+b/x+c*x**(2./3.) Edition integ.f Exécution integ.exe Remarque : attention aux bornes pour x -> ajouter des tests lors des lectures Objet de la 1ère séance de T.P

Cours 4 Langage Algorithme : Recherche Max/Min/Racine Fonctions (prg5) Sous-routines Algorithme : Recherche Max/Min/Racine Rappel formule : Intégration méthode de Gauss

Algorithmes Recherche Min/Max/Rac 1) Bissection

Algorithmes Recherche Min/Max/Rac 2)Newton-Raphson

Cours 5 Langage Rappel formules : Sous-routines Entrées/Sorties Variables globales Rappel formules : Formule de dérivation Interpolation de Lagrange Integration Euler Runge Kutta Tri à bulles et tournoi Minimisation : moindres carrés ET PLUS SI AFFINITES….

Why ? Se est semiconducteur Et si Se est confiné ? Expériences en cours… -> Simulation : dans la silicalite Why ? Se est metallique dans ce canal ! Laser La lumière connecte les chaines: Se est conducteur dans les 2 directions !

Programme 5 : Fonctions Fonction formule 3 types de fonctions Fonction formule Fonction externe (p.ex. d’une librairie) Sous-routine BUT : Structurer le programme. Simplifier la compréhension Source Exécution

Fonction Formule Implicit none Real*8 :: X,Y,FUNCJY FUNCJY(X,Y)=X+Y+2 Write(*,*)FUNCJY(2.0D1,3.0D2) END

Fonction externe Implicit none Real*8 :: X,Y,FUNCJY X=2.0D1; Y=3.0D2 Write(*,*)FUNCJY(X,Y) END Function FUNCJY(A,B) Real*8 :: A,B,FUNCJY FUNCJY=A+B

Sous-routine Bloc d’instructions (petit programme) Appel : Syntaxe Call MySubroutine(Arg1, Arg2…) Syntaxe Program … End Subroutine Mysubroutine(MonArg1, MonArg2…) Integer :: MonArg1, MonArg2 !exemple MonArg2=MonArg1*10 !exemple Différent d’une fonction : le nom ne retourne pas de valeur et n’a donc pas de type (pas de déclaration dans le programme appelant).

Programme 5 : Fonctions Fonction formule 3 types de fonctions Fonction formule Fonction externe (p.ex. d’une librairie) Sous-routine BUT : Structurer le programme. Simplifier la compréhension Source Exécution

Entrees-Sorties 1 : Lire dans un fichier Syntaxe : READ( où, comment) Avec où : un entier, par défaut, 5 = clavier comment : un format(code spécial), * = libre Exemple Read(5,*) a,b Read(3, 2F12.5) a,b Pour être accessible, un fichier doit d’abord être ouvert Syntaxe OPEN(identifiant, caractéristiques) Où identifiant = un entier Caractéristiques = descriptions (séparées par des ,) Exemples Open(3, file=‘spectre.dat’,form=‘unformatted’,status=‘old’)

Entrées-Sorties 2 : Ecrire dans un fichier Syntaxe : WRITE( où, comment) Avec où : un entier, par défaut, 6 = écran comment : un format(code spécial), * = libre Exemple Write(6,*)’Resultat’, a+b, ‘avec a,b=‘,a,’,’b Write(6, 2F12.5) a,b Variante : format réutilisable : instruction FORMAT Write(6, 100) a,b !100 est une adresse, nr donne a une ligne 100 FORMAT(2D12.5) Variante : si form = ‘UNFORMATTED’ WRITE(où) Après utilisation, un fichier doit d’ être refermé Syntaxe CLOSE (identifiant) Où identifiant = un entier !qui identifie un fichier Exemple compliqué… Close(12)

Formules Algorithme Tri à bulles + programmation LIVE Formule de Lagrange en 4 points Statistiques Intégration méthode de Gauss Algorithme Tri à bulles + programmation LIVE

Structure du programme real*8, allocatable :: x(:) Integer :: N Call Lit_data(N, x) Call Trie_data_bulles(N,x) Call Ecrit_data(N,x)

Les formats pour Entrées/Sorties (I/O) Appel (p.ex.) Write(6,101)’Coucou’,a,b,I format(A6,F12.5,D12.5,3X,I4) Les principaux codes An Chaîne de n caractères In Entier à n caractères (-1000 : 5 caractères) Fm.n Réel en notation fixe à m caractères, dont n décimales ( -1000.32 : 8 caractères, F8.2) Em.n Réel*4, notation scientifique (m=n+7) ( -0.43E-02 , E9.2) Dm.n Réel*8, notation scientifique (m=n+7) nX décalage de n caractères vers la droite (insère n blancs) / passe à l’enregistrement suivant (à la ligne)

Simulation can save you ! Prévoir l’évolution du climat Eviter les catastrophes (El nino…) The ‘earth simulator’ (Japon – 5000CPu) Maillage de la terre – océans et atmosphère – équations résolues par éléments finis

Formation spontanée d’un typhon !

Variables locales et variables globales On désire que certaines variables, constantes soient présentes dans le programme principal ET les sous-routines fonctions etc… Problème : par défaut les variables, cstes etc… sont LOCALES au bloc ou elles sont déclarées Solution 1: transmettre ces variables commes ARGUMENTS aux differentes fonctions et sous-routines Call MySub(Arg1,Arg2,Arg3….) vite fastidieux, mais rigoureux Solution 2: créer des ‘paquets’ de variables communes Syntaxe COMMON /Etiquette/variable1, variable2…. Ce COMMON doit figurer dans chaque bloc où on veut utiliser Var1… rapide mais dangereux Solution 3: rassembler les variables à globaliser dans un bloc MODULE Appel par use MonModule en tete de programme, de sous-r., de fonction… Remarque : peut aussi y placer des fonctions

Cours 7 Rapatrier et représenter ses résultats Rappel formules : Ajustement par la méthode du Chi**2 Intégration systèmes d’équations : Runge-Kutta et Euler Application ‘live’ Ajustement par une fonction Extensions : Graphisme (Win-excel) – (Calcul-Disspla) – (Win-MsDev) Usage librairie Math externe (Nag – ESSL)

How does a single-wall carbon nanotube grow ? Effect of catalyst – mechanism ? -> Simulation… JYR & Giulia Galli 2004 Hongjie Dai, Stanford, 2001

Ajustements de données par une fonction… Méthode du Chi-carré Usage type : on choisit un modèle et on ajuste aux données (xi,yi) Modele : y = f(a,x) a = paramètre à ajuster Exemple : y = exp(ax) Principe : Minimiser la somme des carrés des écarts au modèle Revient à trouver le minimum d’une fonction Et si plusieurs paramètres ?

Comment représenter graphiquement ses résultats ? 1. après rapatriement, utiliser votre logiciel de graphisme préféré ! (excel, kaleidagraph, sigmaplot, mathcad…) Procédure Excel à illustrer… 2. utiliser des librairies graphiques présentes sur la machine (appel à des sous-routines) Sur calcul : libraire DISSPLA, utiliser dis90links à la place de xlf90 Sur windows : MsDev possède des librairies graphiques (regarder dans aide/index/…)

Exemple pour dessin 2D 1) Prepare le terminal Call prepa(xaxis, yaxis, idev) 2) Prepare la zone de dessin Call aread2d(xaxis, yaxis) 3) Prepare les axes Call graf(XORIG,XSTEP,XFIN,YORIG,YSTEP,YFIN) 4) Dessin Call CURVE, ………

Exemple de sous routine ‘maison’ qui utilise des routines DISSPLA : Prepa.f : à appeler pour préparer l’affichage Dessin.f : dessine fonction3D (prg exe3D) Foret.f : simule un feu de forêt (prg foret) Dessin à 3D : (prg pir.f) Appliquer à routine d’ajustement…

Etapes de la réalisation d’un prg (f90) Program voici Implicit none … 1) Edition du texte (source) -> mon_programme.f90 2) Compilation et production fichier objet -> mon_programme.o 011000101010100101000101010101010111100010000 011000101010100101000101010101010111100010000 3) Linkage et production fichier exécutable -> mon_programme.exe 00101010101111100011101010010000011

Compiler un prg Relier aux routines DISSPLA Exécuter…. Xlf90 monprog.f ( crée objet monprog.o) Xlf prepa.f (f77, crée objet prepa.o) Xlf courbe.f (f77, exemple, crée courbe.o) Dis90links monprog.o prepa.o courbe.o –o monprog.exe ./monprog.exe

Interlude… Thou shall not sleep…

Application – a la fin du cours… Lire N Lire x(i), y(i) pour I de 1 à N Trouver le minimum du chi**2 avec une précision donnee tol (p. ex. Bissection) Prg ajustechi_graf.f Prg ajustechi_dyn.f

Rapatrier par connexion ftp… A partir d’un browser web : ftp://calcul.ulg.ac.be A partir d’une fenêtre de terminal ( ou d’un programme adhoc, Wsftp, fetch, cuteftp, ftppro etc…) ftp –i calcul.ulg.ac.be puis entrer login puis password cd mon_directory ls (event. donne la liste du contenu du repertoire) get nom_fichier_a_ramener.ext quit

Application ‘live’ Tri par tournoi de données et histogramme… Avec graphisme !!!

Your mission : Lire dans un fichier data.txt : N_cotes (nbre entier) x(i) pour I = 1,N_cotes Classer ces N_cotes nombres par ordre décroissant Ecrire les nombres classés dans un fichier data_tri.txt Calculer l’ histogramme des données Afficher l’histogramme à l’écran Programme

Structure real*8, allocatable :: x(:) character*40 :: histo(20) Call Lit_data(N, x) Call Trie_data(N,x) Call Ecrit_data(N,x) Call Callisto(N,x,histo) Affiche histo

Cours 8 0. Commentaire sur la précision des calculs Langage : les formats (rappel) Appel à des librairies mathématiques ESSL / Numerical recipes 3. Simulation numérique Expériences ‘virtuelles’ Exemple : Automates Cellulaires Simulation d’un feu de forêt Phénomenes non-linéaires

Usage de librairies externes Pourquoi ? Fonctions et sous-routines OPTIMISEES (rapidité-mémoire-précision) qui implémentent des algorithmes numériques Exemple simple : routine qui calcule les racines d’une fonction Exemple compliqué : routine qui calcule la solution d’un système linéaire de 100 équations à 100 inconnues Pourquoi le programmer soi-même alors que la routine/fonction existe dans une librairie et qu’elle est probablement mieux codée, testée, efficace et générale ?

Librairie Numerical Recipes Pas domaine public -> demander accord au détenteur du copyright… Librairie ESSL xlf –l essl mon_prog.f –o mon_prog.exe -qsource Remarque : faire usage des potentialités de fortran 90, par exemple, conjugaison d’une matrice

Exemples Resl.f résolution systeme linéaire N équations (usage de routine Essl: DGEF et DGES Guide and Reference_DGES.htm Guide and Reference_DGEF.htm Numerical recipes : gaussj

Attention : numerical recipes n’est pas du domaine public SUBROUTINE gaussj(a,n,np,b,m,mp) INTEGER m, mp, n, np, NMAX REAL a(np, np),b(np, mp) INTEGER i, icol, irow, j, k, l, ll, indxc(NMAX), indxr(NMAX), ipiv(NMAX) PARAMETER (NMAX=50) !Linear equation solution by Gauss-Jordan elimination, equation (2.1.1) above. !a(1:n,1:n) is an input matrix stored in an array of physical dimensions np by np. !b(1:n,1:m) is an input matrix containing the m right-hand side vectors, stored in an array !of physical dimensions np by mp. On output, a(1:n,1:n) is replaced by its matrix !inverse, and b(1:n,1:m) is replaced by the corresponding set of solution vectors. !Parameter: NMAX is the largest anticipated value of n. !The integer arrays ipiv, indxr,andindxc are used !for bookkeeping on the pivoting. REAL big,dum,pivinv

Expériences virtuelles ? Dans certains cas, il vaut mieux ne pas réaliser l’expérience (Coût, danger etc… ex: bombe nucléaire) Parfois les équations sont connues (remarque : souvent, on réalise des approximations) Intégration numérique avec discrétisation du temps et de l’espace (conditions initiales en données) Parfois les interactions (forces) sont connues mais pas les équations ! Comment faire pour obtenir les solutions? Exemple : systèmes non-linéaires, turbulence, convection, la météo, les cours de bourse…

Une approche en développement : les automates cellulaires Principes : l’espace et le temps sont discretisés et les variables aussi (à la différence des techniques dites d’ éléments finis des ingénieurs) Données: 1. la configuration initiale 2. la loi d’interaction-évolution T=n T=n+1 Rose -> Blanc Au moins 1 voisin est rose -> Rose Sinon -> Blanc T=0 T=1 T=2 Remarque : on construit ici un exemple de tapis de Sierpinski

Application : simulation d’un feu de forêt Remarques : La loi d’évolution peut être probabiliste Certains automates reproduisent les lois de la physique-chimie (exemple : mécanique des fluides, diffusion-réaction) en passant à la limite d’un nombre infini de cellules (dx et dt tendent vers 0).

Cours 9 Résumé matière examen + nombres aléatoires et Monte Carlo Algorithme : Construction histogramme Droite régression et minimisation Chi**2 Programme : Transformée de Fourier -> calcul de diffraction

Exemple questions rapides Quel sera le résultat à l’écran des instructions suivantes : integer :: a, b a=2; b = 3E18 write(*,*) a, b R : ...

Exemple questions rapides Comment déclare-t-on une variable A avec le type suivant (syntaxe F90 SVP) ? Variable booléenne R : … Traduisez en Fortran 90 les formes de boucles suivantes : Pour i allant de -3 à 800 par pas de 3 faire ….. Fin de boucle

Exemple questions rapides Quelles sont les erreurs dans le programme suivant : implicit none integer :: a = 3, b = 2 write(*,*) entrez une valeur au clavier SVP read(5,*) b b = b ! attention il y a un piège if ((b .lt. 0) and (b.gt.0)) then End