In molti programmi, il calcolo delle somme e la validazione dei dati sono operazioni essenziali che richiedono l'uso di istruzioni di controllo come if, goto e stop. Queste istruzioni consentono di implementare logiche decisionali per verificare, calcolare e gestire flussi di esecuzione in modo efficiente.

Ad esempio, nel programma P23-sum.f che calcola la somma dei primi n numeri interi, vediamo l'utilizzo di un ciclo che somma progressivamente i numeri da 1 fino a n. L'istruzione if (i.eq.n) viene utilizzata per determinare quando il ciclo deve fermarsi, quindi l'uso del goto 20 permette di saltare alla fine del programma una volta che il valore di i è uguale a n. In questo modo, il programma stampa sia il valore calcolato della somma che il valore ottenuto tramite la formula matematica n*(n+1)/2. I risultati sono sempre uguali, a dimostrazione che il calcolo è stato eseguito correttamente.

Successivamente, nel programma P24-valid1.f, vediamo l'applicazione di una dichiarazione if per la validazione dei dati inseriti. Se la velocità immessa è negativa o zero, il programma emette un messaggio di errore e termina immediatamente con l'istruzione stop. Questa è una validazione molto semplice, ma efficace, che impedisce l'esecuzione del programma con dati non validi.

Un altro esempio interessante si trova nel programma P25-valid2.f, dove viene utilizzata l'istruzione if aritmetica per verificare se la velocità immessa è valida. Se la velocità è negativa o zero, il programma permette all'utente di inserire nuovamente un valore valido, grazie al ritorno al punto di inserimento dei dati tramite l'istruzione goto 10. Inoltre, questo programma calcola anche la distanza percorsa in un determinato tempo, moltiplicando la velocità per il tempo.

Nel programma P26-promotion.f, il calcolo dello stato di promozione di uno studente viene effettuato in base ai voti ottenuti. Se la percentuale di voti è inferiore al 40%, lo studente viene considerato "fail". In caso contrario, lo studente passa. Questo tipo di validazione è cruciale nei sistemi educativi e viene realizzato con una semplice istruzione if. Il programma usa anche la conversione dei voti in percentuale per determinare il risultato, mostrando come le istruzioni di controllo possano essere adattate a diverse logiche di calcolo.

L'esempio successivo, P27-promotion2.f, espande la logica di promozione a più materie. In questo caso, la promozione viene determinata dalla media dei voti in quattro soggetti. Ogni volta che i voti vengono inseriti, vengono sommati sia i voti ottenuti che i voti massimi. La somma totale viene poi utilizzata per calcolare la percentuale, e in base a questa, viene determinato se lo studente passa o fallisce. L'uso delle istruzioni goto consente di gestire il flusso del programma in modo che l'utente possa inserire nuovamente i dati nel caso di errori.

Un altro programma interessante è P28-series-sum2.f, che calcola la somma di una serie di numeri di potenza. La logica di calcolo si basa sull'utilizzo dell'istruzione if per determinare quando il programma deve fermarsi, quando i raggiunge il valore di n. Qui viene calcolata la somma di una serie di termini della forma 1 + X + X^2 + X^3 + ... + X^n, e l'uso di if per fermare il ciclo al termine della serie è fondamentale per evitare loop infiniti.

Infine, nel programma P29-fibonacci.f, viene calcolata la sequenza di Fibonacci, un esempio classico di serie numerica. La sequenza di Fibonacci è definita da una serie di numeri in cui ogni numero è la somma dei due precedenti. Ad esempio, i numeri sono: 1, 1, 2, 3, 5, 8, 13, 21, e così via. L'istruzione stop viene utilizzata per fermare l'esecuzione del programma quando si supera un determinato limite (in questo caso, 20.000), impedendo l'overflow e mantenendo il programma sicuro e controllato.

