La traduction de cette page n'est pas à jour. Cliquez ici pour voir la dernière version en anglais.

polyfit

Ajuster des courbes polynomiales

Syntaxe

p = polyfit(x,y,n)

[p,S] = polyfit(x,y,n)

[p,S,mu] = polyfit(x,y,n)

Description

p = polyfit(x,y,n) renvoie les coefficients d’un polynôme p(x) de degré n qui est le meilleur ajustement (au sens des moindres carrés) pour les données de y. Les coefficients de p sont des puissances décroissantes, et la longueur de p est n+1

$$p(x)=p_1{x}^n+p_2{x}^{n-1}+\mathrm{...}+p_{n}x+p_{n+1}.$$

[p,S] = polyfit(x,y,n) renvoie également une structure S pouvant être utilisée comme entrée dans polyval pour obtenir des estimations d’erreur.

[p,S,mu] = polyfit(x,y,n) effectue un centrage et une mise à l’échelle pour améliorer les propriétés numériques du polynôme et de l’algorithme d’ajustement. Cette syntaxe renvoie également mu, qui est un vecteur à deux éléments avec des valeurs de centrage et de mise à l’échelle. mu(1) est mean(x), et mu(2) est std(x). À l’aide de ces valeurs, polyfit centre x sur zéro et le met à l’échelle pour obtenir un écart-type unitaire,

$$\widehat{x}=\frac{x-\overline{x}}{{\sigma }_x}.$$

Exemples

Ajuster un polynôme sur une fonction trigonométrique

Générez 10 points régulièrement espacés le long d’une courbe sinusoïdale dans l’intervalle [0,4*pi].

x = linspace(0,4*pi,10);
y = sin(x);

Utilisez polyfit pour ajuster un polynôme du 7e degré sur les points.

p = polyfit(x,y,7);

Évaluez le polynôme sur une grille plus fine et tracez les résultats.

x1 = linspace(0,4*pi);
y1 = polyval(p,x1);
figure
plot(x,y,'o')
hold on
plot(x1,y1)
hold off

Ajuster un polynôme sur un jeu de points

Créez un vecteur de 5 points régulièrement espacés dans l’intervalle [0,1] et évaluez $$y(x)=(1+x{)}^{-1}$$ au niveau de ces points.

x = linspace(0,1,5);
y = 1./(1+x);

Ajustez un polynôme de degré 4 sur les 5 points. Généralement pour n points, vous pouvez ajuster un polynôme de degré n-1 afin qu’il passe exactement par les points.

p = polyfit(x,y,4);

Évaluez la fonction originale et l’ajustement polynomial sur une grille de points plus fine entre 0 et 2.

x1 = linspace(0,2);
y1 = 1./(1+x1);
f1 = polyval(p,x1);

Tracez les valeurs de la fonction et l’ajustement polynomial dans l’intervalle plus large de [0,2], les points utilisés pour obtenir l’ajustement polynomial étant mis en évidence par des cercles. L’ajustement polynomial est bon dans l’intervalle original de [0,1], mais diverge rapidement de la fonction ajustée en dehors de cet intervalle.

figure
plot(x,y,'o')
hold on
plot(x1,y1)
plot(x1,f1,'r--')
legend('y','y1','f1')

Ajuster un polynôme sur une fonction d’erreur

Générez dans un premier temps un vecteur de points x espacés régulièrement dans l’intervalle [0,2.5], puis évaluez erf(x) au niveau de ces points.

x = (0:0.1:2.5)';
y = erf(x);

Déterminez les coefficients du polynôme approximatif de degré 6.

p = polyfit(x,y,6)

p = 1×7

    0.0084   -0.0983    0.4217   -0.7435    0.1471    1.1064    0.0004

Pour déterminer la qualité de l’ajustement, évaluez le polynôme aux points de données et générez une table indiquant les données, l'ajustement et l’erreur.

f = polyval(p,x);
T = table(x,y,f,y-f,'VariableNames',{'X','Y','Fit','FitError'})

T=26×4 table
     X        Y          Fit         FitError  
    ___    _______    __________    ___________

      0          0    0.00044117    -0.00044117
    0.1    0.11246       0.11185     0.00060836
    0.2     0.2227       0.22231     0.00039189
    0.3    0.32863       0.32872    -9.7429e-05
    0.4    0.42839        0.4288    -0.00040661
    0.5     0.5205       0.52093    -0.00042568
    0.6    0.60386       0.60408    -0.00022824
    0.7     0.6778       0.67775     4.6383e-05
    0.8     0.7421       0.74183     0.00026992
    0.9    0.79691       0.79654     0.00036515
      1     0.8427       0.84238      0.0003164
    1.1    0.88021       0.88005     0.00015948
    1.2    0.91031       0.91035    -3.9919e-05
    1.3    0.93401       0.93422      -0.000211
    1.4    0.95229       0.95258    -0.00029933
    1.5    0.96611       0.96639    -0.00028097
      ⋮

Dans cet intervalle, les valeurs interpolées et les valeurs réelles concordent assez bien. Créez un tracé pour montrer qu’en dehors de cet intervalle, les valeurs extrapolées divergent rapidement des données réelles.

