Apprendre Fortran en bref pdf


Télécharger Apprendre Fortran en bref pdf

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Ecole Normale Superieure´

Cours d’introduction aux el´ ements finis´

Mars 2009

Tahar Zamene BOULMEZAOUD`                                                                            FORTRAN 90 EN BREF

Sommaire.

1. Les types et les operateurs.´ 2. Les instructions de controle.ˆ

3.   Les subroutines.

4.   Les fonctions.

5.   Les parametres des subroutines et fonctions.`

6.   Les modules.

7.   Les entrees-sorties standards.´

8.   Les fichiers.

9.   Quelques fonctions interinseques.`

Les points essentiellement non traites dans ce r´ esum´ e sont:´

•    Les pointeurs.

•    La surdefinition des op´           erateurs (vers une programmation orient´    ee-objet en fortran 90).´

On renvoie pour toutes ces questions a:`

Claude DELLANOY, Programmer en Fortran 90, Guide complet, Editions Eyrolles, 1993.

1    Gen´ eralit´       es.´

•    Dans tout ce document, une expression est ecrite en´    gras quand elle est reserv´ ee. Quand une expression est´ placee entre deux crochets´               [ ], cela signifie qu’elle est optionnelle (ou facultative).

•    Les commentaires en Fortran 90 s’ecrivent sous la forme:´

! commentaire

•    Le Fortran 90 ne fait pas de difference entre les majuscules et les minuscules.´

•    En format libre de Fortran 90, et contrairement au Fortran 77 (dit format fixe), une instruction peut commencer a n’importe quel emplacement de la ligne. En outre, une ligne peut avoir une longueur quelconque`       a` concurrence de 132 caracteres (il n’y a donc pas de d` ecoupage de la ligne en trois zones comme en Fortran´ 77).

•    Plusieurs instructions peuvent etreˆ ecrites sur une m´ eme ligne,ˆ a condition d’` etre sˆ epar´ ees par un point´ virgule ;.

•    Une instruction peut etre prolongˆ ee sur plusieurs lignes,´ a condition de mettre le caract` ere` & en fin de chacune des lignes incompletes.`

2    Les types simples.

LE TYPE ENTIER: integer

            LE TYPE BOOLEEN´     : logical (.true. or .false.).

            LES TYPES REELS´     : real ou double precision.

Une constante reelle doit´           etreˆ       ecrite de pr´          ef´ erence avec un point virgule afin d’´         eviter qu’elle ne soit consid´   er´ ee´ comme une variable entiere lors des op`          erations (ex.: 3.20E+5, 1., 3.0, 3.21D12).´

     La declaration d’une constante ou d’une variable d’un type simple se fait de la mani´ ere suivante:`

             type, parameter ::                                   nom_constante = valeur ! decl. d’une constante

       type                                   ::             nom_variable                                              ! decl. d’une variable

LE TYPE COMPLEXE : complex.

Il s’agit plutot d’un type structure. Les deux fonctions´ real() et aimag() fournissent respectivement la partie reelle et la partie imaginaire d’un nombre complexe. Les constantes complexes s’´            ecrivent sous la forme (1.0, 2.0)´ par exemple. La construction d’un nombre complexe a partir de deux variables r` eelles se fait en utilisant la fonction´ cmplx(); par exemple cmplx(x, y).

3    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 enti´ ere de la` partie reelle de´ z s’il est de type entier.

4    Les types structures.´

4.1     Le type tableau.

4.1.1     Declaration.´

On declare un tableau de la mani´ ere 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 d´ eclaration:´

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).

4.1.2     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 parenth´               eses):`

a(1) = 2.0 ; t(7, -1) = 2*p + 3.0; t(2*i, 2*j+1) = i - j

4.1.3     Operations sur les tableaux.´

Les operateurs (unaires ou binaires) qui sont applicables´ a des variables d’un type donn` e 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, o´ u 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 priorit` e et de la conversion implicite sont les m´ emes que ceux des types associˆ           es.´

4.1.4     Les sous-tableaux.

Un sous-tableau est un tableau construit par extraction d’une partie d’elements d’un tableau. On le note en g´ en´ 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 /))

