LES OPERATEURS AGISSANT SUR LES TYPES SIMPLES

liste par ordre de priorite:´
** (puissance), * / , + – (unaires), + – (binaires), == /= < > <= >= (les quatres derniers operateurs´ de comparaˆıson ne sont pas utilisables avec les complexes), .not. , .and. , .or. , .eqv. .neqv. (operateurs´ logiques).
Dans les expressions, la conversion forcee´ (implicite) se fait dans le sens
integer → real → double precision
Dans les affectations, le terme a` droite est converti au type du terme de gauche. Ainsi, p. ex., lors d’une affectation du genre x = z, ou` z est un complexe, x prendra la partie reelle´ de z si x est de type reel´ ou la partie entiere` de la partie reelle´ de z s’il est de type entier.

Les types structures

Le type tableau

Declaration

On declare´ un tableau de la maniere` suivante:
type, dimension([imin_1:] imax_1, [imin_2:] imax_2,…) :: nom_tableau
On appelle profil d’un tableau la liste de ses etendues´ dans chaque direction. Ainsi, dans la declaration:´
real, dimension(4) :: a
real, dimension(8, -2:9) :: t
le tableau a a comme profil (4) tandis que le tableau t a comme profil (8, 12).

Construction d’un tableau

Syntaxe:
nom_tableau = (/ liste de valeurs /)
Exemple:
a = (/ 2, -1, 11, 3 /)
a = 2*(/ 3, -4, p, n + m/) + 3 ! n et m sont deux entiers
a = (/ (3*i +1, i = 1, 4, 2), 20, 8 /) ! En boucle (le 2 etant le pas)
a = (/ ((2*i-j, i = 1, 2), j = 1, 2) /)
La ref´erence´ a` un el´ement´ d’un tableau se fait en mettant l’indice (ou les indices entre parentheses):`
a(1) = 2.0 ; t(7, -1) = 2*p + 3.0; t(2*i, 2*j+1) = i – j
! reserve un emplacement ! libere l’emplacement
! reserve encore cet emplacement

Operations sur les tableaux

Les operateurs´ (unaires ou binaires) qui sont applicables a` des variables d’un type donne´ sont
• applicables aussi aux tableaux (ou sous-tableaux) de profils identiques et dont les el´ements´ sont de ce type. Ainsi on peut ecrire´ -a, a + b, a*b, ou` a et b sont des tableaux de type scalaires et ayant le memeˆ profil,
• applicables aussi entre une variable et un tableau du memeˆ type. Ainsi, on peut ecrire´ 2.0 ∗ a + x, a/3, sqrt(a), ou` a est un tableau de reels´ par exemple et x une variable de type reel´.
Les regles` de priorite´ et de la conversion implicite sont les memesˆ que ceux des types associes´.

Les sous-tableaux

Un sous-tableau est un tableau construit par extraction d’une partie d’elements´ d’un tableau. On le note en gen´eral´ de la maniere` suivante:
nom_tableau([debut]: [fin] [: pas])
Exemple:
a(2:4), a(1:4:2) ou a(::), a(:) ou a , t(:,0:8), t(:,:) (=t)
On peut aussi utiliser un vecteur d’indices (tableau d’entiers). La syntaxe est la suivante:
nom_tableau(liste_des_indices)
Exemple:
b = a ((/ 1, 3/)), b = a((/ i/2, i = 2, 8 /))

Tableaux dynamiques

Declaration´ :
type, dimension(:,:,…), allocatable :: nom_tableau
On utilise ensuite l’instruction allocate() pour allouer un emplacement memoire:´
allocate(nom_tableau(imin:imax,…) [, stat = var_ent])
L’attribut stat renvoie la valeur entiere` 0 si l’espace a et´e´ effectivement alloue´.
Pour liberer´ l’emplacement occupe´ par un tableau dynamique, on utilise l’instruction deallocate().
Exemple:
integer :: n, p, reserv
dimension, dimension(:,:), allocatable :: mat
print *, ’Entrer les tailles de la matrice:’ read *, n, p
allocate(mat(n,p), stat = reserv)
if (reserv > 0) deallocate(mat)
allocate(mat(n,p))

L’instruction where

Permet d’effectuer un test global sur les tableaux.
Syntaxe:
where (expression_logique_tableau)
instructions
[ elsewhere
instructions
]
end where
Exemple:
where (a > = 0)
b = sqrt(a)
elsewhere
b = sqrt(-a)
end where

Les chaˆınes de caracteres

Declaration

character ([len =] nbr_caract) :: nom_chaine [= ‘‘ ch_cste ‘‘]
Les chaˆınes peuvent etreˆ ecrites´ entre deux apostrophes (’ ’) ou entre guillemets (“ “).

Les sous-chaˆınes de caracteres

Syntaxe :
nom_chaine([debut] : [fin ])
Exemple:
character (20) :: prenom
character (len = 5) :: abrege
prenom = ‘‘Stephane’’
abrege = premier(1:5)

L’operateur de concatenation

Il permet de concatener´ deux chaˆınes (sans enlever le caractere` vide).
Syntaxe :
chaine_1 // chaine_2
On peut enlever le caractere` vide d’une chaˆıne en utilisant la fonction trim().
La ref´erence´ a` l’el´ement´ d’une chaˆıne se fait de la memeˆ maniere` que pour un tableau.

Type structure

Il permet de regrouper un ensemble d’el´ements´ de types differents´ dans un seul objet. Un el´ement´ de la structure est appelle´ “champ”.
Declaration´ du type de la structure:
type nom_struct
type_1 :: nom_champ1
type_2 :: nom_champ2
:
:
end type nom
Declaration´ d’une variable de type structure:
type (nom_struct) :: nom_variable [ = structure_constante ]
Initialisation d’une variable de type structure:
nom_variable = nom_struct(liste_des_valeurs)
Exemple:
type produit
integer :: numero
integer :: quantite
real :: prix
end type produit
type(produit) :: tomates, lait, cafe, the
lait = produit(214, 45, 4.25)
tomate%prix = 8.40
tomate%numero = 30
tomate%quantite = 70
print *, ’Entrer le numero, la quantite et le prix du the :’
read *, the
cafe = the

L’instruction If

Syntaxe:
[nom:] if (expression_booleenne_1) then
:
instructions
:
[ else if (expression_booleenne_2) then
:
instructions
: ]
[ else
:
instructions
: ] endif [nom]
Dans le cas d’une seule instruction (sans else), on peut ecrire´
if (expression_booleenne) instruction

L’instruction Select case

Syntaxe:
[nom:] select case (var_scalaire)
[ case(valeurs_1)
:
instructions
:
case(valeurs_2)
:
instructions
:
case default
:
instrcutions ]
end select [nom]

L’instruction de boucle avec compteur

Syntaxe:
[nom:] do var = debut, fin [, pas]
:
instructions
:
end do [nom]

L’instruction de boucle sans compteur

Syntaxe:
[nom:] do
:
instructions
:
end do [nom]

Les instructions Exit et Cycle

L’instruction exit, placee´ dans une boucle, permet de sortir de la boucle (et donc d’interrompre son deroulement)´.
L’instruction cycle permet quant a` elle de passer prematur´ement´ au tour suivant de la boucle.
Syntaxe:
exit [nom_de_la_boucle]
cycle [nom_de_la_boucle]

1. Les types et les operateurs.
2. Les instructions de controle.
3. Les subroutines.
4. Les fonctions.
5. Les paramètres des subroutines et fonctions.
6. Les modules.
7. Les entrées-sorties standards.
8. Les fichiers.
9. Quelques fonctions interinsèques.