PROYECTO FINAL ELT-205
INTERPOLACIÓN POLINÓMICA EN LA FORMA DE LAGRANGE
I. INTRODUCCIÓN
En distintas ramas de la ciencia existen situaciones que se requiere encontrar una función que
verifique un conjunto de datos experimentales en un cierto intervalo de la variable
independiente y permita predecir la existencia de otros valores con la aproximación adecuada.
La interpolación polinómica en la forma de Lagrange es uno de los varios métodos que existen
para hallar una función a partir de un conjunto determinado de puntos. Se trata de una
reformulación del polinomio de interpolación de Newton que evita el cálculo de las diferencias
divididas.
II. OBJETIVO
Crear un programa informático que resuelva, haciendo uso de métodos numéricos, un problema
de análisis numérico.
III. MARCO TEÓRICO
En análisis numérico, el polinomio de Lagrange es una forma de presentar el polinomio que
interpola un conjunto de puntos dado. Fue publicado por Joseph-Louis de Lagrange en 1795,
pero descubierto por Edward Waring en 1779 y redescubierto más tarde por Leonhard Euler en
1783. Este método se define como sigue:
Dado un conjunto de k + 1 puntos
donde todos los xj se asumen distintos, el polinomio interpolador en la forma de Lagrange es la
combinación lineal
de bases polinómicas de Lagrange
Para todo i ≠ j, lj(x) incluye en el numerador el término (x - xi), de modo que el producto completo
valdrá cero en x = xi
Por otro lado,
En otras palabras, todas las bases polinómicas de Lagrange valen cero en x = xi excepto lj(x),
para el que aplica lj(xj) = 1, puesto que carece del término (x - xi) en el numerador.
Por tanto, se deriva que yjlj(xj) = yj, en cada punto xj, L(xj) = yi + 0 + 0 + … + 0 = yj
demostrando que L interpola la función de forma exacta.
Gráficamente, el interpolador de Lagrange genera una gráfica para cada lj y al final se obtiene la
función polinómica L(x) que es la suma de las gráficas generadas, obteniendo así una función
que pasa exactamente por todos los puntos dados inicialmente.
Existen varias desventajas al hacer uso de este método:
Si se aumenta el número de puntos a interpolar (o nodos) con la intención de mejorar la
aproximación a una función, también lo hace el grado del polinomio interpolador así
obtenido, por norma general. De este modo, aumenta la dificultad en el cálculo,
haciéndolo poco operativo manualmente a partir del grado 4, dado que no existen
métodos directos de resolución de ecuaciones de grado 4, salvo que se puedan tratar
como ecuaciones bicuadradas, situación extremadamente rara.
La tecnología actual permite manejar polinomios de grados superiores sin grandes
problemas, a costa de un elevado consumo de tiempo de computación. Pero, a medida
que crece el grado, mayores son las oscilaciones entre puntos consecutivos o nodos. Se
podría decir que a partir del grado 6 las oscilaciones son tal que el método deja de ser
válido, aunque no para todos los casos.
Sin embargo, pocos estudios requieren la interpolación de tan solo 6 puntos. Se suelen
contar por decenas e incluso centenas. En estos casos, el grado de este polinomio sería
tan alto que resultaría inoperable. Por lo tanto, en estos casos, se recurre a otra técnica
de interpolación, como por ejemplo a la Interpolación polinómica de Hermite o a los
splines cúbicos
Otra gran desventaja, respecto a otros métodos de interpolación, es la necesidad de
recalcular todo el polinomio si se varía el número de nodos.
El error del polinomio de interpolación viene definido por el siguiente teorema:
Sea una función -veces derivable. Si es el polinomio de interpolación
de en los puntos y , entonces:
donde .
IV. PROCEDIMIENTO
Se puede destacar cuatro etapas en todo el proceso del desarrollo del programa: primero se
tiene un código simple y poco versátil, en el que de acuerdo a los datos iniciales se debía editar
unas cuantas líneas del código para que la interpolación se realizase correctamente, se
presentaba en una tabla las bases polinómicas para cada iteración donde el valor de x va
creciendo de acuerdo a un incremento previamente establecido. La sintaxis, para cuatro pares
de datos iniciales, es:
x(1)=-6; x(2)=0; x(3)=4; x(4)=7;
f(1)=13.56; f(2)=-7.65; f(3)=-1.24; f(4)=87.97;
X(1)=-6;
n=1;
xi(1)=X;
while X<8
L0(n)=((X-x(2))*(X-x(3))*(X-x(4)))/((x(1)-x(2))*(x(1)-x(3))*(x(1)-x(4)));
L1(n)=((X-x(1))*(X-x(3))*(X-x(4)))/((x(2)-x(1))*(x(2)-x(3))*(x(2)-x(4)));
L2(n)=((X-x(1))*(X-x(2))*(X-x(4)))/((x(3)-x(1))*(x(3)-x(2))*(x(3)-x(4)));
L3(n)=((X-x(1))*(X-x(2))*(X-x(3)))/((x(4)-x(1))*(x(4)-x(2))*(x(4)-x(3)));
fn(n)=L0(n)*f(1)+L1(n)*f(2)+L2(n)*f(3)+L3(n)*f(4);
xi(n)=X;
X=X+1;
n=n+1;
end
Tabla=table(xi.',L0.',L1.',L2.',L3.',fn.','VariableNames',{'x' 'L0' 'L1' 'L2' 'L3'
'f(x)'});
disp(Tabla3)
En una segunda etapa fue conveniente la reducción y optimización del código, el programa iba
calculando automáticamente la cantidad de bases polinómicas necesarias en base a los datos
ingresados, la tabla de valores se generaba finalmente con un incremento de x definido
previamente. La sintaxis, para seis pares de datos, es la siguiente:
x(1)=1; x(2)=1.7; x(3)=2.9; x(4)=4; x(5)=4.5; x(6)=5;
f(1)=3; f(2)=5.17; f(3)=23.46; f(4)=36.45; f(5)=40.86; f(6)=44;
X=x(1)-1;
inc=0.1;
N=round((x(end)+1-X)/inc)
fxt=zeros(N,1);
xit=zeros(N,1);
Lt=zeros(N,length(x));
for k=1:N
S=0;
L=ones(1,length(x));
for i=1:length(x)
for j=1:length(x)
if i~=j
l=(X-x(j))/(x(i)-x(j));
L(i)=L(i)*l;
end
end
S=S+(f(i)*L(i));
end
Lt(k,:)=L;
fxt(k,1)=S;
xit(k,1)=X;
X=X+inc;
end
t = [xit, Lt, fxt];
Tabla = table(xit,Lt,fxt,'VariableNames',{'x' 'L' 'f(x)'});
Hasta este punto solo se tiene un interpolador que mediante la forma de Lagrange genera una
tabla con los valores que corresponden a un x que varía con un incremento constante, así que
la tercera etapa consiste en modificar el programa y que tome a x como una variable en todo
momento y, de acuerdo al número de datos, genere la función polinómica y la simplifique para
mostrarla al usuario, además, se añade la posibilidad de mostrar la gráfica de la función
obtenida.
La aplicación funcionaba perfectamente dentro de MATLAB, pero ocurría un problema al
momento de crear la aplicación de escritorio, por lo que fue necesario cambiar el modificar el
código, pero que produjera los mismos resultados.
Todo el procedimiento general del código se ve resumido en el siguiente diagrama de flujo:
V. PROGRAMA FINAL
Finalmente, con ayuda del diseñador de aplicaciones incluido dentro de la suite de MATLAB, se
juntó la sintaxis hecha en la segunda etapa (recuadro azul) con la sintaxis creada en la tercera
etapa (recuadro amarillo), de esa manera se tiene el siguiente código interno del programa
creado:
classdef Lagrangev2 < matlab.apps.AppBase
% Properties that correspond to app components
properties (Access = public)
PolinomiodeLagrangeUIFigure matlab.ui.Figure
TabladeinterpolacinPanel matlab.ui.container.Panel
IncremenetodexEditFieldLabel matlab.ui.control.Label
IncremenetodexEditField matlab.ui.control.NumericEditField
GenerartabladeinterpolacinButton matlab.ui.control.Button
MostrartablaButton matlab.ui.control.Button
NosegenerningunatablaLabel matlab.ui.control.Label
TablageneradaconxitoLabel matlab.ui.control.Label
EntradadedatosPanel matlab.ui.container.Panel
bcalc matlab.ui.control.Button
ndatos matlab.ui.control.NumericEditField
NdedatosEditFieldLabel matlab.ui.control.Label
polinomio matlab.ui.control.TextArea
PoinomioTextAreaLabel matlab.ui.control.Label
xin matlab.ui.control.NumericEditField
xEditFieldLabel matlab.ui.control.Label
fxin matlab.ui.control.NumericEditField
fxEditFieldLabel matlab.ui.control.Label
datos matlab.ui.control.Table
grafica matlab.ui.control.UIAxes
end
properties (Access = private)
Datosx
Datosfx
end
% Callbacks that handle component events
methods (Access = private)
% Code that executes after component creation
function startupFcn(app)
app.datos.ColumnFormat = {'numeric','numeric'};
app.xin.Enable = 'off';
app.fxin.Enable = 'off';
end
% Value changed function: ndatos
function ndatosValueChanged(app, event)
global n
app.Datosfx = 0;
app.Datosx = 0;
n = app.ndatos.Value;
c = zeros(n,2);
app.datos.Data = c
end
% Button pushed function: bcalc
function bcalcButtonPushed(app, event)
global fi xi n S
fi = app.Datosfx;
xi = app.Datosx;
L=zeros(n);
for i=1:n
P=1;
for j=1:n
if i~=j
P=conv(P,poly(xi(j)))/(xi(i)-xi(j));
end
end
L(i,:)=P;
end
S=fi*L;
f=poly2str(S,'x');
x=0:0.01:5;
y=polyval(S,x);
plot(app.grafica,x,y);
app.polinomio.Value = f;
app.xin.Enable = 'on';
app.xin.Value = zeros;
app.fxin.Enable = 'on';
app.fxin.Value = zeros;
app.IncremenetodexEditFieldLabel.Enable = 'on';
app.IncremenetodexEditField.Enable = 'on';
app.IncremenetodexEditField.Value = zeros;
app.GenerartabladeinterpolacinButton.Enable = 'on';
app.NosegenerningunatablaLabel.Enable = 'on';
app.TablageneradaconxitoLabel.Visible = 'off';
app.NosegenerningunatablaLabel.Visible = 'on';
app.GuardartablaButton.Enable = 'off';
end
% Cell edit callback: datos
function datosCellEdit(app, event)
indices = event.Indices;
newData = event.NewData;
xi = app.Datosx;
fi = app.Datosfx;
if indices(2) == 1
xi(indices(1)) = newData;
end
if indices(2) == 2
fi(indices(1)) = newData;
end
app.Datosx = xi;
app.Datosfx = fi;
end
% Value changed function: xin
function xinValueChanged(app, event)
x = app.xin.Value;
global S
fxval=polyval(S,x)));
app.fxin.Value = fxval;
end
% Button pushed function: GenerartabladeinterpolacinButton
function GenerartabladeinterpolacinButtonPushed(app, event)
app.NosegenerningunatablaLabel.Visible = 'off';
global fi xi inc Tabla
x = xi;
f = fi;
X=x(1)-1;
N=round((x(end)+1-X)/inc);
fxt=zeros(N,1);
xit=zeros(N,1);
Lt=zeros(N,length(x));
for k=1:N
S=0;
L=ones(1,length(x));
for i=1:length(x)
for j=1:length(x)
if i~=j
l=(X-x(j))/(x(i)-x(j));
L(i)=L(i)*l;
end
end
S=S+(f(i)*L(i));
end
Lt(k,:)=L;
fxt(k,1)=S;
xit(k,1)=X;
X=X+inc;
end
Tabla = table(xit,Lt,fxt,'VariableNames',{'x' 'L' 'f(x)'});
app.TablageneradaconxitoLabel.Visible = 'on';
app.MostrartablaButton.Enable = 'on';
end
% Value changed function: IncremenetodexEditField
function IncremenetodexEditFieldValueChanged(app, event)
global inc
inc = app.IncremenetodexEditField.Value;
end
% Button pushed function: MostrartablaButton
function MostrartablaButtonPushed(app, event)
global Tabla
[name, dir] = uiputfile({'*.xls','Hoja de Cálculo';'*.xlsx','Libro de
Excel'},'Guardar Como','InterpLagrange.xls');
writetable(Tabla,[dir, name],'Sheet','Valores');
end
end
% Component initialization
methods (Access = private)
% Create UIFigure and components
function createComponents(app)
% Create PolinomiodeLagrangeUIFigure and hide until all components are created
app.PolinomiodeLagrangeUIFigure = uifigure('Visible', 'off');
app.PolinomiodeLagrangeUIFigure.Position = [100 100 680 517];
app.PolinomiodeLagrangeUIFigure.Name = 'Polinomio de Lagrange';
% Create TabladeinterpolacinPanel
app.TabladeinterpolacinPanel = uipanel(app.PolinomiodeLagrangeUIFigure);
app.TabladeinterpolacinPanel.Title = 'Tabla de interpolación';
app.TabladeinterpolacinPanel.Position = [24 26 632 66];
% Create IncremenetodexEditFieldLabel
app.IncremenetodexEditFieldLabel = uilabel(app.TabladeinterpolacinPanel);
app.IncremenetodexEditFieldLabel.HorizontalAlignment = 'right';
app.IncremenetodexEditFieldLabel.Enable = 'off';
app.IncremenetodexEditFieldLabel.Position = [10 12 103 22];
app.IncremenetodexEditFieldLabel.Text = 'Incremeneto de ''x''';
% Create IncremenetodexEditField
app.IncremenetodexEditField = uieditfield(app.TabladeinterpolacinPanel,
'numeric');
app.IncremenetodexEditField.ValueChangedFcn = createCallbackFcn(app,
@IncremenetodexEditFieldValueChanged, true);
app.IncremenetodexEditField.Enable = 'off';
app.IncremenetodexEditField.Position = [128 12 46 22];
% Create GenerartabladeinterpolacinButton
app.GenerartabladeinterpolacinButton = uibutton(app.TabladeinterpolacinPanel,
'push');
app.GenerartabladeinterpolacinButton.ButtonPushedFcn = createCallbackFcn(app,
@GenerartabladeinterpolacinButtonPushed, true);
app.GenerartabladeinterpolacinButton.Enable = 'off';
app.GenerartabladeinterpolacinButton.Position = [197 12 177 22];
app.GenerartabladeinterpolacinButton.Text = 'Generar tabla de interpolación';
% Create MostrartablaButton
app.MostrartablaButton = uibutton(app.TabladeinterpolacinPanel, 'push');
app.MostrartablaButton.ButtonPushedFcn = createCallbackFcn(app,
@MostrartablaButtonPushed, true);
app.MostrartablaButton.Enable = 'off';
app.MostrartablaButton.Position = [504 12 109 23];
app.MostrartablaButton.Text = 'Mostrar tabla';
% Create NosegenerningunatablaLabel
app.NosegenerningunatablaLabel = uilabel(app.TabladeinterpolacinPanel);
app.NosegenerningunatablaLabel.HorizontalAlignment = 'center';
app.NosegenerningunatablaLabel.Enable = 'off';
app.NosegenerningunatablaLabel.Position = [363 5 153 36];
app.NosegenerningunatablaLabel.Text = {'No se generó'; 'ninguna tabla'};
% Create TablageneradaconxitoLabel
app.TablageneradaconxitoLabel = uilabel(app.TabladeinterpolacinPanel);
app.TablageneradaconxitoLabel.HorizontalAlignment = 'center';
app.TablageneradaconxitoLabel.Visible = 'off';
app.TablageneradaconxitoLabel.Position = [390 5 99 36];
app.TablageneradaconxitoLabel.Text = {'¡Tabla generada'; 'con éxito!'};
% Create EntradadedatosPanel
app.EntradadedatosPanel = uipanel(app.PolinomiodeLagrangeUIFigure);
app.EntradadedatosPanel.Title = 'Entrada de datos';
app.EntradadedatosPanel.Position = [24 174 216 325];
% Create bcalc
app.bcalc = uibutton(app.PolinomiodeLagrangeUIFigure, 'push');
app.bcalc.ButtonPushedFcn = createCallbackFcn(app, @bcalcButtonPushed, true);
app.bcalc.Position = [93 189 78 22];
app.bcalc.Text = 'Calcular';
% Create ndatos
app.ndatos = uieditfield(app.PolinomiodeLagrangeUIFigure, 'numeric');
app.ndatos.ValueChangedFcn = createCallbackFcn(app, @ndatosValueChanged, true);
app.ndatos.Position = [158 450 31 22];
% Create NdedatosEditFieldLabel
app.NdedatosEditFieldLabel = uilabel(app.PolinomiodeLagrangeUIFigure);
app.NdedatosEditFieldLabel.HorizontalAlignment = 'right';
app.NdedatosEditFieldLabel.Position = [75 450 68 22];
app.NdedatosEditFieldLabel.Text = 'Nº de datos';
% Create polinomio
app.polinomio = uitextarea(app.PolinomiodeLagrangeUIFigure);
app.polinomio.Editable = 'off';
app.polinomio.HorizontalAlignment = 'center';
app.polinomio.FontName = 'Cambria';
app.polinomio.FontWeight = 'bold';
app.polinomio.FontAngle = 'italic';
app.polinomio.Position = [110 119 532 41];
% Create PoinomioTextAreaLabel
app.PoinomioTextAreaLabel = uilabel(app.PolinomiodeLagrangeUIFigure);
app.PoinomioTextAreaLabel.HorizontalAlignment = 'center';
app.PoinomioTextAreaLabel.Position = [42 129 69 22];
app.PoinomioTextAreaLabel.Text = 'Poinomio:';
% Create xin
app.xin = uieditfield(app.PolinomiodeLagrangeUIFigure, 'numeric');
app.xin.ValueChangedFcn = createCallbackFcn(app, @xinValueChanged, true);
app.xin.Position = [350 189 93 22];
% Create xEditFieldLabel
app.xEditFieldLabel = uilabel(app.PolinomiodeLagrangeUIFigure);
app.xEditFieldLabel.HorizontalAlignment = 'right';
app.xEditFieldLabel.Position = [310 189 25 22];
app.xEditFieldLabel.Text = 'x';
% Create fxin
app.fxin = uieditfield(app.PolinomiodeLagrangeUIFigure, 'numeric');
app.fxin.ValueDisplayFormat = '%.5f';
app.fxin.Editable = 'off';
app.fxin.Position = [528 189 93 22];
% Create fxEditFieldLabel
app.fxEditFieldLabel = uilabel(app.PolinomiodeLagrangeUIFigure);
app.fxEditFieldLabel.HorizontalAlignment = 'right';
app.fxEditFieldLabel.Position = [488 189 25 22];
app.fxEditFieldLabel.Text = 'f(x)';
% Create datos
app.datos = uitable(app.PolinomiodeLagrangeUIFigure);
app.datos.ColumnName = {'x'; 'f(x)'};
app.datos.RowName = {};
app.datos.ColumnEditable = true;
app.datos.CellEditCallback = createCallbackFcn(app, @datosCellEdit, true);
app.datos.Position = [42 223 180 205];
% Create grafica
app.grafica = uiaxes(app.PolinomiodeLagrangeUIFigure);
title(app.grafica, 'Gráfica de la función')
xlabel(app.grafica, 'x')
ylabel(app.grafica, 'f(x)')
zlabel(app.grafica, 'Z')
app.grafica.Position = [264 231 378 253];
% Show the figure after all components are created
app.PolinomiodeLagrangeUIFigure.Visible = 'on';
end
end
% App creation and deletion
methods (Access = public)
% Construct app
function app = Lagrangev2
% Create UIFigure and components
createComponents(app)
% Register the app with App Designer
registerApp(app, app.PolinomiodeLagrangeUIFigure)
% Execute the startup function
runStartupFcn(app, @startupFcn)
if nargout == 0
clear app
end
end
% Code that executes before app deletion
function delete(app)
% Delete UIFigure when app is deleted
delete(app.PolinomiodeLagrangeUIFigure)
end
end
end
El programa solicita el número de par de datos que tenga y posteriormente se habilitará la celda
con los espacios indicados previamente donde el usuario ingresará los pares de datos, una vez
le dé al botón “Calcular” el programa empezará a calcular la función polinómica, la cual se
mostrará en el recuadro libre y se dibujará la gráfica de la función obtenida. También hay un
recuadro donde el usuario puede ingresar el valor de x que quiera conocer y el programa
evaluará la función obteniendo el valor de f(x) en el recuadro adyacente.
En la parte inferior del programa se encuentra un sector en donde, luego de calcular la función,
se solicita que el usuario ingrese el incremento de x para crear una tabla de interpolación en
formato Excel, la tabla incluye los valores de x que se irán evaluando, con un incremento
constante, desde x1+1 hasta xn+1; los valores de las bases polinómicas (Ln) para cada x y el
valor de f(x).
VI. RESULTADOS
Se adjuntarán imágenes mostrando el funcionamiento del programa a continuación.
Vista inicial de la aplicación
Vista de la aplicación luego de ingresar los datos y pulsar “Calcular”
Vista de la aplicación mostrando el valor de f(x) para cualquier x y luego de ingresar un incremento de x
para generar la tabla de interpolación, nótese que se habilita el botón “Mostrar tabla”.
Vista de la tabla generada en formato Excel.
VII. BIBLIOGRAFÍA
Mulero, J., & Gandía, C. (2020). Interpolación polinomial.
http://rua.ua.es/dspace/handle/10045/102428
Interpolación polinómica de Lagrange - Wikipedia, la enciclopedia libre. (n.d.). Retrieved July
14, 2021, from https://es.wikipedia.org/wiki/Interpolación_polinómica_de_Lagrange
5.1 Polinomio de interpolacion de Lagrange - sistrevolution. (n.d.). Retrieved July 14, 2021,
from https://sites.google.com/site/sistrevolution/5-1-interpolacion
MATLAB Documentation - MathWorks América Latina. (n.d.). Retrieved July 16, 2021, from
https://la.mathworks.com/help/matlab/