4.1.5     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 allou´  e.´

Pour liberer l’emplacement occup´ e 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) ! reserve un emplacement if (reserv > 0) deallocate(mat)              ! libere l’emplacement allocate(mat(n,p))      ! reserve encore cet emplacement

4.1.6      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

4.2     Les chaˆ?nes de caracteres.`

4.2.1     Declaration.´

character ([len =] nbr_caract) :: nom_chaine [= ‘‘ ch_cste ‘‘]

Les chaˆ?nes peuvent etreˆ ecrites entre deux apostrophes (’ ’) ou entre guillemets (“ “).´

4.2.2     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)

4.2.3     L’operateur de concat´ enation.´

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 maniˆ           ere que pour un tableau.`

4.3     Type structure.

Il permet de regrouper un ensemble d’el´ ements de types diff´ erents 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

2. LES INSTRUCTIONS DE CONTROLE.ˆ

5      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

6       L’instruction Select case.

Syntaxe:

[nom:] select case (var_scalaire) [ case(valeurs_1) :

instructions

: case(valeurs_2)

:

instructions

: case default :

instrcutions ] end select [nom]

7     L’instruction de boucle avec compteur.

Syntaxe:

[nom:] do var = debut, fin [, pas]

: instructions

:

end do [nom]

8     L’instruction de boucle sans compteur.

Syntaxe:

[nom:] do

: instructions

:

end do [nom]

9     Les instructions Exit et Cycle.

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

exit [nom_de_la_boucle] cycle [nom_de_la_boucle]

10      L’instruction Do while (boucle conditionnelle).

Syntaxe:

[nom:] do while (expression_booleenne) : instructions

:

end do [nom]

11      Les instructions Goto et stop.

L’instruction go to permet de sauter directement vers une instruction executable rep´ er´ ee par une´ etiquette´ (nombre entier non nul comportant au maximum 5 chiffres et place devant l’instruction sur laquelle on souhaite se brancher).´ Quant a l’instruction` stop, elle permet d’arreter un programme.´ Syntaxe:

go to etiquette stop

On distingue essentiellement deux types de subroutines: internes et externes.

12      Subroutines externes.

Une subroutine externe est une “unite de compilation s´ epar´ ee”. Elle est donc ind´ ependante´ a priori des autres sous-` programmes. Ses variables locales ne sont donc reconnues nulle part en dehors d’elle-meme. Les variables localesˆ du programme appellant ne sont pas reconnues en consequence´ a l’int` erieur de la subroutine (´ a moins qu’elles ne` soient partagees` a travers un module).` Syntaxe:

subroutine nom_subroutine(liste_es_parametres formels)

Declarations des parametres formels

Declarations des variables locales :

Instructions

:

end subroutine nom_subroutine

L’appel d’une subroutine externe par un autre sous programme se fait en utilisant l’instruction call et cela de la maniere suivante:`

call nom_subroutine(liste_des_parametres_effectifs)

On peut aussi effectuer un appel avec des arguments a mots cl` es, c’est-´ a-dire qu’on pr` ecise le nom de chaque´ parametre formel devant sa valeur:`

call nom_subroutine(nom_par_1 = valeur_1, nom_par_2 = valeur_2,...)

13      Les subroutines internes.

Une subroutine interne est une subroutine qui fait partie d’un sous programme (elle est donc compilee avec ce´ sous-programme). Elle n’est pas utilisable en dehors de ce sous-programme (meme en faisant une interface). Lesˆ declaration et les corps des subroutines et fonctions internes se font´   a la fin du sous-programme qui les accueille` apres l’instruction` contains.

Syntaxe:

