Come verificare se tre lati formano un triangolo in un programma Fortran

Il controllo della validità di un triangolo, dato un insieme di tre lati, è una delle applicazioni più semplici della logica di programmazione, in particolare nel contesto di linguaggi come Fortran. La condizione necessaria affinché tre numeri a, b, c possano rappresentare i lati di un triangolo è che la somma di due lati sia sempre maggiore del terzo. In altre parole, devono essere soddisfatte tre disuguaglianze:

1. $a + b > c$

2. $b + c > a$

3. $c + a > b$

Se queste tre condizioni sono vere, i numeri possono formare un triangolo, altrimenti no. Il programma che segue implementa questa logica di controllo usando un'espressione logica combinata con l'operatore .AND. in Fortran, che permette di verificare se tutte le disuguaglianze sono soddisfatte simultaneamente.

fortran
Copy code
PROGRAM P39_triangle3

  INTEGER :: a, b, c
  PRINT *, 'Input a, b, c'
  READ *, a, b, c
  IF ((a + b .GT. c) .AND. (b + c .GT. a) .AND. (c + a .GT. b)) THEN
     PRINT *, a, b, c, 'form a triangle'
  ELSE
     PRINT *, a, b, c, 'do not form a triangle'
  END IF
  STOP
END PROGRAM

Il programma sopra riceve in input tre numeri interi e verifica se formano un triangolo. Se le condizioni sono vere, stampa che i lati formano un triangolo, altrimenti segnala che non lo sono. Un esempio di esecuzione potrebbe essere:

Input 1:

css
Copy code
Input a, b, c
6 3 9

6 3 9 do not form a triangle

Input 2:

css
Copy code
Input a, b, c
4 6 8

4 6 8 form a triangle

Oltre a questa semplice verifica, ci sono altre funzionalità che possono essere aggiunte al programma, come una pausa temporanea tramite il comando PAUSE. Questo comando permette all'utente di fermare l'esecuzione del programma per esaminare i risultati o decidere se proseguire. La funzione PAUSE può essere particolarmente utile in scenari interattivi, dove il flusso del programma deve essere temporaneamente interrotto per raccogliere ulteriori input o semplicemente per visualizzare un messaggio.

Ecco un esempio di utilizzo del comando PAUSE in un programma:

fortran
Copy code
PROGRAM P40_pause
  REAL :: X, Y, A, B
  PRINT *, 'ENTER VALUES OF X AND Y'
  READ *, X, Y
  PRINT *, 'X, Y:', X, Y
  PAUSE
  PRINT *, 'ENTER VALUES OF A AND B'
  READ *, A, B
  PRINT *, 'A, B:', A, B
  STOP
END PROGRAM

In questo esempio, dopo aver inserito i valori di X e Y, il programma si ferma con una richiesta di input per proseguire. L'utente può decidere di continuare l'esecuzione digitando go o terminare il programma inserendo un altro comando.

Un altro aspetto interessante che emerge dalla programmazione Fortran riguarda l'uso dei cicli DO per ripetere un blocco di codice un numero specifico di volte. Un esempio classico è la somma di una serie di numeri, come nel caso della somma dei primi 100 numeri interi. Questo tipo di operazione è facilmente realizzabile attraverso un ciclo DO, che ripete il calcolo dell'incremento a ciascun passaggio.

Ecco un programma che calcola la somma dei primi 100 numeri interi:

fortran
Copy code
PROGRAM P41_series_sum3
  INTEGER :: SUM, I
  PRINT *, 'PROGRAM TO FIND SERIES SUM S=1+2+3+4+......+100'
  SUM = 0
  DO I = 1, 100
    SUM = SUM + I
  END DO
  PRINT *, 'THE SUM IS =', SUM
  STOP
END PROGRAM

Per calcolare il fattoriale di un numero, il ciclo DO può essere utilizzato per moltiplicare i numeri da 1 fino a N. Il programma seguente mostra come calcolare il fattoriale di un numero dato:

fortran
Copy code
PROGRAM P42_factorial
  INTEGER :: FACT, I, N
  PRINT *, 'ENTER THE NUMBER'
  READ *, N
  FACT = 1
  DO I = 1, N
    FACT = FACT * I
  END DO
  PRINT *, 'FACTORIAL OF', N, 'IS', FACT
  STOP
END PROGRAM

L'approccio di programmazione in Fortran evidenziato in questi esempi mette in luce la potenza delle istruzioni di controllo e dei cicli per risolvere problemi matematici e logici in modo semplice ed efficiente.

