L’istruzione PRINT nel Fortran è una versione semplificata dell’istruzione WRITE, ed il suo formato è il seguente:

      PRINT f,lista di variabili

dove “f” è un numero intero, indica al computer di scrivere i dati con il formato specificato dall’istruzione FORMAT individuata dall’etichetta con il numero “f”; se “f” viene posto uguale ad un “*” (asterisco), specificheremo di utilizzare un formato “libero”, cioè quello predefinito nel FORTRAN (in questo caso, i valori delle variabili verranno stampati in una sola riga, con 7 decimali se sono variabili R4, 15 se sono R8, ecc.).

Tale istruzione ci permette di scrivere ciò che viene specificato nella lista di variabili direttamente sullo schermo del computer su cui viene eseguito il programma.

Si noti che il comando “print *” è seguito da una virgola, e che le virgole compaiono tra gli elementi successivi da stampare. E’ opportuno osservare anche che le le stringhe devono essere racchiuse da virgolette doppie o singole. Il comando “print *” su una riga da solo e senza virgola  viene utilizzato come un avanzamento riga.

Esempio di utilizzo dell’istruzione print nel Fortran:

program somma
implicit none
integer :: somma, a

print*, "Questo programma esegue una somma. Inserire 0 per terminare la somma."
open(unit=10, file="Somma.DAT")

somma = 0

do
 print*, "Inserisci il numero da sommare:"
 read*, a
 if (a == 0) then
  exit
 else
  somma = somma + a
 end if
 write(10,*) a
end do

print*, "Somma =", somma
write(10,*) "Somma =", somma
close(10)

end

 LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• Istruzione WRITE formattata nel Fortran
• Cicli a condizione finale nel Fortran
• Cicli a condizione iniziale nel Fortran
• Istruzione Select Case nel Fortran
• Istruzione if nel Fortran

L’istruzione WRITE nel Fortran permette di scrivere il contenuto di una variabile secondo un preventivato formato. La sintassi dell’istruzione WRITE è la seguente:

 WRITE(UNIT=u,FMT=f,ERR=e) lista di variabili

•  dove  u è un numero intero che assume ha la funzione di specificare l’indirizzamento della scrittura e cioè sul terminale (UNIT=6) oppure sul disco;
• FMT=f, dove “f” è un numero intero, indica al computer di scrivere i dati con il formato specificato dall’istruzione FORMAT individuata dall’etichetta con il numero “f”;
• la specifica (ERR=e) è opzionale e serve per controllare che il processo di scrittura abbia avuto successo.

Le parole chiave “UNIT=” e “FMT=” possono essere omesse, quindi possiamo sintetizzare il comando in  WRITE(u,f,…), assicurandoci però che il numero che si riferisce all’unità di uscita preceda l’etichetta del formato. Se “f” viene posto uguale ad un “*” (asterisco), specificheremo di utilizzare un formato “libero”, cioè quello predefinito nel FORTRAN (in questo caso, i valori delle variabili verranno stampati in una sola riga, con 7 decimali se sono variabili R4, 15 se sono R8, ecc.).

 Se la specifica ERR non è presente e si verifica una condizione di errore  il computer fermerà l’esecuzione. Se invece si è specificato ERR=e, dove “e” è un altro numero di etichetta, quando si verifica una condizione di errore durante la scrittura il computer continuerà l’esecuzione del programma dalla riga etichettata con “e”.

Un esempio dell’utilizzo dell’istruzione WRITE nel Fortran è il seguente:

WRITE (*,10) j,var 10 FORMAT (“L’iterazione”,I3,”ha fornito il seguente risultato”,F7.3)

La parentesi (*,10) indica di scrivere a video (*) con formato 10 (10 è l’etichetta del formato), è importante che tale etichetta non sia stata già utilizzata. Il formato scelto prevede del testo per indicare il significato dei valori e dei descrittori di formato che indicano in che modo devono essere espressi i valori delle variabili.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• Cicli a condizione finale nel Fortran
• Cicli a condizione iniziale nel Fortran
• Istruzione Select Case nel Fortran
• Istruzione if nel Fortran
• Le Procedure di Modulo nel Fortran

