METHODES NUMERIQUES

ET PROGRAMMATION
2ème Année Physique
2020 – 2021

W.L.Rahal
11/19/2021

1
 PROGRAMME
 Chapitre 1: La programmation en Fortran

 Chapitre2: initiation à Matlab

 Chapitre 3: Intégration numérique

 Chapitre 4: Résolution numérique des équations

non linéaires

 Chapitre 5: Résolution numérique des systèmes

d’équations linéaires
11/19/2021 2
 Chapitre 1:
La programmation en Fortran

11/19/2021 3
 1. Types de langages informatiques

 Plus de 2500 langages

 BUT: COMMUNIQUER AVEC L’ORDINATEUR

 DIFFÉRENTS TYPES DE LANGAGES

•1ère génération: Code machine
•2ème génération: Assembleur
•3ème génération: Fortran, C++, Pascal, visual Basic…
•4ème génération: Matlab, Mathematica, Scilab…
•5ème génération: Utilise des contraintes et non des algorithmes:
Prolog, Mercury…
11/19/2021 4
 2. Structure générale d’un programme

Déf. Un programme est un texte qui respecte les règles

du langage pour résoudre un problème donné.

Program Nom_du_prg

Déclarations

Instructions
exécutables

End

11/19/2021 5
 2.1. Déclaration
des variables

 Déf. une variable désigne un emplacement mémoire

dont le contenu peut changer au cours d’un prg.

un Identificateur (nom )

 Déclaration
un type (entier, réel, caractère…)

6
 2.1.1. Identificateur d’une variable:

Une suite de caractères alphanumériques

(lettres non accentuées, chiffres, underscore)
Le premier caractère doit être une lettre,
la longueur est limitée à 31 caractères,
Pas de différence minuscules/majuscules.

Exemples:
X, y, sOmme, racine_carree, z2r, A2343…etc.

11/19/2021 7
 2.1.2. Type d’une variable:

Le type d’une variable détermine l’ensemble des valeurs

qu’elle peut prendre:
 Type numérique (entier ou réel)

◦ Entier (codé sur 4 octets)

◦ Réel simple précision (codé sur 4 octets)
◦ Réel double précision (codé sur 8 octets)
◦ Complexe (codé sur 4 ou 8 octets)
 Type logique : VRAI ou FAUX

 Type caractère: lettres majuscules, minuscules,

chiffres, symboles, …

8
 2.1.3. Instruction IMPLICIT NONE

 Par défaut, les variables dont l’identificateur commence

par les caractères I à N sont de type INTEGER. Toutes
les autres sont de type REAL.
 L’instruction IMPLICIT NONE annule cette règle car elle

impose à l’utilisateur de déclarer toutes les variables

utilisées.
 Cette instruction est recommandée car elle permet de

détecter un certain nombre d’erreurs à la compilation.

 IMPLICIT NONE se place avant la déclaration des

variables.

11/19/2021 9
2.1.4. Exemples de déclarations de variables (1)

 Les entiers
◦ Integer a
◦ Integer::a=5
◦ Integer::a=7 , b=5 , c=8
 Les réels
◦ Real x
◦ Real :: x=5.3 , y=6.9 , z= 4.9E-3
◦ Double precision :: r=1.5d2
 Les complexes
◦ Complex :: p=(5.2 , 9) , m=(2 , 4)

11/19/2021 10
2.1.4. Exemples de déclarations de variables (2)

 Les caractères
◦ Character adresse
◦ Character :: adresse=‘ cité 5 juillet, 27000 ‘
◦ Character * 30 :: adresse=‘ cité 5 juillet, 27000 ‘
◦ Character (LEN=30):: adresse=‘ cité 5 juillet, 27000 ‘

 Les variables logiques

◦ Logical :: valeur
◦ Logical :: valeur1=.true. , valeur2= .false.

11/19/2021 11
 2.1.5. Les constantes

 Integer, parameter :: nombre = 20

 Real, parameter :: pi = 3.141592
 Ou bien:
 Integer:: nombre
 Real:: pi
 Parameter (nombre = 20, pi = 3.141592)

 La valeur des variables « nombre » et « pi » ne

peuvent plus être modifiée.

11/19/2021 12
 2.1.6. Remarques importantes

 Les commentaires s’écrivent sous la forme:

