Fortran
Controllo dell'esecuzione

Se costrutto

Il costrutto if (chiamato istruzione IF blocco in FORTRAN 77) è comune in molti linguaggi di programmazione. Esegue condizionatamente un blocco di codice quando un'espressione logica viene valutata su true.

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

dove,

• nome : il nome del costrutto if (facoltativo)
• expr - un'espressione logica scalare racchiusa tra parentesi
• block - una sequenza di zero o più istruzioni o costrutti

Un nome di costrutto all'inizio di un'istruzione if then deve avere lo stesso valore del nome del costrutto alla end if dell'istruzione, e dovrebbe essere univoco per l'attuale unità di ambito.

Nelle istruzioni if , (in) le uguaglianze e le espressioni logiche che valutano un'istruzione possono essere utilizzate con i seguenti operatori:

.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

Esempi:

! 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

Un uso storico del costrutto if è in quella che viene definita un'istruzione "aritmetica se". Poiché questo può essere sostituito da costrutti più moderni, tuttavia, non è coperto qui. Maggiori dettagli possono essere trovati qui .

SELEZIONA il costrutto CASE

Un costrutto di select case esegue condizionalmente un blocco di costrutti o istruzioni in base al valore di un'espressione scalare in un'istruzione select case . Questo costrutto di controllo può essere considerato come una sostituzione del goto calcolato.

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

dove,

• nome : il nome del costrutto di select case (facoltativo)
• expr - un'espressione scalare di tipo intero, logico o carattere (racchiusa tra parentesi)
• case-value : una o più espressioni scalari di intero, logico o di inizializzazione del carattere racchiuse tra parentesi
• block - una sequenza di zero o più istruzioni o costrutti

Esempi:

! 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 questo esempio, (:-1) valore del caso è un intervallo di valori corrispondenti a tutti i valori inferiori a zero, (0) corrisponde agli zeri e (1:) corrisponde a tutti i valori sopra lo zero, la sezione default interessa se altre sezioni lo hanno fatto non eseguito.

Costruisci il blocco DO

Un costrutto do è un costrutto ciclico che ha un numero di iterazioni governate da un controllo di ciclo

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

Nella forma in alto, la variabile loop i passa attraverso il loop 5 volte, prendendo a turno i valori da 1 a 5. Dopo che il costrutto ha completato la variabile di ciclo ha il valore 6, cioè la variabile di ciclo viene incrementata ancora una volta dopo il completamento del ciclo .

Più in generale, il costrutto do loop può essere compreso come segue

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

Il ciclo inizia con i con il valore per first , incrementando ogni iterazione per step fino a quando i è maggiore last (o meno last se la dimensione del passo è negativa).

È importante notare che poiché Fortran 95, la variabile di ciclo e le espressioni di controllo del ciclo devono essere numeri interi.

Un'iterazione può essere interrotta prematuramente con l'istruzione del cycle

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

e l'intero costrutto potrebbe cessare l'esecuzione con l'istruzione exit

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

do costrutti possono essere nominati:

do_name: do i=1, 5
end do do_name

che è particolarmente utile quando vi sono annidati do costrutti

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 costrutti possono anche avere un controllo di ciclo indeterminato, "per sempre" o fino a quando una determinata condizione non viene soddisfatta

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

o

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

Ciò consente anche di un infinito do ciclo attraverso un .true. dichiarazione

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

Un costrutto do può anche lasciare l'ordine delle iterazioni indeterminato

do concurrent (i=1:5)
end do

notando che la forma del controllo del ciclo è la stessa di un controllo forall .

Esistono varie restrizioni sulle istruzioni che possono essere eseguite all'interno dell'intervallo di un costrutto do concurrent che sono progettate per garantire che non vi siano dipendenze tra le iterazioni del costrutto. Questa indicazione esplicita da parte del programmatore può consentire una maggiore ottimizzazione (inclusa la parallelizzazione) da parte del compilatore, che può essere difficile da determinare diversamente.

Le variabili "private" all'interno di un'interazione possono essere realizzate utilizzando un costrutto di block all'interno del do concurrent :

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

Un'altra forma di blocco do costruire utilizza un marcato continue dichiarazione invece di un end do :

    do 100, i=1, 5
100 continue

È persino possibile annidare tali costrutti con un'istruzione di terminazione condivisa

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

Entrambe queste forme, e specialmente la seconda (che è obsolescente), devono essere generalmente evitate per motivi di chiarezza.

Infine, v'è anche un non-blocco do costruire. Ciò è ritenuto essere anche obsoleti e viene descritto altrove , insieme a metodi per ristrutturare come blocco do costruire.

DOVE costruisci

Il costrutto where , disponibile in Fortran90 in poi, rappresenta un costrutto do mascherato. L'istruzione masking segue le stesse regole dell'istruzione if , ma viene applicata a tutti gli elementi dell'array dato. L'utilizzo di where consente di eseguire operazioni su un array (o più array della stessa dimensione), i cui elementi soddisfano una determinata regola. Questo può essere usato per semplificare le operazioni simultanee su più variabili.

Sintassi:

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

Qui,

• nome - è il nome dato al blocco (se nominato)
• mask - è un'espressione logica applicata a tutti gli elementi
• block - serie di comandi da eseguire

Esempi:

! 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