Fortran
Contrôle de l'exécution

Si construire

La construction if (appelée instruction IF de bloc dans FORTRAN 77) est commune à de nombreux langages de programmation. Il exécute conditionnellement un bloc de code lorsqu'une expression logique est évaluée à true.

[name:] IF (expr) THEN
    block
[ELSE IF (expr) THEN [name]
    block]
[ELSE [name]
   block]
END IF [name]

où,

• name - le nom de la construction if (facultatif)
• expr - une expression logique scalaire entre parenthèses
• block - une séquence de zéro ou plusieurs instructions ou constructions

Un nom de construction au début d'une instruction if then doit avoir la même valeur que le nom de la construction à la end if instruction end if et doit être unique pour l'unité de portée actuelle.

Dans les instructions if , les égalités (in) et les expressions logiques évaluant une instruction peuvent être utilisées avec les opérateurs suivants:

.LT.  which is <   ! less than
.LE.           <=  ! less than or equal
.GT.           >   ! greater than
.GE.           >=  ! greater than or equal
.EQ.           =   ! equal
.NE.           /=  ! not equal
.AND.              ! logical and
.OR.               ! logical or
.NOT.              ! negation

Exemples:

! simplest form of if construct
if (a > b) then
    c =  b / 2
end if
!equivalent example with alternate syntax
if(a.gt.b)then
   c=b/2
endif

! named if construct
circle: if (r >= 0) then
    l = 2 * pi * r
end if circle

! complex example with nested if construct
block: if (a < e) then
    if (abs(c - e) <= d) then
        a = a * c
    else
        a = a * d
    end if
else
    a = a * e
end if block

Une utilisation historique de la construction if trouve dans une instruction appelée "arithmétique if". Étant donné que cela peut être remplacé par des constructions plus modernes, il n'est cependant pas couvert ici. Plus de détails peuvent être trouvés ici .

SELECT CASE construit

Une construction de select case exécute conditionnellement un bloc de constructions ou d'instructions en fonction de la valeur d'une expression scalaire dans une instruction de select case . Cette construction de contrôle peut être considérée comme un remplacement du goto calculé.

[name:] SELECT CASE (expr)
[CASE (case-value [, case-value] ...) [name]
   block]...
[CASE DEFAULT [name]
   block]
END SELECT [name]

où,

• name - le nom de la construction de select case (facultatif)
• expr - une expression scalaire de type entier, logique ou caractère (entre parenthèses)
• valeur de casse - une ou plusieurs expressions d'initialisation scalaires entières, logiques ou de caractères entre parenthèses
• block - une séquence de zéro ou plusieurs instructions ou constructions

Exemples:

! simplest form of select case construct
select case(i)
case(:-1)
    s = -1
case(0)
    s = 0
case(1:)
    s = 1
case default
    print "Something strange is happened"
end select

Dans cet exemple, la valeur de cas (:-1) correspond à une plage de valeurs correspondant à toutes les valeurs inférieures à zéro, (0) correspond à des zéros et (1:) correspond à toutes les valeurs supérieures à zéro, la section default implique Non exécuté.

Bloc DO construire

Une construction do est une construction en boucle qui a un nombre d'itérations régi par un contrôle de boucle

integer i
do i=1, 5
  print *, i
end do
print *, i

Dans la forme ci-dessus, la variable de boucle i traverse la boucle 5 fois, en prenant les valeurs 1 à 5 tour à tour. Une fois que la construction a terminé, la variable de boucle a la valeur 6, c'est-à-dire que la variable de boucle est incrémentée une fois de plus après l'achèvement de la boucle .

De manière plus générale, le do construction de la boucle peut être comprise comme suit

integer i, first, last, step
do i=first, last, step
end do

La boucle commence par i avec la valeur first , incrémenter chaque itération par step jusqu'à ce que i est supérieur à la last (ou moins de la last si la taille de pas est négatif).

Il est important de noter que depuis Fortran 95, la variable de boucle et les expressions de contrôle de boucle doivent être des nombres entiers.

Une itération peut se terminer prématurément avec l'instruction de cycle

do i=1, 5
  if (i==4) cycle
end do

et la construction entière peut cesser l'exécution avec l'instruction de exit

do i=1, 5
  if (i==4) exit
end do
print *, i

do constructions peuvent être nommées:

do_name: do i=1, 5
end do do_name

ce qui est particulièrement utile lorsque sont imbriqués do des constructions

do1: do i=1, 5
  do j=1,6
    if (j==3) cycle        ! This cycles the j construct
    if (j==4) cycle        ! This cycles the j construct
    if (i+j==7) cycle do1  ! This cycles the i construct
    if (i*j==15) exit do1  ! This exits the i construct
  end do
end do1

Est- do constructions peuvent aussi avoir un contrôle de boucle indéterminé, soit "pour toujours" ou jusqu'à ce qu'une condition donnée soit remplie

integer :: i=0
do
  i=i+1
  if (i==5) exit
end do

ou

integer :: i=0
do while (i<6)
  i=i+1
end do

Cela permet également de do boucle infinie via une .true. déclaration

print *,'forever'
do while(.true.)
  print *,'and ever'
end do

Un do construct peut aussi laisser l'ordre des itérations indéterminé

do concurrent (i=1:5)
end do

notant que la forme du contrôle de boucle est la même que dans un contrôle forall .

Il existe diverses restrictions sur les instructions qui peuvent être exécutées dans le cadre d'une structure do concurrent conçues pour garantir qu'il n'y a pas de dépendance de données entre les itérations de la construction. Cette indication explicite par le programmeur peut permettre une meilleure optimisation (y compris la parallélisation) par le compilateur, ce qui peut être difficile à déterminer autrement.

Les variables "privées" dans une interaction peuvent être réalisées en utilisant une construction de block dans le do concurrent :

do concurrent (i=1:5, j=2:7)
  block
    real tempval  ! This is independent across iterations
  end block
end do

Une autre forme du bloc do construire utilise une étiquette continue déclaration au lieu d'une end do :

    do 100, i=1, 5
100 continue

Il est même possible d'imbriquer de telles constructions avec une instruction de terminaison partagée

    do 100, i=1,5
    do 100, j=1,5
100 continue

Ces deux formes, et en particulier la seconde (qui est obsolète), doivent généralement être évitées pour des raisons de clarté.

Enfin, il y a aussi un non-bloc do construire. Ceci est également considéré comme obsolète et est décrit ailleurs , ainsi que des méthodes de restructuration en bloc do construire.

O construct construire

La where construction, disponible en Fortran90 représente partir d' un masqué do construire. L'instruction de masquage suit les mêmes règles que l'instruction if , mais s'applique à tous les éléments du tableau donné. Utilisation de where permet d'effectuer des opérations sur un tableau (ou plusieurs tableaux de même taille), dont les éléments satisfont à une certaine règle. Cela peut être utilisé pour simplifier les opérations simultanées sur plusieurs variables.

Syntaxe:

[name]: where (mask)
    block
[elsewhere (mask)
    block]
[elsewhere
    block]
end where [name]

Ici,

• name - est le nom donné au bloc (s'il est nommé)
• mask - est une expression logique appliquée à tous les éléments
• block - série de commandes à exécuter

Exemples:

! Example variables
real:: A(5),B(5),C(5)
A = 0.0
B = 1.0
C = [0.0, 4.0, 5.0, 10.0, 0.0]

! Simple where construct use
where (C/=0)
    A=B/C
elsewhere
    A=0.0
end

! Named where construct
Block: where (C/=0)
    A=B/C
elsewhere
    A=0.0
end where Block