x1 = (0:0.1:5)';
y1 = erf(x1);
f1 = polyval(p,x1);
figure
plot(x,y,'o')
hold on
plot(x1,y1,'-')
plot(x1,f1,'r--')
axis([0  5  0  2])
hold off

Utiliser le centrage et la mise à l’échelle pour améliorer les propriétés numériques

Créez une table de données démographiques pour les années 1750 à 2000 et tracez les points de données.

year = (1750:25:2000)';
pop = 1e6*[791 856 978 1050 1262 1544 1650 2532 6122 8170 11560]';
T = table(year, pop)

T=11×2 table
    year       pop   
    ____    _________

    1750     7.91e+08
    1775     8.56e+08
    1800     9.78e+08
    1825     1.05e+09
    1850    1.262e+09
    1875    1.544e+09
    1900     1.65e+09
    1925    2.532e+09
    1950    6.122e+09
    1975     8.17e+09
    2000    1.156e+10

plot(year,pop,'o')

Utilisez polyfit avec trois sorties pour ajuster un polynôme du 5e degré en utilisant le centrage et la mise à l’échelle, ce qui améliore les propriétés numériques du problème. polyfit centre les données sur year au niveau 0 et les met à l'échelle pour obtenir un écart-type de 1, ce qui évite la création d’une matrice de Vandermonde mal conditionnée dans le calcul de l'ajustement.

[p,~,mu] = polyfit(T.year, T.pop, 5);

Utilisez polyval avec quatre entrées pour évaluer p avec les années mises à l’échelle, (year-mu(1))/mu(2). Tracez les résultats par rapport aux années d’origine.

f = polyval(p,year,[],mu);
hold on
plot(year,f)
hold off

Régression linéaire simple

Ajustez un modèle de régression linéaire simple sur un ensemble de points de données discrets en 2D.

Créez quelques exemples de vecteurs de points de données (x,y). Ajustez un polynôme du premier degré sur les données.

x = 1:50; 
y = -0.3*x + 2*randn(1,50); 
p = polyfit(x,y,1); 

Évaluez le polynôme ajusté p aux points de x. Tracez le modèle de régression linéaire obtenu avec les données.

f = polyval(p,x); 
plot(x,y,'o',x,f,'-') 
legend('data','linear fit') 

Régression linéaire avec estimation d’erreurs

Ajustez un modèle linéaire sur un jeu de points de données et tracez les résultats, en incluant une estimation de l’intervalle de prédiction à 95 %.

Créez quelques exemples de vecteurs de points de données (x,y). Utilisez polyfit pour ajuster un polynôme du premier degré sur les données. Spécifiez deux sorties pour renvoyer les coefficients de l'ajustement linéaire ainsi que la structure d’estimation d’erreurs.

x = 1:100; 
y = -0.3*x + 2*randn(1,100); 
[p,S] = polyfit(x,y,1); 

Évaluez la correspondance du polynôme de premier degré dans p au niveau des points de x. Spécifiez la structure d’estimation d’erreurs en tant que troisième entrée pour que polyval calcule une estimation d’erreur standard. L’estimation de l’erreur standard est renvoyée dans delta.

[y_fit,delta] = polyval(p,x,S);

Tracez les données d'origine, l'ajustement linéaire et l’intervalle de prédiction à 95 % $\mathit{y}\pm 2\Delta$.

plot(x,y,'bo')
hold on
plot(x,y_fit,'r-')
plot(x,y_fit+2*delta,'m--',x,y_fit-2*delta,'m--')
title('Linear Fit of Data with 95% Prediction Interval')
legend('Data','Linear Fit','95% Prediction Interval')

Arguments d'entrée

x — Points de requête

vecteur

Points de requête, spécifiés sous forme de vecteur. Les points dans x correspondent aux valeurs de la fonction ajustée contenues dans y. Si x n’est pas un vecteur, polyfit le convertit en un vecteur colonne x(:).

Des messages d’avertissement apparaissent lorsque x dispose de points répétés (ou presque), ou si x doit être centré et mis à l’échelle.

Types de données : single | double
Support des nombres complexes : Oui

y — Valeurs ajustées aux points de requête

vecteur

Valeurs ajustées aux points de requête, spécifiées sous forme de vecteur. Les valeurs de y correspondent aux points de requête contenus dans x. Si y n’est pas un vecteur, polyfit le convertit en un vecteur colonne y(:).

Types de données : single | double
Support des nombres complexes : Oui

n — Degré d'ajustement polynomial

scalaire entier positif

Degré de correspondance polynomiale, spécifié sous forme de scalaire entier positif. n spécifie la puissance polynomiale du coefficient le plus à gauche dans p.

Arguments de sortie

p — Coefficients polynomiaux ajustés par la méthode des moindres carrés

vecteur

Coefficients polynomiaux ajustés par la méthode des moindres carrés, renvoyés sous forme d’un vecteur. p est de longueur n+1 et contient les coefficients polynomiaux en puissances décroissantes, la puissance la plus élevée étant n. Si x ou y contient des valeurs NaN et n < length(x), alors tous les éléments de p sont NaN. Si vous spécifiez trois arguments de sortie pour centrer et mettre à l’échelle les données, alors polyfit renvoie des coefficients différents dans p par rapport aux données qui ne sont pas centrées et mises à l’échelle.