! Commentaire
 Le Fortran ne fait pas de différence entre les majuscules
et les minuscules.
 Une ligne peut avoir une longueur maximale de 132
caractères.
 Une instruction peut être prolongée sur plusieurs lignes,
à condition de mettre le caractère & à la fin de chaque
lignes incomplètes.

Plusieurs instructions, séparées par un point virgule;
peuvent être écrites sur une même ligne.

11/19/2021 13
 2.2. Les opérateurs (1/2)
Les opérateurs arithmétiques Les opérateurs relationnels

11/19/2021 14
 2.2. Les opérateurs (2/2)
Les opérateurs logiques L’opérateur de concaténation

Exemple:

‘‘BON’’ // ‘‘JOUR’’  ‘‘BONJOUR’’

Character(len=10)::ch=‘‘BON’’
Ch=ch //‘‘JOUR’’ ! Résultat erroné
Ch= TRIM(ch) // ‘‘JOUR’’ ! Valide
11/19/2021 15
2.2.1. Priorité des opérateurs

Exemple: Evaluer les

expressions suivantes:

12 * 5 + 5 / 5 – 5 ** 2

Réponse: 36.

10 / 5 – 2 * 8 ** 2 * 3 / 2
+2

Réponse: - 188

11/19/2021 16
3. LES INSTRUCTIONS DE CONTROLE

Déf. C’est des instructions qui permettent de réaliser des choix

ou des boucles.

11/19/2021 17
 3.1. L’instruction IF
3.1.1. CAS D’UN CHOIX SIMPLE:

if ( Expression_logique) then
… ! Instructions exécutées quand l’expression logique est vraie
Else
… ! Instructions exécutées quand l’expression logique est fausse
End if
Dans le cas où la partie introduite par le else n’existe pas:
if ( Expression_logique) then
… ! Instructions exécutées quand l’expression logique est vraie
End if

if ( Expression_logique) Instruction !cas d’une seule instruction

11/19/2021 18
 3.1. L’instruction IF
EXEMPLES:

if (delta>=0) then
Write(*,*) ‘‘L’equation admet des solutions reelles’’
Else
Write(*,*) ‘‘L’equation admet des solutions complexes’’
End if

if ( carac==‘bonjour’) then
Carac = ‘‘Bonne journee’’
Write(*,*) carac
End if

if ( carac==‘bonjour’) Carac = ‘‘Bonne journee’’

11/19/2021 19
 3.1.2. CAS D’UNE INSTRUCTION IF IMBRIQUÉE:

if ( Expression1) then
… ! Expression1 vraie
if ( Expression2) then
… ! Expression1 Expression2 vraies
Else
… ! Expression1 vraie, Expression2 fausse
End if

Else
… ! Expression 1 fausse
End if

11/19/2021 20
 EXEMPLE

if ( delta.GE.0) then
Write(*,*) " Le discriminant est positif "
if ( delta.EQ.0) then
Write(*,*) "Une solution double "
Else
Write(*,*) " Deux solutions reelles "
End if
Else
Write(*,*) ‘’Discriminant negatif, deux solutions complexes’’
End if

11/19/2021 21
 3.1.3. L’INSTRUCTION ELSE IF:

if ( Expression_logique_1) then
… ! Instructions exécutées quand l’expression logique1 est vraie
Else if ( Expression_logique_2) then
… ! Instructions exécutées quand l’expression logique2 est vraie
Else if ( Expression_logique_3) then
… ! Instructions exécutées quand l’expression logique3 est vraie
Else
… ! Instructions exécutées quand toutes les expressions
logiques ! précédantes sont fausses
End if

11/19/2021 22
EXEMPLE

if (age<3) then
Write(*,*) "Nourisson"
Else if (age<13) then
Write(*,*) "Enfant"
Else if (age<18) then
Write(*,*) "Adolescent"
Else if (age<80) then
Write(*,*) "Adulte"
Else
Write(*,*) "Personne agée"
End if

11/19/2021 23
 3.2. L’INSTRUCTION SELECT CASE