debut_sous_programme_accueillant :

:

:

:

contains

corps des fonctions et subroutines internes

end contains

end sous_programme_accueillant

Les variables locales du sous-programme pere sont alors des variables` globales par rapport aux subroutines et fonctions internes et y sont donc reconnues. A l’int` erieur d’une subroutine interne, une variable globale (d´ eclar´ ee´ dans le programme pere) deviendrait masqu` ee (et donc n’existe plus) si un param´ etre formel ou une variable locale` a la subroutine interne porte le m` eme nom que cette variable globale.ˆ

14        Declaration d’une subroutrine externe en interface.´

Elle sert a pr` ed´ eclarer une subroutine ou une fonction externe dans le sous-programme appellant (programme´ principale, subroutine ou fonction externes: unite de compilation s´ epar´ ee de celle de la subroutine).´ Syntaxe:

program nom implicite none

INTERFACE subroutine nom(parametres_formels)

declaration des parametres_formels

end subroutine nom END INTERFACE :

: end

On distingue aussi les externes et les internes (de maniere identiques aux subroutines). Notons que tout ce` qu’on a dit concernant les interfaces d’une subroutine reste valable pour une fonction.

15       Declaration d’une fonction.´

function nom_funct(parametres_formels) [result (nom_var)] declaration des parametres formels type_du_resltat              :: nom_funct [ nom_var]

:

: end function nom_funct

La variable nom var est destinee´ a contenir le r` esultat. En cas o´ u` result n’est pas utilise, c’est le nom de la fonction´ nom fonct qui sert a stocker le r` esultat.´

Quand une fonction externe n’est pas declar´ ee en interface, sa d´ eclaration dans le programme appellant est n´ ecessaire´ et cela se fait en utilisant la commande external de la maniere suivante`

type_du_resultat :: nom_funct external nom_funct

16      Fonctions recursives.´



Une fonction est dite recursive si elle appelle elle m´ eme (directement ou de maniˆ ere crois` ee).´ Il est necessaire´ qu’elle soit pred´ eclar´ ee en interface du programme appellant.´ L’attribut result est par ailleurs necessaire dans ce´ cas.

Syntaxe:

recursive function nom_funct(parametres_formels) result (nom_var) declaration des parametres formels type_du_resltat :: nom_var

:

:

end function nom_var

17      Fonctions renvoyant un tableau.

Il est possible en Fortran 90 qu’une fonction renvoie un tableau. Lors de la declaration de cette fonction, le tableau´ peut-etre dˆ eclar´ e de mani´ ere rigide (profil connu) ou alors de mani` ere adjustable en pr` ecisant le profil´ a partir des` parametres formels de la fonction elle-m`         eme.ˆ Exemple:

function moyenne(n, note)

                           integer                                                          :: n

integer, dimension(3, 120) :: note integer, dimension(120)               :: moyenne ! profil rigide :

:

end function moyenne

function moyenne2(n, note)

                           integer                                                     :: n

integer, dimension(3, n) :: note integer, dimension(n)        :: moyenne2 ! profil adjustable :

:

end function moyenne2

18     Les fonctions et les subroutines gen´ eriques.´