Il ciclo a condizione finale nel Fortran, che comunemente viene identificato dal termine repeat-until, esegue il controllo della condizione dopo che le istruzioni presenti nel blocco vengano eseguite, subito prima dell’istruzione END DO. Così le istruzioni del corpo del ciclo verranno sempre eseguite almeno una volta.

La forma generale del costrutto è la seguente:

[nome :] DO
istruzione 1
istruzione 2
........
IF (espressione logica ) EXIT
END DO [nome ]

Riporto di seguito un semplice programma d’esempio che ci permette di capire il funzionamento di un ciclo di questo genere. Si tratta di un programma che dopo aver richiesto di digitare un numero, stampa a video tutti i numeri a parire da 1 fino al numero inserito.

program stampanumeri
implicit none
integer :: i, n
!
! Utilizzo istruzione exit
!
write(*,*)’Digita un intero positivo’
read(*,*)n
i=1
do
      write(*,*)i
      if(i==n)exit
      i=i+1
end do
end program stampanumeri

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• Cicli a condizione iniziale nel Fortran
• Istruzione Select Case nel Fortran
• Istruzione if nel Fortran
• Le Procedure di Modulo nel Fortran
• I moduli nel Fortran

Il ciclo a condizione iniziale nel Fortran, che comunemente viene identificato dal termine to ciclo while, esegue il controllo della condizione prima che le istruzioni presenti nel blocco sia eseguite. Allora le dichiarazioni presenti nel corpo verranno ripetute fino a quando la condizione specificata risulterà vera.

La forma generale del costrutto è la seguente:

do while (espressione logica)
     istruzione1
     istruzione2
     ………….
end do

L’esecuzione del blocco di istruzioni presente all’interno del ciclo avviene secondo la sequenza di seguito indicata:

1. viene dapprima valutato il valore dell’espressione logica riportata tra parentesi;
2. se il corrispondente valore risulta .FALSE., nessuna istruzione del blocco viene eseguita e il controllo passa alla prima istruzione che compare dopo l’istruzione END DO;
3. se invece tale valore risulta .TRUE., allora viene eseguito il blocco di istruzioni a partire dalla prima istruzione che segue l’istruzione DO WHILE;
4. nel momento in cui viene raggiunta l’istruzione finale del ciclo, il controllo ritorna all’istruzione DO WHILE; quindi l’espressione logica è valutata nuovamente e il ciclo viene ripetuto.

Di seguito riporto un semplice esempio che effettua un ciclo while per eseguire una valutazione di una certa funzione e ripete tale calcolo fintantoche lo scarto risulta maggiore o uguale della tolleranza. Quando tale valore risulta minore il ciclo si arresta.

do while (scarto.ge.toll)
iter = iter +1
fval=g(fk)
scarto = abs(fval - fk)
fk = fval
end do

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• Istruzione Select Case nel Fortran
• Istruzione if nel Fortran
• Le Procedure di Modulo nel Fortran
• I moduli nel Fortran

L’istruzione Select Case nel Fortran può essere usata per eseguire un insieme di criteri di selezione di multi-alternativa, in questo modo consente al programmatore di selezionare un
particolare blocco di istruzioni da eseguire in funzione del valore assunto da una variabile di
controllo di tipo intero o carattere, o da un’espressione logica. La sintassi del costrutto è la seguente:

nome : SELECT CASE (espressione di CASE)
CASE (selettore 1) nome
istruzione 1
istruzione 2
.......
CASE (selettore 2) nome
istruzione 1
istruzione 2
.......
.....
CASE DEFAULT nome
(selettore 2) nome
istruzione 1
istruzione 2
.......
END SELECT nome

Come già anticipato il selettore può essere un numero intero, un carattere, o un’espressione logica. Così come i blocchi dell’istruzione IF_ELSE, i costrutti CASE possono anche essere etichettati con un nome.

Se il valore della espressione di CASE è compreso nell’intervallo dei valori inseriti nel selettore 1 verranno eseguite le istruzioni del blocco istruzione 1; mentre se il valore della espressione di CASE è compreso nell’intervallo dei valori di selettore 2 verranno eseguite le istruzioni del blocco istruzione 2 , e in modo simile per le altre alternative inserite nel costrutto.

