Jsjs

1. Interpolación de LaGrange
El polinomio interpolante de LaGrange es simplemente un reacomodo del polinomio de
diferencias divididas de newton. Así, del polinomio de diferencias divididas de primer
grado,
1
2
1
2
1
1
1
)
(
)
(
)
(
)
(
)
(
x
x
x
f
x
f
x
x
x
f
x
P





)
(
)
(
)
(
)
(
)
(
1
)
(
)
(
1
2
1
2
1
2
1
1
1
x
x
x
x
x
f
x
x
x
x
x
f
x
P













)
(
)
(
)
(
)
(
)
(
)
(
)
(
1
2
1
2
2
1
2
1
1
x
x
x
x
x
f
x
x
x
x
x
f
x
P






Se le puede efectuar el siguiente arreglo,
Reduciendo se obtiene,
Que es el polinomio interpolante de primer grado de LaGrange. El reacomodo anterior
se puede hacer para los polinomios de diferencias divididas de Newton de más alto
grado, así, para el polinomio de segundo grado el reacomodo permite obtener,
P
1(x)= f (x1)+(x- x1)f1 x2, x1
[ ]
f1 x2, x1
[ ] =
f (x2 )- f (x1)
x2 - x1
Donde:
Por lo que

2. )
(
)
(
)
(
)
(
)
(
)
(
)
(
)
(
)
(
)
(
)
(
)
(
)
(
)
(
)
(
)
(
2
3
2
1
3
1
3
3
2
3
1
2
1
2
3
1
3
2
1
2
1
2
x
x
x
x
x
x
x
x
x
f
x
x
x
x
x
x
x
x
x
f
x
x
x
x
x
x
x
x
x
f
x
P















El algoritmo del método de interpolación de LaGrange es el siguiente:
 




 


1
1
1
1
)
(
)
(
n
i
n
i
j
j j
i
j
i
n
x
x
x
x
x
f
x
P
El polinomio interpolante de LaGrange, es solo un reacomodo del polinomio
interpolante en diferencias divididas de Newton. La diferencia está en la
programación de cada algoritmo.
El siguiente programa permite seleccionar de una función discreta de m pares
ordenados el conjunto de pares ordenados que contiene el dado de entrada, x
y que permitirá hacer la interpolación, este conjunto de pares ordenados
dependerá del grado del polinomio interpolante 𝑃𝑛(𝑥), que deberá ser, n < m.

3. % Programa principal
% Programa que llama la función "Lagrange"
% Programa que interpola utilizando el polinomio de LaGrange.
clear all;
clc;
% se lee el vector xi y yi
fprintf('Escribe la función tabulada (x, y).n');
x = input('x = ');
y = input('y = ');
% se lee el No. de datos
n = length(x);
% Se pide el grado del polinomio interpolante
m = input('Escriba el grado del polinomio interpolante: ');
% No. de datos
nd = m + 1;

4. % se inicia con ceros x1 y y1
for i = 1:nd
x1(i) = 0;
y1(i) = 0;
end
% Dato de entrada o valor de x a interpolar
xr = input('Escriba el dato a interpolar, xr = ');
nd = m + 1;
if m < n
if xr < x(1)
fprintf('¡Error! Valor de %f a interpolar está fuera de la función tabulada.n',xr);
return;
end
if xr > x(n)
fprintf('¡Error! Valor de %f a interpolar está fuera de la función tabulada.n',xr);
return;
end
i = 2;
while ~(xr >= x(i-1) && xr <= x(i))
i = i + 1;
end

5. Li = i - 1;
Ls = i;
if Li == 1
for j = Li:m+1
x1(j) = x(j);
y1(j) = y(j);
end
fx1 = Lagrange(m, xr, x1, y1);
else
if Ls == n
j = 1;
for i = Ls - m:Ls
x1(j) = x(i);
y1(j) = y(i);
j = j + 1;
end
fx1 = Lagrange(m, xr, x1, y1);
else

6. if nd/2 - floor(nd/2) == 0
inc = floor(nd / 2);
inc = inc - 1;
Li = Li - inc;
Ls = Ls + inc;
if Li < 0
t = abs(Li);
Li = Li + t;
Ls = Ls + t;
end
if Ls > n
t = Ls - (n - 1);
Li = Li - t;
Ls = Ls - t;
end
j = 1;
for i = Li:Ls
x1(j) = x(i);
y1(j) = y(i);
j = j + 1;
end
fx1 = Lagrange(m, xr, x1, y1);
else

7. inc = floor(nd/2);
inci = inc - 1;
Li = Li - inci;
Ls = Ls + inc;
if Ls > n - 1
t = Ls - (n - 1);
Li = Li - t;
Ls = Ls - t;
end
if Li < 0
t = Abs(Li);
Li = Li + t;
Ls = Ls + t;
end
j = 1;
for i = Li+1:Ls+1
x1(j) = x(i);
y1(j) = y(i);
j = j + 1;
end
fx1 = Lagrange(m, xr, x1, y1);
end
end

8. end
else
fprintf(' ¡Error! No es posible la interpolación para este grado del polinomio.n');
return;
end
fprintf('El resultado de la interpolación: y(%f) = %fn',xr, fx1);

9. % Función que es llamada por "IntPolacionLagrange"
% En está función se efectua la interpolación con el uso
% del polinomio interpolante de Lagrage.
function yest = Lagrange(n, xr, x, y)
s = 0;
for i = 1:n+1
p = 1;
for j = 1:n+1
if i ~= j
p = p * (xr - x(j)) / (x(i) - x(j));
end
end
s = s + y(i) * p;
end
yest = s;
end