Une subroutine (ou une fonction) gen´ erique est une subroutine qui a un seul nom mais qui correspond en fait´       a` plusieurs subroutines (ou fonctions). Il s’agit donc de regrouper sous un seul nom toute une famille de subroutines. Pour definir une fonction ou une subroutine g´          en´ erique, il suffit de:´

•    definir “classiquement” les diff´            erentes subroutines de la famille,´

•    ecrire ensuite une interface qui sp´      ecifie le nom g´    en´ erique et les interfaces des diff´ erentes subroutines de la´ famille.

Illutration par un exemple:

Imaginons qu’on a dej´ a` ecrit trois subroutines´ aff ent(), aff reel() et aff tab(), qui affichent respectivement un entier donne en param´ etre, un r` eel ou un tableau de r´ eels. Pour en faire une subroutine g´ en´ erique qui s’appelle´ affiche(), il suffit de creer la bloc d’interface appropri´   e:´

interface affiche                ! le nom generique est ‘‘affiche’’ subroutine aff_ent(n) integer :: n

end subroutine aff_ent

subroutine aff_real(x) integer :: x

end subroutine aff_real

subroutine aff_tab(t) real, dimension(:) :: t

end subroutine aff_ent

end interface affiche

A la rencontre d’un appel` call affiche(), le compilateur se sert du bloc d’interface correspondant pour determiner´ automatiquement quel est le sous programme (aff ent(), aff real() ou aff tab()) a appeller effectivement.`

5. LES PARAMETRES DES SUBROUTINES ET FONCTIONS.`

19      Les trois sortes de parametres formels.`

On distingue essentiellement trois types:

•    Argument d’entree: cela signifie que la valeur du param´ etre ne peut-` etre “changˆ ee”´ a l’int` erieur de la sub-´ routine. Cela se fait en rajoutant l’attribut intent(in) lors de la declaration du param´ etre.` Exemple:

integer, intent(in) :: p

•    Argument de sortie: cela signifie que la valeur du parametre ne peut-` etre “utilisˆ ee”´ a l’int` erieur de la sub-´ routine. Cela se fait en rajoutant l’attribut intent(out) lors de la declaration du param´ etre.`

•    Argument d’entree-sortie: cela signifie que la valeur du param´ etre peut-` etre “utilisˆ ee” et “chang´ ee”´ a l’int` erieur´ de la subroutine. Cela se fait en rajoutant l’attribut intent(inout) lors de la declaration du param´ etre.`

20      Parametres optionnels.`

Un argument est dit “optionnel” s’il est autorise´ a` etre abscent lors de l’appel effectif de la subroutine. Cela signifieˆ qu’il est prevu´ a l’int` erieur de la subroutine un traitement de ce cas. Lors de la d´          eclaration du param´ etre formel en` question, on rajoute le qualificatif optional. Exemple:

integer, optional :: p

Le test de presence ou de non pr´ esence d’un param´ etre optionnel se fait` a l’int` erieur de la subroutine en utilisant la´ fonction booleenne´ present() (exemple: present(p)) qui renvoie la valeur vraie si le parametre est pr` esent lors de´ l’appel de la subroutine.

21      Parametres statiques.`

A priori, entre deux appels succ` essifs d’une m´ eme subroutine, les valeurs des variables locales ne sont pas con-ˆ servees. Ce sont des variables automatiques. Pour rendre une variable locale statique (ce qui lui permet en partic-´ ulier de conserver sa valeur entre deux appels) on utilise le qualificatif save.

integer, save :: x

22      Les tableaux en arguments.

Quand l’un ou plusieurs des parametres formels d’une subroutine (ou une fonction) est un tableau, on est confront`               e´ au probleme de d` eclaration du profil du tableau. Il y’a trois mani´        eres de le faire:`

•    Declaration rigide (dans ce cas la taille est connue lors de l’´          ecriture de la subroutine).´ Exemple:

subroutine moyenne(note) integer, dimension(1:120) :: note :

:

•    Declaration ajustable avec le profil en param´ etre aussi. Dans ce cas, la taille du tableau n’est pas fixe, mais` depend d’un autre (ou de plusieurs) param´              etre formel.` Exemple:

subroutine moyenne(note, p, n) integer             :: n, p

integer, dimension(p:n) :: note :

:

•    Declaration ajustable sans profil. La subroutine ne dispose d’aucune information sur le profil du tableau´ (mais le rang doit etre connu) et suppose donc que lors de l’appel de cette subroutine, le tableau existe dˆ      ej´ a` et est alloue. Exemple:´

subroutine moyenne(ecrit, oral ) integer, dimension(:,:) :: ecrit integer, dimension(:)          :: oral :

:

23      Transmission d’une subroutine en parametre.`