Come utilizzare i loop annidati e gli array in Fortran per risolvere problemi numerici

Nel campo dell'analisi numerica, uno degli strumenti più potenti che possiamo utilizzare è il ciclo annidato (nested loop), combinato con gli array. In questa sezione esploreremo alcuni esempi pratici di utilizzo di questi strumenti in Fortran, con applicazioni che spaziano dalla somma di triplette di numeri interi alla ricerca di numeri primi, fino alla gestione di triplette pitagoriche.

La somma di tre numeri interi

Ecco un esempio di programma in Fortran per calcolare la somma di tre numeri interi, letti dall'utente, ripetuta per un numero dato di volte:

fortran
Copy code
write(*,*) 'input how many times you want to sum'
read*, n
do 10 i=1, n
   mt = 0
   write(*,*) 'input integers one after another'
   do 20 j=1, 3
      read*, m
20    mt = mt + m
   print*, 'sum ', i, '  sum value   ', mt
10 continue
end

Questo programma, dopo aver ricevuto un numero di ripetizioni dall'utente, somma tre numeri per volta, stampando la somma al termine di ogni ciclo.

Le triplette pitagoriche

Ecco un esempio di programma per trovare le triplette pitagoriche fino a 100:

fortran
Copy code
write(*,*) 'Pythagorean triplets   sum'
do 10 i=1, 100
   do 10 j=i+1, 100
      do 10 k=i+2, 100
         if ((i**2 + j**2) .eq. k**2) then
            sum = i + j + k
            write(*,*) i, j, k, '                ', sum
         endif
10 continue
end

I numeri primi

Un altro problema interessante che possiamo risolvere con i cicli annidati è la ricerca dei numeri primi. Un numero primo è un numero maggiore di 1 che non ha divisori oltre a 1 e a sé stesso. Per trovare tutti i numeri primi fino a 100, possiamo utilizzare un ciclo esterno che scorre i numeri da 2 a 100, e un ciclo interno che verifica se ciascun numero è divisibile per altri numeri minori di esso.

Il programma seguente trova tutti i numeri primi fino a 100:

fortran
Copy code
write(*,*) 'Prime nos upto 100'

c = 0 ! Inizializzatore per contare i numeri primi
do 10 i=2, 100 ! Controlla i numeri tra 2 e 100
   nc = sqrt(real(i)) + 1
   do 20 j=2, nc ! Ogni numero è diviso per tutti i numeri fino alla radice quadrata di i
      if (i .eq. 2) goto 7 ! Due è considerato primo
      if (mod(i, j) .eq. 0) goto 10 ! Se il resto è zero, il numero non è primo
20 continue
7 c = c + 1
write(*,*) i
10 continue
write(*,*) 'total count', c
end

Il programma scorre i numeri da 2 a 100, verifica se sono divisibili per numeri compresi tra 2 e la loro radice quadrata, e stampa quelli che risultano primi.

Ottimizzare lo spazio nella stampa

Se volessimo trovare tutti i numeri primi fino a 1000, potremmo trovarci ad affrontare un problema di spazio, poiché i numeri sono numerosi. Una soluzione elegante è quella di memorizzare i numeri primi in un array e poi stamparli in gruppi, riducendo così il numero di righe necessarie per visualizzare il risultato.

fortran
Copy code
INTEGER PRIME(1000), PC

PC = 0
do 10 i=2, 1000
   nc = sqrt(real(i)) + 1
   do 20 j=2, nc
      if (i .eq. 2) goto 7
      IR = MOD(i, j)
      if (IR .eq. 0.0) goto 10
20 continue
7 PC = PC + 1
PRIME(PC) = i
10 continue
write(*,*) 'COUNT OF PRIME NUMBERS BETWEEN 1 AND 1000:', PC
write(6, 12) (PRIME(i), i = 1, PC)
12 FORMAT(12I5)
stop
end

Calcolare la somma dei fattoriali

Infine, un altro esempio interessante riguarda il calcolo della somma dei fattoriali di tutti gli interi fino a un numero $n$. Tuttavia, è importante ricordare che se $n$ è maggiore di 12, il risultato potrebbe non essere memorizzato correttamente in un tipo di dato intero, a causa della crescita esponenziale dei fattoriali.

Il programma sottostante calcola la somma dei fattoriali di tutti i numeri da 1 a $n$:

fortran
Copy code
WRITE(*,*) 'INPUT THE VALUE OF N, max value 12'

