MATLAB Language
Interpolation avec MATLAB

Syntaxe

1. zy = interp1 (x, y);
2. zy = interp1 (x, y, 'méthode');
3. zy = interp1 (x, y, 'méthode', 'extrapolation');
4. zy = interp1 (x, y, zx);
5. zy = interp1 (x, y, zx, 'méthode');
6. zy = interp1 (x, y, zx, 'méthode', 'extrapolation');

Interpolation par morceaux en 2 dimensions

Nous initialisons les données:

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

La surface ressemble à la suivante.

Maintenant, nous définissons les points où nous voulons interpoler:

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

Nous pouvons maintenant effectuer l'interpolation la plus proche,

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

interpolation linéaire,

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

interpolation cubique

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

ou interpolation spline:

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

Interpolation par morceaux 1 dimension

Nous utiliserons les données suivantes:

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

Ici, x et y sont les coordonnées des points de données et z sont les points pour lesquels nous avons besoin d'informations.

z = 0:0.25:50;

Une méthode permettant de trouver les valeurs y de z est l'interpolation linéaire par morceaux.

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

On calcule ici la ligne entre deux points adjacents et obtient z_y en supposant que le point serait un élément de ces lignes.

interp1 fournit d'autres options comme l'interpolation la plus proche,

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

interpolation suivante,

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

interpolation précédente,

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

Interpolation cubique par morceaux préservant la forme,

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

convolution cubique, z_y = interp1 (x, y, z, 'v5cubic');

et interpolation spline

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

Les interpolations constantes par morceaux sont les plus proches, les suivantes et les suivantes.

Interpolation polynomiale

Nous initialisons les données que nous voulons interpoler:

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

Cela signifie que la fonction sous-jacente pour les données dans l'intervalle [0,10] est sinusoïdale. Maintenant, les coefficients des polynômes approximatifs sont calculés:

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

Voici x la valeur x et y la valeur y de nos points de données et le troisième nombre est l'ordre / degré du polynôme. Nous définissons maintenant la grille que nous voulons calculer notre fonction d'interpolation sur:

zx = 0:0.1:10;

et calculer les valeurs y:

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

On peut voir que l'erreur d'approximation de l'échantillon diminue lorsque le degré du polynôme augmente.

Alors que l'approximation de la ligne droite dans cet exemple comporte des erreurs plus importantes, le polynôme d'ordre 3 estime que la fonction sinusale est relativement bonne dans cet intervalle.

L’interpolation avec les polynômes de l’ordre 5 et de l’ordre 10 n’a presque aucune erreur d’approbation.

Cependant, si l'on considère les performances hors échantillon, on constate que les commandes trop élevées ont tendance à suréquiper et donc à produire de mauvais résultats. Nous fixons

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

et

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

Si nous regardons l'intrigue, nous voyons que la performance hors échantillon est la meilleure pour la commande 1

et continue d'empirer avec un degré croissant.