Utilisez polyval pour évaluer p au niveau des points de requête.

S — Structure d’estimation des erreurs

structure

Structure d’estimation des erreurs. Cette structure de sortie facultative est principalement utilisée comme entrée de la fonction polyval pour obtenir des estimations d’erreur. S contient les champs suivants :

Champ	Description
R	Facteur R triangulaire (éventuellement permuté) d’une décomposition QR de la matrice de Vandermonde de x
df	Degrés de liberté
normr	Norme des résidus

Si les données de y sont aléatoires, une estimation de la matrice de covariance de p est (Rinv*Rinv')*normr^2/df, où Rinv est l’inverse de R.

Si les erreurs dans les données de y sont indépendantes et normales avec une variance constante, alors [y,delta] = polyval(...) produit des limites d’erreur qui contiennent au moins 50 % des prédictions. En d’autres termes, y ± delta contient au moins 50 % des prédictions des observations futures à x.

mu — Valeurs de centrage et de mise à l’échelle

vecteur à deux éléments

Valeurs de centrage et de mise à l’échelle, renvoyées sous la forme d’un vecteur à deux éléments. mu(1) correspond à mean(x), et mu(2) correspond à std(x). Ces valeurs centrent les points de requête dans x sur zéro avec un écart-type unitaire.

Utilisez mu comme quatrième entrée de polyval pour évaluer p aux points mis à l’échelle, (x - mu(1))/mu(2).

Limitations

• Pour les problèmes comportant de nombreux points, l’augmentation du degré de l’ajustement polynomial via polyfit ne permet pas toujours d’obtenir une meilleure correspondance. Les polynômes d’ordre élevé peuvent osciller entre les points de données, ce qui produit un mauvais ajustement aux données. Dans de tels cas, vous pouvez utiliser un ajustement polynomiale d’ordre inférieur (qui tend à être plus lisse entre les points) ou une technique différente, en fonction du problème.

• Par nature, les polynômes sont des fonctions oscillantes non bornées. Elles ne sont donc pas adaptées à l’extrapolation de données bornées ou de données monotones (croissantes ou décroissantes).

Algorithmes

polyfit utilise x pour former la matrice de Vandermonde V avec n+1 colonnes et m = length(x) lignes, ce qui donne le système linéaire suivant

$$\left(\begin{array}{cccc}{x}_1^n& x_1^{n-1}& \cdots & 1\\ x_2^n& x_2^{n-1}& \cdots & 1\\ ⋮& ⋮& \ddots & ⋮\\ x_m^n& x_m^{n-1}& \cdots & 1\end{array}\right)\left(\begin{array}{c}{p}_1\\ p_2\\ ⋮\\ p_{n+1}\end{array}\right)=\left(\begin{array}{c}{y}_1\\ y_2\\ ⋮\\ y_m\end{array}\right),$$

que polyfit résout avec p = V\y. Puisque les colonnes de la matrice de Vandermonde sont des puissances du vecteur x, le nombre de conditions de V est souvent élevé pour les correspondances d’ordre élevé, ce qui se traduit par une matrice de coefficients singulière. Dans de tels cas, le centrage et la mise à l’échelle peuvent améliorer les propriétés numériques du système et produire un ajustement plus fiable.

Capacités étendues

Tall arrays

Calculer avec des arrays possédant plus de rangées que la mémoire ne peut en contenir.

Notes d’usage et limitations :

X et Y doivent être des vecteurs colonne.

Pour plus d’informations, consultez Tall array.

Génération de code C/C++

Générez du code C et C++ avec MATLAB® Coder™.

Notes d’usage et limitations :

• Consultez Variable-Sizing Restrictions for Code Generation of Toolbox Functions (MATLAB Coder).

Environnement basé sur les threads

Exécutez du code en arrière-plan avec MATLAB® backgroundPool ou accélérez le code avec Parallel Computing Toolbox™ ThreadPool.

Cette fonction supporte entièrement les environnements basés sur des threads. Pour plus d’informations, consultez Run MATLAB Functions in Thread-Based Environment.

GPU Arrays

Accélérez le code en exécutant les calculs sur une unité de traitement graphique (GPU) avec Parallel Computing Toolbox™.

Cette fonction supporte entièrement les GPU arrays. Pour plus d’informations, consultez Exécutez les fonctions MATLAB sur un GPU (Parallel Computing Toolbox).

Distributed arrays

Divisez les tableaux volumineux dans la mémoire combinée de votre cluster avec Parallel Computing Toolbox™.

Cette fonction supporte entièrement les distributed arrays. Pour plus d’informations, consultez Exécuter des fonctions MATLAB avec des tableaux distribués (Parallel Computing Toolbox).

Historique des versions

Introduit avant R2006a

Voir aussi

cov | lscov | poly | polyint | polyder | polyval | roots

Rubriques

• Programmatic Fitting