Category Archives: Fortran

Le funzioni nel Fortran


FORTRANLe funzioni, nel Fortran, rappresentano un tipo di sottoprogrammi che, se necessario, possono essere richiamati più volte all’interno del programma principale per soddisfare una particolare esigenza ed effettuare degli opportuni calcoli.

Le funzioni definite dall’utente, a differenza delle funzioni standard già ingoblate nell’ambiente di programmazione, vengono scritte al fine di soddisfare uno specifico scopo che nessun altro strumento a disposizione del programmatore è in grado di soddisfare.

Le funzioni sono definite attraverso un costrutto del tipo:

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

È tramite il nome della funzione che si richiama la funzione all’interno del programma principale. Gli argomenti contenuti nelle parentesi tonde sono gli identificatori su cui la funzione opera.

Le funzioni lavorano sui valori memorizzati negli argomenti e restituiscono un risultato del tipo specificato. L’elenco degli identificatori costituisce un insieme di oggetti fittizi, ai quali, quando il sottoprogramma viene richiamato, vengono rimpiazzati i valori degli argomenti dell’istruzione chiamante.

Dopo la definizione della una funzione, csegue il blocco di istruzioni che costituiscono il sottoprogramma. Tra queste vi deve essere almeno un’istruzione di assegnazione con il nome della funzione a sinistra del segno di uguale, che assegna un valore a questa variabile e che viene quindi restituito al programma chiamante al termine della funzione, che come tutti i programmi deve terminare con END.

Vediamo come esempio un programma che richiama al suo interno una funzione:

MODULE Circle
!---------------------------------------------------------------------
! ! Modulo che contiene la definizione delle variabili necessarie
! per la computazione dell'area del cerchio di raggio r !
!---------------------------------------------------------------------
REAL, PARAMETER :: Pi = 3.1415927
REAL :: radius
END MODULE Circle
PROGRAM Area
!---------------------------------------------------------------------
! ! Questo programma computa l'area del cerchio dato il raggio !
! Uses: MODULE Circle ! FUNCTION Area_Circle (r) !
!---------------------------------------------------------------------
16
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 raggio del cerchio write(*, '(A)', ADVANCE =
"NO") "Digita il raggio del cerchio: " read(*,*) radius
! Write out area of circle using function call write(*,100) "Area
del cerchio con raggio", radius, " is", &
Area_Circle(radius)
100 format (A, 2x, F6.2, A, 2x, F11.2)
END PROGRAM Area
!-----Area_Circle----------------------------------------------------
! ! Funzione che calcola l'area del cerchio di raggio r !
!---------------------------------------------------------------------
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

Questo programma usa la funzione Area_Circle per computare l’area d’un cerchio di raggio r. La funzione compare dopo l’istruzione di fine programma della zona principale di programma, in modo da essere classificata come subprogram esterno. Poichè è una procedura esterna, il programma principale usa un INTERFACE BLOCK per definire tutti i parametri richiesti dalla funzione Area_Circle.

La versione in fortran 90 del subprogram funzione si comporta allo stesso modo del subprogram funzione presente nel fortran 77. Si noti che l’ unica differenza sostanziale qui è la capacità di dichiarare esplicitamente gli argomenti della funzione in se.Prendere la nota speciale del descrittore INTENT(IN) del tipo.

Questo attributo della variabile r nel subprogram di funzione identifica rigorosamente la variabile r come variabile di input. Tali variabili non possono essere modificati dal subprogram in modo involontario.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Sottoprogrammi nel Fortran


FORTRANCosì come già accadeva per il fortran 77, anche il nuovo formato fortran 90 ci consente di suddividere un programma principali in una serie di sottoprogrammi. tali sottoprogrammi possono essere di due tipi:

  1. funzioni
  2. subroutine

In entrambi i casi è poi possibile suddividere il sottoprogrammi in ulteriori due forme:

  1. sottoprogramma interno
  2. sottoprogramma esterno.

I sottoprogrammi interni sono quelle procedure che possono comparire nell’ambito del programma principale. mentre i  sottoprogrammi esterni sono quelli che compaiono in una sezione separata di programma dopo l’ istruzione principale END del programma.

