UNIVERSIDAD PRIVADA BOLIVIANA

“TRABAJO PRÁCTICO # 2”

Materia: Métodos numéricos

Tarea: Trabajo práctico

Estudiante: Vera Ojeda Camilli Angelina

Entrega del Informe: 18 de diciembre de 2023

1. Enunciado del problema
Se realiza un experimento para determinar el porcentaje de alargamiento de un material
conductor eléctrico en función de la temperatura, los datos que resultan son:

Tabla 1: Datos del problema

Temperatura (°C) 200 250 300 375 425 475
% alargamiento 11 13 14 15 17 19

Método: Diferencias Divididas de Avance

2. Solución del problema

Con base en los datos proporcionados en la tabla 1, se ha generado el siguiente gráfico:

Figura 1: Gráfico en función a tabla 1

2.1 Calculo con el Método de Interpolación con Polinomios

En este método, se inicia construyendo la tabla de diferencias divididas mediante un bucle for. A
partir de la tabla de valores iniciales, se calculan y representan punto por punto los valores obtenidos
mediante el polinomio. Asimismo, se determinan los valores utilizando las funciones polyfit y polyval
de Matlab para posteriormente calcular la diferencia entre estos y los valores obtenidos con el
polinomio. A continuación, se presenta un gráfico que ilustra estas diferencias punto a punto.

Figura 2: Gráfico obtenido de la diferencia entre interpolación de Newton (DDA) y Polyfit/Polyval

2.2 Cálculo con el Método de Splines
En este enfoque, la construcción de la matriz para un polinomio de sexto grado sigue un proceso
análogo (siendo el programa adaptable para polinomios de cualquier orden). Se procede al cálculo de
las M's y, a continuación, se determinan los valores punto a punto en los mismos intervalos de valores.
Adicionalmente, se efectúan cálculos utilizando la función interp1 con el método 'spline'. Las
discrepancias entre los resultados obtenidos mediante el polinomio y aquellos derivados de interp1 se
calculan de manera similar a la descrita anteriormente. A continuación, se presentan las diferencias
resultantes.

Figura 3: Gráfico obtenido de la diferencia entre método splines y interp1

2.3 Comparación de los resultados con el método de Splines y el Método de Interpolación con
Polinomios

Figura 3: Datos del problema dibujados con una cruz en negro, valores estimados con las Splines con un
símbolo de rojo y, los valores estimados con el Polinomio de Interpolación con otro símbolo de color azul.

3. Conclusiones
 3.1 En la comparación de los resultados entre los códigos desarrollados y las funciones integradas
de MATLAB, se observó una coherencia notable en los valores numéricos, evidenciando
diferencias mínimas que sugieren una implementación precisa de los métodos de interpolación.
La validación cruzada en distintos conjuntos de datos respaldó la consistencia y robustez de las
implementaciones, generando así confianza en la exactitud de los resultados obtenidos.
3.2 El polinomio de interpolación exhibió oscilaciones más pronunciadas, especialmente en los
extremos del intervalo de interpolación, un fenómeno esperado debido al comportamiento de
Runge. En contraste, los splines cúbicos demostraron ser eficaces en controlar las oscilaciones
no deseadas, generando curvas suaves y más representativas de la naturaleza continua de los
datos.
La simplicidad inherente de los splines, al dividir el conjunto de datos en segmentos, condujo
a una representación más clara y fácilmente interpretable, en comparación con la complejidad
inherente de los polinomios de interpolación de alto grado. La visualización gráfica confirmó
que los splines proporcionan una interpolación más suave y adaptada a la naturaleza de los
datos, especialmente en situaciones donde los polinomios de interpolación pueden generar
oscilaciones excesivas.
4. Anexo
4.1 Método de Interpolación con Polinomios
function [yi, p, b] = inter_newton(x, y, xi)
% Validación de las entradas
if nargin ~= 3
error('Se requieren tres argumentos de entrada.');
end

n = length(x);
b = zeros(n);

% Llenar la primera columna de la tabla de diferencias divididas

b(:, 1) = y(:);

% Calcular la tabla de diferencias divididas

for j = 2:n
for i = 1:n-j+1
b(i, j) = (b(i+1, j-1) - b(i, j-1)) / (x(i+j-1) - x(i));
end
end

% Calcular el dato interpolado con el método de polinomio de interpolación

yi = b(1, 1);
for j = 1:n-1
term = b(1, j+1);
for i = 1:j
term = term * (xi - x(i));
end
yi = yi + term;
end

% Construir el polinomio en formato de cadena

p = num2str(b(1, 1));
 for j = 2:n
signo = '';
if b(1, j) >= 0
signo = '+';
end

x1 = '';
for i = 1:j-1
signo2 = '';
if x(i) >= 0
signo2 = '+';
end
x1 = strcat(x1, '*(x', signo2, num2str(-x(i)), ')');
end

p = strcat(p, signo, num2str(b(1, j)), x1);

end
% Calcular la interpolación con polyfit y polyval para diferentes xi
xi_range = linspace(min(x), max(x), 10); % Puntos de xi para el gráfico
yi_newton = zeros(size(xi_range));
yi_polyfit = zeros(size(xi_range));

