MATLAB Language
Interpolazione con MATLAB

Sintassi

1. zy = interp1 (x, y);
2. zy = interp1 (x, y, 'metodo');
3. zy = interp1 (x, y, 'metodo', 'estrapolazione');
4. zy = interp1 (x, y, zx);
5. zy = interp1 (x, y, zx, 'metodo');
6. zy = interp1 (x, y, zx, 'metodo', 'estrapolazione');

Interpolazione a tratti 2 dimensionale

Inizializziamo i dati:

[X,Y] = meshgrid(1:2:10);
Z = X.*cos(Y) - Y.*sin(X);

La superficie appare come la seguente.

Ora impostiamo i punti in cui vogliamo interpolare:

[Vx,Vy] = meshgrid(1:0.25:10); 

Ora possiamo eseguire l'interpolazione più vicina,

Vz = interp2(X,Y,Z,Vx,Vy,'nearest');

interpolazione lineare,

Vz = interp2(X,Y,Z,Vx,Vy,'linear');

interpolazione cubica

Vz = interp2(X,Y,Z,Vx,Vy,'cubic');

o interpolazione spline:

Vz = interp2(X,Y,Z,Vx,Vy,'spline');

Interpolazione a tratti 1 dimensionale

Useremo i seguenti dati:

x = 1:5:50;
y = randi([-10 10],1,10);

Con la presente x ed y sono le coordinate dei punti di dati e z sono i punti che hanno bisogno di informazioni circa.

z = 0:0.25:50;

Un modo per trovare i valori y di z è l'interpolazione lineare a tratti.

z_y = interp1(x,y,z,'linear');

Con la presente si calcola la linea tra due punti adiacenti e si ottiene z_y assumendo che il punto sarebbe un elemento di quelle linee.

interp1 fornisce anche altre opzioni come l'interpolazione più vicina,

z_y = interp1(x,y,z, 'nearest');

prossima interpolazione,

z_y = interp1(x,y,z, 'next');

interpolazione precedente,

z_y = interp1(x,y,z, 'previous');

Interpolazione cubica a tratti che preserva la forma,

z_y = interp1(x,y,z, 'pchip');

convoluzione cubica, z_y = interp1 (x, y, z, 'v5cubic');

e spline interpolazione

z_y = interp1(x,y,z, 'spline');

Con la presente, interpolazione prossima, successiva e precedente sono parti dell'interpolazione costante.

Interpolazione polinomiale

Inizializziamo i dati che vogliamo interpolare:

x = 0:0.5:10;
y = sin(x/2);

Ciò significa che la funzione sottostante per i dati nell'intervallo [0,10] è sinusoidale. Ora vengono calcolati i coefficienti dei polinomiali approssimati:

p1 = polyfit(x,y,1);
p2 = polyfit(x,y,2);
p3 = polyfit(x,y,3);
p5 = polyfit(x,y,5);
p10 = polyfit(x,y,10);

In questo caso x è il valore xe y il valore y dei nostri punti dati e il terzo numero è l'ordine / grado del polinomio. Ora impostiamo la griglia su cui vogliamo calcolare la nostra funzione di interpolazione:

zx = 0:0.1:10;

e calcola i valori y:

zy1 = polyval(p1,zx);
zy2 = polyval(p2,zx);
zy3 = polyval(p3,zx);
zy5 = polyval(p5,zx);
zy10 = polyval(p10,zx);

Si può vedere che l'errore di approssimazione per il campione si riduce quando aumenta il grado del polinomio.

Mentre l'approssimazione della linea retta in questo esempio ha errori più grandi, il polinomio dell'ordine 3 approssima la funzione sinusale in questo intervallo relativamente buono.

L'interpolazione con i polinomi dell'ordine 5 e dell'ordine 10 non ha quasi alcun errore di approssimazione.

Tuttavia, se consideriamo le prestazioni fuori dal campione, si vede che gli ordini troppo alti tendono a sovraffaticare e, quindi, a fare male il campione. Prepariamo

zx = -10:0.1:40;
p10 = polyfit(X,Y,10);
p20 = polyfit(X,Y,20);

e

zy10 = polyval(p10,zx);
zy20 = polyval(p20,zx);

Se osserviamo la trama, vediamo che le prestazioni fuori campione sono le migliori per l'ordine 1

e continua a peggiorare con sempre maggiore intensità.