La clausola CASE DEFAULT è opzionale e copre tutti gli altri possibili valori della espressione di CASE non previsti dalle altre istruzioni CASE. Se il blocco DEFAULT viene omesso e il valore di espressione non è compreso in un intervallo dei selettori, non sarà eseguita alcuna istruzione.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• Istruzione if nel Fortran
• Le Procedure di Modulo nel Fortran
• I moduli nel Fortran

L’istruzione if nel Fortran rappresenta una struttura per il controllo del flusso di informazioni che ci permette di valutare un’espressione logica e di eseguire un blocco di programma nell’ipotesi tale espressione risulti vera, mentre l’opzione else ci consente di eseguire un altro blocco di programma  nel caso la condizione imposta da if non si avveri.

La forma più generale del costrutto IF-THEN-ELSE-END IF è la seguente:

IF (espressione-logica) THEN
      blocco1
ELSE
     blocco2
END IF

dove le blocco1 e blocco2 sono sequenze di istruzioni eseguibili, e espressione-logica è ovviamente un’espressione logica. L’esecuzione di questo costrutto va come segue:

• l’espressione logica viene valutata, ottenendo un valore logico
• se il risultato è. TRUE., le dichiarazioni contenute nella blocco1 vengono eseguite
• se il risultato è. FALSE., le dichiarazioni contenute nella blocco 2 sono eseguiti
• dopo il termine dell’esecuzione di istruzioni in blocco 1 o blocco 2, la seguente dichiarazione END IF viene eseguita.

Esempio di codice fortran
Il seguente codice prima legge un intero e lo deposita in una variabile intera. Poi, se il numero può essere diviso per 2 (cioè, se il numero è un multiplo di 2),  l’istruzione WRITE (*,*) contenuta tra IF e ELSE viene eseguita e dimostra che il numero è pari, altrimenti, l’istruzione WRITE (*, * ) contenuta tra ELSE END IF viene eseguita e mostra che il numero è dispari.

function MOD(x, y)
!calcola il resto di x diviso y.
INTEGER :: Number

READ(*,*) Number
IF (MOD(Number, 2) == 0) THEN
    WRITE(*,*) Number, ‘ pari’
ELSE
    WRITE(*,*) Number, ‘ dispari’
END IF
end function

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• Le Procedure di Modulo nel Fortran
• I moduli nel Fortran
• Cicli a condizione iniziale nel Fortran
• Istruzione Select Case nel Fortran

Abbiamo imparato ad usare i moduli nel Fortran, e ne abbiamo apprezzato l’enorme utilità quale deposito di variabili e costanti a cui ogni unità di programma può attingere. Ma i moduli sono ben altro e ci consentono di definire al proprio interno delle vere e proprie procedure che ogni unità di programma che accede al modulo potrà in questo modo utilizzare, facendo uso dell’istruzione USE.

Ricordiamo a tal proposito che un modulo di programma è reso accessibile alle varie unità di programma attraverso l’istruzione USE. Tali procedure vengono, pertanto, chiamate procedure di modulo nel Fortran e vengono compilate come parte del modulo.

 Le procedure che si trovano all’interno di un modulo devono essere posizionate dopo le dichiarazioni dei dati e devono essere precedute dall’istruzione CONTAINS. Questa istruzione indica al compilatore che le istruzioni successive rappresentano delle procedure di modulo.

Di seguito si riporta un programma che fa uso di una procedura di modulo per calcolare il prodotto di una matrice per un vettore.

module OperazioniMatriceVettore
integer, parameter :: N = 3 ! costante globale.
contains

function moltiplicazioneMatriceVettore ( A, b ) result( c )
implicit none
! Definizione delle dimensioni di A e b.
real, dimension( :, : ), intent( in ) :: A
real, dimension( : ), intent( in ) :: b
real, dimension( size( b ) ) :: c
integer N
integer i
N = size( b )
c = 0.0
do i = 1, N
c = c + b( i ) * A( :, i )
end do
end function moltiplicazioneMatriceVettore

end module OperazioniMatriceVettore

