PRACTICA # 3
Ajuste de curvas (Polinomios de regresión),
Interpolación de Newton, Interpolación de
Lagrange.

Resumen — En esta presente práctica vamos a realizar una breve
introducción teoría para cada método con el objetivo de tener
más claro el tema, para luego llevar a cabo la programación en
matlab de los diferentes métodos de ajuste de curvas,
interpolación de newton e interpolación de Lagrange con su
explicación respectiva de cada método.
Abstract— In this present practice we will make a brief
introduction theory for each method in order to have clearer the
subject, and then carry out programming in matlab of different
methods of curve fitting, interpolation newton and interpolation
of Lagrange with their respective explanation of each method.
Palabras claves—Interpolación, regresión, matlab.
I. INTRODUCCIÓN
U N problema que se presenta con frecuencia en las
ciencias experimentales y en ingeniería es tratar de
construir una función (denominada “función interpolante”) de
la que se conoce una serie de datos (denominados “datos de
interpolación”). Estos datos pueden ser fruto de las
observaciones realizadas en un determinado experimento en el
que se relacionan dos o más variables e involucran valores de
una función y/o de sus derivadas.
Es una forma de regresión lineal en el que la relación entre la
variable independiente x y la variable dependiente Y se
modela como un polinomio de orden n. Regresión polinómica
se ajusta a una relación no lineal entre el valor de x y la media
condicional correspondiente de y, denotado E, y se ha
utilizado para describir los fenómenos no lineales.
El objetivo será determinar una función que verifique estos
datos y que además sea fácil de construir y manipular. Por su
sencillez y operatividad los polinomios se usan
frecuentemente como funciones interpolantes. [1]
1
II. MARCO TEÓRICO
 REGRESIÓN POLINOMIAL
El procedimiento de mínimos cuadrados se puede extender
fácilmente al ajuste de datos con un polinomio de grado
superior. Por ejemplo, suponga que ajustamos un polinomio
de segundo grado o cuadrático: [1]
𝑦 = 𝑎0 + 𝑎1 𝑥 + 𝑎2 𝑥 2 + 𝑒
En este caso, la suma de los cuadrados de los residuos es
𝑆𝑟 = ∑𝑛𝑖=1(𝑦𝑖 − 𝑎0 − 𝑎1 𝑥𝑖 − 𝑎2 𝑥𝑖2 )2 [1]
Al seguir el procedimiento, obtenemos la derivada de la
ecuación [1] con respecto a cada uno de los coeficientes
desconocidos del polinomio,
𝜕𝑆𝑟
= −2 ∑(𝑦𝑖 − 𝑎0 − 𝑎1 𝑥𝑖 − 𝑎2 𝑥𝑖2 )
𝜕𝑎0
𝜕𝑆𝑟
= −2 ∑ 𝑥𝑖 (𝑦𝑖 − 𝑎0 − 𝑎1 𝑥𝑖 − 𝑎2 𝑥𝑖2 )
𝜕𝑎1
𝜕𝑆𝑟
= −2 ∑ 𝑥𝑖2 (𝑦𝑖 − 𝑎0 − 𝑎1 𝑥𝑖 − 𝑎2 𝑥𝑖2 )
𝜕𝑎2
Estas ecuaciones se igualan a cero y se reordenan para
desarrollar el siguiente conjunto de ecuaciones normales:
(𝑛)𝑎0 + (∑ 𝑥𝑖 )𝑎1 + (∑ 𝑥𝑖2 )𝑎2 = ∑ 𝑦𝑖
(∑ 𝑥𝑖 )𝑎0 + (∑ 𝑥𝑖2 )𝑎1 + (∑ 𝑥𝑖3 )𝑎2 = ∑ 𝑥𝑖 𝑦𝑖 [2]
(∑ 𝑥𝑖2 )𝑎0 + (∑ 𝑥𝑖3 )𝑎1 + (∑ 𝑥𝑖4 )𝑎2 = ∑ 𝑥𝑖2 𝑦𝑖
Donde todas las sumatorias van desde i = 1 hasta n. Observe
que las tres ecuaciones anteriores son lineales y tienen tres
incógnitas: 𝑎0 , 𝑎1 𝑦 𝑎2 . Los coeficientes de las incógnitas se
evalúan de manera directa, a partir de los datos observados
En este caso, el error estándar se formula como sigue: [2]
PRACTICA # 3 2

 POLINOMIOS DE INTERPOLACIÓN DE