READ(*,*) N
IF (N .GT. 12) GOTO 40
IS = 0
DO 10 I = 1, N
   LP = 1
   DO 20 K = 1, I
      LP = LP * K
20 CONTINUE
   IS = IS + LP
10 CONTINUE
WRITE(*,*) 'THE VALUE OF SUMMATION=', IS
END

Questo programma calcola la somma dei fattoriali da 1 a $n$, e limita il valore di $n$ a 12 per evitare problemi con l'overflow numerico.

Considerazioni finali

Gli esempi di cui sopra mostrano come i loop annidati e gli array possano essere utilizzati efficacemente in Fortran per risolvere problemi complessi di analisi numerica. È fondamentale comprendere che, sebbene i cicli annidati possano essere estremamente utili, è necessario fare attenzione alla loro efficienza, specialmente quando si lavora con grandi quantità di dati o si cercano soluzioni a problemi complessi. L'uso delle radici quadrate, come nel caso della ricerca dei numeri primi, è una tecnica comune per ridurre il numero di operazioni necessarie e migliorare l'efficienza del programma.

Come Calcolare Integrali e Derivate Numeriche Utilizzando Fortran: Tecniche e Applicazioni

Nel mondo dell'analisi numerica, l'uso di metodi numerici per risolvere problemi complessi è fondamentale. Alcune delle tecniche più utilizzate riguardano il calcolo di integrali, la differenziazione numerica e l'interpolazione di funzioni. Oggi esamineremo alcune di queste tecniche, in particolare quelle legate all'uso del linguaggio di programmazione Fortran, come nel caso del calcolo di integrali attraverso il metodo di Monte Carlo, e l'uso delle formule di interpolazione di Newton-Gregory per ottenere valori intermedi da tabelle di dati.

Una delle applicazioni più comuni in analisi numerica è il calcolo di un integrale definito. La tecnica di Monte Carlo è un esempio di metodo che può essere implementato facilmente in Fortran. Un esempio di codice Fortran, che calcola l'integrale di una funzione in un intervallo definito, si basa sulla generazione di numeri casuali per stimare il valore dell'integrale. Il codice qui proposto utilizza una funzione di generazione di numeri casuali per ottenere punti nel dominio dell'integrale e poi calcolare la media ponderata dei valori della funzione su questi punti.

Ad esempio, per un valore di seed come "987654321", il programma calcola il valore dell'integrale per diverse dimensioni del campione (da 1 milione a 9 milioni di punti), e riporta non solo l'integrale stimato, ma anche l'errore associato ad ogni stima. Il programma esegue l'intero processo in pochi secondi, dimostrando l'efficacia di Monte Carlo anche con un numero elevato di punti.

Tuttavia, il risultato dell'integrale non è mai perfetto. L'errore tende a diminuire man mano che aumentano il numero di punti campionati. Allo stesso modo, la variabilità nelle stime può essere influenzata dal "seed" utilizzato per il generatore di numeri casuali, come mostrato dai due esempi con valori di seed diversi (987654321 e 123456789). Questo suggerisce che il metodo di Monte Carlo è soggetto a variazioni legate alla casualità e che l'affidabilità del risultato migliora con l'aumento del numero di punti.

Parallelamente al calcolo numerico degli integrali, un altro strumento potente in analisi numerica è l'interpolazione dei dati. Quando ci troviamo di fronte a una serie di valori tabulati di una funzione, possiamo voler stimare il valore della funzione in un punto intermedio. In Fortran, questo problema viene risolto utilizzando la formula di interpolazione di Newton-Gregory, che può essere applicata sia in direzione "avanti" che "indietro" in base alla posizione del punto di interpolazione rispetto ai dati tabulati.

La formula di interpolazione "avanti" di Newton-Gregory è utile quando il punto di interpolazione si trova all'inizio della tabella. La formula è costruita in modo iterativo, utilizzando le differenze finite tra i valori successivi della funzione. La variabile "u" rappresenta il rapporto tra la differenza tra il punto di interpolazione e il primo valore della tabella, diviso l'incremento tra i valori consecutivi. L'algoritmo calcola il valore della funzione al punto di interpolazione come una somma di termini che dipendono dalle differenze finite.

Anche qui, il linguaggio Fortran dimostra la sua versatilità, consentendo la gestione di dati tabulati e la loro interpolazione in modo molto efficiente, come illustrato nel codice che segue la formula di interpolazione "avanti". Allo stesso modo, l'interpolazione "indietro" è implementata con un altro programma che calcola il valore della funzione in un dato punto, partendo da una serie di valori.

