Die Übersetzung dieser Seite ist veraltet. Klicken Sie hier, um die neueste Version auf Englisch zu sehen.

polyfit

Polynomiale Kurvenanpassung

Syntax

p = polyfit(x,y,n)

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

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

Beschreibung

p = polyfit(x,y,n) gibt die Koeffizienten für ein polynomiales p(x) n. Grades zurück, das eine optimale Anpassung (im Sinne kleinster Quadrate) für die Daten in y darstellt. Die Koeffizienten in p sind nach Potenz in absteigender Reihenfolge angeordnet und die Länge von p ist 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) gibt auch eine Struktur S zurück, die als Eingabe in polyval verwendet werden kann, um Fehlerschätzungen zu erhalten.

[p,S,mu] = polyfit(x,y,n) verbessert durch Zentrierung und Skalierung die numerischen Eigenschaften des polynomialen Algorithmus und des Anpassungsalgorithmus. Diese Syntax gibt zusätzlich mu zurück. Dabei handelt es sich um einen aus zwei Elementen bestehenden Vektor mit Zentrierungs- und Skalierungswerten. mu(1) ist mean(x) und mu(2) ist std(x). polyfit zentriert mithilfe dieser Werte x bei null und skaliert den Wert, um die Standardabweichung der Einheiten zu ermitteln,

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

Beispiele

Anpassen eines Polynoms an die trigonometrische Funktion

Erstellen Sie 10 Punkte mit gleichen Abständen entlang einer Sinuskurve im Intervall [0,4*pi].

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

Passen Sie mithilfe von polyfit ein Polynom 7. Grades an die Punkte an.

p = polyfit(x,y,7);

Werten Sie das Polynom auf einem feineren Raster aus und plotten Sie die Ergebnisse.

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

Anpassen eines Polynoms an einen Satz von Punkten

Erstellen Sie einen Vektor mit 5 gleichmäßig verteilten Punkten im Intervall [0,1] und werten Sie $$y(x)=(1+x{)}^{-1}$$ an diesen Punkten aus.

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

Passen Sie ein Polynom 4. Grades an die 5 Punkte an. Im Allgemeinen können Sie für n Punkte ein Polynom n-1. Grades so anpassen, dass es exakt durch die Punkte verläuft.

p = polyfit(x,y,4);

Werten Sie die Originalfunktion und die polynomiale Anpassung auf einem feineren Punkteraster zwischen 0 und 2 aus.

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

Plotten Sie die Funktionswerte und die polynomiale Anpassung im breiteren Intervall [0,2] und verwenden Sie dabei die Punkte, die Sie zum Ermitteln der polynomialen Anpassung verwendet haben (als Kreise hervorgehoben). Die polynomiale Anpassung ist im Originalintervall [0,1] gut, weicht außerhalb dieses Intervalls jedoch schnell von der angepassten Funktion ab.

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

Anpassen eines Polynoms an die Fehlerfunktion

Erstellen Sie zunächst einen Vektor aus x Punkten, die im Intervall [0,2.5] gleichmäßig verteilt sind, und werten Sie anschließend erf(x) an diesen Punkten aus.

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

Bestimmen Sie die Koeffizienten des approximierenden Polynoms 6. Grades.

p = polyfit(x,y,6)

p = 1×7

    0.0084   -0.0983    0.4217   -0.7435    0.1471    1.1064    0.0004

Um festzustellen, wie gut die Anpassung ist, werten Sie das Polynom an den Datenpunkten aus und erstellen Sie eine Tabelle, in der Daten, Anpassung und Fehler aufgeführt sind.

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
      ⋮

In diesem Intervall stimmen die interpolierten Werte und die tatsächlichen Werte recht gut überein. Erstellen Sie ein Diagramm, um darzustellen, wie die extrapolierten Werte außerhalb dieses Intervalls schnell von den tatsächlichen Daten abweichen.

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

Verbessern numerischer Eigenschaften mithilfe von Zentrierung und Skalierung

Erstellen Sie eine Tabelle mit Populationsdaten für die Jahre 1750 bis 2000 und plotten Sie die Datenpunkte.

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