𝑆𝑟
𝑆𝑦⁄𝑥 =√ [3] LAGRANGE
𝑛 − (𝑚 + 1)
El polinomio de interpolación de Lagrange es simplemente
 INTERPOLACIÓN DE NEWTON MEDIANTE una reformulación del polinomio de Newton que evita el
DIFERENCIAS DIVIDIDAS cálculo de las diferencias divididas, y se representa de manera
Existe una gran variedad de formas alternativas para expresar concisa como[1]
una interpolación polinomial. El polinomio de interpolación
de Newton en diferencias divididas.
𝑛

Ejemplos de interpolación polinomial: a) de primer grado 𝑓𝑛 (𝑥) = ∑ 𝐿𝑖 (𝑥)𝑓(𝑥𝑖 ) [5]

(lineal) que une dos puntos, b) de segundo grado (cuadrática o 𝑖=0
parabólica) que une tres puntos y c) de tercer grado (cúbica)
que une cuatro puntos. [1]
Donde
𝑛
𝑥 − 𝑥𝑗
𝐿𝑖 (𝑥) = ∏
𝑥𝑖 − 𝑥𝑗
𝑗=0
𝑗≠𝑖

Donde ∏ designa el “producto de”. Por ejemplo, la versión

lineal (n = 1) es

𝑥 − 𝑥1 𝑥 − 𝑥0
Ilustración 1 De hecho se puede probar que dados n + 1 puntos, con 𝑓1 (𝑥) = 𝑓(𝑥0 ) + 𝑓(𝑥1 ) [6]
abscisas distintas entre sí, existe uno y sólo un polinomio de grado a 𝑥0 −𝑥1 𝑥1 − 𝑥0
lo más n que pasa por estos puntos.
Y la versión de segundo grado es
La forma más simple de interpolación consiste en unir dos
puntos con una línea recta. Dicha técnica, llamada (𝑥 − 𝑥1 )(𝑥 − 𝑥2 )
interpolación lineal, se ilustra de manera gráfica en la 𝑓2 (𝑥) = 𝑓(𝑥0 )
(𝑥0 − 𝑥1 )(𝑥0 − 𝑥2 )
ilustración 2 Utilizando triángulos semejantes, (𝑥 − 𝑥0 )(𝑥 − 𝑥2 )
+ 𝑓(𝑥1 )
(𝑥1 − 𝑥0 )(𝑥1 − 𝑥2 )
𝑓1 (𝑥) − 𝑓(𝑥0 ) 𝑓(𝑥1 ) − 𝑓(𝑥0 ) (𝑥 − 𝑥0 )(𝑥 − 𝑥1 )
= + 𝑓(𝑥2 ) [7]
𝑥 − 𝑥0 𝑥1 − 𝑥0 (𝑥2 − 𝑥0 )(𝑥2 − 𝑥1 )
Reordenándose se tiene

𝑓(𝑥1 ) − 𝑓(𝑥0 )
𝑓1 (𝑥) = 𝑓(𝑥0 ) + (𝑥 − 𝑥0 ) [4]
𝑥1 − 𝑥0

III. DESARROLLO

REGRESIÓN POLINOMIAL

clear all
clc
disp('----Regresión Polinomial----')
disp(' ')
disp(' ')
syms x Px
disp('Para obtener un polinomio de la forma:')
Ilustración 2 Esquema gráfico de la interpolación lineal. Las áreas
sombreadas indican los triángulos semejantes usados para obtener la disp('P(x)=a0 + a1*x +a2*x^2 +...+ anx^n')
fórmula de la interpolación lineal. disp('Dado los n+1 puntos')
disp(' ')
disp(' ')
PRACTICA # 3 3

X=input('Ingrese los valores de X de la forma [...] \n') b=zeros(n);

