Types de bases de Fortran 90 : Integer, Real, Double Precision et

Types de bases de Fortran 90 : Integer, Real, Double Precision et Logical
integer
permet de représenter des nombres entiers
Les limitations dépendent de la machine :
-32 768
à
32 767
-2 147 483 648
à
2 147 483 647
ou
constante entière : sous la forme décimal : -647
499
il est également possible de fournir des constantes écrites en base :
2 (binaire)
B’101101’
8(octale)
O’56027’
16(hexadécimale)
Z’7A8BF’
Le type real : permet de représenter des nombres réels.
Domaine couvert et précision
De 10-78 à 1075
avec une précision relative de l’ordre de 10-6.
Notation de constantes de type réel
-
Décimale
Exponentielle
24.789
4.25 e-6
-.98
623.2 E11
Le type double precision : plus grande précision (précision relative de l’ordre de 10-15)
Les constantes du type double précision doivent s’écrire sous forme exponentielle en utilisant
la lettre D (ou d) à la place de la lettre E (ou e) :
1.2d-6
Le type logical :
Deux valeurs possible :vrai et faux
program valeur_logique
integer :: n,p
logical :: range
print *, ‘donnez deux nombres entiers’
read *, n, p
range= n<p
print *, ‘valeur = ‘, range
end
donnez deux nombres entiers
27
valeur = T
range = .true.
donnez deux nombres entiers
22 7
valeur = F
range = .false.
CONVERSIONS IMPLICITES
Opérateurs sur deux opérandes de types différentes : dans ce cas le compilateur met en place
de conversion de l’un des opérandes dans le type de l’autre.
Hiérarchie :
integer -> real -> double precision
integer ::
real ::
double precision ::
n1, n2
x1, x2
z
n1+x1
(n1 est convertie en real, avant d’être ajoutée à x1. Le résultat est de type real).
x1/x2+z
(le quotient x1/x2 est d’abord évalué en real. Le résultat est convertie en double precision
pour être ajouté à la valeur de z. Le résultat est de type double precision)
CONSTANTE SYMBOLIQUE
Symbole auquel on attribue une valeur qui ne pourra pas être modifiée par le programme.
Pour cela on ajoute l’attribut parameter dans une déclaration de type.
integer, parameter :: iter=5
En Fortran 77 :
parameter (iter=5)
integer iter
Le type complexe
Une variable de type complexe est représentée en mémoire sous la forme de deux nombres de
type real, avec les limitations inhérentes à ce type.
Constantes de type complexe
: s’écrivent sous la forme de deux nombres (entiers ou réels en notation décimale ou
exponentielle) séparées par une virgule et placés entre parenthèses.
(2.3e2 , -45.)
(0 , 1)
correspond à 230 – 45 i
correspond à i
Les opérations mixtes
Dans ce cas il y a conversion d’un des deux opérandes de type entier ou réel en complexe
(…partie imaginaire nulle).
Les fonctions usuelles relatives aux complexes
CMPLX
x=4;
y=2
z= cmplx(x,y)
REAL
real(z)
AIMAG
aimag(z)
CNJG donne le complexe conjugué du complexe fournit en argument.
Les instructions de contrôle
(choix, boucles : répétitions)
Instruction simple conditionnée
if (expression à valeur logique) instruction simple
l’instructions est exécutée si et seulement si l’évaluation de l’expression donne la valeur
« vrai »
if ( nbre > max) max=nbre
Séquence conditionnée : if (…) then / end if
if ( expression à valeur logique) then
séquence d’instructions exécutables
endif
L’alternative : if (…) then/else/endif
if (condition) then
séquence 1
else
séquence 2
endif
exemple: contrôle des dimensions d’un paquet-poste: Un paquet est accepté si ses trois
dimensions (Longueur, largeur, hauteur) vérifient les conditions suivants :
- un rectangle de 10cmx7cm doit pouvoir s’inscrire dans une face au moins ;
- L+l+h ≤ 100 cm
- plus grande dimension (L) ≤ 60 cm
program paquet_poste
integer, parameter :: maxlong=60, &
minlong=10, &
minlarg = 7, &
maxsom = 100
integer
::
long, larg, haut
print *, ‘ donner les dimensions ( &
&longueur, largeur, hauteur) ‘
read *, long, larg, haut
if (long <= maxlong .and.
long >= minlong.and.
larg >= minlarg .and.
long+larg+haut <= maxsom) then
print *, ‘paquet accepté”
else
print *, ‘paquet refusé’
end if
end program
&
&
&
Choix multiple: If…then/elseif/…endif
if (explog1) then
séq1 ! explog1 est vraie
else if (explog2) then
séq2 !explog1 est fausse et explog2 est vraie
else if (explog3) then
séq3 !explog1 et explog2 sont fausses et explog3 est vraie
else
séq4 ! explog1, explog2 et explog3 sont fausses
end if
cherchons pour une suite numérique les extrema (max et min)
if (nbre > max) then
max = nbre
elseif (nbre < min) then
min = nbre
end if
(si la séquence n+1 est vide, le ELSE final disparaît.
Les alternatives imbriquées
if (explog1) then
séquence1
! exécutée si explog1 est vraie
if (explog2) then
séq2 ! exécutée si explog1 et explog2 sont vraies
else
séq3 ! exécutée si explog1 est vraie et explog2 est fausse
end if
else
séq4 !exécutée si explog1 est fausse
end if
La Boucle avec compteur
do i=a,b
séquence
end do
répéter le bloc en donnant successivement à i les valeurs a, a+1, a+2, …b
Il est possible de préciser un « incrément » différent de 1 :
do i = a , b , 3
print * , i, i*i, sqrt(real(i))
end do
syntaxe:
[nom : ] do var = debut, fin, [, pas]
bloc
end do [nom]
var: variable de type integer
debut, fin et pas : expressions de type integer
si le pas est omis, il est pris égal à 1.
La Boucle « tant que » : do while
- répétition conditionnelle
syntaxe :
[nom : ] do while (exp_logique)
bloc
end do [nom]
exp_logique doit être définie avant de commencer la boucle.
(« danger »: boucle infinie …)
program exemple_do_while
implicit none
integer :: n, somme
somme=0
do while (somme < 100)
print *, ‘donnez un nombre entier’
read *, n
somme = somme + n
end do
print *, ‘somme obtenue : ‘, somme
end
la boucle étiquetée
do 10 i = 1, 10
bloc
10 continue
Les instructions exit et cycle
L’instruction EXIT permet de quitter une boucle : CYCLE, elle, permet de court-circuiter la
fin d’une itération particulière (pour passer à la suivante) sans quitter la boucle.
somtot : do i = 1, 1000
somme = …
if (somme >= sommax) exit
…
sompart : do k = 1, kmax
…
if (valeur > valseuil) exit
if (valeur > valmax) exit somtot
…
enddo sompart
…
enddo somtot
do j=0, jmax
if (x(j) <= 0.) cycle
xlo(j)=log (x(j))
…
end do
L’instruction select case
select case (exp)
case (s1)
séquence1
case (s2)
séquence2
…
case (sn)
séquence_n
case default
séquence n+1
end select
(le choix complémentaire DEFAULT peut être omis si la séquence (n+1) est vide.
Exp : expression scalaire de type integer, logical ou character
select case (mois)
case (1,3,5,7,8,10,12)
nbjours=31
case (4,6,9,11)
nbjours=30
case(2)
if (mod(ianne,4) = = 0) then
nbjours=29
else
nbjours=28
end if
case default
print *, ‘erreur’
end select
print *, ‘nombre de jours du mois ‘, mois, ‘ = ‘, nbjours
select case (reponse)
case (‘oui’)
….
case (‘non’)
…
case (default)
…
end select
Les instructions go to et stop
go to etiquette
Pour terminer l’exécution d’un programme : end
if (….) go to 2000
…
2000 end
il existe aussi l’instruction stop
if (…) stop
ou bien
if (…) then
print *, ‘erreur dans …’
stop
end if