Verwenden Sie polyfit mit drei Ausgaben zur Anpassung eines Polynoms 5. Grades mithilfe von Zentrierung und Skalierung, wodurch sich die numerischen Eigenschaften des Problems verbessern. polyfit zentriert die Daten in year bei 0 und skaliert sie, sodass sich eine Standardabweichung von 1 ergibt. Auf diese Weise lässt sich eine falsch konditionierte Vandermonde-Matrix in der Anpassungsberechnung vermeiden.

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

Verwenden Sie polyval mit vier Eingaben, um p mit den skalierten Jahren, (year-mu(1))/mu(2), auszuwerten. Plotten Sie die Ergebnisse in Abhängigkeit von den ursprünglichen Jahren.

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

Einfache lineare Regression

Passen Sie ein einfaches lineares Regressionsmodell an einen Satz diskreter zweidimensionaler Datenpunkte an.

Erstellen Sie einige Vektoren aus Stichprobendatenpunkten (x,y). Passen Sie ein Polynom ersten Grades an die Daten an.

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

Werten Sie das angepasste Polynom p an den Punkten in x aus. Plotten Sie das resultierende lineare Regressionsmodell mit den Daten.

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

Lineare Regression mit Fehlerschätzung

Passen Sie ein lineares Modell an einen Satz von Datenpunkten an und plotten Sie die Ergebnisse. Berücksichtigen Sie dabei eine Schätzung eines 95%-Vorhersageintervalls.

Erstellen Sie einige Vektoren aus Stichprobendatenpunkten (x,y). Verwenden Sie polyfit, um ein Polynom ersten Grades an die Daten anzupassen. Geben Sie zwei Ausgaben an, um die Koeffizienten für die lineare Anpassung und die Fehlerschätzstruktur zurückzugeben.

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

Werten Sie die Anpassung des Polynoms 1. Grades in p an den Punkten in x aus. Geben Sie die Fehlerschätzstruktur als dritte Eingabe an, sodass polyval eine Schätzung des Standardfehlers berechnet. Die Standardfehlerschätzung wird in delta zurückgegeben.

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

Plotten Sie die Originaldaten, die lineare Anpassung und das 95%-Vorhersageintervall $\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')

Eingabeargumente

x — Abfragepunkte

Vektor

Abfragepunkte, angegeben als Vektor. Die Punkte in x entsprechen den Werten der angepassten Funktion, die in y enthalten ist. Wenn x kein Vektor ist, konvertiert polyfit den Wert in einen Spaltenvektor x(:).

Es werden Warnmeldungen angezeigt, wenn x wiederholte (oder nahezu wiederholte) Punkte umfasst oder wenn x möglicherweise zentriert oder skaliert werden muss.

Datentypen: single | double
Unterstützung komplexer Zahlen: Ja

y — Angepasste Werte an Abfragepunkten

Vektor

Angepasste Werte an Abfragepunkten, angegeben als Vektor. Die Werte in y entsprechen den Abfragepunkten, die in x enthalten sind. Wenn y kein Vektor ist, konvertiert polyfit den Wert in einen Spaltenvektor y(:).

Datentypen: single | double
Unterstützung komplexer Zahlen: Ja

n — Grad der polynomialen Anpassung

positiver ganzzahliger Skalar

Grad der polynomialen Anpassung, angegeben als positiver ganzzahliger Skalar. n gibt die polynomiale Potenz des Koeffizienten in p an, der sich ganz links befindet.

Ausgabeargumente

p — Polynomiale Koeffizienten nach der Kleinste-Quadrate-Methode

Vektor

Polynomiale Koeffizienten nach der Kleinste-Quadrate-Methode, zurückgegeben als Vektor. p hat die Länge n+1 und enthält die polynomialen Koeffizienten nach Potenz in absteigender Reihenfolge, wobei die höchste Potenz n ist. Wenn x oder y NaN-Werte und n < length(x) enthalten, sind alle Elemente in p NaN. Wenn Sie drei Ausgabeargumente zum Zentrieren und Skalieren der Daten angeben, gibt polyfit andere Koeffizienten in p zurück, als dies bei nicht zentrierten und nicht skalierten Daten der Fall ist.

Verwenden Sie polyval, um p an den Abfragepunkten auszuwerten.

S — Fehlerschätzstruktur

Struktur

Fehlerschätzstruktur. Diese optionale Ausgabestruktur wird vor allem als Eingabe für die Funktion polyval verwendet, um Fehlerschätzungen zu erhalten. S enthält die folgenden Felder:

