polyfit

R2026b

Polynomiale Kurvenanpassung

Syntax

coeffs = polyfit(x,y,n)

[coeffs,fitStats] = polyfit(x,y,n)

[coeffs,fitStats,centerScale] = polyfit(x,y,n,Normalize=tf)

Beschreibung

coeffs = polyfit(x,y,n) gibt die Koeffizienten für ein Polynom p(x) n. Grades zurück, das im Sinne kleinster Quadrate am besten zu den Daten in y passt, wobei das entstehende Polynom

$$p(x)=\mathrm{coeffs}(1)\cdot x^n+\mathrm{coeffs}(2)\cdot x^{n-1}+\mathrm{...}+\mathrm{coeffs}(n)\cdot x+\mathrm{coeffs}(n+1).$$

entspricht.

[coeffs,fitStats] = polyfit(x,y,n) gibt zudem geeignete Statistiken zurück, mit denen sich der Prognosefehler mithilfe der polyval-Funktion einschätzen lässt.

[coeffs,fitStats,centerScale] = polyfit(x,y,n,Normalize=tf) bietet die Option zur Normalisierung, sofern passend. Wenn Sie Normalize auf true festlegen, zentriert polyfit x bei 0 und skaliert den Wert so, dass er der Transformation $$\widehat{x}=\frac{x-\overline{x}}{{\sigma }_x}.$$ entsprechend eine Standardabweichung von 1 aufweist. In diesem Fall gibt polyfit zudem die Ausgabe centerScale als Vektor mit zwei Elementen zurück, der die Mittel- und Skalierungswerte mean(x) und std(x) enthält. Wenn Sie Normalize auf false festlegen, wandelt polyfit x und centerScale nicht in einen Vektor mit zwei Elementen um, der 0 und 1 enthält. (seit R2026b)

Vor R2026b: Die Normalisierung wird implizit durch die Anzahl der Ausgabeargumente gesteuert. Durch Zurückgabe eines dritten Ausgabearguments wird die Normalisierung automatisch aktiviert. Weitere Informationen dazu finden Sie unter Versionsverlauf.

Beispiele

Einfache lineare Regression

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

Erstellen Sie zwei 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); 
coeffs = polyfit(x,y,1); 

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

f = polyval(coeffs,x);

plot(x,y,"o")
hold on
plot(x,f)
legend("Sample data","First-degree polynomial")
hold off

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 ein Polynom 7. Grades an die Daten an.

coeffs = polyfit(x,y,7);

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

x2 = linspace(0,4*pi);
yfit = polyval(coeffs,x2);

plot(x,y,"o")
hold on
plot(x2,yfit)
legend("Sample data","Seventh-degree polynomial")
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\left(x\right)=\frac{1}{1+x}$ an diesen Punkten aus.

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

Passen Sie ein Polynom 5. Grades an die Daten 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.

coeffs = polyfit(x,y,4);

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

x2 = linspace(0,2);
yfcn = 1./(1+x2);
yfit = polyval(coeffs,x2);

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 ursprünglichen Funktion ab.

plot(x,y,"o")
hold on
plot(x2,yfcn)
plot(x2,yfit,"--")
legend("Sample data","1/(1+x)","Fourth-degree polynomial")
hold off

Anpassen eines Polynoms an die Fehlerfunktion

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

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

Passen Sie ein Polynom 6. Grades an die Daten an.

coeffs = polyfit(x,y,6)

coeffs = 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.

