MATLAB Language
Interpolation mit MATLAB

Syntax

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

Stückweise Interpolation 2 dimensional

Wir initialisieren die Daten:

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

Die Oberfläche sieht wie folgt aus.

Jetzt setzen wir die Punkte, an denen wir interpolieren möchten:

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

Wir können jetzt die nächste Interpolation durchführen,

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

lineare Interpolation,

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

kubische Interpolation

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

oder Spline-Interpolation:

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

Stückweise Interpolation 1 dimensional

Wir werden folgende Daten verwenden:

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

Hierbei sind x und y die Koordinaten der Datenpunkte und z die Punkte, über die wir Informationen benötigen.

z = 0:0.25:50;

Eine Möglichkeit, die y-Werte von z zu finden, ist die stückweise lineare Interpolation.

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

Hiermit berechnet man die Linie zwischen zwei benachbarten Punkten und erhält z_y durch die Annahme, dass der Punkt ein Element dieser Linien wäre.

interp1 bietet auch andere Optionen wie die nächste Interpolation,

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

nächste interpolation,

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

vorherige Interpolation

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

Formbewahrende stückweise kubische Interpolation

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

kubische Faltung, z_y = interp1 (x, y, z, 'v5cubic');

und Spline-Interpolation

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

Hiermit sind stückweise konstante Interpolationen nahe, nächster und vorhergehender Interpolation.

Polynominterpolation

Wir initialisieren die Daten, die wir interpolieren möchten:

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

Das heißt, die zugrunde liegende Funktion für die Daten im Intervall [0,10] ist sinusförmig. Nun werden die Koeffizienten der approximierenden Polynome berechnet:

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);

Hierbei ist x der x-Wert und y der y-Wert unserer Datenpunkte und die dritte Zahl ist die Ordnung / Grad des Polynoms. Wir setzen jetzt das Gitter, in dem wir unsere Interpolationsfunktion berechnen wollen:

zx = 0:0.1:10;

und berechnen Sie die y-Werte:

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

Man kann sehen, dass der Näherungsfehler für die Probe kleiner wird, wenn der Polynomgrad ansteigt.

Während die Näherung der geraden Linie in diesem Beispiel größere Fehler aufweist, approximiert das Polynom der Ordnung 3 die Sinusfunktion in diesem Intervall relativ gut.

Die Interpolation mit Polynomen der Ordnungen 5 und 10 hat fast keinen Apprroximierungsfehler.

Betrachtet man jedoch die Out-of-Sample-Performance, stellt man fest, dass zu hohe Orders dazu neigen, übermäßig zu fit zu sein und daher außerhalb der Samples schlecht abschneiden. Legen wir fest

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

und

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

Wenn wir einen Blick auf die Grafik werfen, sehen wir, dass die Out-of-Sample-Leistung für die Bestellung am besten ist

und wird mit zunehmendem Grad immer schlechter.