Feld	Beschreibung
R	Dreiecksfaktor R (möglicherweise permutiert) aus einer QR-Zerlegung der Vandermonde-Matrix von x
df	Freiheitsgrade
normr	Norm des Residuums

Wenn die Daten in y zufällig sind, ist eine Schätzung der Kovarianzmatrix von p gleich (Rinv*Rinv')*normr^2/df, wobei Rinv die Inverse von R ist.

Wenn die Fehler in den Daten in y unabhängig und normal mit einer konstanten Varianz sind, dann generiert [y,delta] = polyval(...) Fehlergrenzen, die mindestens 50 % der Vorhersagen enthalten. Dies bedeutet, dass y ± delta mindestens 50 % der Vorhersagen zukünftiger Beobachtungen bei x enthält.

mu — Zentrierungs- und Skalierungswerte

Vektor mit zwei Elementen

Zentrierungs- und Skalierungswerte, die als Vektor mit zwei Elementen zurückgegeben werden. mu(1) ist mean(x) und mu(2) ist std(x). Diese Werte zentrieren die Abfragepunkte in x bei null mit einer Standardabweichung der Einheiten.

Verwenden Sie mu als vierte Eingabe in polyval, um p an den skalierten Punkten (x - mu(1))/mu(2) auszuwerten.

Einschränkungen

• Bei Problemen mit vielen Punkten führt die Erhöhung des Grades der polynomialen Anpassung mithilfe von polyfit nicht immer zu einer besseren Anpassung. Polynome hoher Ordnung können zwischen den Datenpunkten oszillieren und zu einer schlechteren Anpassung an die Daten führen. In diesen Fällen können Sie abhängig vom Problem eine polynomiale Anpassung niedriger Ordnung (die in der Regel zwischen den Punkten glatter ist) oder eine andere Technik verwenden.

• Polynome sind naturgemäß unbeschränkte, oszillatorische Funktionen. Daher sind sie nicht besonders gut für die Extrapolation begrenzter oder monotoner (ansteigend oder abfallend) Daten geeignet.

Algorithmen

polyfit verwendet x, um die Vandermonde-Matrix V mit n+1 Spalten und m = length(x) Zeilen zu bilden, die das folgende lineare System ergibt,

$$\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),$$

das polyfit mit p = V\y löst. Da die Spalten in der Vandermonde-Matrix Potenzen des Vektors x sind, ist die Konditionszahl von V für Anpassungen hoher Ordnung oft groß, sodass sich eine singuläre Koeffizientenmatrix ergibt. In diesen Fällen können die numerischen Eigenschaften des Systems durch Zentrierung und Skalierung verbessert werden, sodass die Anpassung zuverlässiger wird.

Erweiterte Fähigkeiten

Tall Arrays

Rechnen mit Arrays, die mehr Zeilen haben, als in den Speicher passen.

Hinweise zur Verwendung und Einschränkungen:

X und Y müssen Spaltenvektoren sein.

Weitere Informationen finden Sie unter Tall-Arrays.

C/C++ Codegenerierung

Generieren Sie C und C++ Code mit MATLAB® Coder™.

Hinweise zur Verwendung und Einschränkungen:

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

Thread-Based Environment

Führen Sie mithilfe von MATLAB® backgroundPool den Code im Hintergrund aus oder machen Sie den Code mit der Parallel Computing Toolbox™ ThreadPool schneller.

Diese Funktion bietet vollständige Unterstützung für thread-basierte Umgebungen. Weitere Informationen finden Sie unter Run MATLAB Functions in Thread-Based Environment.

GPU-Arrays

Schnellere Codeausführung durch Ausführen auf einer Grafikkarte (GPU) mit der Parallel Computing Toolbox™.

Diese Funktion bietet vollständige Unterstützung für Grafikkarten-Arrays. Weitere Informationen finden Sie unter Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Verteilte Arrays

Partitionieren von großen Arrays über den kombinierten Speicher Ihres Clusters mit Parallel Computing Toolbox™.

Diese Funktion bietet vollständige Unterstützung für verteilte Arrays. Weitere Informationen finden Sie unter Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Versionsverlauf

Eingeführt vor R2006a

Siehe auch

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

Themen

• Programmatic Fitting