Calcolatore Derivata in un Punto con MATLAB

Inserisci la funzione e il punto per calcolare la derivata numerica utilizzando il metodo delle differenze finite centrali

Risultati del Calcolo

Funzione:

Punto x₀:

Derivata approssimata f'(x₀):

Guida Completa: Come Calcolare la Derivata in un Punto con MATLAB

Il calcolo delle derivate in punti specifici è un’operazione fondamentale in analisi matematica, ingegneria e scienze applicate. MATLAB offre potenti strumenti per eseguire queste operazioni sia in modo simbolico che numerico. Questa guida approfondita ti mostrerà:

I fondamenti matematici behind le differenze finite
Come implementare diversi metodi di approssimazione in MATLAB
Analisi degli errori e considerazioni sulla precisione
Applicazioni pratiche in ingegneria e fisica
Confronto tra metodi simbolici e numerici

1. Fondamenti Matematici

1.1 Definizione di Derivata

La derivata di una funzione f(x) in un punto x₀ è definita come:

f'(x₀) = lim
h→0 f(x₀ + h) – f(x₀)
h

In pratica, non possiamo fare tendere h a zero (sarebbe divisione per zero), quindi usiamo valori molto piccoli di h per approssimare la derivata.

1.2 Metodi delle Differenze Finite

Esistono tre principali metodi per approssimare le derivate:

Differenze finite in avanti:
f'(x₀) ≈ f(x₀ + h) – f(x₀)
h

Errore: O(h)
Differenze finite all’indietro:
f'(x₀) ≈ f(x₀) – f(x₀ – h)
h

Errore: O(h)
Differenze finite centrali:
f'(x₀) ≈ f(x₀ + h) – f(x₀ – h)
2h

Errore: O(h²) – più accurato

Riferimento Accademico:

Per una trattazione rigorosa degli errori di troncamento nelle differenze finite, consultare il testo “Finite Difference Methods” del Massachusetts Institute of Technology (MIT).

2. Implementazione in MATLAB

2.1 Metodo delle Differenze Finite Centrali

Ecco come implementare il metodo più accurato in MATLAB:

function df = central_difference(f, x0, h)
    % f: handle alla funzione (es: @(x) x.^2 + sin(x))
    % x0: punto in cui calcolare la derivata
    % h: passo per le differenze finite
    df = (f(x0 + h) - f(x0 - h)) / (2 * h);
end

Esempio d’uso:

% Definisci la funzione
f = @(x) x.^3 + 2*x.^2 - 4*x + 1;

% Calcola la derivata in x=2 con h=0.01
x0 = 2;
h = 0.01;
derivata = central_difference(f, x0, h);

disp(['La derivata in x=', num2str(x0), ' è circa ', num2str(derivata)]);

2.2 Confronto tra i Metodi

La seguente tabella mostra un confronto tra i tre metodi per la funzione f(x) = x³ + 2x² – 4x + 1 in x=2 (valore esatto della derivata: 16):

Metodo	h = 0.1	h = 0.01	h = 0.001	Errore % (h=0.01)
Differenze in avanti	15.6100	15.9601	15.9960	0.24%
Differenze all’indietro	16.4100	16.0401	16.0040	0.25%
Differenze centrali	16.0000	16.0000	16.0000	0.00%

Come si può osservare, il metodo delle differenze centrali fornisce risultati significativamente più accurati anche con valori di h maggiori.

2.3 Derivata Simbolica con MATLAB

MATLAB offre anche la possibilità di calcolare derivate in modo simbolico usando il Symbolic Math Toolbox:

syms x
f = x^3 + 2*x^2 - 4*x + 1;
df = diff(f);  % Calcola la derivata simbolica
df_value = subs(df, x, 2);  % Valuta in x=2
disp(['Derivata esatta in x=2: ', char(df_value)]);

Documentazione Ufficiale:

Per approfondire le funzionalità simboliche di MATLAB, consultare la documentazione ufficiale del Symbolic Math Toolbox.

3. Analisi degli Errori

3.1 Errori di Troncamento e Arrotondamento

Quando si usano le differenze finite, ci sono due principali fonti di errore:

Errore di troncamento: Deriva dall’approssimazione della definizione di derivata. Diminuisce con h più piccolo.
Errore di arrotondamento: Causato dalla precisione finita dei calcolatori. Aumenta quando h diventa troppo piccolo.

La figura seguente mostra l’errore totale in funzione di h per la funzione f(x) = sin(x) in x=π/4:

Si osserva che:

Per h grandi domina l’errore di troncamento
Per h molto piccoli domina l’errore di arrotondamento
Esiste un valore ottimale di h (tipicamente tra 10⁻² e 10⁻⁴)

