polyfit

Ajuste polinomial de curvas

Sintaxis

p = polyfit(x,y,n)

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

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

Descripción

p = polyfit(x,y,n) devuelve los coeficientes de un polinomio p(x) de grado n que mejor encajen (o que tengan los mínimos cuadrados) con los datos de y. Los coeficientes de p están en potencias descendentes y la longitud de p es n+1 donde

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

[p,S] = polyfit(x,y,n) también devuelve una estructura S que se puede utilizar como entrada en polyval para obtener cálculos de error.

[p,S,mu] = polyfit(x,y,n) realiza centrado y escalado para mejorar las propiedades numéricas tanto del polinomio como del algoritmo de ajuste. Esta sintaxis además devuelve mu, que es un vector de dos elementos con valores de centrado y escalado. mu(1) es mean(x) y mu(2) es std(x). Con estos valores, polyfit centra x en cero y lo escala a la desviación estándar de unidad,

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

Ejemplos

Ajustar un polinomio a la función trigonométrica

Genere 10 puntos equidistantes en una curva sinusoidal del intervalo [0,4*pi].

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

Utilice polyfit para ajustar un polinomio de 7 grados a los puntos.

p = polyfit(x,y,7);

Evalúe el polinomio en una cuadrícula más estrecha y represente los resultados.

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

Ajustar un polinomio a un grupo de puntos

Cree un vector de 5 puntos equidistantes en el intervalo [0,1] y evalúe $$y(x)=(1+x{)}^{-1}$$ en esos puntos.

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

Ajuste un polinomio de grado 4 a los 5 puntos. En general, si hay n puntos puede ajustar un polinomio de grado n-1 para que se adapte de forma exacta a los puntos.

p = polyfit(x,y,4);

Evalúe la función original y el ajuste polinomial en una cuadrícula más estrecha de puntos entre 0 y 2.

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

Represente los valores de la función y el ajuste polinomial en el intervalo [0,2] más amplio, con los puntos utilizados para obtener el ajuste polinomial destacados como círculos. El ajuste polinomial es correcto en el intervalo [0,1] original, pero difiere rápidamente de la función ajustada fuera de ese intervalo.

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

Ajustar un polinomio a una función de error

En primer lugar, genere un vector de x puntos equidistantes en el intervalo [0,2.5] y, después, evalúe erf(x) en esos puntos.

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

Determine los coeficientes del polinomio aproximador de grado 6.

p = polyfit(x,y,6)

p = 1×7

    0.0084   -0.0983    0.4217   -0.7435    0.1471    1.1064    0.0004

Para comprobar si el ajuste es correcto, evalúe el polinomio en los puntos de datos y genere una tabla que muestre los datos, el ajuste y el error.

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
      ⋮

En este intervalo, los valores interpolados y los valores reales se aproximan bastante. Cree una gráfica para ver cómo, fuera de este intervalo, los valores extrapolados difieren rápidamente de los valores reales.

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

Usar el centrado y el escalado para mejorar las propiedades numéricas

Cree una tabla con datos de población de los años 1750 a 2000 y represente los puntos de datos.

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

Utilice polyfit con tres salidas para ajustar un polinomio de grado 5 utilizando el centrado y el escalado, lo que mejora las propiedades numéricas del problema. polyfit centra los datos de year en 0 y los escala hasta alcanzar una desviación estándar de 1, con lo que se evita una matriz de Vandermonde mal condicionada en el cálculo del ajuste.

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

Utilice polyval con cuatro entradas para evaluar p con los años escalados, (year-mu(1))/mu(2). Represente los resultados con respecto a los años originales.

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

Regresión lineal simple

Ajuste un modelo de regresión lineal simple a un grupo de puntos de datos 2D discretos.

Cree unos pocos vectores de puntos de datos (x,y) de ejemplo. Ajuste un polinomio de primer grado a los datos.

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

Evalúe el polinomio p ajustado en los puntos de x. Represente el modelo de regresión lineal resultante con los datos.

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

Regresión lineal con estimación de errores

Ajuste un modelo lineal a un grupo de puntos de datos y represente los resultados, incluido un cálculo de un intervalo de predicción del 95%.

Cree unos pocos vectores de puntos de datos (x,y) de ejemplo. Utilice polyfit para ajustar un polinomio de primer grado a los datos. Especifique dos salidas para devolver los coeficientes del ajuste lineal, así como la estructura de estimación de errores.

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

p = 1×2

   -0.3142    0.9614

S = struct with fields:
           R: [2×2 double]
          df: 98
       normr: 22.7673
    rsquared: 0.9407

Evalúe el ajuste polinomial de primer grado de p en los puntos de x. Especifique la estructura de estimación de errores como la tercera entrada, para que polyval calcule una estimación del error estándar. La estimación del error estándar se devuelve en delta.

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

Represente los datos originales, el ajuste lineal y un intervalo de predicción $\mathit{y}\pm 2\Delta$ del 95%.

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

Argumentos de entrada

x — Puntos de consulta

vector

Puntos de consulta, especificados como vector. Los puntos de x se corresponden con los valores ajustados de la función que contiene y. Si x no es un vector, polyfit lo convierte en un vector columna x(:).

Aparecen mensajes de advertencia cuando x tiene puntos repetidos (o casi repetidos) o si x necesita centrado y escalado.

Tipos de datos: single | double
Soporte de números complejos: Sí

y — Valores ajustados en puntos de consulta

vector