Oltre a questi esempi, è fondamentale che i lettori comprendano come le istruzioni di controllo possano essere utilizzate per implementare logiche più complesse e per gestire situazioni in cui gli input dell'utente non siano corretti. La possibilità di gestire il flusso del programma con goto, if e stop rende questi strumenti potenti per la programmazione in Fortran, ma anche in altri linguaggi, ed è essenziale per ottenere risultati accurati e affidabili. Inoltre, è importante notare che l'uso delle istruzioni di controllo non solo serve a validare i dati, ma anche a migliorare l'efficienza del programma, ottimizzando la gestione dei cicli e delle condizioni.

Come Calcolare e Usare Funzioni e Subroutine in Fortran per Operazioni Complesse

In programmazione, spesso è necessario svolgere operazioni complesse e ripetitive. Fortran, un linguaggio storico di programmazione scientifica e numerica, offre potenti strumenti come le funzioni e le subroutine per semplificare la scrittura del codice e migliorare la modularità. In questo capitolo, esploreremo come calcolare coefficienti come il nCr (combinazioni) e il Coefficiente di Pearson attraverso l'uso di funzioni e subroutine, evidenziando la struttura e i vantaggi di questi approcci.

Un programma tipico per calcolare nCr in Fortran può utilizzare una funzione subprogramma che calcola i fattoriali necessari. Il calcolo di nCr, che rappresenta il numero di combinazioni di n oggetti presi a r, può essere realizzato con la formula:

nCr=n!r!(n−r)!nCr = \frac{n!}{r!(n-r)!}

Per fare questo, dobbiamo calcolare i fattoriali di n, r e n-r. L'uso di una funzione permette di separare questa logica dal programma principale, semplificando il codice e migliorando la sua leggibilità. Ad esempio:

fortran
PROGRAM COMBINAZIONI
  IMPLICIT NONE
  INTEGER N, R, NCR, NF, RF, NRF
  PRINT *, 'Inserisci i valori di n e r:'
  READ(*,*) N, R
  NF = FATTORIALE(N)
  RF = FATTORIALE(R)
  NRF = FATTORIALE(N - R)
  NCR = NF / (RF * NRF)
  PRINT *, 'nCr = ', NCR
END PROGRAM
FUNCTION FATTORIALE(N)
  INTEGER N, FATTORIALE, I
  FATTORIALE = 1
  DO I = 2, N
     FATTORIALE = FATTORIALE * I
  END DO
  RETURN
END FUNCTION

In questo esempio, il programma calcola il valore di nCr separando la logica del calcolo del fattoriale in una funzione separata. L'uso della funzione FATTORIALE rende il codice più modulare e facilmente riutilizzabile.

Un altro esempio di utilizzo delle funzioni riguarda la concatenazione di stringhe, un'operazione comune in molti programmi. Fortran offre l'operatore // per concatenare le stringhe. In un programma, possiamo concatenare stringhe in sequenza utilizzando una funzione che ci consente di ripetere l'operazione più volte:

fortran
PROGRAM CONCATENA
  CHARACTER(5) X1, X2, XX
  X1 = 'ABC'
  X2 = 'DEF'
  XX = CONCATENA_STRINGHE(X1, X2)
  PRINT *, XX
END PROGRAM
FUNCTION CONCATENA_STRINGHE(A, B)
  CHARACTER(5) A, B
  CHARACTER(10) CONCATENA_STRINGHE
  CONCATENA_STRINGHE = A // B
  RETURN
END FUNCTION

In questo caso, la funzione CONCATENA_STRINGHE restituisce la concatenazione di due stringhe, separando il codice che si occupa della logica di concatenazione dal corpo principale del programma.

Un altro uso avanzato delle funzioni in Fortran riguarda il calcolo del Coefficiente di Pearson, utilizzato per determinare la correlazione tra due variabili. Il coefficiente di Pearson varia tra -1 e 1, indicando una correlazione negativa, nessuna correlazione o una correlazione positiva. La formula per il calcolo è la seguente:

r=∑(xi−xˉ)(yi−yˉ)∑(xi−xˉ)2∑(yi−yˉ)2r = \frac{\sum (x_i - \bar{x})(y_i - \bar{y})}{\sqrt{\sum (x_i - \bar{x})^2 \sum (y_i - \bar{y})^2}}