3.2 Scelta Ottimale di h

La scelta di h dipende dalla funzione e dall’hardware. Una regola pratica è:

h_opt ≈ √ε |f(x0)|
dove ε è la precisione macchina (≈ 2.22 × 10⁻¹⁶ per double in MATLAB)

In pratica, valori di h tra 0.001 e 0.01 funzionano bene per la maggior parte delle funzioni.

4. Applicazioni Pratiche

4.1 Ottimizzazione in Ingegneria

Le derivate sono fondamentali nei metodi di ottimizzazione come:

Metodo del gradiente (gradient descent)
Metodo di Newton
Algoritmi genetici con informazioni sul gradiente

Esempio: Minimizzazione di una funzione costo:

function [x_min, f_min] = gradient_descent(f, df, x0, alpha, tol, max_iter)
    % f: funzione obiettivo
    % df: handle alla funzione derivata (può usare differenze finite)
    % x0: punto iniziale
    % alpha: learning rate
    % tol: tolleranza per la convergenza
    % max_iter: numero massimo di iterazioni

    x = x0;
    for i = 1:max_iter
        grad = df(x);
        x_new = x - alpha * grad;

        if abs(x_new - x) < tol
            break;
        end
        x = x_new;
    end

    x_min = x;
    f_min = f(x);
end

4.2 Simulazione di Sistemi Fisici

In fisica, le derivate rappresentano:

Velocità (derivata della posizione)
Accelerazione (derivata della velocità)
Corrente (derivata della carica)

Esempio: Calcolo della velocità istantanea da dati posizionali:

% Dati posizionali (tempo in secondi, posizione in metri)
t = 0:0.1:10;
x = 2*t.^2 + 3*t + 1;  % Legge oraria

% Calcola velocità con differenze centrali
v = zeros(size(t));
for i = 2:length(t)-1
    v(i) = (x(i+1) - x(i-1)) / (t(i+1) - t(i-1));
end

% Estrapolazione per i punti finali
v(1) = (x(2) - x(1)) / (t(2) - t(1));
v(end) = (x(end) - x(end-1)) / (t(end) - t(end-1));

plot(t, v);
xlabel('Tempo (s)');
ylabel('Velocità (m/s)');
title('Velocità istantanea calcolata con differenze finite');

4.3 Elaborazione di Segnali

In DSP (Digital Signal Processing), le derivate sono usate per:

Rilevamento dei bordi in immagini
Analisi di segnalie audio (envelope detection)
Filtri derivativi

5. Confronto: Metodi Simbolici vs Numerici

Criterio	Metodi Simbolici	Metodi Numerici (Differenze Finite)
Precisione	Esatta (limitata solo dalla precisione simbolica)	Approssimata (dipende da h)
Velocità	Lento per funzioni complesse	Molto veloce
Requisiti	Symbolic Math Toolbox	Solo MATLAB base
Funzioni supportate	Qualsiasi funzione derivabile	Qualsiasi funzione, anche definita punto-punto
Derivate di ordine superiore	Semplice (diff(f, n))	Richiede applicazioni ripetute
Uso in ottimizzazione	Ideale per funzioni note analiticamente	Necessario per funzioni definite solo numericament

Quando usare i metodi numerici:

Quando la funzione è nota solo attraverso dati sperimentali
Quando si lavora con funzioni definite a tratti o non derivabili analiticamente
In applicazioni real-time dove la velocità è critica

Quando usare i metodi simbolici:

Quando si necessita di precisione assoluta
Per derivare funzioni matematiche complesse
Quando si devono calcolare derivate di ordine superiore

6. Best Practices per l'Implementazione

6.1 Validazione dei Risultati

Sempre confrontare i risultati numerici con:

Derivate simboliche (quando possibile)
Valori noti da tabelle o letteratura
Risultati ottenuti con h diversi

Esempio di validazione:

% Funzione test: f(x) = e^x
f = @(x) exp(x);
df_exact = @(x) exp(x);  % Derivata esatta

x0 = 1;
h_values = [0.1, 0.01, 0.001];

for h = h_values
    df_approx = central_difference(f, x0, h);
    df_true = df_exact(x0);
    error = abs(df_approx - df_true) / df_true * 100;

    fprintf('h=%.4f: Approssimata=%.6f, Esatta=%.6f, Errore=%.4f%%\n', ...
            h, df_approx, df_true, error);
end

6.2 Gestione degli Errori

Implementare sempre controlli su:

Divisione per zero (h=0)
Valori di h troppo grandi o troppo piccoli
Funzioni non definite in alcuni punti

Esempio robusto:

