Fortran
Uitvoering controle

Als construct

De if constructie (een block-instructie IF genoemd in FORTRAN 77) is gebruikelijk in veel programmeertalen. Het voert voorwaardelijk één codeblok uit wanneer een logische expressie als waar wordt geëvalueerd.

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

waar,

• naam - de naam van het if-construct (optioneel)
• expr - een scalaire logische uitdrukking tussen haakjes
• block - een reeks van nul of meer statements of constructen

Een constructnaam aan het begin van een if then instructie moet dezelfde waarde hebben als de constructnaam aan het end if instructie en moet uniek zijn voor de huidige scoping-eenheid.

In if statements, (in) gelijkheden en logische expressies die een statement evalueren, kunnen worden gebruikt met de volgende operatoren:

.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

Voorbeelden:

! 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

Een historisch gebruik van het if construct bevindt zich in een zogenaamde "rekenkundige if" -instructie. Aangezien dit kan worden vervangen door modernere constructies, wordt het hier echter niet behandeld. Meer details zijn hier te vinden.

SELECT CASE-constructie

Een select case construct voert voorwaardelijk een blok constructs of statements uit, afhankelijk van de waarde van een scalaire expressie in een select case statement. Dit besturingsconstruct kan worden beschouwd als een vervanging voor berekende goto .

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

waar,

• naam - de naam van de select case constructie (optioneel)
• expr - een scalaire uitdrukking van het type geheel getal, logisch of teken (tussen haakjes)
• case-value - een of meer scalaire integer-, logische of tekeninitialisatie-expressies tussen haakjes
• block - een reeks van nul of meer statements of constructen

Voorbeelden:

! 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

In dit voorbeeld is (:-1) hoofdwaarde een bereik van waarden die overeenkomen met alle waarden kleiner dan nul, (0) overeen met nullen en (1:) overeen met alle waarden boven nul, default houdt in dat andere secties niet uitgevoerd.

Blok DO construct

Een do constructie is een lusconstructie met een aantal iteraties die worden geregeld door een lusregeling

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

In de bovenstaande vorm passeert de lusvariabele i 5 keer de lus, waarbij de waarden 1 tot 5 worden genomen. Nadat het construct is voltooid, heeft de lusvariabele de waarde 6, dat wil zeggen dat de lusvariabele na de voltooiing van de lus nogmaals wordt verhoogd .

Meer in het algemeen kan het do lusconstructie als volgt worden begrepen

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

De lus begint met i met de waarde first , waarbij elke iteratie step wordt verhoogd totdat i groter is dan de last (of kleiner dan de last als de stapgrootte negatief is).

Het is belangrijk op te merken dat sinds Fortran 95 de lusvariabele en de lusbesturingsuitdrukkingen een geheel getal moeten zijn.

Een iteratie kan voortijdig worden beëindigd met het cycle

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

en de hele constructie kan worden gestopt met de exit instructie

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

do constructs kunnen worden genoemd:

do_name: do i=1, 5
end do do_name

hetgeen in het bijzonder nuttig wanneer er geneste do constructen

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

do constructen kunnen ook onbepaalde lusbesturing hebben, "voor altijd" of totdat aan een bepaalde voorwaarde is voldaan

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

of

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

Dit maakt ook een oneindige do lus mogelijk via een .true. uitspraak

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

Een do constructie kan ook de volgorde van iteraties onbepaald laten

do concurrent (i=1:5)
end do

waarbij wordt opgemerkt dat de vorm van lusbesturing hetzelfde is als bij een forall besturing.

Er zijn verschillende beperkingen op de instructies die kunnen worden uitgevoerd binnen het bereik van een do concurrent constructie die zijn ontworpen om ervoor te zorgen dat er geen gegevensafhankelijkheid is tussen iteraties van de constructie. Deze expliciete indicatie door de programmeur kan een grotere optimalisatie (inclusief parallellisatie) door de compiler mogelijk maken, hetgeen moeilijk kan zijn om anders te bepalen.

"Particuliere" variabelen binnen een interactie kunnen worden gerealiseerd door gebruik te maken van een block in de do concurrent :

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

Een andere vorm van het block do construct gebruikt een gelabelde continue instructie in plaats van een end do :

    do 100, i=1, 5
100 continue

Het is zelfs mogelijk om dergelijke constructies te nestelen met een gedeelde beëindigingsverklaring

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

Beide vormen, en vooral de tweede (die verouderd is), moeten over het algemeen worden vermeden omwille van de duidelijkheid.

Ten slotte is er ook een non-block do construct. Dit wordt ook geacht te zijn verouderd en elders beschreven , samen met werkwijzen voor het herstructureren als blok do construct.

WAAR construeren

Het where construct, vanaf Fortran90 beschikbaar, vertegenwoordigt een gemaskeerd do construct. De maskeerinstructie volgt dezelfde regels als de if instructie, maar wordt toegepast op alle elementen van de gegeven array. Met behulp van where kunnen bewerkingen worden uitgevoerd op een array (of meerdere arrays van dezelfde grootte), waarvan de elementen voldoen aan een bepaalde regel. Dit kan worden gebruikt om gelijktijdige bewerkingen op verschillende variabelen te vereenvoudigen.

Syntaxis:

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

Hier,

• naam - is de naam die aan het blok is gegeven (indien benoemd)
• mask - is een logische uitdrukking die op alle elementen wordt toegepast
• block - reeks uit te voeren commando's

Voorbeelden:

! 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