program MatriceVettore
use OperazioniMatriceVettore
implicit none
real, dimension( N, N ) :: A
real, dimension( N ) :: b, c
! Riempie A è  b with con numeri random.
call random_number( A )
call random_number( b )
! Calcola il prodotto matrice * vettore, A*b.
c = moltiplicazioneMatriceVettore ( A, b )
print *, ‘Prodotto matrice vettore = ‘, c
end program MatriceVettore

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• I moduli nel Fortran
• Cicli a condizione iniziale nel Fortran
• Istruzione Select Case nel Fortran
• Istruzione if nel Fortran

Nelle applicazioni di programmazione ingegneristiche, si incontra spesso il caso di parametri, variabili e sottoprogrammi che devono essere ripartiti in diverse unità di programma. Per risolvere tale problema si possono utilizzare i moduli nel Fortran che rappresentano un’unità  speciale di programma che raccoglie le collezioni di dichiarazioni e di subprograms in modo da poterle importare in altre unità di programma.

La funzionalità dell’unità modulo è simile a quella dell’archivio di intestazione di C. I Moduli semplici vengono definiti attraverso al seguente struttura:

MODULE name
        corpo
END MODULE name

Si noti che questa è la forma più semplice dell’unità del modulo. Esistono forme più generali che ci permettono l’inclusione dei subprograms e delle procedure. Richiameremo soltanto la forma più semplice dell’unità del modulo .

Un modulo di programma è reso accessibile alle varie unità di programma attraverso l’istruzione USE. Per meglio comprendere l’utilizzo dei moduli nel Fortran consideriamo il seguente programma che usa un modulo nel calcolo dell’area d’un cerchio:

MODULE Circle
!---------------------------------------------------------------------
! ! Modulo che contiene le definizioni delle variabili necessarie per 
! il calcolo dell'area di un cerchio noto il raggio !
!---------------------------------------------------------------------
    REAL, PARAMETER :: Pi = 3.1415927
    REAL :: radius
END MODULE Circle
PROGRAM Area
!---------------------------------------------------------------------
! ! Questo programma calcola l'area di un cerchio noto che sia il raggio  
! Uses: MODULE Circle ! FUNCTION Area_Circle (r) !
!---------------------------------------------------------------------
USE Circle, ONLY : radius IMPLICIT NONE
INTERFACE
   FUNCTION Area_Circle (r)
      REAL, INTENT(IN) :: r
   END FUNCTION Area_Circle
END INTERFACE
! Prompt user per il valore del raggio 
write(*, '(A)', ADVANCE ="NO") "Digita il valore del raggio: " 
read(*,*) radius
! Scrive l'area utilizzando la function call 
write(*,100) "Area del cerchio di raggio", radius, " e", &
Area_Circle(radius)
100 format (A, 2x, F6.2, A, 2x, F11.2)
END PROGRAM Area
!-----Area_Circle----------------------------------------------------
! ! Funzione per il calcolo dell'area del cerchio !
!---------------------------------------------------------------------
FUNCTION Area_Circle(r) USE Circle, ONLY : Pi
   IMPLICIT NONE REAL :: Area_Circle REAL, INTENT(IN) :: r
   Area_Circle = Pi * r * r
END FUNCTION Area_Circle

In questo esempio, definiamo un modulo che dichiara il tipo delle due variabili reali pi e raggio. In più, in questo modulo, dichiariamo il valore del parametro pi. Per usare il modulo nel programma principale, impieghiamo l’istruzione USE.

Usiamo poi una forma speciale dell’ istruzione USE che specifica che siamo soltanto interessati al valore del raggio nel programma principale, cioè nel programma del modulo viene utilizzato un solo componente. Similmente, usiamo soltanto il parametro pi nel subprogram Area_Circle attraverso l’istruzione USE che compare in quella procedura.

L’istruzione USE deve comparire all’inizio della parte di dichiarazione dell’unità di programma che usa il modulo!! Deve comparire anche prima dell’istruzione IMPLICIT NONE!

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• Le subroutine nel Fortran
• Le funzioni nel Fortran
• Sottoprogrammi nel Fortran
• Gli array bidimensionali in Fortran
• Gli array monodimensionali nel Fortran