function df = safe_central_difference(f, x0, h)
    if h == 0
        error('h non può essere zero');
    end

    if abs(h) > 1
        warning('h è grande: i risultati potrebbero essere imprecisi');
    end

    try
        f_plus = f(x0 + h);
        f_minus = f(x0 - h);
        df = (f_plus - f_minus) / (2 * h);
    catch ME
        error('Errore nella valutazione della funzione: %s', ME.message);
    end
end

6.3 Ottimizzazione delle Prestazioni

Per calcoli su larghe scale:

Vettorizzare le operazioni quando possibile
Usare array preallocati
Considerare l'uso di GPU con Parallel Computing Toolbox

Esempio vettorizzato:

% Calcola derivata in multiple punti contemporaneamente
x_points = linspace(0, 10, 100);
h = 0.01;
df_values = zeros(size(x_points));

for i = 1:length(x_points)
    df_values(i) = central_difference(f, x_points(i), h);
end

plot(x_points, df_values);

7. Estensioni Avanzate

7.1 Derivate Parziali

Per funzioni multivariata f(x,y), la derivata parziale rispetto a x in (x₀,y₀):

function dfdx = partial_derivative_x(f, x0, y0, h)
    dfdx = (f(x0 + h, y0) - f(x0 - h, y0)) / (2 * h);
end

% Esempio d'uso:
f_xy = @(x,y) x.^2 + y.^2 + x.*y;
dfdx = partial_derivative_x(f_xy, 1, 2, 0.01);

7.2 Derivate di Ordine Superiore

La derivata seconda può essere approssimata con:

function d2f = second_derivative(f, x0, h)
    d2f = (f(x0 + h) - 2*f(x0) + f(x0 - h)) / (h^2);
end

7.3 Metodo di Richardson

Per migliorare ulteriormente la precisione, si può usare l'estrapolazione di Richardson:

function df = richardson_derivative(f, x0, h)
    % Prima approssimazione con h
    D1 = (f(x0 + h) - f(x0 - h)) / (2 * h);

    % Seconda approssimazione con h/2
    D2 = (f(x0 + h/2) - f(x0 - h/2)) / h;

    % Estrapolazione di Richardson
    df = (4 * D2 - D1) / 3;
end

Questo metodo riduce l'errore a O(h⁴).

8. Risorse Addizionali

Corsi Universitari Rilevanti:

Introduction to Numerical Analysis - MIT OpenCourseWare
Convex Optimization - Stanford University

Libri Consigliati:

"Numerical Recipes: The Art of Scientific Computing" - Press et al.
"Applied Numerical Methods with MATLAB" - Chapra
"MATLAB Guide" - Higham & Higham

9. Errori Comuni e Come Evitarli

9.1 Scelta Sbagliata di h

Problema: Usare h troppo grande (bassa precisione) o troppo piccolo (errori di arrotondamento).

Soluzione: Testare sempre con diversi valori di h (es: 0.1, 0.01, 0.001) e verificare la convergenza.

9.2 Funzioni Non Derivabili

Problema: Applicare le differenze finite a funzioni con discontinuità o cuspidi.

Soluzione: Verificare sempre il dominio della funzione e usare metodi one-sided vicino ai punti problematici.

9.3 Precisione Macchina

Problema: Per h molto piccoli, (f(x₀+h) - f(x₀-h)) può essere affetto da cancellazione catastrofica.

Soluzione: Usare precisione maggiore (se disponibile) o metodi come l'estrapolazione di Richardson.

9.4 Confondere Derivata e Differenza

Problema: Interpretare [f(x+h) - f(x)] come derivata invece che come differenza finita.

Soluzione: Ricordare che la derivata è il limite del rapporto incrementale, non il rapporto stesso.

10. Applicazione Pratica: Tracciamento di Traiettorie

Un'applicazione interessante è il calcolo della velocità e accelerazione da dati di posizione. Supponiamo di avere i seguenti dati GPS:

Tempo (s)	Posizione X (m)	Posizione Y (m)
0.0	0.0	0.0
0.1	0.4	0.1
0.2	0.7	0.4
0.3	0.9	0.9
0.4	1.0	1.6
0.5	0.9	2.5

Possiamo calcolare velocità e accelerazione con:

% Dati
t = [0:0.1:0.5]';
x = [0; 0.4; 0.7; 0.9; 1.0; 0.9];
y = [0; 0.1; 0.4; 0.9; 1.6; 2.5];

% Calcola velocità (differenze centrali)
vx = zeros(size(x));
vy = zeros(size(y));

for i = 2:length(t)-1
    vx(i) = (x(i+1) - x(i-1)) / (t(i+1) - t(i-1));
    vy(i) = (y(i+1) - y(i-1)) / (t(i+1) - t(i-1));