Ciò è del tutto simile a quanto già si faceva nel fortran 77 trattandosi pur sempre di programmazione procedurale.  Inoltre, così come in fortran 77, i sottoprogrammi del tipo function, nel fortran 90, hanno un tipo esplicito e sono indirizzati a restituire un valore.

Mentre i sottoprogrammi del tipo subroutine, non hanno tipo esplicito e restituiscono il risultato o nessun valore con una chiamata del parametro CONTAINS(). Poichè porremo l’attenzione sui sottoprogrammi esterni, è essenziale l’utilizzo di una caratteristica del fortran 90 conosciuta come INTERFACE BLOCKS.

Questo blocco è una caratteristica di sicurezza che permette che i programmi principali ed i subprograms esterni si connettano giustamente. Un INTERFACE BLOCKS si accerta che il programma chiamante ed il subprogram abbiano il numero ed il tipo corretti di argomenti.

Ciò aiuta il compilatore a rilevare l’uso errato d’un subprogram . Un INTERFACE BLOCK consiste di:

1. numero di argomenti
2. tipo di ogni argomento
3. che tipo del value(s) ha restituito il subprogram

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Gli array bidimensionali in Fortran


FORTRANUn array bidimensionale, anche detto matrice, è una variabile strutturata tale che i suoi elementi sono tutti dello stesso tipo e il meccanismo di accesso diretto ai suoi elementi consiste di due espressioni intere dette indici.

In Fortran gli array bidimensionali e in generale multidimensionali possono essere dichiarati nel modo seguente:

REAL, DIMENSION(2,3) :: A
REAL, DIMENSION(0:1,0:2) :: B
INTEGER,DIMENSION(10,20,3) :: I

Il limite massimo sul Rank (il numero di dimensioni) d’un array è 7. I valori degli elementi d’un array multidimensionale possono essere assegnati in un modo simile a quello per la varietà unidimensionale.

Ad esempio, i valori 1, 2, 3, 4, 5, 6 possono essere assegnati all’array bidimensionale A nel modo seguente:

A = (/ 1, 2, 3, 4, 5, 6 /)

Ciò assegna i valori dell’array di A nell’ordine della colonna simile alle regole di fortran 77. L’assegnazione dei valori di un array ad un altro array è consentita a condizione che entrambi gli array in questione abbiano la stessa dimensione fisica. Per esempio,

B = A

assegna i valori precedentemente assegnati all’array A all’array B. Così come con gli array unidimensionali, gli operatori e le funzioni applicate normalmente alle espressioni semplici, possono anche essere applicati agli array multidimensionali che hanno lo stesso numero di elementi.

Sono altresì disponibili diverse funzioni intrinseche per elaborare gli array multidimensionali. Quelle più utili sono:

  • MAXVAL(A, D): restituisce un array che contiene i valori massimi lungo la dimensione D(se la D e omessa, restituisce il valore massimo dell’intero array)
  • MAXLOC(A) : restituisce la locazione di memoria del valore max lungo D di A
  • SUM(A, D) : restituisce un array che contiene le somme degli elementi di A lungo la dimensione D (se la D e omessa,restituisce la somma degli elementi dell’ intero array)
  • MATMUL(A, B): restituisce il prodotto di A e della B
  • TRANSPOSE(A): restituisce la trasposta del 2d array A

Un array può essere allocatable ,cioè, può essergli assegnata una locazione di memoria precisa durante l’esecuzione. Vediamo allora come ichiarare un array allocatable reale A,

REAL, DIMENSION(:,:), ALLOCATABLE :: A

Nel momento di esecuzione, i limiti reali per l’array A possono essere determinati dalla istruzione:

ALLOCATE(A(N, N), STAT = AllocateStatus) SE (AllocateStatus/ = 0)
                      ARRESTO ” * * * non abbastanza ***” di memoria

Qui, la N ed AllocateStatus sono variabili numero intero. AllocateStatus prende il valore 0 se la ripartizione riesce o un certo altro valore dipendente della macchina se la  memoria risulta insufficiente.