Oltre a queste tecniche di base, Fortran può essere utilizzato per risolvere vari tipi di problemi fisici, come la simulazione di un pendolo semplice, l'evoluzione della radioattività, il comportamento di circuiti CR e LC, e l'applicazione della legge di raffreddamento di Newton. Tutti questi problemi possono essere affrontati tramite metodi numerici che coinvolgono la soluzione di equazioni differenziali o la simulazione di sistemi dinamici.

Come risolvere problemi numerici in analisi matematica utilizzando i metodi numerici

L'analisi numerica è fondamentale per risolvere equazioni che non possono essere affrontate facilmente con metodi algebrici o analitici. In particolare, il metodo di Newton-Raphson e il metodo di bisezione sono due approcci comuni per risolvere equazioni trascendentali come quella di $x = \tan(x)$, dove la convergenza non è garantita facilmente. Se si tenta di applicare il metodo iterativo senza una buona approssimazione iniziale, il processo di convergenza potrebbe fallire. Per esempio, nel caso di $\tan(x)$, la funzione cambia rapidamente, quindi una stima iniziale deve essere molto vicina alla soluzione effettiva. Nel metodo di Newton-Raphson, una buona stima iniziale per la prima radice è 4.4, mentre nel metodo della bisezione il bracketing dovrebbe essere effettuato tra i valori [4.4, 4.6] per garantire una buona convergenza.

Un altro esempio di applicazione dei metodi numerici è il problema del decadimento radioattivo. La legge del decadimento di un nucleo radioattivo è descritta dalla equazione differenziale:

dove $\lambda$ è la costante di decadimento, che indica il numero di nuclei che decadono per unità di tempo per nucleo. Integrando questa equazione si ottiene:

dove $N_0$ è il numero di nuclei al tempo $t = 0$. Utilizzando il metodo di Runge-Kutta (RK), possiamo risolvere questa equazione per determinare il numero di nuclei in qualsiasi momento successivo. Nel nostro esempio, utilizzando $\lambda = 0.5$, $t = 2$ anni e $N_0 = 1000$, possiamo osservare come il numero di nuclei decresce nel tempo.

Un altro interessante esempio di applicazione dei metodi numerici è il calcolo della corrente in un circuito RC. Se consideriamo un circuito RC in cui un condensatore è caricato e collegato a una fonte di corrente continua, la legge di Kirchhoff ci fornisce l'equazione:

Nel nostro esempio numerico, abbiamo i seguenti parametri: $E = 20 \, V$, $R = 1000 \, \Omega$, e $C = 500 \, \mu F$. La costante di tempo $\tau = RC$ e il massimo carico $Q_f = C \cdot E$ ci permettono di calcolare la corrente massima iniziale $I_0 = E/R = 0.02$ e di osservare l'evoluzione del carico e della corrente nel tempo. L'uso del metodo di Runge-Kutta fornisce una soluzione numerica precisa per determinare il comportamento del circuito.

Infine, nei circuiti LC, che combinano induttanze e condensatori, l'analisi della corrente in un circuito LC può essere un compito complesso. Quando un condensatore caricato viene scollegato e collegato a un'induttanza, l'equazione del movimento per il circuito LC diventa:

Questo sistema di equazioni differenziali descrive l'oscillazione del carico nel circuito. La soluzione di tale equazione richiede l'uso di metodi numerici come il metodo di Runge-Kutta per risolvere le equazioni di secondo ordine e ottenere il comportamento del sistema nel tempo.

In ogni esempio trattato, l'approccio numerico permette di risolvere in modo preciso equazioni che sarebbero altrimenti difficili da affrontare con metodi analitici. La capacità di utilizzare metodi come Newton-Raphson, Runge-Kutta o la bisezione per risolvere problemi complessi è essenziale in molti campi, dall'ingegneria alla fisica, e consente di ottenere risultati pratici anche in presenza di equazioni non lineari o con soluzioni difficili da calcolare direttamente.

L'importanza dell'accuratezza iniziale nella scelta delle stime per i metodi iterativi è fondamentale. Un'approssimazione iniziale accurata, specialmente nei problemi di equazioni trascendentali o nei circuiti, riduce notevolmente il numero di iterazioni necessarie per raggiungere una soluzione soddisfacente. Inoltre, il controllo degli errori e la comprensione della stabilità dei metodi numerici sono aspetti chiave per evitare risultati imprecisi o divergenza del processo di calcolo.