REMARQUES:
SELECT CASE (Expression)
1. (Expression) peut être de type:
CASE (sélecteur1) Integer, logical ou character.
Instructions1
CASE (sélecteur2) 2. Les sélecteurs doivent être du
Instructions2 même type que (expression).
CASE (sélecteur3)
Instructions3 3. L’ordre des instructions CASE
CASE (sélecteur4) n’est pas important.
Instructions4
CASE DEFAULT 4. Le sélecteur peut comporter:
Instructions5 • Une seule valeur case(5)
• Un intervalle case (2:5)
END SELECT case(:9) case (2:)
• Une liste case (7, 9:45, 90:)
• Une variable case (n)
11/19/2021 24
EXEMPLE

SELECT CASE (mois)

CASE (4, 6, 9, 11)
nb_jours = 30
CASE (1, 3, 5, 7:8, 10, 12)
nb_jours = 31
CASE (2)
!----------------------------------
select case (annee_bissextile)
case (.true.)
nb_jours = 29
case (.false.)
nb_jours = 28
End select
!----------------------------------
CASE DEFAULT
print *, '' Numéro de mois invalide''
END SELECT

11/19/2021 25
 3.3. Boucle avec compteur

DO variable = debut , fin , pas

! Bloc d’instructions
END DO

Remarques:
• Variable est de type entier

• Le pas peut être positif ou négatif

• Si le pas n’est pas indiqué, il est pris =1.

Exemple:
DO i = 1, 5 , 2
x=x+1
END DO

11/19/2021 26
 3.4. Boucle sans compteur
(DO WHILE)

DO WHILE (Expression logique)

! Bloc d’instructions
END DO

Remarques:
• Répétition conditionnelle.

• Le nombre d’itérations n’est pas donné dans le prg.

Exemple:
DO WHILE ( somme <10)
somme= somme +1
END DO

11/19/2021 27
 3.4. Boucle DO infinie

DO
! Bloc d’instructions
END DO

L’exécution du bloc d’instruction ne s’arrête pas!

Exemple:
DO
somme= somme +1
END DO

11/19/2021 28
 3.5. Autres instructions

EXIT : pour sortir prématurément d’une boucle.

CYCLE: Pour passer prématurément au tour de boucle suivant.

GO TO: sauter directement vers une instruction repérée par une

étiquette (nombre entier /=0)

STOP: Arrêter le programme.

11/19/2021 29
4. LES TABLEAUX

11/19/2021 30
 4. Les tableaux
 Un tableau est un ensemble d'éléments de même type
désignés par un seul identificateur.

 On peut définir des tableaux de tous types : entiers, réels,

caractères, …

 Pourquoi?

Pour stocker la tension de 16 expériences différentes.

REAL :: v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, &
v11, v12, v13, v14, v15, v16

Avec les tableaux:

REAL, DIMENSION (16) :: tension

11/19/2021 31
 4.1 Déclaration des tableaux
TYPE, DIMENSION (expr1,...,exprn) :: nom_tab
! Avec : n<=7

Exemples: L’indice du tableau commence par 1.

 INTEGER, DIMENSION (3) :: a

 REAL, DIMENSION (2,3) :: Z

 COMPLEX , DIMENSION (100) :: R

Pour changer les indices du tableau.

 INTEGER, DIMENSION (0,2) :: a

 REAL, DIMENSION (-1:0, 5:7) :: Z

 COMPLEX , DIMENSION (-50 : 49) :: R

REAL :: a(3), Z (-1:0, 5:7), R (-50 : 49) ! Non recommandé

11/19/2021 32
 4.2. Initialisation des élements d’un tableau

Initialiser tous les éléments du tableau avec la même valeur:

INTEGER, DIMENSION(5000) :: tableau=1

Utiliser la boucle do
INTEGER, DIMENSION(10) :: tableau
INTEGER :: indice
DO indice = 1, 10, 1
tableau (indice) = indice * 2
END DO

ou bien:
tableau = (/ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 /)
4.3. Exemples de lecture des éléments d’un tableau

Do i=1,10
Write (*,*) ‘’Donner l’element ‘’ ,i , ‘’du vecteur’’
Read(*,*) x(i)
Enddo

Do i=1,5
Do j=1,3
Write (*,*) ‘’Donner l’element ‘’ ,i ,j , ‘’de la matrice’’
Read(*,*) x(i,j)
Enddo
Enddo

11/19/2021 34
 4.4. L’instruction WHERE
C’est une instruction applicable aux tableaux.
WHERE (Expression_Logique_tableau)
Instructions
ELSE WHERE
Instructions
END WHERE