end

% Estrapolazione per i punti finali (differenze in avanti/all'indietro)
vx(1) = (x(2) - x(1)) / (t(2) - t(1));
vy(1) = (y(2) - y(1)) / (t(2) - t(1));
vx(end) = (x(end) - x(end-1)) / (t(end) - t(end-1));
vy(end) = (y(end) - y(end-1)) / (t(end) - t(end-1));

% Calcola accelerazione (derivata seconda)
ax = zeros(size(x));
ay = zeros(size(y));

for i = 2:length(t)-1
    ax(i) = (vx(i+1) - vx(i-1)) / (t(i+1) - t(i-1));
    ay(i) = (vy(i+1) - vy(i-1)) / (t(i+1) - t(i-1));
end

% Plotting
figure;
subplot(2,1,1);
plot(t, vx, 'r', t, vy, 'b');
legend('V_x', 'V_y');
title('Velocità');
xlabel('Tempo (s)');
ylabel('Velocità (m/s)');

subplot(2,1,2);
plot(t, ax, 'r', t, ay, 'b');
legend('A_x', 'A_y');
title('Accelerazione');
xlabel('Tempo (s)');
ylabel('Accelerazione (m/s^2)');

Questo approccio è ampiamente usato in:

Sistemi di navigazione (GPS, INS)
Analisi biomeccanica del movimento
Robotica (controllo del movimento)

11. Confronto con Altri Software

Strumento	Sintassi per Derivata	Precisione	Velocità	Costo
MATLAB (simbolico)	diff(f, x)	Esatta	Media	$$$ (richiede toolbox)
MATLAB (numerico)	central_difference(f, x0, h)	Approssimata	Molto veloce	$ (solo MATLAB base)
Python (SymPy)	diff(f, x)	Esatta	Media	Gratis
Python (NumPy)	np.gradient(f)	Approssimata	Molto veloce	Gratis
Wolfram Alpha	"derivative of x^2 at x=3"	Esatta	Immediata	Gratis (online)
Excel	= (f(x+h)-f(x-h))/(2*h)	Approssimata	Lenta	Gratis (base)

MATLAB si distingue per:

Integrazione con altri toolbox (Simulink, Control System, etc.)
Performance ottimizzate per calcoli numerici
Ambiente interattivo per prototipazione rapida

12. Esempio Completo: Ottimizzazione di una Funzione

Supponiamo di voler trovare il minimo della funzione f(x) = x⁴ - 3x³ + 2 usando il metodo del gradiente con derivate approssimate:

% Funzione obiettivo
f = @(x) x.^4 - 3*x.^3 + 2;

% Derivata (usando differenze centrali)
df = @(x) central_difference(f, x, 0.001);

% Parametri del gradiente
x0 = 0;       % Punto iniziale
alpha = 0.01; % Learning rate
tol = 1e-6;   % Tolleranza
max_iter = 1000;

% Algoritmo del gradiente
x = x0;
history = zeros(max_iter, 1);

for i = 1:max_iter
    history(i) = x;
    grad = df(x);
    x_new = x - alpha * grad;

    if abs(x_new - x) < tol
        break;
    end
    x = x_new;
end

% Risultati
fprintf('Minimo trovato in x = %.6f\n', x);
fprintf('Valore funzione nel minimo: %.6f\n', f(x));
fprintf('Numero iterazioni: %d\n', i);

% Plotting della convergenza
figure;
plot(0:i-1, history(1:i), 'o-');
xlabel('Iterazione');
ylabel('Valore di x');
title('Convergenza del metodo del gradiente');
grid on;

Output atteso:

Minimo trovato in x = 2.250000
Valore funzione nel minimo: -6.093750
Numero iterazioni: 42

Questo esempio mostra come le derivate numeriche possano essere usate efficacemente in algoritmi di ottimizzazione anche quando non si conosce la forma analitica della derivata.

13. Conclusioni

Il calcolo delle derivate in un punto usando MATLAB è una competenza fondamentale per ingegneri, fisici e data scientist. I punti chiave da ricordare sono:

Le differenze finite centrali offrono il miglior compromesso tra precisione e semplicità
La scelta di h è critica: tipicamente 0.01 è un buon punto di partenza
Validare sempre i risultati con metodi alternativi quando possibile
Per applicazioni critiche, considerare metodi più avanzati come l'estrapolazione di Richardson
MATLAB offre sia approcci simbolici (precisione) che numerici (velocità)

Con la pratica e l'attention ai dettagli implementativi, sarai in grado di applicare queste tecniche a una vasta gamma di problemi scientifici e ingegneristici.