Un array può essere liberato dalla memoria usando il comando di DEALLOCATE:

DEALLOCATE (A, Stat = DeAllocateStatus)

Di nuovo, DeAllocateStatus rappresenta una variabile  numero intero il cuivalore è 0 se la cancellazione avviene.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Gli array monodimensionali nel Fortran


FORTRANUn array monodimensionale rappresenta una struttura dati complessa, statica e omogenea, usata in molti linguaggi di programmazione derivante dalla nozione matematica di vettore. Più precisamente, l’array è in genere classificato come un costruttore di tipo: in altre parole, esso consente di definire nuovi tipi di dati a partire da tipi preesistenti.

Nel Fortran la dimensione di un array può essere specificata da un’istruzione di specifica del tipo :

REAL, DIMENSION(10) :: A
INTEGER,DIMENSION(0:9):: B

Qui, i due array A, B sono stati quotati con 10 scanalature di memoria. L’ indice dell’array reale A inizia da 1 mentre l’indice per l’array B parte da 0. Il valore dei diversi elementi dell’array A può essere inizializzato a 1, 2, 3…, 10 da uno dei due metodi:

A = (/ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 /)

o,

A = (/ (I, I = 1, 10) /)

L’assegnazione dei valori di un array ad un altro è permessa a condizione che entrambi gli array in questione abbiano la stessa dimensione fisica. Per esempio:

B = A

assegna i valori precedentemente assegnati all’ array di A all’ array B. Gli operatori e le funzioni applicate normalmente alle espressioni semplici possono anche essere applicati agli array che hanno lo stesso numero di elementi. Per esempio,

A = A + B C = 2*C

assegna all’elemento ith di A il valore della somma degli elementi ith degli array A e B. In modo analogo all’elemento ith dell’array C è assegnato il valore uguale all’elemento ith di A moltiplicato per 2.

Il costrutto WHERE può essere usato per assegnare i valori ai diversi elementi d’un array; vediamo come:

WHERE ( la sequenza di argomento logico)
       ISTRUZIONE di assegnazioni di array !Blocco 1
ELSEWHERE
       ISTRUZIONE di assegnazioni di array !Blocco2
END WHERE

Per esempio, se ad A sono assegnati i valori

A = (/ (I, I = 1.10) /)