Il est possible d’avoir comme parametre formel une subroutine. Il suffit pour ce faire de de d` eclarer une interface´ correpondant a cette subroutine au d` ebut de la subroutine dont elle est param´ etre.` Exemple:

subroutine integrale(a, b, fct, resultat)

implicit none real         :: a, b, resultat

interface

function fct(x) real, intent(in) :: x

                                       real                                        :: fct

end function fct

end interface

:

:

end subroutine integrale 24 Le format libre

Il s’agit du format *.

Le format libre en lecture: On dipose d’une grande liberte pour entrer les donn´ ees en format libre en lecture´ (avec read *). Ainsi par exemple on peut taper 389.45, 3.8945e2 ou 0.38945e3 pour une variable reelle qui vaut´ 389.45 et T, t, TRUE, true, .true., .T. ou .t. pour variable de type logical qui vaut “vrai”.

La separation de donn´       ees entr´                ees se fait avec´   des separateurs´  qui sont la virgule (,), l’espace vide et le retour a la` ligne. Quant on doit entrer la meme donnˆ             ee plusieurs fois, on peut la mettre en facteur sous la forme´

n*valeur

ce qui d’evite d’entrer´ valeur au clavier n fois (voir exemple 1 tableau I ci-dessous).

Si on veut eviter d’entrer une valeur (qui va donc rester inchang´ ee), on le fait en ne mettant rien entre´ deux virgules (voir exemple 2, tableau I). De meme, le caractˆ ere` / en fin de ligne signifie que tous les donnees suivantes et non´ entrees encore restent inchang´ ees dans le programme (voir exemple 3, Tableau I).´



Le format libre en ecriture:´ L’ecriture d’une variable en format libre est laiss´ e´ a la libert` e de la machine qui´ le fait en fonction du type de la variable ou de l’expression affiches. Dans ce cas, la pr´ esentation du r´ esultat affich´ e´ n’est pas maˆ?trisee, ce qui n’est pas tr´ es commode lorsque on affiche des tableaux ou beaucoup de variables. La` solution pour une bonne presentation est d’utiliser un format avec descripteurs (voir ci-dessous).´

25       Les formats avec descripteurs

Un format en gen´ eral est une liste de descripteurs mis sous la forme´

’(descpt_1, descpt_2,...,descpt_n)’

et place derri´ ere` print ou read comme suit

print ’(descpt_1, descpt_2,...,descpt_n)’, exp_1,...,exp_2

ou` descpt1, descpt2,...,descptn sont les descripteurs et exp1,...,exp2 sont les expressions

(ou les variables) a afficher selon la pr` esentation indiqu´ ee par ces descripteurs.´

Les principaux descripteurs: Ici, n et m designent deux constantes enti´ eres nont sign` ees. On a les descrip-´ teurs suivants pour afficher les types simples et dit descripteurs actif (car ils aggissent sur l’affichage ou la lecture des expressions ou variables associes):´ in : affiche (ou lit) la variable entiere` correspondante sur n caracteres.`

En.m : affiche (ou lit) la variable entiere` correspondante sur n caracteres.`

Un module est une unite de compilation s´ epar´ ee comportant un ensemble de d´ eclarations susceptibles d’´ etreˆ partagees par plusieurs sous-programmes. Ces d´ eclarations sont en g´ en´ eral des d´ eclarations de variables, de types,´ de subroutines et fonctions et d’interfaces. L’inter´ et d’un module rˆ eside donc dans la possibilit´ e de remplacer ces´ declarations dans le d´ ebut des sous programmes qui les utilisent par un simple appel au module (ce qui revient´ donc a expliciter le contenu du module). Il est pr` ef´ erable de mettre un module dans un fichier s´ epar´ e.´

26      Structure d’un module.

module nom_module : declarations

:

end module nom_module

SYNTAXE D’UN APPEL: on place l’expression use nom_module

au debut du sous-programme qui s’en sert.´

7.LES ENTREES-SORTIES STANDARDS´

Le but de ce paragraphe est de preciser comment ma´ ˆ?triser la lecture et l’ecriture standards (c’est´ a dire lecture` a partir du clavier et affichae au moniteur).`

La syntaxe gen´ eral d’une instruction d’entree ou de sortie standard est la suivante:´

READ fmt, liste_d_elements                                                               PRINT fmt, liste_d_elements

ou` fmt est le format qui figure sous l’une des quatres formes suivantes:

* : c’est le format libre,

une chaˆ?ne de cacarteres`     : elle comporte une liste de descripteurs nom d’une variable de type chaˆ?ne de cacarteres`

une etiquette: qui est nombre entier non nul comportant au maximum cinq chiffres,

Le parametre` listedelements contient quant a lui la liste des` elements´ a lire ou` a´ ecrire. Par le mot´ el´ ement´ on entend soit une expression, soit une variable soit une liste avec boucle implicite (de la forme (listeelements, i = debut, fin [, pas]).

                  9. QUELQUES FONCTIONS INTERINSEQUES`          A FORTRAN 90.`

27      Fonctions arithmetiques:´

Abs(x) (valeur absolue), Acos(x), Asin(x), Atan(x), Atan2(x, y) (argument dans ] ? ?,?] du nombre complexe z = x + iy), sin(x), cos(x), exp(x), sqr(x)(carre de´ x), sqrt(x) (racine de x), log(x), log10(x), sinh(x), cosh(x), tan(x), tanh(x), sqrt(x), conjg(z), dim(x, y) (fournit max(x ? y,0)), max(x1, x2,...), min(x1, x2,...), mod(a, p) (reste de la division de a par p), floor(x) (partie entiere de` x), aint(x) (partie fractionnaire de x), nint(x) (l’entier le plus proche de x), ceiling(x) (fournit l’entier immediatement superieur´ a` x).

28      Fonctions relatives aux chaˆ?nes de caracteres:`

achar(i): fournit une chaˆ?ne de longueur 1 correpondant au i-eme caract`           ere de la table ASCII.` iachar(c): fournit le numero du caract´    ere`        c dans la table ASCII. len( chaine ): longueur d’une chaˆ?ne, trim( chaine ): founit une chaˆ?ne en enlevant les blancs de chaine, repeat( chaine, n ): founit une chaˆ?ne obtenue en concatenant´     n fois chaine, len trim( chaine ): longueur d’une chaˆ?ne sans compter les espaces vides, lge( chaine1, chaine2 ): = vrai si chaine1 ? chaine2. lle( chaine1, chaine2 ): = vrai si chaine1 ? chaine2. lgt( chaine1, chaine2 ): = vrai si chaine1 > chaine2. llt( chaine1, chaine2 ): = vrai si chaine1 < chaine2.

29      Fonctions relatives aux tableaux.

all(a): fournit la valeur vraie si tous les el´ ements du tableau logique´   a sont vrais, any(a): fournit la valeur vraie si l’un des el´ ements du tableau logique´     a est vrai, count(a): fournit le nombre des valeurs vraies du tableau logique a, dot product(a, b): produit scalaire de deux tableaux a et b de rang 1, MatMul (m1, m2): produit de deux matrices m1 et m2,

Maxval(a): fournit la plus grande valeur d’un tableau a,

Minval(a): fournit la plus petite valeur d’un tableau a,

    Product(a): fournit le produit des el´ ements d’un tableau´ a,

Size(a[, dim]): fournit la taille de a. Si dim est present, il fournit l’´    etendue dans la direction´ dim, Sum(a): fournit la somme des el´ ements d’un tableau´      a, Transpose(m): fournit la transposee d’une matrice´         m.



331