Y=input('Ingrese los valores de Y de la forma [...] \n') b(:,1)=X(:).^0;
plot (X,Y,'xk') disp('Matriz de coeficientes de (a0, a1,...,an)t')
%Calcular el número de datos for j=2:(n)
n=length(X) b(:,j)=X(:).^(j-1);
b=zeros(n); end
b(:,1)=X(:).^0; procederá entonces obtener los Valores de an y
disp('Matriz de coeficientes de (a0, a1,...,an)t') consecuentemente evaluara la matriz antes mencionada y
for j=2:(n) precederá a resolver el sistema de ecuaciones obtenido todo
b(:,j)=X(:).^(j-1); esto se lleva acabo gracias a los siguientes comandos:
end a=b
%obtiene los valores de an disp('Inversa de la matriz de coeficientes')
a=b c=a^-1
disp('Inversa de la matriz de coeficientes') disp('Solucion del sistema de ecuaciones')
c=a^-1 A=c*Y'
disp('Solucion del sistema de ecuaciones') Luego de que el programa allá resuelto la ecuación procederá
A=c*Y' a formar el polinomio de regresión. Y graficara los puntos
%CONTRUIR EL POLINOMIO dados para comprobar que el polinomio se cumple en la
B=A'; gráfica. Por lo tanto
XX(1,1)=x^0; disp('Polinomio de interpolación')
for i=2:n ZZ=XX;
XX(1,1)=x.^(i-1); disp('Polinomio de la forma [anx^n +an-1x^(n-1) +...+ a0]')
end P=(B.*ZZ);
disp('Polinomio de interpolacion') Px=(sum(P));
ZZ=XX; disp('Px=')
disp('Polinomio de la forma [anx^n +an-1x^(n-1) +...+ a0]') format short
P=(B.*ZZ); pretty(Px)
Px=(sum(P)); disp('la variable de uso es "x"')
disp('Px=') disp(' ')
format short x=input('ingrese el valor de "x" a interpolar\n')
pretty(Px) disp('valor interpolado')
disp('la variable de uso es "x"') Y=subs(Px,x)
disp(' ') hold on
x=input('ingrese el valor de "x" a interpolar\n') G=X(1,1)-1:0.02:X(1,n)+1;
disp('valor interpolado') H=zeros(size(G));
Y=subs(Px,x) plot(G,H,'r')
hold on ezplot(Px,[X(1,1)-1,X(1,n)+1])
G=X(1,1)-1:0.02:X(1,n)+1;
H=zeros(size(G));
plot(G,H,'r')
ezplot(Px,[X(1,1)-1,X(1,n)+1])
plot(x,Y,'or') INTERPOLACIÓN DE NEWTON MEDIANTE DIFERENCIAS
xlabel(x) DIVIDIDAS
grid on
clear all
EXPLICACION REGRESION POLINOMIAL. clc
Clear all , clc nos permitirá borrar datos de la ventana para disp('Interpolacion de Newton');
poder trabajar en una ventana limpia. disp('interpolacion');
A continuación el programa nos dará a conocer la forma del n=input('ingrese el grado del polinomio, n=');
polinomio de regresión y procederá a pedirnos los valores de fprintf('Se necesitan %.0f puntos\n',n+1);
los puntos tanto en X como en Y con los siguientes comandos: disp('ingrese los puntos');
disp('P(x)=a0 + a1*x +a2*x^2 +...+ anx^n') for i=1:n+1
disp('Dado los n+1 puntos') fprintf('x%.0f=',i-1);
disp(' ') X(i)=input(' ');
disp(' ') fprintf('y%.0f=',i-1);
X=input('Ingrese los valores de X de la forma [...] \n') Y(i)=input(' ');
Y=input('Ingrese los valores de Y de la forma [...] \n') end
Procederá entonces a calcular el numero de datos para formar DD=zeros(n+1);
la matriz de coeficientes: DD(:,1)=Y;
n=length(X) for k=2:n+1
PRACTICA # 3 4

for J=k:n+1 end