Forme simplifiée:
WHERE (Expression_Logique_Tableau) Instructions

Exemple:
WHERE (a.LT.0.0) a=0.0
Met tous les éléments négatifs du tableau à 0
 4.4. L’instruction WHERE

Exemple:

36

11/19/2021
 5. Les entrées, les sorties, les formats.
5.1. LES ENTREES:
 Pour lire des données au clavier, on peut utiliser le format par défaut

(format libre) :
read (*,*) variable
Ou bien
read*, variable

5.2. LES SORTIES:

 Pour écrire à l’écran, on utilise: write(*,*) variable ou print*, variable

 On peut aussi écrire en alternant caractères et variables:

write (*,*) ‘var1=‘ , variable1, 'var2 =‘ , variable2

(*,*)
Périphérique Format

( Par défaut: Clavier et écran)

11/19/2021 37
 5.3. Les formats
5.3.1. Le format libre:

Par défaut:
ENTIERS: 11
REAL : 14.6
DOUBLE PRECISION 23.15

Gabarit: 14,
Attention: REAL 14.6 6 après la virgule,
(14-6) partie entière point décimal inclue

11/19/2021 38
5.3.2. L’écriture formatée:

11/19/2021 39
 Autre exemple:
program cours
! Ecriture formatée avec étiquette
WRITE (*, 10) (n, SQRT(real(n)),n = 1, 20)
10 FORMAT (I5, F8.4)
! Ecriture formatée sans étiquette
WRITE(*,'(F12.6)') 2.5
end

10 représente l’étiquette du format utilisé.

RECAPITULATIF:

• i: Entiers
• F: Réel en notation flottante
• E: Réels en notation exponentielle.
• A: Chaine de caractères

11/19/2021 40
 6. Les fonctions et subroutines
6.1. Les Subroutines
 Une subroutine est un bloc d'instructions appelable du prg.
 Elle est définie par :
 Un nom

 Des paramètres formels

Subroutine  nomsub(pf1, pf2, pf3, ...) 

type pf1 
type pf2 
type pf3 
... 
Déclaration des variables locales 
... 
Instructions exécutables 
... 
return 
end

11/19/2021 41
 6.1. 1. Appel d'une subroutine

 L'appel d'une subroutine se fait avec l'instruction call

(depuis le prg principal, subroutine ou fonction)
 call nomsub (v1, v2, v3, ...)
Les arguments v1, v2, v3 peuvent être :
◦ des variables du bloc fonctionnel,
◦ des constantes (déconseillé !).

Très important
Les types des arguments v1, v2, v3,... doivent
correspondre à ceux des paramètres
formels pf1, pf2, pf3,...

11/19/2021 42
 6.1.2. Exemple de subroutine
subroutine polar(x, y, r, theta) 
Écrire une subroutine qui calcule les
      real x, y, r, theta 
coordonnées polaires associées à
des coordonnées cartésiennes (x,y).
      real pi , temp
      pi=4*atan(1)  !calcul de pi
      r=sqrt(x**2+y**2) 
      temp=atan(y/x) 
      if (x.gt.0) then 
        theta=temp 
      else if (x.lt.0) then 
        theta=-temp 
      else if (x.eq. 0) then 
Program test_sub
         if (y.ge.0d0) then 
      real a, b, rho, phi             theta=pi/2 
      ...           else 
      call polar (a, b, rho, phi)             theta=-pi/2 
      ...           endif 
      end       endif 
      return 
      end 11/19/2021 43
 6.2. Les fonctions
 Une fonction identique à une subroutine, mais son nom contient
en plus une valeur.
 on l'utilise à droite du signe = dans une instruction d'affectation.
 Par exemple       pi=4*atan(1)

Type function nomfonc (pf1, pf2, ...) 
type pdf1 
type pdf2 
... 
déclarations des variables locale 
... 
instructions exécutables 
... 
return 
end

11/19/2021 44
 6.2.1. Exemple de fonction
 Fonction qui calcule le rayon-vecteur  associé à un couple (x,y).
program test
real abscis, ordonn
real rayon
read(*,*) abscis, ordonn
r=rayon(abscis, ordonn)
write(*,*) r
end

real function rayon (x, y)

real x, y
rayon= sqrt (x**2+y**2)
return
end

11/19/2021 45
Fin du chapitre 1

11/19/2021 46