for k = 1:length(xi_range)
xi_current = xi_range(k);

% Interpolación de Newton
yi_newton(k) = b(1, 1);
for j = 1:n-1
term = b(1, j+1);
for i = 1:j
term = term * (xi_current - x(i));
end
yi_newton(k) = yi_newton(k) + term;
end

% Interpolación con polyfit y polyval

coeficientes = polyfit(x, y, n-1);
yi_polyfit(k) = polyval(coeficientes, xi_current);
end

% Calcular la diferencia entre los resultados

diff = abs(yi_newton - yi_polyfit);

% Graficar la diferencia
figure;
plot(xi_range, diff, 'o-');
xlabel('x');
ylabel('Diferencia entre Newton y Polyfit/Polyval');
title('Diferencia entre Interpolación de Newton y Polyfit/Polyval para diferentes
xi');
end

4.2 Método de Splines

• Función spline_interpolacion
function y_splines = spline_interpolacion(x, y, x_evaluar)
n = length(x);

% Construir la matriz tridiagonal

h = diff(x);

% Calcular las segundas diferencias

delta = diff(y) ./ h;

% Ajustar las longitudes de h y delta

h = h(1:end-1);

% Calcular las derivadas segundas

alpha = 3 * delta(1:end-1) - 3 * delta(2:end);

l = zeros(1, n-2);
mu = zeros(1, n-2);
z = zeros(1, n-2);

% Resolver sistema tridiagonal

for i = 2:n-2
l(i) = 2 * (x(i+2) - x(i));
mu(i) = h(i) / l(i);
z(i) = (alpha(i-1) - h(i-1) * z(i-1)) / l(i);
end

% Calcular coeficientes de los splines cúbicos

l(end+1) = 1;
z(end+1) = 0;
c = zeros(1, n-1);
b = zeros(1, n-1);
d = zeros(1, n-1);

for j = n-2:-1:1
c(j) = z(j) - mu(j) * c(j+1);
b(j) = (y(j+1) - y(j)) / h(j) - h(j) * (c(j+1) + 2 * c(j)) / 3;
d(j) = (c(j+1) - c(j)) / (3 * h(j));
end

% Evaluar la interpolación en los puntos deseados

y_splines = zeros(size(x_evaluar));

for i = 1:n-1
indices = find(x_evaluar >= x(i) & x_evaluar <= x(i+1));
xx = x_evaluar(indices);
yy = y(i) + b(i) * (xx - x(i)) + c(i) * (xx - x(i)).^2 + d(i) * (xx -
x(i)).^3;
y_splines(indices) = yy;
end

% Graficar los resultados

figure;
hold on;

% Graficar datos originales

 plot(x, y, 'o', 'DisplayName', 'Datos Originales');

% Graficar splines cúbicos

for i = 1:n-1
xx = linspace(x(i), x(i+1), 100);
yy = y(i) + b(i) * (xx - x(i)) + c(i) * (xx - x(i)).^2 + d(i) * (xx -
x(i)).^3;
plot(xx, yy, 'DisplayName', sprintf('Spline %d', i));
end

legend;
xlabel('x');
ylabel('y');
title('Interpolación con Splines Cúbicos');
end

• Función
function comparar_interpolaciones(x, y, x_evaluar)
% Calcular interpolación con splines cúbicos
y_splines = spline_interpolacion(x, y, x_evaluar);

% Calcular interpolación con interp1

y_interp1 = interp1(x, y, x_evaluar, 'spline');

% Calcular la diferencia
diferencia = y_interp1 - y_splines;

% Graficar resultados
figure;
plot(x_evaluar, y_splines, 'r-', 'DisplayName', 'Interpolación con Splines');
hold on;
plot(x_evaluar, y_interp1, 'b-', 'DisplayName', 'Interpolación con Interp1');

% Marcar puntos de evaluación

scatter(x_evaluar, interp1(x, y, x_evaluar, 'spline'), 'kx', 'DisplayName',
'Puntos de Evaluación');

xlabel('Temperatura');
ylabel('% de alargamiento');
title('Comparación entre Splines e Interp1');
legend;
end

4.3 Comparación de los resultados con el Método de Splines y el Método de Interpolación con
Polinomios
function comparar_metodos_interpolacion(temperaturas, alargamientos)
% Puntos de evaluación para la interpolación
x_evaluar = linspace(min(temperaturas), max(temperaturas), 1000);
 % Método de Splines
y_splines = spline_interpolacion(temperaturas, alargamientos, x_evaluar);

% Método de Interpolación con Polinomios (Newton)

[y_interpolado, polinomio_interpolante] = inter_newton(temperaturas,
alargamientos, x_evaluar);

% Graficar resultados
figure;
hold on;

% Datos originales
plot(temperaturas, alargamientos, 'kx', 'DisplayName', 'Datos Originales');

% Splines
plot(x_evaluar, y_splines, 'r-', 'DisplayName', 'Splines');

% Interpolación con Polinomios (Newton)

plot(x_evaluar, y_interpolado, 'b-', 'DisplayName', 'Polinomio de
Interpolación');

xlabel('Temperatura (°C)');
ylabel('Porcentaje de Alargamiento');
title('Comparación de Métodos de Interpolación');
legend;