Calcolatore Numerico per Esercizi MATLAB
Inserisci i parametri per calcolare soluzioni numeriche con metodi implementabili in MATLAB. Seleziona il metodo, inserisci i dati e ottieni risultati dettagliati con visualizzazione grafica.
Guida Completa al Calcolo Numerico con Esercizi Svolti in MATLAB
Il calcolo numerico rappresenta una branca fondamentale della matematica applicata che si occupa di sviluppare algoritmi per approssimare soluzioni di problemi matematici. In questo contesto, MATLAB si pone come uno degli strumenti più potenti e versatili, grazie alla sua capacità di implementare efficientemente metodi numerici complessi con sintassi relativamente semplice.
1. Introduzione ai Metodi Numerici
I metodi numerici sono tecniche utilizzate per formulare problemi matematici in modo che possano essere risolti mediante operazioni aritmetiche. Questi metodi sono essenziali quando:
- Non esistono soluzioni analitiche esatte
- Le soluzioni analitiche sono troppo complesse da calcolare
- Si richiede una soluzione approssimata con un certo grado di precisione
In MATLAB, possiamo implementare questi metodi sfruttando:
- Funzioni built-in ottimizzate (come fzero per trovare zeri di funzione)
- Toolbox specializzati (Optimization Toolbox, Symbolic Math Toolbox)
- Implementazioni personalizzate tramite script M-file
2. Metodi per la Ricerca degli Zeri
Uno dei problemi fondamentali del calcolo numerico è trovare le radici di un’equazione non lineare f(x) = 0. I metodi più comuni includono:
2.1 Metodo di Bisezione
Il metodo di bisezione è un metodo semplice e robusto che richiede solo la continuità della funzione nell’intervallo [a, b] e che f(a) e f(b) abbiano segni opposti (teorema degli zeri).
function [root, iter] = bisection(f, a, b, tol, max_iter)
fa = f(a);
if sign(fa) == sign(f(b))
error(‘f(a) e f(b) devono avere segni opposti’);
end
for k = 1:max_iter
c = (a + b)/2;
fc = f(c);
if abs(fc) < tol || (b-a)/2 < tol
root = c;
iter = k;
return;
end
if sign(fc) ~= sign(fa)
b = c;
else
a = c;
fa = fc;
end
end
root = (a + b)/2;
iter = max_iter;
end
Vantaggi: Sempre convergente se f è continua e cambia segno nell’intervallo.
Svantaggi: Convergenza lineare (lenta rispetto ad altri metodi).
2.2 Metodo di Newton-Raphson
Il metodo di Newton (o Newton-Raphson) utilizza la derivata della funzione per ottenere convergenza quadratica sotto opportune condizioni.
function [root, iter] = newton(f, df, x0, tol, max_iter)
for k = 1:max_iter
fx = f(x0);
if abs(fx) < tol
root = x0;
iter = k;
return;
end
dfx = df(x0);
if dfx == 0
error(‘Derivata nulla. Metodo fallito.’);
end
x0 = x0 – fx/dfx;
end
root = x0;
iter = max_iter;
end
Vantaggi: Convergenza quadratica (molto veloce vicino alla soluzione).
Svantaggi: Richiede la derivata; può divergere se la stima iniziale è lontana dalla soluzione.
| Metodo | Ordine di Convergenza | Derivata Richiesta | Intervallo Iniziale | Robustezza |
|---|---|---|---|---|
| Bisezione | Lineare (1) | No | Sì (con f(a)f(b) < 0) | Alta |
| Newton-Raphson | Quadratica (2) | Sì | No (punto iniziale) | Media |
| Secante | Superlineare (~1.62) | No | No (due punti iniziali) | Media |
| Regula Falsi | Lineare (1) | No | Sì (con f(a)f(b) < 0) | Alta |
3. Integrazione Numerica
L’integrazione numerica (quadratura) approssima il valore di un integrale definito. I metodi più comuni includono:
3.1 Regola del Trapezio
Approssima l’area sotto la curva con trapezi invece di rettangoli (come nel metodo dei rettangoli).
function I = trapezoidal(f, a, b, n)
h = (b – a)/n;
I = (f(a) + f(b))/2;
for k = 1:n-1
I = I + f(a + k*h);
end
I = I * h;
end
Errore: O(h²) dove h = (b-a)/n.
3.2 Regola di Simpson
Utilizza parabole per approssimare la funzione, ottenendo una precisione maggiore:
function I = simpson(f, a, b, n)
if mod(n, 2) ~= 0
error(‘n deve essere pari per la regola di Simpson’);
end
h = (b – a)/n;
I = f(a) + f(b);
for k = 1:n-1
x = a + k*h;
if mod(k, 2) == 0
I = I + 2*f(x);
else
I = I + 4*f(x);
end
end
I = I * h/3;
end
Errore: O(h⁴), molto più accurato della regola del trapezio per n sufficientemente grande.
| Metodo | Formula | Ordine Errore | Num. Punti | Note |
|---|---|---|---|---|
| Rettangoli (sinistra/destra) | hΣf(x_i) | O(h) | n+1 | Meno accurato |
| Trapezio | h/2 [f(a) + 2Σf(x_i) + f(b)] | O(h²) | n+1 | Buon compromesso |
| Simpson | h/3 [f(a) + 4Σf(x_{2i-1}) + 2Σf(x_{2i}) + f(b)] | O(h⁴) | n+1 (n pari) | Molto accurato |
| Gauss-Legendre (2 punti) | w₁f(x₁) + w₂f(x₂) | O(h⁴) | 2 | Pesi e nodi prefissati |
4. Equazioni Differenziali Ordinarie (ODE)
MATLAB offre funzioni avanzate per risolvere ODE, ma è istruttivo implementare metodi base come Eulero.
4.1 Metodo di Eulero
Il metodo più semplice per risolvere problemi a valore iniziale:
y’ = f(t, y), y(t₀) = y₀
function [t, y] = euler(f, t0, y0, tf, h)
t = t0:h:tf;
y = zeros(size(t));
y(1) = y0;
for i = 1:length(t)-1
y(i+1) = y(i) + h * f(t(i), y(i));
end
end
Errore locale: O(h²); errore globale: O(h).
4.2 Metodo di Runge-Kutta (RK4)
Un metodo più accurato che combina più stime della pendenza:
function [t, y] = rk4(f, t0, y0, tf, h)
t = t0:h:tf;
y = zeros(size(t));
y(1) = y0;
for i = 1:length(t)-1
k1 = f(t(i), y(i));
k2 = f(t(i) + h/2, y(i) + h/2*k1);
k3 = f(t(i) + h/2, y(i) + h/2*k2);
k4 = f(t(i) + h, y(i) + h*k3);
y(i+1) = y(i) + h/6 * (k1 + 2*k2 + 2*k3 + k4);
end
end
Errore locale: O(h⁵); errore globale: O(h⁴).
5. Sistemi di Equazioni Lineari
La risoluzione di sistemi lineari Ax = b è fondamentale in molte applicazioni. MATLAB offre l’operatore \ (backslash) che implementa metodi ottimali in base alla struttura della matrice.
5.1 Eliminazione di Gauss
Trasforma la matrice in forma triangolare superiore tramite operazioni elementari:
function x = gauss_elimination(A, b)
n = length(b);
for k = 1:n-1
for i = k+1:n
m = A(i,k)/A(k,k);
A(i,k:n) = A(i,k:n) – m*A(k,k:n);
b(i) = b(i) – m*b(k);
end
end
% Sostituzione all’indietro
x = zeros(n,1);
x(n) = b(n)/A(n,n);
for i = n-1:-1:1
x(i) = (b(i) – A(i,i+1:n)*x(i+1:n))/A(i,i);
end
end
Complessità: O(n³) per una matrice n×n.
5.2 Fattorizzazione LU
Decompone A in L (triangolare inferiore) e U (triangolare superiore):
[L, U] = lu(A);
x = U \ (L \ b); % Equivalente a A\x
6. Ottimizzazione in MATLAB
MATLAB offre potenti funzioni per l’ottimizzazione non lineare:
f = @(x) x(1)^2 + 10*x(2)^2; % Funzione di Rosenbrock
x0 = [-1, 2]; % Punto iniziale
options = optimoptions(‘fminunc’, ‘Algorithm’, ‘quasi-newton’);
[x, fval] = fminunc(f, x0, options);
7. Risorse Accademiche e Libri di Riferimento
Per approfondire il calcolo numerico con MATLAB, consultare:
- Dipartimento di Matematica del MIT – Corsi avanzati su metodi numerici
- Università della California, Davis – Numerical Analysis – Materiali didattici e pubblicazioni
- NIST Digital Library of Mathematical Functions – Funzioni speciali e algoritmi numerici
Libri consigliati:
- “Numerical Recipes: The Art of Scientific Computing” – Press et al.
- “Numerical Analysis” – Burden & Faires
- “MATLAB Guide” – Higham & Higham
- “Scientific Computing with MATLAB” – Quarteroni & Saleri
8. Errori e Stabilità Numerica
La precisione dei metodi numerici è influenzata da:
- Errore di troncamento: Approssimazione del metodo (es: serie di Taylor troncata)
- Errore di arrotondamento: Precisione finita dei calcolatori (IEEE 754)
- Condizionamento: Sensibilità del problema ai dati in ingresso
Il numero di condizione di una matrice A è dato da:
κ(A) = ||A|| · ||A⁻¹||
A = rand(10);
cond_A = cond(A); % Numero di condizione in norma 2
if cond_A > 1e3
disp(‘Matrice mal condizionata’);
end
9. Applicazioni Pratiche
Il calcolo numerico con MATLAB trova applicazione in:
- Ingegneria: Analisi strutturale, dinamica dei fluidi (CFD), controllo automatico
- Fisica: Simulazione di sistemi quantistici, meccanica celeste
- Finanza: Valutazione di derivati (modello Black-Scholes), ottimizzazione di portafoglio
- Biologia: Modelli epidemiologici, dinamica delle popolazioni
- Data Science: Apprendimento automatico, ottimizzazione di algoritmi
10. Best Practices in MATLAB
Per scrivere codice MATLAB efficiente:
- Evita cicli for quando possibile (vettorizza le operazioni)
- Prealloca gli array per migliorare le prestazioni
- Usa le funzioni built-in ottimizzate (es: sum, mean)
- Documenta il codice con commenti e help
- Valida sempre gli input con nargin e error
- Usa tic/toc per misurare le prestazioni
function y = my_function(x, param)
% MY_FUNCTION Calcola qualcosa di utile
% y = MY_FUNCTION(x, param) restituisce y basato su x e param
%
% Inputs:
% x – vettore di input
% param – parametro opzionale (default = 1)
%
% Output:
% y – risultato
if nargin < 2
param = 1;
end
% Preallocazione per efficienza
y = zeros(size(x));
% Calcolo vettorizzato
y = param .* sin(x) + cos(x.^2);
end
11. Confronto tra MATLAB e Altri Strumenti
| Caratteristica | MATLAB | Python (NumPy/SciPy) | Julia | R |
|---|---|---|---|---|
| Sintassi | Concise, orientata alle matrici | Generale, richiede import | Simile a MATLAB | Orientata alla statistica |
| Prestazioni | Buone (JIT compilation) | Buone (con Numba) | Eccellenti (compilato) | Moderate |
| Visualizzazione | Eccellente (funzioni built-in) | Buona (Matplotlib/Seaborn) | Buona (Plots.jl) | Eccellente (ggplot2) |
| Toolbox | Ampia gamma (commerciali) | Librerie open-source | In crescita | Focus su statistica |
| Costo | Commerciale (licenza) | Gratuito | Gratuito | Gratuito |
| Integrazione | Buona con Simulink | Eccellente (API) | Buona (C/Fortran) | Buona (RStudio) |
12. Esercizi Pratici con Soluzioni
Di seguito alcuni esercizi tipici con soluzioni in MATLAB:
Esercizio 1: Metodo di Bisezione
Problema: Trovare la radice di f(x) = e^x – 3x nell’intervallo [0, 2] con tolleranza 1e-5.
f = @(x) exp(x) – 3*x;
[x, iter] = bisection(f, 0, 2, 1e-5, 100);
fprintf(‘Radice trovata in x = %.8f dopo %d iterazioni\n’, x, iter);
Esercizio 2: Integrazione con Simpson
Problema: Calcolare ∫₀¹ e^(-x²) dx con n=100.
f = @(x) exp(-x.^2);
I = simpson(f, 0, 1, 100);
fprintf(‘Integrale approssimato: %.8f\n’, I);
Esercizio 3: Equazione Differenziale
Problema: Risolvere y’ = -2ty, y(0)=1 su [0,1] con h=0.1 usando Eulero e RK4.
f = @(t,y) -2*t*y;
[t_eul, y_eul] = euler(f, 0, 1, 1, 0.1);
% Soluzione con RK4
[t_rk4, y_rk4] = rk4(f, 0, 1, 1, 0.1);
% Soluzione esatta: y(t) = exp(-t^2)
t_exact = linspace(0,1,11);
y_exact = exp(-t_exact.^2);
% Confronto
plot(t_eul, y_eul, ‘b-o’, t_rk4, y_rk4, ‘r-s’, t_exact, y_exact, ‘k-‘);
legend(‘Eulero’, ‘RK4’, ‘Esatta’);
xlabel(‘t’); ylabel(‘y(t)’);
title(‘Confronto tra metodi per ODE’);
13. Debugging e Validazione
Per assicurare la correttezza dei risultati:
- Confronta con soluzioni analitiche quando disponibili
- Testa con input noti (es: f(x)=x²-4 ha radici ±2)
- Usa fplot per visualizzare la funzione
- Verifica la convergenza al variare di h o tol
- Utilizza MATLAB Cody per esercizi interattivi
% Test del metodo di bisezione su f(x) = x^2 – 4
f = @(x) x.^2 – 4;
[x, iter] = bisection(f, 0, 3, 1e-6, 100);
fprintf(‘Radice trovata: %.6f (atteso: 2.000000)\n’, x);
fprintf(‘Errore assoluto: %.6f\n’, abs(x – 2));
14. Ottimizzazione delle Prestazioni
Per codice MATLAB performante:
- Usa vectorization invece di cicli
- Evita variabili globali
- Usa logical indexing per filtrare dati
- Considera MATLAB Coder per generare codice C
- Profila il codice con profile viewer
% Versione con ciclo (lenta)
n = 1e6;
x = rand(n,1);
y = zeros(n,1);
tic;
for i = 1:n
y(i) = sin(x(i)) + cos(x(i)^2);
end
toc;
% Versione vettorizzata (veloce)
tic;
y = sin(x) + cos(x.^2);
toc;
15. Conclusioni
Il calcolo numerico in MATLAB offre un potente insieme di strumenti per risolvere problemi matematici complessi che non ammettono soluzioni analitiche chiuse. La scelta del metodo appropriato dipende da:
- Precisione richiesta
- Complessità computazionale
- Stabilità numerica
- Disponibilità della derivata (per metodi come Newton)
MATLAB si distingue per:
- Ambiente interattivo per prototipazione rapida
- Visualizzazione integrata
- Ampia libreria di funzioni ottimizzate
- Integrazione con Simulink per sistemi dinamici
Per diventare proficiente nel calcolo numerico con MATLAB, si consiglia di:
- Implementare manualmente i metodi di base per comprenderne il funzionamento
- Sperimentare con diversi parametri (h, tol, n) per osservare gli effetti sulla precisione
- Confrontare i risultati con le funzioni built-in di MATLAB
- Applicare i metodi a problemi reali nel proprio dominio di studio
Il calcolo numerico rimane una competenza fondamentale per scienziati, ingegneri e data scientist, e MATLAB continua a essere uno degli ambienti più efficaci per la sua implementazione pratica.