yfit = polyval(coeffs,x);
T = table(x,y,yfit,y-yfit,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 liegen die interpolierten Werte und die tatsächlichen Werte recht nahe beieinander. Erstellen Sie ein Diagramm, um darzustellen, dass die extrapolierten Werte außerhalb dieses Intervalls schnell von den tatsächlichen Daten abweichen.

x2 = (0:0.1:5)';
fcnextrap = erf(x2);
fitextrap = polyval(coeffs,x2);

plot(x,y,"o")
hold on
plot(x2,fcnextrap)
plot(x2,fitextrap,"--")
xlim([0 5])
legend("Sample data","erf(x)","Sixth-degree polynomial")
hold off

Normalisieren der Daten zum Verbessern der numerischen Konditionierung

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

x = 1750:25:2000;
y = 1e6*[791 856 978 1050 1262 1544 1650 2532 6122 8170 11560];

Passen Sie mithilfe von polyfit ein Polynom 5. Grades an die Punkte an. Sie können die numerische Konditionierung verbessern, indem Sie vor dem Anpassen des Polynoms den Abfragevektor normalisieren. In diesem Beispiel werden die year-Daten normalisiert und es wird ein angepasstes Polynom 5. Grades berechnet. Die Funktion gibt außerdem die für die Normalisierung verwendeten Mittel- und Skalierungswerte zurück.

[coeffsNorm,~,centerScale] = polyfit(x,y,5,Normalize=true);

Normalisieren Sie die Abfragepunkte mit derselben Mitte und Skalierung und werten Sie das Polynom anschließend aus, indem Sie beim Aufrufen der polyval-Funktion centerScale angeben. Plotten Sie dann die Ergebnisse.

yfit = polyval(coeffsNorm,x,[],centerScale);

plot(x,y,"o")
hold on
plot(x,yfit)
legend("Sample data","Fifth-degree polynomial")
hold off

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 = 0:100; 
y = -0.3*x + 2*randn(1,101); 
[coeffs,fitStats] = polyfit(x,y,1);

Werten Sie das Polynom 1. Grades 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.

[yfit,delta] = polyval(coeffs,x,fitStats);

Plotten Sie die Originaldaten, die lineare Anpassung und das 95%-Vorhersageintervall $yfit\pm 2\Delta$.

plot(x,y,"o")
hold on
plot(x,yfit)

xinterval = [x flip(x)];
yinterval = [yfit-2*delta flip(yfit)+2*delta];
interval = fill(xinterval,yinterval,"yellow",FaceAlpha=0.2);

legend("Sample data","First-degree polynomial","95% prediction interval")
hold off

Eingabeargumente

x — Abfragepunkte

Vektor

Abfragepunkte, angegeben als Vektor. Die Abfragepunkte in x entsprechen den passenden Werten in y. Wenn x kein Vektor ist, konvertiert polyfit den Wert in einen Spaltenvektor x(:).

Eine falsch konditionierte Anpassung kann die Folge von (beinahe) wiederholten Abfragepunkten, Abfragepunkten mit zu großem Abstand oder eines zu hohen Polynomgrads sein. Fügen Sie eindeutige Abfragepunkte hinzu, normalisieren Sie die Daten durch Angabe von Normalize=true oder verringern Sie den Grad, um die Konditionierung zu verbessern.

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

y — Angepasste Werte an Abfragepunkten

Vektor

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

Datentypen: double | single
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 ersten Koeffizienten in coeffs an.

Eine falsch konditionierte Anpassung kann die Folge eines zu hohen polynomialen Grads sein. Verringern Sie den Grad, um die Konditionierung zu verbessern.

tf — Option zum Normalisieren von Abfragepunkten

true oder 1 | false oder 0

Seit R2026b

Option zum Normalisieren der Abfragepunkte in x vor der Anpassung, angegeben als einer der folgenden Werte für den Normalize-Parameter:

• true oder 1: Normalisiert die Abfragepunkte in x vor der Polynomanpassung durch Zentrierung bei 0 und Skalierung auf eine Standardabweichung von 1.

• false oder 0: Die Abfragepunkte in x werden vor Anpassen des Polynoms nicht normalisiert.

Wenn Sie die dritte Ausgabe centerScale angeben, verwendet polyfit standardmäßig Normalize=true. Andernfalls ist die Standardeinstellung Normalize=false.

Durch die Normalisierung wird die numerische Konditionierung verbessert, insbesondere im Fall von Polynomen höheren Grades oder Abfragepunkten mit zu großem Abstand.

Beispiel: [coeffs,~,centerScale] = polyfit(x,y,n,Normalize=true) normalisiert die Abfragepunkte in x, passt ein Polynom n. Grades an und gibt den Mittel- und Skalierungswert zusätzlich zu den polynomialen Koeffizienten der normalisierten Abfragepunkte zurück.

Ausgabeargumente

coeffs — Koeffizienten der polynomialen Anpassung nach der Kleinste-Quadrate-Methode

Vektor

Koeffizienten der polynomialen Anpassung nach der Kleinste-Quadrate-Methode, zurückgegeben als Vektor. coeffs hat die Länge n+1 und enthält die polynomialen Koeffizienten nach Potenz in absteigender Reihenfolge, wobei der höchste polynomiale Grad n ist.

Wenn x oder y mindestens einen NaN-Wert und n < length(x) enthalten, sind alle Elemente in coeffs NaN.

Sie können das durch coeffs dargestellte Polynom mithilfe von polyval auswerten. Wenn Sie polyfit mit Normalize=true aufrufen, enthält coeffs andere polynomiale Koeffizienten als beim Normalisieren der Daten. Bei normalisierten Daten müssen Sie zudem centerScale angeben, wenn Sie das Polynom mithilfe von polyval auswerten.

fitStats — Anpassungsstatistiken

Struktur

Anpassungsstatistiken, zurückgegeben als Struktur mit den folgenden Feldern.

Feld	Beschreibung
R	Dreiecksfaktor R (möglicherweise permutiert) aus einer QR-Zerlegung der Vandermonde-Matrix von x
df	Freiheitsgrad der Anpassung
normr	Euklidische Norm des Residuums
rsquared (seit R2024a)	Bestimmtheitskoeffizient (nicht angepasstes R-Quadrat)

Sie können mithilfe von fitStats mit polyval den Standardfehler bei der Prognose einer zukünftigen Beobachtung schätzen. Wenn Sie polyfit mit Normalize=true aufrufen, geben Sie centerScale zusätzlich zu fitStats an, wenn Sie polyval verwenden.

Verwenden Sie bei Zufallsdaten in y zur Schätzung der Kovarianz der polynomialen Koeffizienten (Rinv*Rinv')*normr^2/df, wobei Rinv die Inverse von R ist.

centerScale — Mittel- und Skalierungswerte

Vektor mit zwei Elementen

Mittel- und Skalierungswerte zur Normalisierung der Abfragepunkte in x, zurückgegeben als Vektor mit zwei Elementen.

• Wenn Sie Normalize=true angeben, entspricht centerScale(1) mean(x) und centerScale(2) entspricht std(x).

• Wenn Sie Normalize=false angeben, entspricht centerScale(1) 0 und centerScale(2) entspricht 1.

Wenn Sie das angepasste Polynom mithilfe derselben Normalisierung auswerten möchten, können Sie centerScale als vierte Eingabe von polyval angeben.

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 (einheitlich ansteigend oder einheitlich abfallend) Daten geeignet.

Algorithmen

polyfit verwendet x, um eine 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 coeffs = 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 Angabe von Normalize=true 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.

Die Funktion polyfit unterstützt Tall-Arrays mit folgenden Verwendungshinweisen 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:

• Für die Eingabeargumente x und y:

  • Sie müssen zum Zeitpunkt der Codegenerierung den Eingabevektor als Vektor mit fester Größe oder variabler Länge angeben. Entweder die erste oder die zweite Dimension des Vektors können eine variable Größe aufweisen. Alle anderen Dimensionen müssen die feste Größe 1 aufweisen.

GPU-Codegenerierung

Generieren von CUDA® Code für NVIDIA® Grafikprozessoren mit dem GPU Coder™.

Siehe die Verwendungshinweise und Einschränkungen im Abschnitt zur C/C++ Codegenerierung. Dieselben Verwendungshinweise und Einschränkungen gelten auch für die Grafikkarten-Codegenerierung.

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.

Die Funktion polyfit 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™.

Die Funktion polyfit bietet vollständige Unterstützung für Grafikkarten-Arrays. Zum Ausführen der Funktion auf einer Grafikkarte geben Sie die Eingabedaten als gpuArray (Parallel Computing Toolbox) an. 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™.

Die Funktion polyfit 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

R2026b: Explizite Steuerung der Normalisierung von Abfragepunkten

Geben Sie das Normalize-Argument an, um explizit zu steuern, ob polyfit die Abfragepunkte vor der Anpassung normalisiert.

Wenn Sie Normalize=true angeben, zentriert polyfit die Abfragepunkte bei 0 und skaliert sie so, dass sie einer Standardabweichung von 1 entsprechen. Erst dann erfolgt die Anpassung. Die zurückgegebenen polynomialen Koeffizienten und Anpassungsstatistiken beziehen sich auf die normalisierten Abfragepunkte $$\widehat{x}=\frac{x-\overline{x}}{{\sigma }_x}.$$

Bisher wurde die Normalisierung implizit durch die Anzahl der Ausgabeargumente gesteuert. Wenn Sie beispielsweise ein drittes Ausgabeargument festlegten, wie in [coeffs,~,centerScale] = polyfit(x,y,n), wurden die Abfragepunkte automatisch normalisiert. Diese Syntax wird weiterhin unterstützt. Die Verwendung von Normalize wird jedoch empfohlen, da das Normalisierungsverhalten durch sie expliziert wird und nicht mehr von der Anzahl der Ausgabeargumente abhängt.

R2024a: Die Fehlerschätzstruktur umfasst den R-Quadrat-Wert

Wenn Sie die Struktur der Anpassungsstatistiken fitStats als zweite Ausgabe zurückgeben, umfasst die Struktur das Feld rsquared. rsquared ist der Bestimmtheitskoeffizient oder der (nicht angepasste) R-Quadrat-Wert. Verwenden Sie fitStats und die polyval-Funktion, um Fehlerschätzungen zu ermitteln.

Siehe auch

Funktionen

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

Themen

• Programmatic Fitting
• Lineare Regression mit einer Prädiktorvariable