Valores ajustados en puntos de consulta, especificados como vector. Los valores de y se corresponden con los puntos de consulta que contiene x. Si y no es un vector, polyfit lo convierte en un vector columna y(:).

Tipos de datos: single | double
Soporte de números complejos: Sí

n — Grado de ajuste polinomial

escalar entero positivo

Grado de ajuste polinomial, especificado como escalar entero positivo. n especifica la potencia polinomial del coeficiente situado a la izquierda del todo de p.

Argumentos de salida

p — Coeficientes polinomiales con ajuste de mínimos cuadrados

vector

Coeficientes polinomiales con ajuste de mínimos cuadrados, devueltos como vector. p presenta la longitud n+1 y contiene los coeficientes polinomiales en potencias descendentes; la potencia más alta es n. Si x o y contienen valores NaN y n < length(x), todos los elementos de p son NaN. Si especifica tres argumentos de salida para centrar y escalar los datos, entonces polyfit devuelve diferentes coeficientes en p, comparados con las situaciones en que los datos no están centrados o escalados.

Utilice polyval para evaluar p en los puntos de consulta.

S — Estructura de estimación de errores

estructura

Estructura de estimación de errores Esta estructura de salida opcional se utiliza sobre todo como entrada de la función polyval para obtener estimaciones de errores. S contiene los campos en esta tabla.

Campo	Descripción
R	Factor triangular R (posiblemente permutado) de una descomposición QR de la matriz de Vandermonde de x
df	Grados de libertad
normr	Norma de los residuos
rsquared	Coeficiente de determinación o R al cuadrado (sin ajustar)

Si los datos de y son aleatorios, una estimación de la matriz de covarianzas de p es (Rinv*Rinv')*normr^2/df, en la que Rinv es la inversa de R.

Si los errores de los datos de y son independientes y normales con varianza constante, [y,delta] = polyval(...) produce límites de error que contienen al menos el 50% de las predicciones. Es decir, que y ± delta contiene al menos el 50% de las predicciones de las observaciones futuras de x.

mu — Valores de centrado y escalado

vector de dos elementos

Valores de centrado y escalado, devueltos como vector de dos elementos. mu(1) es mean(x) y mu(2) es std(x). Estos valores centran los puntos de consulta de x en cero con una desviación estándar de unidad.

Utilice mu como cuarta entrada de polyval para evaluar p en los puntos escalados, (x - mu(1))/mu(2).

Limitaciones

• Si hay problemas con muchos puntos, aumentar el grado de ajuste polinomial con polyfit no siempre tiene como resultado un mejor ajuste. Los polinomios de orden alto pueden oscilar entre los puntos de datos, lo que provoca un peor ajuste a los datos. En esos casos, puede usar un ajuste polinomial de menor orden (que tiende a resultar más suave entre puntos) u otra técnica, según el problema.

• Los polinomios son funciones desacotadas y oscilatorias por naturaleza. Por lo tanto, no son muy adecuados para extrapolar datos acotados o monotónicos (ascendentes o descendentes).

Algoritmos

polyfit usa x para formar una matriz de Vandermonde V con n+1 columnas y m = length(x) filas, lo que tiene como resultado un sistema lineal

$$\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 resuelve con p = V\y. Puesto que las columnas de la matriz de Vandermonde son potencias del vector x, el número de condición de V suele ser mayor en los ajustes de orden alto, lo que tiene como resultado una matriz de coeficientes singular. En esos casos, el centrado y el escalado pueden mejorar las propiedades numéricas del sistema para obtener un ajuste más fiable.

Capacidades ampliadas

Arreglos altos

Realice cálculos con arreglos que tienen más filas de las que caben en la memoria.

La función polyfit es compatible con arreglos altos con las siguientes notas y limitaciones de uso:

X e Y deben ser vectores columna.

Para obtener más información, consulte Arreglos altos.

Generación de código C/C++

Genere código C y C++ mediante MATLAB® Coder™.

Notas y limitaciones de uso:

• Para los argumentos de entrada x e y:

  • Debe especificar el vector de entrada como un vector de tamaño fijo o de longitud variable en el tiempo de generación del código. La primera o la segunda dimensión del vector pueden ser de tamaño variable. El resto de dimensiones debe tener un tamaño fijo de 1.

Entorno basado en subprocesos

Ejecute código en segundo plano con MATLAB® backgroundPool o acelere código con Parallel Computing Toolbox™ ThreadPool.

Esta función es totalmente compatible con entornos basados en subprocesos. Para obtener más información, consulte Ejecutar funciones de MATLAB en entornos basados en subprocesos.

Arreglos GPU

Acelere código mediante la ejecución en una unidad de procesamiento gráfico (GPU) mediante Parallel Computing Toolbox™.

La función polyfit es totalmente compatible con los arreglos de GPU. Para ejecutar la función en una GPU, especifique los datos de entrada como un gpuArray (Parallel Computing Toolbox). Para obtener más información, consulte Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Arreglos distribuidos

Realice particiones de arreglos grandes por toda la memoria combinada de su cluster mediante Parallel Computing Toolbox™.

Esta función es totalmente compatible con los arreglos distribuidos. Para obtener más información, consulte Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Historial de versiones

Introducido antes de R2006a

R2024a: La estructura de estimación de errores incluye el valor de R al cuadrado

Cuando devuelva la estructura de estimación del error S como una segunda salida, la estructura incluye el campo rsquared. rsquared es el coeficiente de determinación o el valor de R al cuadrado (sin ajustar). Utilice S con la función polyval para obtener las estimaciones de errores.

Consulte también

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

Temas

• Ajuste programático