DD(J,k)=[DD(J,k-1)-DD(J-1,k-1)]/[X(J)-X(J-k+1)]; yn=[];
end for i=1:n+1
end l=input('Ingrese los puntos en (y) =');
disp('La matriz de diferencias divididas es:'); yn=[yn,l];
disp(DD); end
disp('El polinomio de newton es'); plot(xn,yn)
syms x; grid on
polnew=DD(1,1); f=0;
P=1; for i=1:n+1
for i=1:n L=1;
P=P*(x-X(i)); for j=1:n
polnew=polnew+P*DD(i+1,i+1); if j~=i
end L=L*(x-xn(j))/(xn(i)-xn(j));
polnew=expand(polnew); end
pretty(polnew); end
x=input('ingrese el valor de x a interpolar,x='); f=f+L*yn(i);
vi=eval(polnew); end
fprintf('el valor interpolado es %.2f\n',vi); f=simplify(f);
hold on; display('el polinomio interpolado de langrage es=')
grid on; display(f)
ezplot(polnew,[X(1) X(n+1)]); hold on
plot(x,vi,'r+'); a=ezplot(x,f,[k(1) k(n)]);
axis ([x:y])
EXPLICACION INTERPOLACION DE NEWTON. set(a,'Color','r')
Clc all nos permite borrar los datos de la ventana para poder hold off
seguir trabajando.
n=input('ingrese el grado del polinomio, n='); el programa EXPLICACIÓN POLINOMIO DE LAGRANGE.
comenzara pidiéndonos el grado del polinomio a interpolarse Clc all nos sirve para borrar los datos de la pantalla y poder
por el método de Diferencias Divididas, trabajar.
Luego nos mostrara un mensaje que nos diga el número de n= input('Ingrese el grado del polinomio: '); este comando nos
puntos a ingresarse y procederá a pedirnos la cantidad de pide ingresar el grado del polinomio el cual vamos a
dichos puntos antes mencionados con el siguiente comando interpolar.
dado a continuación: Luego de haber ingresado el grado del polinomio a interpolar
fprintf('Se necesitan %.0f puntos\n',n+1); el programa nos pedirá los puntos en x del polinomio
disp('ingrese los puntos'); mediante el comando dado que es:
Entonces procederá a evaluar los puntos mediante diferencias for i=1:n+1
divididas; k(i)=input('Ingrese los puntos en (x) =');
DD=zeros(n+1); xn=[xn,k(i)];
DD(:,1)=Y; end
for k=2:n+1 yn=[];
for J=k:n+1 Luego los puntos en y del polinomio.
DD(J,k)=[DD(J,k-1)-DD(J-1,k-1)]/[X(J)-X(J-k+1)]; for i=1:n+1
end l=input('Ingrese los puntos en (y) =');
end yn=[yn,l];
Terminados una vez los procedidmientos anteriores evaluado end
y formada nuestra matriz dividida nos mostrara la misma plot(xn,yn)
matriz mencionada y también a continuación el polinomio de grid on
Interpolación de Newton. f=0;
y comenzara a evaluar e interpolar el polinomio.
INTERPOLACIÓN DE LAGRANGE for i=1:n+1
clear all L=1;
clc for j=1:n
display('Interpolación de Lagrange') if j~=i
syms x L=L*(x-xn(j))/(xn(i)-xn(j));
n= input('Ingrese el grado del polinomio: '); end
xn=[]; end
for i=1:n+1
k(i)=input('Ingrese los puntos en (x) ='); f=simplify(f); nos simplificara el polinomio
xn=[xn,k(i)]; display('el polinomio interpolado de langrage es=')
PRACTICA # 3 5

display(f) , luego el programa nos mostrara el polinomio REFERENCIAS

interpolado, posteriormente su grafica con el comando
siguiente; a=ezplot(x,f,[k(1) k(n)]);
IV. CONCLUSIONES
 Se determinó y constato que el método numérico de
Regresión polinomial es una herramienta para
investigar la dependencia de una variable
dependiente y en función de una variable
independiente x. y = f(x)
[𝟏] CHAPRA, Steven C. Canale, et al. Métodos numéricos
para ingenieros. McGraw-Hill,, 2007.
[𝟐] MATHEWS, John H.; FINK, Kurtis D. Métodos
numéricos con Matlab. Prentice Hall, 2000.
[𝟑] NAKAMURA, Shoichiro. Métodos numéricos aplicados
con software. Mexico: Prentice-Hall Hispanoamericana, 1992.

 El aumento de grado no siempre mejora la

aproximación.
 El polinomio de interpolación suele usarse para
estimar valores de una función tabulada, en las  NOTA: los estudiantes: Aguirre Fabián, Franco
abscisas que no aparecen en la tabla en la cual Muñoz, Tulcán Andrés No colaboran en el informe.
utilizamos una programación en matlab para llegar a
la solución mucho más rápido.