allora, possiamo studiare la possibilit`a di assegnare gli elementi del- l’ array B come:

WHERE (A > 5)
       B = 1
ELSEWHERE
       B = 0
END WHERE

Ciò assegna alla B i valori 0, 0, 0, 0, 0, 1, 1, 1, 1, 1. Parecchie funzioni intrinseche sono disponibili per elaborare gli array. Alcuni di queste sono:

  • DOT_PRODUCT(A, B) :restituisce il prodotto scalare di A e della B.
  • MAXVAL(A) :restituisce il valore massimo degli elementi dell’array A
  • MAXLOC(A) :restituisce la locazione di memoria del valore massimo di A
  • PRODUCT(A) :restituisce il prodotto degli elementi di A
  • SUM(A) :restituisce lasomma degli elementi di A

Un array può essere allocatable ,cioè, può essergli assegnato la locazione di memoria durante l’esecuzione. La dichiarazione di un array allocatable reale A,si effetua nel modo seguente:

REAL, DIMENSION(:), ALLOCATABLE :: A

Al tempo di esecuzione, i limiti reali per l’array A possono essere determinati dall’istruzione

ALLOCATE (A(N))

dove la N è una variabile numero intero che precedentemente è stata assegnata. Per accertarsi che abbastanza memoria sia a disposizione per assegnare lo spazio per il vostro array, usare l’opzione STAT del comando di ALLOCATE nel seguente modo:

ALLOCATE (A(N), STAT = AllocateStatus) IF (AllocateStatus /= 0)
                        ARRESTO ” * * * non abbastanza ***” memoria

Qui, AllocateStatus è una variabile del tipo numero intero. AllocateStatus prende il valore 0 se la ripartizione riesce o un certo altro valore dipendente dalla macchina se la memoria è insufficiente. Un array può essere liberato dalla memoria usando il comando DEALLOCATE

DEALLOCATE(A, Stat = DeAllocateStatus)

Di nuovo, DeAllocateStatus è una variabile del tipo numero intero il cui valore è 0 se la cancellazione dell’assegnazione riuscisse.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Il ciclo Do implicito nel Fortran


FORTRANIl ciclo DO nel Fortran già visto nella lezione precedente può essere realizzato anche in una forma implicita che permette di esprimere l’operazione in un modo molto più compatto; tale costrutto risulta molto comodo nelle operazioni di ingresso/uscita, vediamo allora un esempio:

WRITE(*,10) ( lista(i), i=1,7 ) 10 FORMAT (1X,’lista=’,10F9.3 )

Questa istruzione permette di visualizzare la lista di argomenti in funzione dell’indice i. Quindi saranno visualizzati gli elementi dell’array lista nel seguente ordine:

lista(1),lista(2),lista(3),lista(4),lista(5),lista(6),lista(7)

Gli argomenti di una lista di output possono essere del tipo: costante, espressione o elemento di un array. Nell’istruzione WRITE ogni argomento della lista viene stampato una volta per ogni iterazione, ne risulta che l’operazione precedente stamperà i 10 elementi del vettore lista sulla stessa riga.

E’ logico che in una operazione del genere gli argomenti possono essere più di uno infatti la forma generale di una istruzione che contiene un ciclo implicito è la seguente:

WRITE (unita,format)(val1,val2,….,i=inizio,fine,step)
READ(unita,format)(val1,val2,….,i=inizio,fine,step)

dove val1,val2,.. rappresentano i diversi argomenti oggetto dell’istruzione.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

I cicli nel Fortran


FORTRANNel linguaggio Fortran 90 un ciclo, che esegue un blocco di istruzioni un numero determinato di volte, èdetto ciclo iterativo. I cicli DO possono avere una delle due forme:

[nome:] DO indice=inizio,fine,incremento
istruzione1
istruzione2
………
istruzionen
END DO nome

oppure:

[nome:] DO indice=inizio,fine
istruzione1
istruzione2
………
istruzionen
END DO nome

Nel secondo caso l’incremento sarà unitario. Anche in questo caso l’etichetta nome è facoltativa. Nelle strutture di programma precedenti la variabile indice è una variabile intera utilizzata come contatore del ciclo iterativo, mentre le quantità intere inizio, fine e incremento sono i parametri del ciclo; hanno il compito di controllare i valori della variabile indice durante l’esecuzione del ciclo. Il parametro incremento è facoltativo; se è omesso, viene impostato a 1.

Le istruzioni comprese fra DO e END DO formano il corpo del ciclo iterativo; vengono eseguite ad ogni ripetizione del ciclo. Il meccanismo di funzionamento di un ciclo iterativo viene spiegato per passi nel prospetto seguente:

1) Ciascuno dei tre parametri inizio, fine e incremento può essere una costante, una variabile o un’espressione. Se si tratta di variabili o espressioni, i loro valori vengono preventivamente calcolati prima dell’inizio del ciclo.

2) All’inizio dell’esecuzione del ciclo DO, il programma assegna il valore inizio alla variabile di controllo indice. Se indice * incremento <= fine * incremento, il programma esegue le istruzioni all’interno del corpo del ciclo.

3) Dopo che le istruzioni del corpo del ciclo sono state eseguite, la variabile di controllo viene aggiornata nel modo seguente:

indice = indice + incremento

Se indice * incremento risulta ancora inferiore a fine * incremento, il programma ripete le istruzioni contenute nel corpo del ciclo.

4) Il passaggio 2 viene ripetuto fino a quando indice * incremento <= fine * incremento. Nel momento in cui questa condizione non risulta più vera, il controllo passa alla prima istruzione che si trova dopo la fine del ciclo (END DO).

L’esempio che segue ci permetterà di comprendere meglio il meccanismo esaminato nei passi precedenti. Allora analizziamo l’esempio seguente:

DO i = 1, 100
istruzione 1
……
……
10
istruzione n
END DO

In questo caso, le istruzioni da 1 a n saranno eseguite 100 volte. L’indice del ciclo avrà il valore 100 durante l’ultimo passaggio del ciclo. Quando il controllo passa all’istruzione DO dopo il centesimo passaggio, l’indice del ciclo assumerà il valore 101. Poichè 101 *1 > 100 *1, il controllo sarà trasferito alla prima istruzione che segue END DO.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Espressioni logiche nel Fortran


FORTRANLe forme simboliche degli operatori relazionali consentite nel Fortran sono le seguenti:

.Lt. < .GT. > .EQ. =
.LE. <= .GE. > = .NE. / =

Il costrutto IF-ELSE può essere chiamato fissando un’etichetta all’inizio del blocco:

nome : IF ( argomento logico )THEN
    istruzione
ELSE IF ( argomento logico ) THEN
   istruzione
END IF nome

Il costrutto CASE può essere usato per eseguire un insieme dei criteri di selezione di multi-alternativa:

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

Il selettore può essere un numero intero, un carattere, o un’espressione logica. Così come i blocchi di IF_ELSE, i costrutti CASE possono anche essere etichettati con un nome. L’opzione di DEFAULT in una costruzione CASE può essere omessa, ma è preferibile inserirla per migliorare lo stile del codice.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Le dichiarazioni di variabili nel Fortran


FORTRAN

Quando si invoca il comando IMPLICIT NONE, in ambiente FORTRAN, tutte le variabili di programma devono essere specificate esplicitamente. Le istruzione modificate di specifica del tipo possono essere usate per inizializzare le variabili o i parametri, ad esempio analizziamo le seguenti dichiarazioni:

Real :: Di = 0
integer :: Num\_Months = 12
Real,Parameter :: Pi = 3,1415927

La viaribile Di è dichiarata come tipo reale con valori iniziali 0., mentre Num\_Months rappresneta una variabile numero intero con il valore iniziale 12 e pi un parametro reale con il valore 3,1415927.

Il separatore :: (due punti) è richiesto in un’istruzione di specifica del tipo ogni volta che è usato per inizializzare una variabile o per dichiarare un attributo speciale (quale il PARAMETRO). Può essere omesso in altri casi.

Ad esempio, per dichiarare Area_circle come variabile reale, possiamo scrivere:

Area_circle Real

o, equivalentemente

Real :: Area\_circle

La seconda forma è consigliata in quanto presenta uno stile di programmazione uniforme. La precisione di un numero reale, di un numero intero, o complesso, o di una variabile logica può essere specificata usando un parametro del tipo KIND.

Ad esempio, per dichiarare una variabile A come un numero reale con almeno 10 cifre decimali di precisione con una gamma compresa tra -10^34 a 10^34, possiamo scrivere quanto segue:

REAL(KIND = SELECTED\_REAL\_KIND(10,34)) :: A

Se il processore che state usando non può sostenere una variabile con questa specifica di tipo, ne risulterà un errore compile-time. Per dichiarare una variabile reale equivalente a quella in doppia precisione presente nel fortran 77 ,dobbiamo scrivere semplicemente questo:

INTEGER, PARAMETER :: DP = SELECTED\_REAL\_KIND(14)
REAL(KIND = DP) :: A

Ciò dichiara la variabile A come reale e con almeno 14 cifre decimali. Il ;(punto e virgola) è usato come separatore in modo che diverse diverse istruzioni possano essere collocate sulla stessa riga. E’ però opportuno precisare che il posizionamento di più istruzioni su di una singola riga produce un codice poco leggibile, è quindi conveniente utilizzare tale applicazione solo per istruzioni semplici.

Ad esempio tre semplici istruzioni di assegnazione possono essere scritte come:

a=1;b=2;c=3

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Il comando implicit none nel Fortran


FORTRANUn errore frequente che viene commesso dai programmatori è quello di utilizzare una variabile prima che questa venga dichiarata. In realtà tale rischio è tipico dei linguaggi di programmazione procedurali mentre quelli che sono stati realizzati per la programmazione ad oggetti ne sono esenti.

Il motivo di tutto questo è dovuto al fatto che il linguaggio di programmazione Fortran richiede che ogni variabile prima di essere utilizzata sia correttamente dichiarata, e non solo; prima di essere utilizzata dovrà anche essere inizializzata.

E’ questo il motivo per cui ogni programma Fortran, nella sezione dichiarativa presenta una dichiarazione dettagliata di tutte le variabili che in esso vengoo utilizzate.

Ed è proprio in tale momento che si può commettere l’errore di dimenticarsi della dichiarazione di una variabile che quindi verrà utilizzata all’interno del programma senza essere stata utilizzata e provocando quindi un errore.

Per obbligare il programmatore alla dichiarazione di tutte le variabili si utilizza appunto il comando inplicit none.

implicit.none
La sintassi dello statement implicit none è la seguente:

IMPLICIT NONE

Questo statement è utilizzato per evitare errori di utilizzo di variabili.Quando cioè viene utilizzato lo statement implicit none tutte le variabili devono essere dichiarate in una dichiarazione di tipo (dichiarazione specifica).

Ad esempio del tipo:

REAL :: {list of variables}

Nell’ipotesi una variabile venisse utilizzata senza essere stata dichiarata, un errore verrebbe rilevato in fase di compilazione. in questo modo riusciamo ad avere un controllo sulle variabili utilizzate nel programma.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Struttura di base di un programma Fortran


FORTRANUn programma in fortran 90 è caratterizzato dalla seguente struttura:

1) Sezione dichiarativa
E’ posizionata all’inizio e contiene istruzioni non eseguibili quali:

  •     nome del programma preceduto dal testo program;
  •     dichiarazione delle variabili.

2) Sezione esecutiva.
Rappresenta il corpo del programma e contiene le istruzioni eseguibili necessarie per effettuare le operazioni per le quali il programma stesso è stato ideato.

3) Sezione conclusiva.
Contiene le istruzioni che interrompono il programma quali:

  •     stop che interrompe il programma;
  •     end program che dice al compilatore che non c’`e pi`u nulla da compilare.

struttura.fortran

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Compilazione di un programma nel fortran


FORTRANLa procedura di compilazione di un programma fortran 90 avviene in maniera del tutto identica a quella utilizzata nelle precedenti versioni del fortran. Allora per compilare e collegare un codice sorgente fortran 90 con il nome main.f90, dobbiamo semplicemente digitare la seguente riga:

f90 main.f90

Questo creerà un archivio eseguibile chiamato a.out.

I programmi in fortran 90 che usano la forma libera di formato devono avere un’estensione f90. Come per il compilatore fortran 77, anche per il compilatore f90 possiamo specificare il nome del nostro file eseguibile utilizzando la seguente opzione:

f90 main.f90 -o main.out

fortran1

Abbiamo cioè utilizzato l’ opzione -o. Ciò creerà un archivio eseguibile chiamato main.out. Allo stesso modo, possiamo collegarci ad una libreria compilata di fortran 90 :

f90 main.f90 -L/usr/class/sccm001/lib -lmy\_lib90

Ciò collegherà il vostro programma main.f90 alla libreria compilata chiamata libmy\_lib90.a che risiede nell’indice /usr/class/sccm001/lib.

Supponiamo di aver scritto un programma per il calcolo dell’area di un triangolo che avremo chiamato triangolo.f90 a questo punto utilizzando il compilatore, vogliamo ottenere il file eseguibile; procediamo nel seguente modo:

1) Creiamo dapprima il file oggetto:

f90 -c triangolo.f90

Questo comando creerà un file triangolo.o.

2) Creiamo quindi il file eseguibile:

f90 -o triangolo.exe triangolo.o

Questo comando creerà il file triangolo.exe che rappresenta il file eseguibile cercato. A questo punto basterà digitare il nome del file senz estensione per lanciare il programma.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO: