UNIVERSIDAD NACIONAL DE SAN AGUSTIN

FACULTAD DE INGENIERIA DE
PRODUCCION Y SERVICIOS

ESCUELA PROFESIONAL DE
INGENIERIA ELECTRICA

CURSO:
Métodos Numéricos Grupo “C”
TEMA:
Trabajo de Investigación Formativa N° 02

ALUMNOS:
⮚ Aguirre Sacsi, Luis Fernando
⮚ Ancco Panihuara, Aldo Javier
⮚ Arenas Huallpa, Andy Shelton
⮚ Galindo Oviedo, Joseph Alfredo
⮚ Villalba Torres, Jenfred Paul

Docente:
Mg. Bidder Sabino Calapuja Sambrano

AREQUIPA – PERÚ
2024
 TRABAJO DE INVESTIGACIÓN FORMATIVA N° 02
I. PARTE II:
A. SISTEMAS DE ECUACIONES LINEALES MEDIANTE MÉTODOS ITERATIVOS
1. MÉTODO DE JACOBI

Sea el sistema de ecuaciones lineales:

La diagonal principal cumple satisfactoriamente con el criterio de convergencia

o diagonal dominante, de modo que las ecuaciones recurrencia son:

Primera iteración k=1 es:

=
Segunda iteracion k=2 usando el vector hallado:

Procederemos con las iteraciones, las tolerancias calculadas con la ecuación,

llegar a una tolerancia 0.000007

Iteraciones del 0 al 6

Iteración
0.30000 -1.12500 -1.11375 -1.06469 -0.9882 -0.99087 -
0.99705
1.50000 2.36250 3.23125 3.11047 3.02393 2.98241 2.99292
6.37500 5.88759 5.20781 4.88484 4.99240 4.99402 5.00888
Tolerancia 1.73557 1.10310 0.34829 0.12915 0.06631 0.01922

Iteraciones del 7 al 12

Iteración
-1.00107 -1.00063 -1.00011 -0.99991 -0.99996 -1.00000
2.99951 3.00128 3.00041 2.99997 2.99991 2.99998
5.00339 4.99992 4.99936 4.99982 5.00003 5.00004
Tolerancia 0.00947 0.00392 0.00116 0.00023 0.000007
disp('Introduce las ecuaciones en forma simbólica.');
disp('Ejemplo: Para la ecuación 10*x + y + 2*z = 3, introduce: "10*x + y + 2*z ==
11".');
disp('Nota: Usa "==" en lugar de "=" para definir la ecuación.');
syms x y z;

eq1 = input('Ecuación 1: ', 's'); % Ejemplo: "10*x + y + 2*z == 3"

eq2 = input('Ecuación 2: ', 's'); % Ejemplo: "4*x + 6*y - z == 9"
eq3 = input('Ecuación 3: ', 's'); % Ejemplo: "-2*x + 3*y + 8*z == 51"

eq1 = str2sym(eq1);
eq2 = str2sym(eq2);
eq3 = str2sym(eq3);

[A, b] = equationsToMatrix([eq1, eq2, eq3], [x, y, z]);

disp('Sistema en forma matricial:');

disp('A = ');
disp(A);
disp('b = ');
disp(b);

tolerance = input('Introduce la tolerancia (ejemplo: 1e-3): ');

max_iterations = input('Introduce el número máximo de iteraciones: ');

x0 = zeros(size(b)); % Por defecto comienza en [0, 0, 0]

n = length(b);
x = x0;
x_new = zeros(size(x0));

fprintf('Iteración\t x\t\t y\t\t z\n');

for k = 1:max_iterations
for i = 1:n
sum_ = 0;
for j = 1:n
if j ~= i
sum_ = sum_ + A(i, j) * x(j);
end
end
x_new(i) = (b(i) - sum_) / A(i, i);
end

fprintf('%d\t\t %.5f\t %.5f\t %.5f\n', k, x_new(1), x_new(2), x_new(3));

if norm(x_new - x, inf) < tolerance

fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end

if k == max_iterations
fprintf('El método no convergió después de %d iteraciones.\n',
max_iterations);
else
fprintf('La solución aproximada es: [%.5f, %.5f, %.5f]\n', x_new(1), x_new(2),
x_new(3));
end
 Iteración x y z
1 0.30000 1.50000 6.37500
2 -1.12500 2.36250 5.88759
3 -1.11375 3.23125 5.20781
4 -1.06469 3.11047 4.88484
5 -0.98821 3.02393 4.99240
6 -0.99705 2.98241 4.99402
7 -1.00107 2.99951 5.00339
8 -1.00063 3.00128 4.99992
9 -1.00011 3.00041 4.99936
10 -0.99991 2.99997 4.99982
11 -0.99996 2.99991 5.00003
12 -1.00000 2.99998 5.00004

Convergencia alcanzada en 12 iteraciones.

Resolver:

Despejar

interacción 1
● x=y=z=0

interacción 2
● x=1.1 y=1 z=1
1.1
interacción 3
● x=1.1 y=1.32 z=1

1.132

interacción 4
● x=1.132 y=1.32 z=1.022

interacción 5
● x=1.1298 y=1.3286 z=1.0188
interacción 6
● x=1.13098 y=1.32784 z=1.01988

● x=1.130796 y=1.328184 z=1.019686

●
usando el código :
disp('Introduce las ecuaciones en forma simbólica.');
disp('Ejemplo: Para la ecuación 10*x - y + z = 11, introduce: "10*x - y + z == 11".');
disp('Nota: Usa "==" en lugar de "=" para definir la ecuación.');
syms x y z;

eq1 = input('Ecuación 1: ', 's'); % Ejemplo: "10*x - y + z == 11"

eq2 = input('Ecuación 2: ', 's'); % Ejemplo: "-2*x + 10*y - z == 10"
eq3 = input('Ecuación 3: ', 's'); % Ejemplo: "x - y + 10*z == 10"

eq1 = str2sym(eq1);
eq2 = str2sym(eq2);
eq3 = str2sym(eq3);

[A, b] = equationsToMatrix([eq1, eq2, eq3], [x, y, z]);

disp('Sistema en forma matricial:');

disp('A = ');
disp(A);
disp('b = ');
disp(b);
tolerance = input('Introduce la tolerancia (ejemplo: 1e-3): ');
max_iterations = input('Introduce el número máximo de iteraciones: ');

x0 = zeros(size(b)); % Por defecto comienza en [0, 0, 0]

n = length(b);
x = x0;
x_new = zeros(size(x0));

fprintf('Iteración\t x\t\t y\t\t z\n');

for k = 1:max_iterations
for i = 1:n
sum_ = 0;
for j = 1:n
if j ~= i
sum_ = sum_ + A(i, j) * x(j);
end
end
x_new(i) = (b(i) - sum_) / A(i, i);
end

fprintf('%d\t\t %.5f\t %.5f\t %.5f\n', k, x_new(1), x_new(2), x_new(3));

if norm(x_new - x, inf) < tolerance

fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end

x = x_new;
end

if k == max_iterations
fprintf('El método no convergió después de %d iteraciones.\n', max_iterations);
else
fprintf('La solución aproximada es: [%.5f, %.5f, %.5f]\n', x_new(1), x_new(2), x_new(3));
end

respuesta del código

Iteración x y z
1 1.10000 1.00000 1.00000
2 1.10000 1.32000 0.99000
3 1.13300 1.31900 1.02200
4 1.12970 1.32880 1.01860
5 1.13102 1.32780 1.01991
6 1.13079 1.32820 1.01968
Convergencia alcanzada en 6 iteraciones.

HALLAR LAS SOLUCIONES DEL SISTEMA DE ECUACIONES DE 3X3 CON UN ERROR

DEL 0.001.
PASO 1
Ordenar de forma forma que los mayores valores están en la diagonal principal.

PASO 2
Dar un valor a las y despejar en cada ecuación.

PASO 3
Reemplazar y repetir hasta llegar al error deseado.

Iteración 1

Iteración 2

Iteración 3

Iteración 4

Iteración 5
Calculamos el error:

Iteración 6

Calculamos el error:

Respuesta

RESPUESTA EN MATLAB:
Sistema en forma matricial:
A = [25.0000 -0.9000 -0.3000 3.7000 -7.6000 -0.7000 0.9000 0.4000 -7.9000]
b = [24.5000-17.5000-56.8000]

Iteración x1 x2 x3
1 0.98000 2.30263 7.18987
2 1.14908 2.11745 7.66550
3 1.14824 2.15601 7.42787
...

Convergencia alcanzada en 6 iteraciones.

La solución aproximada es: [1.14990, 2.15260, 7.42990]

RESOLVER EL SIGUIENTE SISTEMA DE ECUACIONES

1.- Inicializar las variables x,y,z con valores arbitarios (por ejwmplo ,x=0,y=0,z=0).
2.- calcular los nuevos valores de x,y,z utilizando las nuevas formullas
3.-repetir el paso 2 hasta que se alcance la convergencia (es decir, hasta que los valores
x,y,z dejen cde cambiar significativamente)
Iteración 1

Iteración 2

Iteración 3

Convergencia
Después de varias iteraciones ,los valores de x,y,z convergen a:
X=2.0625
Y=0.7875
Z=3.21875

Código en MAATLAB
disp('Introduce las ecuaciones en forma simbólica.');
disp('Ejemplo: Para la ecuación 10*x - y + z = 11, introduce: "10*x - y + z == 11".');
disp('Nota: Usa "==" en lugar de "=" para definir la ecuación.');
syms x y z;
% Definir las ecuaciones de acuerdo con el sistema dado
eq1 = '2*x + 3*y - z == 5'; % Ecuación 1: 2x + 3y - z = 5
eq2 = 'x - 2*y + 4*z == -2'; % Ecuación 2: x - 2y + 4z = -2
eq3 = '3*x + y + 2*z == 7'; % Ecuación 3: 3x + y + 2z = 7
% Convertir las ecuaciones a formato simbólico
eq1 = str2sym(eq1);
eq2 = str2sym(eq2);
eq3 = str2sym(eq3);
% Convertir el sistema de ecuaciones a su forma matricial
[A, b] = equationsToMatrix([eq1, eq2, eq3], [x, y, z]);
disp('Sistema en forma matricial:');
disp('A = ');
disp(A);
disp('b = ');
disp(b);
% Configurar los parámetros de tolerancia e iteraciones
tolerance = input('Introduce la tolerancia (ejemplo: 1e-3): ');
max_iterations = input('Introduce el número máximo de iteraciones: ');
x0 = zeros(size(b)); % Por defecto comienza en [0, 0, 0]
n = length(b);
x = x0;
x_new = zeros(size(x0));
fprintf('Iteración\t x\t\t y\t\t z\n');
% Método iterativo (Método de Gauss-Seidel)
for k = 1:max_iterations
for i = 1:n
sum_ = 0;
for j = 1:n
if j ~= i
sum_ = sum_ + A(i, j) * x(j);
end
end
x_new(i) = (b(i) - sum_) / A(i, i);
end
% Mostrar los resultados de cada iteración
fprintf('%d\t\t %.5f\t %.5f\t %.5f\n', k, x_new(1), x_new(2), x_new(3));

% Verificar la convergencia
if norm(x_new - x, inf) < tolerance
fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end
% Actualizar el valor de x para la siguiente iteración
x = x_new;
end
% Si no se alcanza la convergencia
if k == max_iterations
fprintf('El método no convergió después de %d iteraciones.\n', max_iterations);
else
fprintf('La solución aproximada es: [%.5f, %.5f, %.5f]\n', x_new(1), x_new(2), x_new(3));
end

2. MÉTODO DE GAUSS-SEIDEL

Resolver mediante el Método de GAUSS-SEIDEL

7x+y-2z=5
-3x-5y+z=-20
2x+2y-6z=-8
Despejando “x”,”y”,”z”

1ra iteración con (0,0,0)

2da iteración:
3ra iteración:

4ta iteración:

5ta iteración:

Por lo que al no haber cambios, se tiene la solución: x=1, y=3.999 y z=2.999

Resolver mediante Gauss Seidel: Aproximar el sistema de ecuaciones; con vector inicial
(-6,3,4)

Solución:
La diagonal principal debe cumplir satisfactoriamente con el criterio de convergencia o
diagonal dominante, para ello:
 Iteracion
0 -6 3 4 ---------------------
1 -4.833 3.922 -3.911 1.49670
2 -5.27037 4.15259 4.12938 0.53546
… … … … …
11 -5.44647 4.03577 4.38572 0.00016
12 -5.44646 4.03572 4.28573 0.00005

disp('Introduce las ecuaciones en forma simbólica.');

disp('Ejemplo: Para la ecuación 1/5*x + 1/2*y + 1/4*z = 7, ingresa: "1/5*x + 1/2*y + 1/4*z ==
7".');
disp('Nota: Usa "==" en lugar de "=" para las ecuaciones.');

syms x y z;

eq1 = input('Ecuación 1: ', 's'); % Ejemplo: "1/5*x + 1/2*y + 1/4*z == 2"

eq2 = input('Ecuación 2: ', 's'); % Ejemplo: "1/2*x + 1/4*y + 1/6z == -1"
eq3 = input('Ecuación 3: ', 's'); % Ejemplo: "1/3*x + 1/6*y + 1/2*z == 1"

eq1 = str2sym(eq1);
eq2 = str2sym(eq2);
eq3 = str2sym(eq3);

% Extraer la matriz de coeficientes y el vector de términos independientes

[A, b] = equationsToMatrix([eq1, eq2, eq3], [x, y, z]);

disp('Sistema en forma matricial:');

disp('A = ');
disp(A);
disp('b = ');
disp(b);

tolerance = input('Introduce la tolerancia (ejemplo: 1e-3): ');

max_iterations = input('Introduce el número máximo de iteraciones: ');

x0 = zeros(size(b)); % Por inicio [-6, 3, 4]

n = length(b);
x = x0;
fprintf('Iteración\t x\t\t y\t\t z\n');

for k = 1:max_iterations
x_new = x; % Copiar valores actuales para actualizarlos
for i = 1:n
sum1 = A(i, 1:i-1) * x_new(1:i-1); % Suma de los valores actualizados
sum2 = A(i, i+1:n) * x(i+1:n); % Suma de los valores previos
x_new(i) = (b(i) - sum1 - sum2) / A(i, i);
end

fprintf('%d\t\t %.5f\t %.5f\t %.5f\n', k, x_new(1), x_new(2), x_new(3));

if norm(x_new - x, inf) < tolerance

fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end
x = x_new; % Actualizar para la siguiente iteración
end

if k == max_iterations
fprintf('El método no convergió después de %d iteraciones.\n', max_iterations);
else
fprintf('La solución aproximada es: [%.5f, %.5f, %.5f]\n', x_new(1), x_new(2), x_new(3));
end

interación x y z
1 -6 3 4
2 -4.833 3.922 -3.911
3 -5.27037 4.15259 4.12938
4 -6.21415 5.18342 -2.17774
5 -7.45121 6.18920 4.27758
6 -6.21415 6.12493 4.29912
7 -6.12411 6.61221 4.31012
8 -5.82414 5.81242 4.31901
9 -5.44648 4.61214 4.33251
10 -5.44647 4.12312 4.35012
11 -5.44646 4.03577 4.38572
12 -5.44646 4.03572 4.28573

Convergencia alcanzada en 12 iteraciones.

Resolver:

Despejar

Iteración 1:
● x=y=z=0
Iteración 2:
● x=1.75 y=2.08333 z=-1.96667

Iteración 3:
● x=2.7625 y=2.09306 z=-2.17111

Iteración 4:
● x=2.81604 y=2.07683 z=-2.17857
Iteración 5:
● x=2.81385 y=2.07485 z=-2.17774

=-2.17758

● x=2.81315 y=2.07476 z=-2.17758

usando el código :
disp('Introduce las ecuaciones en forma simbólica.');
disp('Ejemplo: Para la ecuación 4*x - y + z = 7, ingresa: "4*x - y + z == 7".');
disp('Nota: Usa "==" en lugar de "=" para las ecuaciones.');

syms x y z;

eq1 = input('Ecuación 1: ', 's'); % Ejemplo: "4*x - y + z == 7"

eq2 = input('Ecuación 2: ', 's'); % Ejemplo: "-2*x + 6*y - z == 9"
eq3 = input('Ecuación 3: ', 's'); % Ejemplo: "x + y + 5*z == -6"

eq1 = str2sym(eq1);
eq2 = str2sym(eq2);
eq3 = str2sym(eq3);

% Extraer la matriz de coeficientes y el vector de términos independientes

[A, b] = equationsToMatrix([eq1, eq2, eq3], [x, y, z]);

disp('Sistema en forma matricial:');

disp('A = ');
disp(A);
disp('b = ');
disp(b);
tolerance = input('Introduce la tolerancia (ejemplo: 1e-3): ');
max_iterations = input('Introduce el número máximo de iteraciones: ');
x0 = zeros(size(b)); % Por defecto [0, 0, 0]

n = length(b);
x = x0;
fprintf('Iteración\t x\t\t y\t\t z\n');

for k = 1:max_iterations
x_new = x; % Copiar valores actuales para actualizarlos
for i = 1:n
sum1 = A(i, 1:i-1) * x_new(1:i-1); % Suma de los valores actualizados
sum2 = A(i, i+1:n) * x(i+1:n); % Suma de los valores previos
x_new(i) = (b(i) - sum1 - sum2) / A(i, i);
end

fprintf('%d\t\t %.5f\t %.5f\t %.5f\n', k, x_new(1), x_new(2), x_new(3));

if norm(x_new - x, inf) < tolerance

fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end
x = x_new; % Actualizar para la siguiente iteración
end

if k == max_iterations
fprintf('El método no convergió después de %d iteraciones.\n', max_iterations);
else
fprintf('La solución aproximada es: [%.5f, %.5f, %.5f]\n', x_new(1), x_new(2), x_new(3));
end

interación x y z
1 1.75000 2.08333 -1.96667
2 2.76250 2.09306 -2.17111
3 2.81604 2.07683 -2.17857
4 2.81385 2.07485 -2.17774
5 2.81315 2.07476 -2.17758

Convergencia alcanzada en 5 iteraciones.

Resolver el siguiente sistema de ecuaciones

Método de gauss- seidel

1.-inicializar las variable x,y,z con valores arbitrarios (por ejemplo x=,y=0,z=0)
2.-calcular el nuevo valor de x utilizando la primera ecuación

1.-calcular el nuevo valor de y utilizando la segunda ecuación y el nuevo valor de x

1.- calcular el nuevo valor de z utilizando la tercera ecuación y los nuevos valores de x y y
Se repiten los pasos 2 y 4 hasta que los valores de x,y,z dejen de cambiar significativamente

Iteración 1

Iteracion 2

Iteracion 3

Convergencia después de varias iteraciones ,los valores de x,y,z convergen a :

X=2.903
Y=2.037
Z=1.968

Esa sería la solución del sistema de ecuaciones

Código en MATLAB
disp('Introduce las ecuaciones en forma simbólica.');
disp('Ejemplo: Para la ecuación 4*x - y + z = 7, ingresa: "4*x - y + z == 7".');
disp('Nota: Usa "==" en lugar de "=" para las ecuaciones.');
syms x y z;
% Definir las ecuaciones del sistema
eq1 = '3*x + 2*y - z == 10'; % Ecuación 1: 3x + 2y - z = 10
eq2 = 'x - 3*y + 2*z == -5'; % Ecuación 2: x - 3y + 2z = -5
eq3 = '2*x + y + 4*z == 7'; % Ecuación 3: 2x + y + 4z = 7
% Convertir las ecuaciones a formato simbólico
eq1 = str2sym(eq1);
eq2 = str2sym(eq2);
eq3 = str2sym(eq3);
% Extraer la matriz de coeficientes y el vector de términos independientes
[A, b] = equationsToMatrix([eq1, eq2, eq3], [x, y, z]);
disp('Sistema en forma matricial:');
disp('A = ');
disp(A);
disp('b = ');
disp(b);
% Solicitar parámetros del usuario
tolerance = input('Introduce la tolerancia (ejemplo: 1e-3): ');
max_iterations = input('Introduce el número máximo de iteraciones: ');
x0 = zeros(size(b)); % Solución inicial [0, 0, 0]
n = length(b);
x = x0;
fprintf('Iteración\t x\t\t y\t\t z\n');
% Método iterativo de Gauss-Seidel
for k = 1:max_iterations
x_new = x; % Copiar valores actuales para actualizarlos
for i = 1:n
sum1 = A(i, 1:i-1) * x_new(1:i-1); % Suma de los valores actualizados
sum2 = A(i, i+1:n) * x(i+1:n); % Suma de los valores previos
x_new(i) = (b(i) - sum1 - sum2) / A(i, i);
end
% Mostrar los resultados de cada iteración
fprintf('%d\t\t %.5f\t %.5f\t %.5f\n', k, x_new(1), x_new(2), x_new(3));
% Verificar la convergencia
if norm(x_new - x, inf) < tolerance
fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end
x = x_new; % Actualizar para la siguiente iteración
end
% Si no se alcanza la convergencia
if k == max_iterations
fprintf('El método no convergió después de %d iteraciones.\n', max_iterations);
else
fprintf('La solución aproximada es: [%.5f, %.5f, %.5f]\n', x_new(1), x_new(2), x_new(3));
end

3. MÉTODO DE RELAJACIÓN

Dado el Sistema de ecuación Lineal

Con solucion (3,4,-5)t, determine las ecuaciones para el método SOR con =1.25 y

Para k=1

Para k=2
Para k=3

Para k=4

Para k=5

Para k=6

Usando el metodo de gauss seidel con factor de relajacion ; para resolver (

Usando:

Primeramente haremos el intercambio de filas para que la diagonal principal converja

Hallando para cada raiz las ecuaciones:

Teniendo el vector inicial como: se realizara los calculos

hasta obtener un error menor al 5%.

Para
Para

Para

disp('Introduce las ecuaciones en forma simbólica.');

disp('Ejemplo: Para la ecuación -6*x + 0*y + 12*z = 6, escribe: "-6*x + 0*y + 12*z == 6".');
disp('Nota: Usa "==" en lugar de "=" para las ecuaciones.');

syms x y z;

try
eq1 = input('Ecuación 1: ', 's');
eq2 = input('Ecuación 2: ', 's');
eq3 = input('Ecuación 3: ', 's');

eq1 = str2sym(eq1);
eq2 = str2sym(eq2);
eq3 = str2sym(eq3);
catch
error('Error al interpretar las ecuaciones. Verifica que estén escritas correctamente.');
end

[A, b] = equationsToMatrix([eq1, eq2, eq3], [x, y, z]);

disp('Sistema en forma matricial:');

disp('A = ');
disp(A);
disp('b = ');
disp(b);

tolerance = input('Introduce la tolerancia (ejemplo: 1e-3): ');

max_iterations = input('Introduce el número máximo de iteraciones: ');
omega = input('Introduce el factor de relajación (ejemplo: 1.25): ');
x0 = zeros(size(b));

n = length(b);
x = x0;
fprintf('Iteración\t x\t\t y\t\t z\n');

for k = 1:max_iterations
x_new = x;
for i = 1:n
sum1 = A(i, 1:i-1) * x_new(1:i-1);
sum2 = A(i, i+1:n) * x(i+1:n);
x_new(i) = (1 - omega) * x(i) + (omega / A(i, i)) * (b(i) - sum1 - sum2);
end

fprintf('%d\t\t %.5f\t %.5f\t %.5f\n', k, x_new(1), x_new(2), x_new(3));

if norm(x_new - x, inf) < tolerance

fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end
x = x_new;
end

if k == max_iterations
fprintf('El método no convergió después de %d iteraciones.\n', max_iterations);
else
fprintf('La solución aproximada es: [%.5f, %.5f, %.5f]\n', x_new(1), x_new(2), x_new(3));
end

interación x y z
1 -0.45000 5.25000 -4.29751
2 1.65000 4.36120 5.67211
3 1.97251 4.05412 5.95512

Convergencia alcanzada en 3 iteraciones.

Resolver:

Despejar

Iteración 1:
● x=y=z=0
Iteración 2:
● x=0.75 y=1.13281 z=-0.6543

Iteración 3
● x=0.92749 y=0.83057 z=-0.61065
Iteración 4
● x=0.8021 y=0.85418 z=-0.58432

Iteración 5
● x=0.83606 y=0.86831 z=-0.59586
Usando el código
disp('Introduce las ecuaciones en forma simbólica.');
disp('Ejemplo: Para la ecuación 10*x - 2*y + z = 6, escribe: "10*x - 2*y + z == 6".');
disp('Nota: Usa "==" en lugar de "=" para las ecuaciones.');

syms x y z;

try
eq1 = input('Ecuación 1: ', 's');
eq2 = input('Ecuación 2: ', 's');
eq3 = input('Ecuación 3: ', 's');

eq1 = str2sym(eq1);
eq2 = str2sym(eq2);
eq3 = str2sym(eq3);
catch
error('Error al interpretar las ecuaciones. Verifica que estén escritas correctamente.');
end

[A, b] = equationsToMatrix([eq1, eq2, eq3], [x, y, z]);

disp('Sistema en forma matricial:');

disp('A = ');
disp(A);
disp('b = ');
disp(b);

tolerance = input('Introduce la tolerancia (ejemplo: 1e-3): ');

max_iterations = input('Introduce el número máximo de iteraciones: ');
omega = input('Introduce el factor de relajación (ejemplo: 1.25): ');

x0 = zeros(size(b));

n = length(b);
x = x0;
fprintf('Iteración\t x\t\t y\t\t z\n');

for k = 1:max_iterations
x_new = x;
for i = 1:n
sum1 = A(i, 1:i-1) * x_new(1:i-1);
 sum2 = A(i, i+1:n) * x(i+1:n);
x_new(i) = (1 - omega) * x(i) + (omega / A(i, i)) * (b(i) - sum1 - sum2);
end

fprintf('%d\t\t %.5f\t %.5f\t %.5f\n', k, x_new(1), x_new(2), x_new(3));

if norm(x_new - x, inf) < tolerance

fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end
x = x_new;
end

if k == max_iterations
fprintf('El método no convergió después de %d iteraciones.\n', max_iterations);
else
fprintf('La solución aproximada es: [%.5f, %.5f, %.5f]\n', x_new(1), x_new(2), x_new(3));
end

Iteración x y z
1 0.75000 1.13281 -0.65430
2 0.92749 0.83057 -0.61065
3 0.80210 0.85418 -0.58432
4 0.83606 0.86831 -0.59586
5 0.83254 0.86133 -0.59384

RESOLVER EL SIGUIENTE SISTEMA DE ECUACIONES

METODO DE RELAJACION

1.-inicializar las variables x,y,z con valores arbitrarios (por ejemplo,x=0,y=0,z=0)

2.- calcular el residuo R de cada ecuación

Calcular el cambio ( en cada variable para minimizar el residuo:

Actualizar las variables x,y,z con los cambios calculados

Repetir los pasos 2 y 4 hasta que se alcance la convergencia (los residuos sean menores
que un valor umbral)

Iteración 1=
R1=10-2*0-3*0+0=10
R2=-5-0+2*0-4*0=-5
R3=12-3*0-0-2*0=12
Iteración 2=
R1=10-2*-5-3*-2.5+(-6)=10
R2=-5-(-5)+2*(-2.5)-4*(-6)=13
R3=12-3*(-5)-(-2.5)-2(-6)=30.5

Convergencia
Después de varias iteraciones, los residuos se vuelven menores que un valor umbral (por
ejemplo 0.01).en este caso la convergencia se alcanza después de 5 iteraciones
Solución
X=-6.75
Y=-4
Z=-21.25

Es importante destacar que el método de la relajación es un método iterativo que requiere

una inicialización adecuada de las variables y una convergencia adecuada para obtener la
solución exacta

Código en MATLAB
disp('Introduce las ecuaciones en forma simbólica.');
disp('Ejemplo: Para la ecuación 10*x - 2*y + z = 6, escribe: "10*x - 2*y + z == 6".');
disp('Nota: Usa "==" en lugar de "=" para las ecuaciones.');
syms x y z;
try
% Definir las ecuaciones del sistema
eq1 = '2*x + 3*y - z == 10'; % Ecuación 1: 2x + 3y - z = 10
eq2 = 'x - 2*y + 4*z == -5'; % Ecuación 2: x - 2y + 4z = -5
eq3 = '3*x + y + 2*z == 12'; % Ecuación 3: 3x + y + 2z = 12
% Convertir las ecuaciones a formato simbólico
eq1 = str2sym(eq1);
eq2 = str2sym(eq2);
eq3 = str2sym(eq3);
catch
error('Error al interpretar las ecuaciones. Verifica que estén escritas correctamente.');
end
% Extraer la matriz de coeficientes y el vector de términos independientes
[A, b] = equationsToMatrix([eq1, eq2, eq3], [x, y, z]);
disp('Sistema en forma matricial:');
disp('A = ');
disp(A);
disp('b = ');
disp(b);
% Solicitar parámetros del usuario
tolerance = input('Introduce la tolerancia (ejemplo: 1e-3): ');
max_iterations = input('Introduce el número máximo de iteraciones: ');
omega = input('Introduce el factor de relajación (ejemplo: 1.25): ');
x0 = zeros(size(b)); % Inicialización de la solución (vector cero)
n = length(b);
x = x0;
fprintf('Iteración\t x\t\t y\t\t z\n');
% Método iterativo de Gauss-Seidel con relajación (Método de SOR)
for k = 1:max_iterations
x_new = x; % Copiar valores actuales para actualizarlos
for i = 1:n
% Sumar los productos de los coeficientes anteriores y las soluciones previas
sum1 = A(i, 1:i-1) * x_new(1:i-1);
sum2 = A(i, i+1:n) * x(i+1:n); % Sumar los productos de los coeficientes posteriores y
las soluciones anteriores
% Actualización de la variable en la posición i, con el factor de relajación
x_new(i) = (1 - omega) * x(i) + (omega / A(i, i)) * (b(i) - sum1 - sum2);
end
% Mostrar resultados de cada iteración
fprintf('%d\t\t %.5f\t %.5f\t %.5f\n', k, x_new(1), x_new(2), x_new(3));
% Verificar si se ha alcanzado la convergencia
if norm(x_new - x, inf) < tolerance
fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end
x = x_new; % Actualizar la solución para la siguiente iteración
end
% Si no se alcanza la convergencia
if k == max_iterations
fprintf('El método no convergió después de %d iteraciones.\n', max_iterations);
else
fprintf('La solución aproximada es: [%.5f, %.5f, %.5f]\n', x_new(1), x_new(2), x_new(3));
end

B. SISTEMAS DE ECUACIONES NO LINEALES MEDIANTE NEWTON RHAPSON

1. Resolver

Calcular el vector

Calcular el valor de la estimación del error absoluto

Solución:
Se quiere resolver el sistema de ecuaciones del tipo

Donde las funciones son arbitrarias, llamando entonces a

queremos resolver

para esto debemos usar el esquema iterativo:

 Siendo: la matriz jacobi

Por tanto, debemos resolver la iteración lineal

Seguidamente obetener la interación usando este vector de corrección calculado:

La funcion:

Y la matriz jacobi:
La aproximación inicial es calculamos:

Y por lo tanto, el sistema linea a resolver sera:

Una vez resuelto es

, por lo que entonces:

con continuamos con el proceso y asi obtener , etc… Comprovando la

convergencia con cada calculando: ( )

iteración Estimación errores

k
0 1.5 1.5 0 0
1 1.37881263123 3.362745098980431241 1.862745098 0.559358601
2 1.46794349357 2.722762341213134563 0.635213221 0.232821239
… … … … …
8 1.56584580072 2.449489742783180982 6.59592e-14 2.692773064e-14
9 1.56584580072 2.449489742783180982 0 0

disp('Introduce las ecuaciones no lineales en forma simbólica.');

disp('Ejemplo: Para la ecuación 5x^4 + 7y^2 - 72 = 0, escribe: "5x^2 + 4y^2 - 72".');
disp('Nota: Las variables deben ser consistentes (por ejemplo, x y y).');

syms x y;

try

eq1 = input('Ecuación 1 (f1): ', 's');

eq2 = input('Ecuación 2 (f2): ', 's');

f1 = str2sym(eq1);
f2 = str2sym(eq2);
catch
 error('Error al interpretar las ecuaciones. Verifica que estén escritas correctamente.');
end

J = jacobian([f1, f2], [x, y]);

F = matlabFunction([f1; f2], 'Vars', [x, y]);

J_func = matlabFunction(J, 'Vars', [x, y]);

x0 = input('Introduce el valor inicial para x: ');

y0 = input('Introduce el valor inicial para y: ');

tol = input('Introduce la tolerancia (ejemplo: 1e-3): ');

max_iter = input('Introduce el número máximo de iteraciones: ');

fprintf('Iteración\t x\t\t y\n');

for k = 1:max_iter

F_eval = F(x0, y0);

J_eval = J_func(x0, y0);

delta = -J_eval \ F_eval;

x0 = x0 + delta(1);
y0 = y0 + delta(2);

fprintf('%d\t\t %.5f\t %.5f\n', k, x0, y0);

if norm(delta, inf) < tol

fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end
end

if k == max_iter
fprintf('El método no convergió después de %d iteraciones.\n', max_iter);
else
fprintf('Solución aproximada: x = %.5f, y = %.5f\n', x0, y0);
end

Convergencia alcanzada en 6 iteraciones.

La solución aproximada es: [1.14990, 2.15260, 7.42990]

Gráfica:
 2. Resolver

Calcular el vector

Calcular el valor de la estimación del error absoluto

y también el error relativo

Solución:
Se quiere resolver el sistema de ecuaciones del tipo

Donde las funciones son arbitrarias, llamando entonces a

queremos resolver

para esto debemos usar el esquema iterativo:

Siendo: la matriz jacobi

Por tanto, debemos resolver la iteración lineal

Seguidamente obetener la interación usando este vector de corrección calculado:

La funcion:

Y la matriz jacobi:

La aproximación inicial es calculamos:

Y por lo tanto, el sistema linea a resolver sera:

Una vez resuelto es , por lo que entonces:

con continuamos con el proceso y asi obtener , etc… Comprovando la

convergencia con cada calculando: (

iteración Estimación errores

k
0 0 0 0 0
1 0.500000000000 0.250000000000000000 0.5 1
2 0.486463513355 0.233773976987731913 0.01622692301 0.0333561695
 3 0.486405155458 0.233725502256881952 5.835820949-05 0.0000119975
4 0.486405154668 0.233725501958720785 6.10092e-14 1.254302224e-
14
5 0.486405154669 0.233725501958720785 9e-20 1.850309339e-
19

isp('Introduce las ecuaciones no lineales en forma simbólica.');

disp('Ejemplo: Para la ecuación 2x - cosy = 0, escribe: "2x – cosy ".');
disp('Nota: Las variables deben ser consistentes (por ejemplo, x y y).');

syms x y;

try

eq1 = input('Ecuación 1 (f1): ', 's');

eq2 = input('Ecuación 2 (f2): ', 's');

f1 = str2sym(eq1);
f2 = str2sym(eq2);
catch
error('Error al interpretar las ecuaciones. Verifica que estén escritas correctamente.');
end

J = jacobian([f1, f2], [x, y]);

F = matlabFunction([f1; f2], 'Vars', [x, y]);

J_func = matlabFunction(J, 'Vars', [x, y]);

x0 = input('Introduce el valor inicial para x: ');

y0 = input('Introduce el valor inicial para y: ');

tol = input('Introduce la tolerancia (ejemplo: 1e-3): ');

max_iter = input('Introduce el número máximo de iteraciones: ');

fprintf('Iteración\t x\t\t y\n');

for k = 1:max_iter

F_eval = F(x0, y0);

J_eval = J_func(x0, y0);

delta = -J_eval \ F_eval;

x0 = x0 + delta(1);
y0 = y0 + delta(2);

fprintf('%d\t\t %.5f\t %.5f\n', k, x0, y0);

if norm(delta, inf) < tol

fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end
end

if k == max_iter
fprintf('El método no convergió después de %d iteraciones.\n', max_iter);
else
 fprintf('Solución aproximada: x = %.5f, y = %.5f\n', x0, y0);
end

iteración x y
1 0.50000 0.25000
2 0.486463 0.233773
3 0.486405 0.233725
4 0.486405 0.233725
5 0.486405 0.233725

Convergencia alcanzada en 3 iteraciones.

Gráfica:

3. Resolver

Definición del sistema de funciones:

Punto inicial:
Tolerancia:

Evaluar el sistema en el punto inicial :

Entonces, .

Calcular el Jacobiano :
– Derivada parcial de respecto a :
– Derivada parcial de respecto a :
– Derivada parcial de respecto a :
– Derivada parcial de respecto a :
–
Entonces, el Jacobiano es:
Iteración 2
Nuevo punto:
1. Evaluación de :

Entonces, .

2. Calcular el Jacobiano :
– Derivada parcial de respecto a :
– Derivada parcial de respecto a :
– Derivada parcial de respecto a :
– Derivada parcial de respecto a :

Entonces, el Jacobiano es:

3. Resolver :

Calculando esto, obtenemos:

4. Actualizar el valor de :

Iteración 3
Nuevo punto:
1. Evaluación de :

Entonces, .

2. Calcular el Jacobiano :
– Derivada parcial de respecto a :
– Derivada parcial de respecto a :
– Derivada parcial de respecto a :

– Derivada parcial de respecto a :

Entonces, el Jacobiano es:

3. Resolver : Calculamos:

4. Actualizar el valor de :

Iteración 4
Nuevo punto:
 1. Evaluación de :

Entonces, .

2. Calcular el Jacobiano :
– Derivada parcial de respecto a :
– Derivada parcial de respecto a :

– Derivada parcial de respecto a :

– Derivada parcial de respecto a :

Entonces, el Jacobiano es:

3. Resolver : Calculamos:

4. Actualizar el valor de :

Iteración 5
Nuevo punto:
1. Evaluación de :

Entonces, .

Calcular el Jacobiano :
– Derivada parcial de respecto a :
– Derivada parcial de respecto a :

– Derivada parcial de respecto a :

– Derivada parcial de respecto a :

Entonces, el Jacobiano es:

Resolver : Calculamos:

Actualizar el valor de :

Después de cinco iteraciones, el valor aproximado de la solución es

 RESPUESTA EN MATLAB:
Iteración x y
1 0.20000 1.60000
2 0.10400 1.84000
3 0.09100 1.86800
4 0.08680 1.87430
5 0.08560 1.87670

Convergencia alcanzada en 5 iteraciones.

Solución aproximada: x = 0.0856, y = 1.8767

4. Resolver

Interacción 1
xo=1 yo=1

Interacción 2
xo=-1.16396 yo=4.16395
Interacción 3
xo=-4.05675 yo=1.59097

Interacción 4
xo=-2.45881 yo=0.95503
Interacción 5
xo=-1.89193 yo=0.86597

disp('Introduce las ecuaciones no lineales en forma simbólica.');

disp('Ejemplo: Para la ecuación x^2 + y^2 - 4 = 0, escribe: "x^2 + y^2 - 4".');
disp('Nota: Las variables deben ser consistentes (por ejemplo, x y y).');

syms x y;

try

eq1 = input('Ecuación 1 (f1): ', 's');

eq2 = input('Ecuación 2 (f2): ', 's');

f1 = str2sym(eq1);
f2 = str2sym(eq2);
catch
error('Error al interpretar las ecuaciones. Verifica que estén escritas correctamente.');
end

J = jacobian([f1, f2], [x, y]);

F = matlabFunction([f1; f2], 'Vars', [x, y]);

J_func = matlabFunction(J, 'Vars', [x, y]);

x0 = input('Introduce el valor inicial para x: ');

y0 = input('Introduce el valor inicial para y: ');

tol = input('Introduce la tolerancia (ejemplo: 1e-3): ');

max_iter = input('Introduce el número máximo de iteraciones: ');

fprintf('Iteración\t x\t\t y\n');

for k = 1:max_iter

F_eval = F(x0, y0);

 J_eval = J_func(x0, y0);

delta = -J_eval \ F_eval;

x0 = x0 + delta(1);
y0 = y0 + delta(2);

fprintf('%d\t\t %.5f\t %.5f\n', k, x0, y0);

if norm(delta, inf) < tol

fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end
end

if k == max_iter
fprintf('El método no convergió después de %d iteraciones.\n', max_iter);
else
fprintf('Solución aproximada: x = %.5f, y = %.5f\n', x0, y0);
end

Iteración x y
1 -1.16395 4.16395
2 -4.05668 1.59100
3 -2.45878 0.95504
4 -1.89192 0.86597
5 -1.81769 0.83803

5. Resolver

Interacción 1
xo=1.5 yo=1.5
Interacción 2
xo=1.3125 yo=1.3125

Interacción 3
xo=1.3028 yo=1.3028

disp('Introduce las ecuaciones no lineales en forma simbólica.');

disp('Ejemplo: Para la ecuación x^2 + y^2 - 4 = 0, escribe: "x^2 + y^2 - 4".');
disp('Nota: Las variables deben ser consistentes (por ejemplo, x y y).');

syms x y;

try

eq1 = input('Ecuación 1 (f1): ', 's');

eq2 = input('Ecuación 2 (f2): ', 's');

f1 = str2sym(eq1);
 f2 = str2sym(eq2);
catch
error('Error al interpretar las ecuaciones. Verifica que estén escritas correctamente.');
end
J = jacobian([f1, f2], [x, y]);

F = matlabFunction([f1; f2], 'Vars', [x, y]);

J_func = matlabFunction(J, 'Vars', [x, y]);

x0 = input('Introduce el valor inicial para x: ');

y0 = input('Introduce el valor inicial para y: ');

tol = input('Introduce la tolerancia (ejemplo: 1e-3): ');

max_iter = input('Introduce el número máximo de iteraciones: ');

fprintf('Iteración\t x\t\t y\n');

for k = 1:max_iter

F_eval = F(x0, y0);

J_eval = J_func(x0, y0);

delta = -J_eval \ F_eval;

x0 = x0 + delta(1);
y0 = y0 + delta(2);

fprintf('%d\t\t %.5f\t %.5f\n', k, x0, y0);

if norm(delta, inf) < tol

fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end
end

if k == max_iter
fprintf('El método no convergió después de %d iteraciones.\n', max_iter);
else
fprintf('Solución aproximada: x = %.5f, y = %.5f\n', x0, y0);
end

iteración x y
1 1.31250 1.31250
2 1.30280 1.30280
3 1.30278 1.30278
Convergencia alcanzada en 3 iteraciones.

Solución aproximada: x = 1.30278, y = 1.30278

6. Resolver
Tabla de valores
n x f(x) df/dx xnuevo
1 50 120148.738 7303.965 33.5502
2 33.5502 35613.9146 3245.114 22.57558
3 22.57558 10552.6525 1440.833 15.25158
4 15.25158 3127.65671 638.9284 10.35642
5 10.35642 925.539025 282.7443 7.08301
6 7.08301 275.975897 125.8719 4.890495
7 4.890495 81.8191088 55.36601 3.412709
8 3.412709 25.4235583 23.32544 2.32276
9 2.32276 8.43998522 9.211525 1.406518
10 1.406518 3.03200855 3.472346 0.53333
11 0.53333 0.69121397 2.581121 0.265534
12 0.265534 -0.0632663 3.11434 0.285849
13 0.285849 -0.0005437 3.061156 0.286027
14 0.286027 -4.049E-08 3.0607 0.286027
15 0.286027 0 3.0607 0.286027
16 0.286027 0 3.0607 0.286027

Solución
X=0.286027

Código en MATLAB
disp('Introduce la ecuación no lineal en forma simbólica.');
disp('Ejemplo: Para la ecuación x^3 - 2x^2 + 3x - 1 + sin(x) = 0, escribe: "x^3 - 2*x^2 + 3*x -
1 + sin(x)"');
syms x;
try
% Solicitar la ecuación en formato simbólico
eq1 = input('Ecuación 1 (f1): ', 's');
f1 = str2sym(eq1); % Convertir la cadena a una expresión simbólica
catch
error('Error al interpretar la ecuación. Verifica que esté escrita correctamente.');
end
% Calcular la derivada de la función (para el método de Newton-Raphson)
f1_prime = diff(f1, x);
% Convertir las funciones y su derivada a funciones de MATLAB
F = matlabFunction(f1, 'Vars', {x});
F_prime = matlabFunction(f1_prime, 'Vars', {x});
% Solicitar el valor inicial
x0 = input('Introduce el valor inicial para x: ');

% Solicitar la tolerancia y el número máximo de iteraciones

tol = input('Introduce la tolerancia (ejemplo: 1e-3): ');
max_iter = input('Introduce el número máximo de iteraciones: ');
fprintf('Iteración\t x\n');
% Método de Newton-Raphson
for k = 1:max_iter
F_eval = F(x0); % Evaluar la función en x0
F_prime_eval = F_prime(x0); % Evaluar la derivada en x0
% Actualización de la variable x
delta = -F_eval / F_prime_eval; % Fórmula de Newton-Raphson
x0 = x0 + delta; % Nueva aproximación
% Mostrar resultados de la iteración
fprintf('%d\t\t %.5f\n', k, x0);
 % Comprobar si la diferencia es menor que la tolerancia
if abs(delta) < tol
fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end
end
% Verificar si alcanzó el número máximo de iteraciones
if k == max_iter
fprintf('El método no convergió después de %d iteraciones.\n', max_iter);
else
fprintf('Solución aproximada: x = %.5f\n', x0);
end

7. Resolver

n x f(x) df/dx xnuevo

1 1 0.36789052 -1.36789 1.268947
2 1.268947 0.08452347 -0.74324 1.38267
3 1.38267 0.01468461 -0.48558 1.412911
4 1.412911 0.00102836 -0.41762 1.415374
5 1.415374 6.819E-06 -0.4121 1.41539
6 1.41539 4.2801E-10 -0.41206 1.41539
7 1.41539 7.5495E-15 -0.41206 1.41539
8 1.41539 0 -0.41206 1.41539
9 1.41539 0 -0.41206 1.41539
10 1.41539 0 -0.41206 1.41539

Solución
X=1.41539

Código en MATLAB
disp('Introduce la ecuación no lineal en forma simbólica.');
disp('Ejemplo: Para la ecuación x^2 - 3x + 2 + exp(-x) = 0, escribe: "x^2 - 3*x + 2 + exp(-x)"');
syms x;
try
% Solicitar la ecuación en formato simbólico
eq1 = input('Ecuación 1 (f1): ', 's');
f1 = str2sym(eq1); % Convertir la cadena a una expresión simbólica
catch
error('Error al interpretar la ecuación. Verifica que esté escrita correctamente.');
end
% Calcular la derivada de la función (para el método de Newton-Raphson)
f1_prime = diff(f1, x);
% Convertir las funciones y su derivada a funciones de MATLAB
F = matlabFunction(f1, 'Vars', {x});
F_prime = matlabFunction(f1_prime, 'Vars', {x});
% Solicitar el valor inicial
x0 = input('Introduce el valor inicial para x: ');
% Solicitar la tolerancia y el número máximo de iteraciones
tol = input('Introduce la tolerancia (ejemplo: 1e-3): ');
max_iter = input('Introduce el número máximo de iteraciones: ');
fprintf('Iteración\t x\n');
% Método de Newton-Raphson
for k = 1:max_iter
F_eval = F(x0); % Evaluar la función en x0
F_prime_eval = F_prime(x0); % Evaluar la derivada en x0
% Actualización de la variable x
delta = -F_eval / F_prime_eval; % Fórmula de Newton-Raphson
x0 = x0 + delta; % Nueva aproximación

% Mostrar resultados de la iteración

fprintf('%d\t\t %.5f\n', k, x0);
% Comprobar si la diferencia es menor que la tolerancia
if abs(delta) < tol
fprintf('Convergencia alcanzada en %d iteraciones.\n', k);
break;
end
end
% Verificar si alcanzó el número máximo de iteraciones
if k == max_iter
fprintf('El método no convergió después de %d iteraciones.\n', max_iter);
else
fprintf('Solución aproximada: x = %.5f\n', x0);
end

8. Resolver
Mediante el Metodo de Newton Rhapson, para sistemas, determine una iteración
utilizando

Sabiendo
que

Interacción 1
Para i=0
 9. Resolver: Encontrar una buena aproximación a una raíz de la siguiente función
usando el método de Newton Raphson . Tomar como partida x=1

Sabemos que si
Hallando la

1ra iteración:

2da iteración:

3ra iteración:

4ta iteración:

5ta iteración:

Se puede indicar que una raíz aproximada es x=1.32

II. PARTE III: MÉTODOS DE INTERPOLACIÓN

A. INTERPOLACIÓN POLINOMICA

Obtener el polinomio de interpolacion de los puntos:

Iteración 0 1 2 3
x 0 1 2 3
Y -1 6 31 18

Aproximamos a polinomio cubico como sigue

Valores de la tabla

Reordenando:
En forma matricicial y resolviendo el sistema por el Metodo de gauss – jordán

Se obtiene:

Finalmente:

Reemplazando:

fprintf('Introduce los puntos manualmente:\n');

n = input('Número de puntos: ');

x = zeros(1, n);
y = zeros(1, n);

for i = 1:n
x(i) = input(sprintf('x(%d): ', i));
y(i) = input(sprintf('y(%d): ', i));
end

A = zeros(n);
for i = 1:n
for j = 1:n
A(i, j) = x(i)^(j-1);
end
end

coef = A \ y';

fprintf('\nEl polinomio interpolador es:\n');

syms X;
P = 0;
for i = 1:n
if coef(i) ~= 0
fprintf('%+.4f*X^%d ', coef(i), i-1);
end
P = P + coef(i) * X^(i-1);
end
fprintf('\n\n');

x_eval = input('Introduce el valor de x a evaluar: ');

y_eval = double(subs(P, X, x_eval));
fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, y_eval);

x_plot = linspace(min(x), max(x), 100);

y_plot = double(subs(P, X, x_plot));

plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;

plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación Polinómica');
legend('Puntos originales', 'Polinomio Interpolador');
grid on;

Solucion:
Coeficientes del polinomio cúbico:
9.333 37.000 -20.667 -1

Resolver: En una planta de generación de energía eléctrica, se monitorea el desempeño de

un generador que alimenta una carga resistiva. Se han registrado mediciones de la tensión
de salida del generador y la corriente que fluye a través del circuito en diferentes momentos.
Aunque la resistencia de la carga permanece constante, se ha observado que la corriente
varía en función de los cambios en la tensión. A partir de estas mediciones, se busca
analizar la variación de la potencia activa suministrada por el generador.

Tensión (V) 100 120 140 160

Corriente (A) 5 6 7 8

Obtén la corriente cuando la tensión es 130 V en el generador eléctrico.

Solución:

Imponemos las condiciones de interpolación

Matricialmente:

Resolviendo

x =130, I=6.50Amp

SOLUCION EN MATLAB:
% Datos de entrada
x = [100, 120, 140, 160]; % Tensión en V
y = [5, 6, 7, 8]; % Corriente en A
% Matriz de Vandermonde
A = vander(x);
% Resolver el sistema lineal A * coef = y
coef = A \ y';
% Evaluar el polinomio en x = 130
x_eval = 130;
current_at_130 = polyval(coef, x_eval);
% Mostrar resultados
disp('Coeficientes del polinomio cúbico:');
disp(coef');
disp(['Corriente cuando la tensión es 130 V: ', num2str(current_at_130), ' A']);

SOLUCION:
Coeficientes del polinomio cúbico:
-2.5093e-20 9.9476e-18 5.0000e-02 5.4401e-14

Corriente cuando la tensión es 130 V: 6.5 A

Resolver:
(1,1),(2,4),(3,9). Evalúa en x=2.5
N=2

fprintf('Introduce los puntos manualmente:\n');

n = input('Número de puntos: ');

x = zeros(1, n);
y = zeros(1, n);

for i = 1:n
x(i) = input(sprintf('x(%d): ', i));
y(i) = input(sprintf('y(%d): ', i));
end

A = zeros(n);
for i = 1:n
for j = 1:n
A(i, j) = x(i)^(j-1);
end
end
coef = A \ y';

fprintf('\nEl polinomio interpolador es:\n');

syms X;
P = 0;
for i = 1:n
if coef(i) ~= 0
fprintf('%+.4f*X^%d ', coef(i), i-1);
end
P = P + coef(i) * X^(i-1);
end
fprintf('\n\n');

x_eval = input('Introduce el valor de x a evaluar: ');

y_eval = double(subs(P, X, x_eval));
fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, y_eval);

x_plot = linspace(min(x), max(x), 100);

y_plot = double(subs(P, X, x_plot));

plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;

plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación Polinómica');
legend('Puntos originales', 'Polinomio Interpolador');
grid on;

El polinomio interpolador es:

+1.0000*X^2

Introduce el valor de x a evaluar: 2.5

El valor interpolado en x = 2.5000 es y = 6.2500
Polinomio de interpolaciòn
Dados los puntos (1,2);(2,5);(3,10) y (4,17) encuentre el polinomio de interpolación que pasa
por estos puntos

P(x)=2+3*(x-1)+2*(x-1)*(x-2)+1*(x-1)(x-2)(x-3)
P(x)=2+3*(x-1)+2*(x-1)*(x-2)+1*(x-1)(x-2)(x-3)
P(x)=2+3x-3+2*(x-1)*(x-2)+1*(x-1)(x-2)(x-3)
P(x)=2+3x-3+2*(x^2-2x-x+2)+(x-1)(x-2)(x-3)
P(x)=2+3x-3+2*(x^2-2x-x+2)+(x-1)(x-2)(x-3)
P(x)=2+3x-3+2*(x^2-3x+2)+(x-1)(x-2)(x-3)
P(x)=-1+3x+2*(x^2-3x+2)+(x-1)(x-2)(x-3)
P(x)=-1+3x+2x^2-6x+4+(x-1)(x-2)(x-3)
P(x)=-1+3x+2x^2-6x+4+(x^2-2x-x+2)(x-3)
P(x)=-1+3x+2x^2-6x+4+(x^2-3x+2)(x-3)
P(x)=-1+3x+2x^2-6x+4+(x^3-3x^2+2x-3x^2+9x-6)
P(x)=-1+3x+2x^2-6x+4+(x^3-6x^2+11x-6)
P(x)=-1+3x+2x^2-6x+4+x^3-6x^2+11x-6
P(x)=x^3-4x^2+8x-6

El polinomio de interpolación de los puntos

P(x)=x^3-4x^2+8x-6

Código en MATLAB
% Definición del polinomio P(x) = x^3 - 4x^2 + 8x - 6
fprintf('Interpolación polinómica para el polinomio P(x) = x^3 - 4x^2 + 8x - 6\n');
% Definir los puntos de evaluación manualmente para interpolar
n = 4; % Número de puntos
x = [1, 2, 3, 4]; % Puntos de x para la interpolación (puedes cambiar estos puntos si lo
deseas)
y = x.^3 - 4*x.^2 + 8*x - 6; % Puntos correspondientes de y usando P(x)
% Matriz del sistema de ecuaciones
A = zeros(n);
for i = 1:n
for j = 1:n
A(i, j) = x(i)^(j-1); % Construir la matriz de coeficientes
end
end
% Resolver el sistema de ecuaciones para obtener los coeficientes
coef = A \ y';
% Mostrar el polinomio interpolador
fprintf('\nEl polinomio interpolador es:\n');
syms X;
P = 0;
for i = 1:n
if coef(i) ~= 0
fprintf('%+.4f*X^%d ', coef(i), i-1);
end
P = P + coef(i) * X^(i-1); % Construir el polinomio
end
fprintf('\n\n');
% Evaluar el polinomio interpolador en un valor de x
x_eval = input('Introduce el valor de x a evaluar: ');
y_eval = double(subs(P, X, x_eval));
fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, y_eval);
% Graficar el polinomio y los puntos originales
x_plot = linspace(min(x), max(x), 100); % Crear puntos para la gráfica
y_plot = double(subs(P, X, x_plot)); % Evaluar el polinomio en estos puntos
% Graficar
plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;
plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación Polinómica');
legend('Puntos originales', 'Polinomio Interpolador');
grid on;

Interpolación polinómica

x -2 0 2 3

y=g(x) -4 0 4 21

Imponemos las condiciones de interpolación

Matricialmente: .

Resolviendo
Ecuacion polinómica:

CODIGOS EN MATLAB
%Datos de ingreso
%valores en "x" obtenidos de los datos
x=[-2 0 2 3];
%valores en "y" obtenidos de los datos
y=[-4 0 4 21];
% Matriz de Vandermonde
A = vander(x);
% Resolver el sistema lineal A * coef = y
coef = A \ y';
% Evaluar el polinomio en cualquier valor de "x", por ejemplo 5
x_eval = 5;
current_at_5 = polyval(coef, x_eval);
% Mostrar resultados
disp('Coeficientes del polinomio cúbico:');
disp(coef');

B. INTERPOLACIÓN DE LAGRANGE
Obtener el polinomio interpolador para cierta funcion:

Ahora el polinomio interpolador

fprintf('Introduce los puntos manualmente:\n');

n = input('Número de puntos: ');

x = zeros(1, n);00
y = zeros(1, n);
for i = 1:n
x(i) = input(sprintf('x(%d): ', i));
y(i) = input(sprintf('y(%d): ', i));
end

x_eval = input('Introduce el valor de x para evaluar el polinomio: ');

P_eval = 0;
syms X;
P = 0;

for i = 1:n
L_i = 1;
for j = 1:n
if i ~= j
L_i = L_i * (X - x(j)) / (x(i) - x(j));
end
end

P = P + y(i) * L_i;

P_eval = P_eval + y(i) * double(subs(L_i, X, x_eval));

end

disp('El polinomio de interpolación de Lagrange es:');

disp(expand(P));

fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, P_eval);

x_plot = linspace(min(x), max(x), 100);

y_plot = double(subs(P, X, x_plot));

plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;

plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación de Lagrange');
legend('Datos', 'Polinomio Interpolador');
grid on;

El polinomio de interpolación de Lagrange es:

-(1/12)*x^3 + (20/12)*x^2 – 1

Grafica de la funcion:
Resolver: Dados los valores pares puntos: (-2,0); (0,6); (2.2) y (4,8) ; evaluar f(-1)

PASO 1
Escribimos la fórmula de interpolación por Lagrange.

PASO 2
Ubicamos nuestros puntos.

PASO 3
Empezamos a reemplazar los puntos en la fórmula hallando las

PASO 4
Reemplazamos y en la fórmula.
PASO 5
Simplificamos en polinomio y graficamos para comprobar los puntos.

PASO 6
Evaluar f (-1)

PROGRAMACION:
Código en MATLAB

% Datos de entrada
x = [-2, 0, 2, 4]; % Coordenadas en x
y = [0, 6, 2, 8]; % Coordenadas en y

% Punto donde se evaluará la función

x_eval = -1;

% Inicializar el valor del polinomio en x_eval

f_eval = 0;

% Método de Lagrange
n = length(x); % Número de puntos
for i = 1:n
% Calcular el término de Lagrange L_i(x)
L_i = 1;
for j = 1:n
if j ~= i
L_i = L_i * (x_eval - x(j)) / (x(i) - x(j));
end
end
% Sumar el término L_i * y_i al polinomio
f_eval = f_eval + L_i * y(i);
end

% Mostrar el resultado
fprintf('El valor de f(%f) es aproximadamente %f\n', x_eval, f_eval);
El valor de f(-1.000000) es aproximadamente 5.500000

Resolver: En un circuito RLC serie, se midieron las frecuencias de resonancia en función de

distintos valores de capacitancia, obteniéndose los siguientes datos experimentales:

Frecuencia de
Capacitancia (CCC,
resonancia (fff,
μF)
kHz)
2 1.2
4 0.85
6 0.65
8 0.55

PASO 1
Escribimos la fórmula de interpolación por Lagrange.

PASO 2
Ubicamos nuestros puntos.

PASO 3
Empezamos a reemplazar los puntos en la fórmula hallando las .

PASO 4
Reemplazamos y en la fórmula.

PASO 5
Simplificamos en polinomio y graficamos para comprobar los puntos.
PASO 6
Evaluar P (5)

SOLUCION EN MATLAB:
% Paso 1: Datos iniciales
x = [2, 4, 6, 8]; % Capacitancia (μF)
y = [1.2, 0.85, 0.65, 0.55]; % Frecuencia de resonancia (kHz)
% Paso 2: Inicialización de Lagrange
syms X; % Declarar una variable simbólica para el polinomio
n = length(x); % Número de puntos
P = 0; % Inicializar el polinomio de Lagrange
% Paso 3: Construir el polinomio de Lagrange
for i = 1:n
L_i = 1; % Inicializar el término base de L_i
for j = 1:n
if j ~= i
L_i = L_i * (X - x(j)) / (x(i) - x(j)); % Producto de términos
end
end
P = P + y(i) * L_i; % Construir el polinomio
end

% Simplificar el polinomio
P = simplify(P);

% Mostrar el polinomio simplificado

disp('Polinomio de Lagrange P(x):');
disp(P);

% Paso 4: Evaluar el polinomio en X = 5

X_val = 5;
P_val = double(subs(P, X, X_val)); % Evaluar el polinomio en 5
% Mostrar el resultado de la evaluación
disp(['P(5) = ', num2str(P_val), ' kHz']);
% Paso 5: Graficar el polinomio y los puntos
fplot(P, [1, 9]); % Graficar el polinomio en un rango de 1 a 9 μF
hold on;
plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); % Graficar los puntos
grid on;
title('Interpolación de Lagrange para un sistema RLC');
xlabel('Capacitancia (\muF)');
ylabel('Frecuencia de resonancia (kHz)');
legend('Polinomio de Lagrange', 'Puntos experimentales', 'Location', 'Best');
hold off;

RESPUESTA:
Polinomio de Lagrange
P(x): -(1/960)*X^3 + (1/32)*X^2 - (1/3)*X + 7/6

P(5) = 0.7344 kHz

Resolver: Un transformador fue probado a distintas cargas, y se obtuvieron los siguientes

datos de eficiencia:

Potencia de carga
Eficiencia (%)
(kW)
10 88
20 92
30 93.5
40 94

PASO 1
Escribimos la fórmula de interpolación por Lagrange.

PASO 2
Ubicamos nuestros puntos.

PASO 3
Empezamos a reemplazar los puntos en la formula hallando las

PASO 4
Reemplazamos y en la formula.
PASO 5
Simplificamos en polinomio y graficamos para comprobar los puntos.

PASO 6
Evaluar P (25)

SOLUCION MEDIANTE MATLAB:

% Paso 1: Datos iniciales
x = [10, 20, 30, 40]; % Potencia de carga (kW)
y = [88, 92, 93.5, 94]; % Eficiencia (%)

% Paso 2: Inicialización de Lagrange

syms X; % Variable simbólica
n = length(x); % Número de puntos
P = 0; % Inicializar el polinomio de Lagrange

% Paso 3: Construir el polinomio de Lagrange

disp('Construcción de L_i(x):');
for i = 1:n
L_i = 1; % Inicializar cada término L_i
for j = 1:n
if j ~= i
L_i = L_i * (X - x(j)) / (x(i) - x(j)); % Construir L_i(x)
end
end
fprintf('L_%d(x):\n', i - 1);
disp(simplify(L_i));
P = P + y(i) * L_i; % Sumar los términos ponderados al polinomio
end
% Paso 4: Simplificar el polinomio completo
P = simplify(P);
disp('Polinomio de Lagrange P(x):');
disp(P);

% Paso 5: Evaluar el polinomio en X = 25

X_val = 25; % Punto a evaluar
P_val = double(subs(P, X, X_val)); % Evaluar el polinomio
disp(['P(25) = ', num2str(P_val), ' %']);
% Paso 6: Graficar el polinomio y los puntos
fplot(P, [5, 45]); % Graficar el polinomio
hold on;
plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); % Puntos experimentales
grid on;
title('Interpolación de Lagrange - Eficiencia de un transformador');
xlabel('Potencia de carga (kW)');
ylabel('Eficiencia (%)');
legend('Polinomio de Lagrange', 'Datos experimentales', 'Location', 'Best');
hold off;

RESPUESTA:
Construcción de L_i(x):
L_0(x): -((X - 20)*(X - 30)*(X - 40))/6000
L_1(x): ((X - 10)*(X - 30)*(X - 40))/2000
L_2(x): -((X - 10)*(X - 20)*(X - 40))/2000
L_3(x): ((X - 10)*(X - 20)*(X - 30))/6000
Polinomio de Lagrange P(x): 1/4000*X^3 - 11/400*X^2 + 21/20*X + 80

P(25) = 92.97 %

Resolver: Obtener el polinomio interpolador de Lagrange para cierta función f de la que

conocemos que: f(-1)=1; f(0)=-1 ; f(2)=2 y f(3)=2

PASO 1
Escribimos la fórmula de interpolación por Lagrange.

PASO 2
Ubicamos nuestros puntos.

PASO 3
Empezamos a reemplazar los puntos en la fórmula hallando las .
PASO 4
Reemplazamos y en la fórmula.

PASO 5
Simplificamos en polinomio y graficamos para comprobar los puntos.

SOLUCION EN MATLAB:

lagrange_interpolacion
Número de puntos: 4
x(1): -1
y(1): 1
x(2): 0
y(2): -1
x(3): 2
y(3): 2
x(4): 3
y(4): 2
Introduce el valor de x para evaluar el polinomio: 1
El polinomio de interpolación de Lagrange es:

-(5/12)*x^3 + (19/12)*x^2 - 1

El valor interpolado en x = 1.0000 es y = -0.4167

Resolver.- Una línea de transmisión trifásica presenta un comportamiento no lineal en la
relación entre su frecuencia de operación f (en Hz) y la Z(impedancia característica). Los
valores de Z(f) han sido medidos experimentalmente en tres frecuencias diferentes:

PASO 1
Escribimos la fórmula de interpolación por Lagrange.

PASO 2
Ubicamos nuestros puntos.

PASO 3
Empezamos a reemplazar los puntos en la fórmula hallando las

PASO 4
Reemplazamos y en la fórmula.

PASO 5
Simplificamos en polinomio y graficamos para comprobar los puntos.
RESPUESTA DE MATLAB:

Número de puntos: 4
f(1): 50
Zc(f_1): 45
f(2): 60
Zc(f_2): 40
f(3): 70
Zc(f_3): 38
f(4): 90
Zc(f_4): 30
Introduce el valor de x para evaluar el polinomio: 65

El polinomio de interpolación de Lagrange es: -(13/24000)*x^3 + (9/80)*x^2 - (1907/240)*x +

915/4

El valor interpolado en f = 65.0000 es Zc = 34.3056

Resolver: (1,1)(4,2)(6,3.5)(7,5)
+3.5* +5*

-7*

+5*

fprintf('Introduce los puntos manualmente:\n');

n = input('Número de puntos: ');

x = zeros(1, n);
y = zeros(1, n);

for i = 1:n
x(i) = input(sprintf('x(%d): ', i));
y(i) = input(sprintf('y(%d): ', i));
end

x_eval = input('Introduce el valor de x para evaluar el polinomio: ');

P_eval = 0;
syms X;
P = 0;

for i = 1:n
L_i = 1;
for j = 1:n
if i ~= j
L_i = L_i * (X - x(j)) / (x(i) - x(j));
end
end

P = P + y(i) * L_i;

P_eval = P_eval + y(i) * double(subs(L_i, X, x_eval));

end

disp('El polinomio de interpolación de Lagrange es:');

disp(expand(P));

fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, P_eval);

x_plot = linspace(min(x), max(x), 100);
y_plot = double(subs(P, X, x_plot));

plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;

plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación de Lagrange');
legend('Datos', 'Polinomio Interpolador');
grid on;

Introduce el valor de x para evaluar el polinomio: 5

El polinomio de interpolación de Lagrange es: X^3/36 - (2*X^2)/9 + (31*X)/36 + 1/3

El valor interpolado en x = 5.0000 es y = 2.5556

Resolver. Dados los puntos (1,2),(2,4),(3,6) y (4,8). Encuentre el polinomio de interpolacion

de lagrange que pase por estos puntos

P(x)=2*L1(X)+4*L2(X)+6*L3(X)+8*L4(X)

DONDE
Simplificando la expresión
P(x)=2*L1(X)+4*L2(X)+6*L3(X)+8*L4(X)

P(x)=

Código en MATLAB
% Definición del polinomio P(x) = X^3 - 5X^2 + 10X - 2
fprintf('Interpolación polinómica para el polinomio P(x) = X^3 - 5X^2 + 10X - 2\n');
% Definir los puntos de evaluación manualmente para interpolar
n = 4; % Número de puntos
x = [1, 2, 3, 4]; % Puntos de x para la interpolación (puedes cambiar estos puntos si lo
deseas)
y = x.^3 - 5*x.^2 + 10*x - 2; % Puntos correspondientes de y usando P(x)
% Matriz del sistema de ecuaciones
A = zeros(n);
for i = 1:n
for j = 1:n
A(i, j) = x(i)^(j-1); % Construir la matriz de coeficientes
end
end
% Resolver el sistema de ecuaciones para obtener los coeficientes
coef = A \ y';
% Mostrar el polinomio interpolador
fprintf('\nEl polinomio interpolador es:\n');
syms X;
P = 0;
for i = 1:n
if coef(i) ~= 0
fprintf('%+.4f*X^%d ', coef(i), i-1);
end
P = P + coef(i) * X^(i-1); % Construir el polinomio
end
fprintf('\n\n');
% Evaluar el polinomio interpolador en un valor de x
x_eval = input('Introduce el valor de x a evaluar: ');
y_eval = double(subs(P, X, x_eval));
fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, y_eval);
% Graficar el polinomio y los puntos originales
x_plot = linspace(min(x), max(x), 100); % Crear puntos para la gráfica
y_plot = double(subs(P, X, x_plot)); % Evaluar el polinomio en estos puntos
% Graficar
plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;
plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación Polinómica');
legend('Puntos originales', 'Polinomio Interpolador');
grid on;

Resolver: Dados los valores: (0,1); (1,3) y (2,0); evaluar f(-1)

Escribimos la fórmula de interpolación por Lagrange.

Ubicamos nuestros puntos.

Empezamos a reemplazar los puntos en la fórmula hallando las

Reemplazamos y en la fórmula.
Simplificamos en polinomio y graficamos para comprobar los puntos.

Evaluamos lo solicitado: f (-1)

Código en MATLAB
function ecuacion=mlagrange(xi,fxi)
n=length(xi);
syms x;
for i=1:n
Li=1;
for j=1:n
if j~=i
Li=Li*((x-xi(j))/(xi(i)-xi(j)));
end
end
L(i)=Li;

end

ecuacion=0;
for i=1:n
ecuacion=L(i)*fxi(i)+ecuacion;
end

ecuacion=simplify(expand(ecuacion));

end

En command window colocando los valores: (x,y)=(0,1); (1,3) y (2,0)

>> xi=[0 1 2];

>> fxi=[1 3 0];
>> ecuacion=mlagrange(xi,fxi)

ecuacion =

(9*x)/2 - (5*x^2)/2 + 1

Dibujando la curva en MATLAB

>> plot(xi,fxi,'*','linewidth',8)
>> hold on
>> grid on
>> fplot(ecuacion,[-5 5])
 C. INTERPOLACIÓN DE NEWTON (DIFERENCIAS DIVIDIDAS)

Aproximar el valor de v para i=3.5

1 2 3 4
120 94 75 62

Reemplanzado:

Para i=x=3.5

fprintf('Introduce los puntos manualmente:\n');

n = input('Número de puntos: ');

x = zeros(1, n);
y = zeros(1, n);

for i = 1:n
x(i) = input(sprintf('x(%d): ', i));
 y(i) = input(sprintf('y(%d): ', i));
end

DD = zeros(n, n);
DD(:,1) = y';

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

disp('Tabla de diferencias divididas:');

disp(DD);

syms X;
P = y(1);
for k = 2:n
term = 1;
for m = 1:k-1
term = term * (X - x(m));
end
P = P + DD(1,k) * term;
end

x_eval = input('Introduce el valor de x para evaluar el polinomio: ');

P_eval = double(subs(P, X, x_eval));

disp('El polinomio de interpolación de Newton es:');

disp(expand(P));
fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, P_eval);

x_plot = linspace(min(x), max(x), 100);

y_plot = double(subs(P, X, x_plot));

plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;

plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación de Newton');
legend('Datos', 'Polinomio Interpolador');
grid on;

Tabla de diferencias divididas:

2.0000 2.0000 2.0000 -0.1241
4.0000 6.0000 4.0000 0
21.0000 7.0000 0 0
56.0000 0 0 0

Introduce el valor de x para evaluar el polinomio: 2.5

El polinomio de interpolación de Newton es: - 0.167X^3 + 4.052*X^2 – 38.337*X + 154

El valor interpolado en x = es y =

Evaluar en x=2.5
x 1 2 3 4
F(x) 2 4 10 18
Bo=2

B1=2

B2=2

B3=-1/3

fprintf('Introduce los puntos manualmente:\n');

n = input('Número de puntos: ');

x = zeros(1, n);
y = zeros(1, n);

for i = 1:n
x(i) = input(sprintf('x(%d): ', i));
y(i) = input(sprintf('y(%d): ', i));
end

DD = zeros(n, n);
DD(:,1) = y';

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

disp('Tabla de diferencias divididas:');

disp(DD);

syms X;
P = y(1);
for k = 2:n
term = 1;
for m = 1:k-1
term = term * (X - x(m));
end
P = P + DD(1,k) * term;
end

x_eval = input('Introduce el valor de x para evaluar el polinomio: ');

P_eval = double(subs(P, X, x_eval));

disp('El polinomio de interpolación de Newton es:');

disp(expand(P));
fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, P_eval);
x_plot = linspace(min(x), max(x), 100);
y_plot = double(subs(P, X, x_plot));

plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;

plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación de Newton');
legend('Datos', 'Polinomio Interpolador');
grid on;

Tabla de diferencias divididas:

2.0000 2.0000 2.0000 -0.3333
4.0000 6.0000 1.0000 0
10.0000 8.0000 0 0
18.0000 0 0 0

Introduce el valor de x para evaluar el polinomio: 2.5

El polinomio de interpolación de Newton es: - X^3/3 + 4*X^2 - (23*X)/3 + 6

El valor interpolado en x = 2.5000 es y = 6.6250

Resolver.- Encontrar el polinomio de interpolación que pase por los puntos (1,2),(2,4),(3,6) y
(4,8)
Calculando las diferencias divididas
Luego aplicamos la fórmula de interpolación de newton
P(x)=2+(x-1)*2+(x-1)*(x-2)*0+(x-1)*(x-2)*(x-3)*0

Simplificando la expresión tenemos

P(x)=2x

% Definición del polinomio P(x) = 2x

fprintf('Interpolación polinómica para el polinomio P(x) = 2x\n');

% Definir los puntos de evaluación manualmente para interpolar

n = 4; % Número de puntos
x = [1, 2, 3, 4]; % Puntos de x para la interpolación (puedes cambiar estos puntos si lo
deseas)
y = 2 * x; % Puntos correspondientes de y usando P(x) = 2x

% Matriz del sistema de ecuaciones

A = zeros(n);
for i = 1:n
for j = 1:n
A(i, j) = x(i)^(j-1); % Construir la matriz de coeficientes
end
end

% Resolver el sistema de ecuaciones para obtener los coeficientes

coef = A \ y';

% Mostrar el polinomio interpolador

fprintf('\nEl polinomio interpolador es:\n');
syms X;
P = 0;
for i = 1:n
if coef(i) ~= 0
fprintf('%+.4f*X^%d ', coef(i), i-1);
end
P = P + coef(i) * X^(i-1); % Construir el polinomio
end
fprintf('\n\n');

% Evaluar el polinomio interpolador en un valor de x

x_eval = input('Introduce el valor de x a evaluar: ');
y_eval = double(subs(P, X, x_eval));
fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, y_eval);

% Graficar el polinomio y los puntos originales

x_plot = linspace(min(x), max(x), 100); % Crear puntos para la gráfica
y_plot = double(subs(P, X, x_plot)); % Evaluar el polinomio en estos puntos

% Graficar
plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;
plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación Polinómica');
legend('Puntos originales', 'Polinomio Interpolador');
grid on;

Resolver: Hallar el polinomio de interpolación que pase por los puntos (-1,4),(0,1) y (2,-1)
El polinomio esta dado por:

Pn(x)=d0+d1(x-x0)+d2(x-x0)(x-x1)+d3(x-x0)(x-x1)(x-x2)+… +dn(x-x0)(x-x1)(x-x2)…(x-xn)

Hallando

X0 X1 x2

x -1 0 2

y 4 1 -1

d0 4

d1

d2

Pn(x)=d0+d1(x-x0)+d2(x-x0)(x-x1)+d3(x-x0)(x-x1)(x-x2)+… +dn(x-x0)(x-x1)(x-x2)…(x-xn)
P2(x)= d0+d1(x+1)+d2(x+1)(x)
P2(x)= 4+(-3)(x+1)+(2/3)(x+1)(x)
P2(x)= (1/3)-(7/3)x+(2/3)x2

COMANDO MATLAB

%calcular interpolacion de Newton

%function[yi,p,b]=inter_newton(x,y,xi)
%inicializacion de variables
x=input('introduzca el vector independiente "x"= ');
y=input('introduzca el vector independiente "y"= ');
xi=input('introduzca el valor "xi" a interpolar= ');
n=length(x);
b=zeros(n);
b(:,1)=y(:);
% obtencion de la tabla de diferencias finitas
% dis('obtencion de la tabla de diferencias finitas')
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
% calcula el dato interpolado
% disp ('valor de "y" interpolado: ')
x1=1;
yi=b(1,1);
for j=1:n-1
x1=x1.*(xi-x(j));
yi=yi+b(1,j+i)*x1;
end
disp('el valor de "yi" interpolado es igual a = '),disp (yi);
%construye el polinomio
p=num2str(b(1,1));
xx=x*-1;
for j=2:n
signo='';
if b(1,j)>=0
signo='+';
end
x1='';
for i=1;j-1;
signo2='';
if xx(i)>=0
signo2='+';
end
x1=strcat(x1,'*(x',signo2,num2str(xx(i)),')');
end
p=strcat(p,signo,num2str(b(1,j)),x1);
end
disp('el polinomio de interpolacion de Newton es igual a: ');
p=inline(p)
% grafica de la funcion
plot(x,y);
grid on
 D. INTERPOLACIÓN SPLINE O TRAZADORES

Construya el trazador cúbico libre de los sigueintes datos:

0.8 1.0 1.3

0.223634 0.658092 0.9951

Construccion de un spline cúbico natural:

● Construcción de un spline cúbico natural con la ecuacion

para cada

● Calcular el espaciado de los nodos con la ecuacion

● Encontrar la solucion al sistema de ecucaciones lineaes donde A es

la matriz definida como sigue

● B y x son los vectores

Una vez que se determino los valores de encontraremos las constantes

de la ecución

para cada

Una vez que se determina los valores encontramos las constantes

a partir de la ecuación

para cada

fprintf('Introduce los puntos manualmente:\n');

n = 3;

x = zeros(1, n);
y = zeros(1, n);

for i = 1:n
 x(i) = input(sprintf('x(%d): ', i));
y(i) = input(sprintf('y(%d): ', i));
end

x_eval = input('Introduce el valor de x para evaluar el spline: ');

spline_coeffs = spline(x, y);

y_eval = ppval(spline_coeffs, x_eval);

disp('Coeficientes del spline cúbico por intervalos:');

disp(spline_coeffs);

fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, y_eval);

x_plot = linspace(min(x), max(x), 100);

y_plot = ppval(spline_coeffs, x_plot);

plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;

plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación Spline');
legend('Datos', 'Spline Cúbico');
grid on;

Resolver: Los puntos (1,2.5),(2,4.1),(3,3.7)

Evaluar en x=3.2
Evaluar en x=3.2

fprintf('Introduce los puntos manualmente:\n');

n = 3;

x = zeros(1, n);
y = zeros(1, n);

for i = 1:n
x(i) = input(sprintf('x(%d): ', i));
y(i) = input(sprintf('y(%d): ', i));
end

x_eval = input('Introduce el valor de x para evaluar el spline: ');

spline_coeffs = spline(x, y);

y_eval = ppval(spline_coeffs, x_eval);

disp('Coeficientes del spline cúbico por intervalos:');

disp(spline_coeffs);

fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, y_eval);

x_plot = linspace(min(x), max(x), 100);

y_plot = ppval(spline_coeffs, x_plot);

plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;

plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación Spline');
legend('Datos', 'Spline Cúbico');
grid on;

Introduce el valor de x para evaluar el spline: 3.2

Coeficientes del spline cúbico por intervalos:
form: 'pp'
breaks: [1 3]
coefs: [-1.0000 2.6000 2.5000]
pieces: 1
order: 3
dim: 1

El valor interpolado en x = 3.2000 es y = 3.3800

Resolver: Encontrar la función interpolada que pase por los puntos (0,1),(1,3),(2,5) y (3,7)
Puntos de control

Primero definidos los puntos de control

Coeficientes del spline

Luego calculamos los coeficientes del spline cubico
Spline cubico
Finalmente evaluamos el spline cubico en los puntos de interés para obtener la función
interpolada

Simplificando la expresión, obtenemos

Resultado: El polinomio de interpolación obtenido es

Código en MATLAB
fprintf('Método de interpolación spline cúbico para el polinomio f(x) = x^2 + 2x + 1\n');

% Definir los puntos de evaluación manualmente para interpolar

n = 3; % Número de puntos
x = [0, 1, 2]; % Puntos de x para la interpolación (puedes cambiar estos puntos si lo deseas)
y = x.^2 + 2*x + 1; % Puntos correspondientes de y usando f(x) = x^2 + 2x + 1

% Introducir un valor de x para evaluar el spline

x_eval = input('Introduce el valor de x para evaluar el spline: ');

% Crear el spline cúbico

spline_coeffs = spline(x, y);

% Evaluar el spline en el valor de x proporcionado

y_eval = ppval(spline_coeffs, x_eval);

% Mostrar los coeficientes del spline cúbico

disp('Coeficientes del spline cúbico por intervalos:');
disp(spline_coeffs);

% Mostrar el valor interpolado

fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, y_eval);

% Graficar los puntos originales y el spline

x_plot = linspace(min(x), max(x), 100); % Puntos para graficar
y_plot = ppval(spline_coeffs, x_plot); % Evaluar el spline en estos puntos

% Graficar los resultados

plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;
plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación Spline Cúbico');
legend('Datos', 'Spline Cúbico');
grid on;

E. INTERPOLACIÓN HERMITE

Supongamos que queremos calcular donde a

partir de interoikacuib de hermite en Para ello hacemos la tabla como
interpolacion de newton pero repitiendo cada dato del que conozcamos su derivada. Es
decir:

0 0

0 0

1/4 1

1/4 1

Procedindo de la misma forma que en interpolacion de Newto, obtenemos:

Ahora:

fprintf('Introduce los puntos y las derivadas manualmente:\n');

n = input('Número de puntos: ');

x = zeros(1, n);
y = zeros(1, n);
dy = zeros(1, n);

for i = 1:n
x(i) = input(sprintf('x(%d): ', i));
y(i) = input(sprintf('y(%d): ', i));
dy(i) = input(sprintf('f''(%d): ', i));
end

x_eval = input('Introduce el valor de x para evaluar el polinomio: ');

m = 2 * n;
z = zeros(1, m);
Q = zeros(m, m);

for i = 1:n
z(2 * i - 1) = x(i);
z(2 * i) = x(i);
Q(2 * i - 1, 1) = y(i);
Q(2 * i, 1) = y(i);
Q(2 * i, 2) = dy(i);
if i > 1
Q(2 * i - 1, 2) = (Q(2 * i - 1, 1) - Q(2 * i - 2, 1)) / (z(2 * i - 1) - z(2 * i - 2));
end
end
for j = 3:m
for i = j:m
Q(i, j) = (Q(i, j - 1) - Q(i - 1, j - 1)) / (z(i) - z(i - j + 1));
end
end

p = Q(1, 1);
prod_term = 1;

for i = 2:m
prod_term = prod_term * (x_eval - z(i - 1));
p = p + Q(i, i) * prod_term;
end

disp('Tabla de diferencias divididas de Hermite:');

disp(Q);

fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, p);

x_plot = linspace(min(x), max(x), 100);

y_plot = zeros(1, 100);

for i = 1:100
xi = x_plot(i);
y_plot(i) = Q(1, 1);
prod_term = 1;
for j = 2:m
prod_term = prod_term * (xi - z(j - 1));
y_plot(i) = y_plot(i) + Q(j, j) * prod_term;
end
end

plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;

plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación de Hermite');
legend('Datos', 'Polinomio de Hermite');
grid on;

Introduce el valor de x para evaluar el polinomio: 0.25

Tabla de diferencias divididas de Hermite:

1.0000 0 0 0 0 0
1.0000 0.25000 0 0 0 0
2.0000 2.0000 0.5000 0 0 0
2.0000 0.5000 -0.9000 -3.2000 0 0
2.5000 -1.5000 -5.8000 -4.5500 0.3250 0
3.5000 -0.3000 3.1000 4.5000 6.1250 1.3500

El valor interpolado en x = 0.25000 es y = 0.4018

Interpolación Hermite
x F(x) F(x)'
1 2 0.5
2 3 0.3
3 1.5 -0.2
x=1.5

Zk P.D.D S.D.D T.D.D C.D.D Q.D.D

Z0=1 2
Z1=1 2 0.5
Z2=2 3 1 0.5
Z3=2 3 0.3 -0.7 -1.2
Z4=3 1.5 -1.5 1.8 -0.55 0.325
Z5=3 1.5 -0.2 1.3 3.1 1.825

P.D.D
0.5

S.D.D
0.5
=-0.7
1.8
1.3

T.D.D
-1.2
-0.55
3.1

C.D.D
0.325
1.825

Q.D.D

fprintf('Introduce los puntos y las derivadas manualmente:\n');

n = input('Número de puntos: ');

x = zeros(1, n);
y = zeros(1, n);
dy = zeros(1, n);
for i = 1:n
x(i) = input(sprintf('x(%d): ', i));
y(i) = input(sprintf('y(%d): ', i));
dy(i) = input(sprintf('f''(%d): ', i));
end

x_eval = input('Introduce el valor de x para evaluar el polinomio: ');

m = 2 * n;
z = zeros(1, m);
Q = zeros(m, m);

for i = 1:n
z(2 * i - 1) = x(i);
z(2 * i) = x(i);
Q(2 * i - 1, 1) = y(i);
Q(2 * i, 1) = y(i);
Q(2 * i, 2) = dy(i);
if i > 1
Q(2 * i - 1, 2) = (Q(2 * i - 1, 1) - Q(2 * i - 2, 1)) / (z(2 * i - 1) - z(2 * i - 2));
end
end

for j = 3:m
for i = j:m
Q(i, j) = (Q(i, j - 1) - Q(i - 1, j - 1)) / (z(i) - z(i - j + 1));
end
end

p = Q(1, 1);
prod_term = 1;

for i = 2:m
prod_term = prod_term * (x_eval - z(i - 1));
p = p + Q(i, i) * prod_term;
end

disp('Tabla de diferencias divididas de Hermite:');

disp(Q);

fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, p);

x_plot = linspace(min(x), max(x), 100);

y_plot = zeros(1, 100);

for i = 1:100
xi = x_plot(i);
y_plot(i) = Q(1, 1);
prod_term = 1;
for j = 2:m
prod_term = prod_term * (xi - z(j - 1));
y_plot(i) = y_plot(i) + Q(j, j) * prod_term;
end
end

plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;

plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación de Hermite');
legend('Datos', 'Polinomio de Hermite');
grid on;

Introduce el valor de x para evaluar el polinomio: 1.5

Tabla de diferencias divididas de Hermite:
2.0000 0 0 0 0 0
2.0000 0.5000 0 0 0 0
3.0000 1.0000 0.5000 0 0 0
3.0000 0.3000 -0.7000 -1.2000 0 0
1.5000 -1.5000 -1.8000 -0.5500 0.3250 0
1.5000 -0.2000 1.3000 3.1000 1.8250 0.7500

El valor interpolado en x = 1.5000 es y = 2.4750

Resolver.- Encontrar la función que pase por los puntos (0,1),(1,3) y (2,5)
Y que también satisfaga las condiciones de derivadas f`(0)=2 y f`(2)=4

Puntos de interpolación
Primero definimos los puntos de interpolación

Condiciones de derivada
Luego definimos las condiciones de derivada
f`(0)=2 y f`(2)=4
funciones de hermite
calculamos las funciones de hermite

Finalmente utilizamos la fórmula de interpolación de Hermite

Reemplazando los valores y simplificando la expresión

Donde la función hallada pasa por los puntos dados y también satisface las condiciones de
la derivada.

Código en MATLAB
fprintf('Método de interpolación de Hermite para el polinomio f(x) = x^3 - 2x^2 + 3x + 1\n');
% Definir los puntos de evaluación manualmente para interpolar
n = 3; % Número de puntos
x = zeros(1, n);
y = zeros(1, n);
dy = zeros(1, n);
% Introducir puntos y derivadas
for i = 1:n
x(i) = input(sprintf('x(%d): ', i));
y(i) = x(i)^3 - 2*x(i)^2 + 3*x(i) + 1; % f(x) = x^3 - 2x^2 + 3x + 1
dy(i) = 3*x(i)^2 - 4*x(i) + 3; % f'(x) = 3x^2 - 4x + 3
end

x_eval = input('Introduce el valor de x para evaluar el polinomio: ');

% Preparar el sistema para la interpolación de Hermite
m = 2 * n;
z = zeros(1, m);
Q = zeros(m, m);
% Inicializar los valores de z y la tabla de diferencias divididas
for i = 1:n
z(2 * i - 1) = x(i);
z(2 * i) = x(i);
Q(2 * i - 1, 1) = y(i);
Q(2 * i, 1) = y(i);
Q(2 * i, 2) = dy(i);
if i > 1
Q(2 * i - 1, 2) = (Q(2 * i - 1, 1) - Q(2 * i - 2, 1)) / (z(2 * i - 1) - z(2 * i - 2));
end
end

% Calcular las diferencias divididas superiores

for j = 3:m
for i = j:m
Q(i, j) = (Q(i, j - 1) - Q(i - 1, j - 1)) / (z(i) - z(i - j + 1));
end
end
% Evaluar el polinomio de Hermite en x_eval
p = Q(1, 1);
prod_term = 1;
for i = 2:m
prod_term = prod_term * (x_eval - z(i - 1));
p = p + Q(i, i) * prod_term;
end
% Mostrar los coeficientes de las diferencias divididas de Hermite
disp('Tabla de diferencias divididas de Hermite:');
disp(Q);
% Mostrar el valor interpolado
fprintf('El valor interpolado en x = %.4f es y = %.4f\n', x_eval, p);
% Graficar el polinomio interpolador
x_plot = linspace(min(x), max(x), 100); % Puntos para graficar
y_plot = zeros(1, 100);
for i = 1:100
 xi = x_plot(i);
y_plot(i) = Q(1, 1);
prod_term = 1;
for j = 2:m
prod_term = prod_term * (xi - z(j - 1));
y_plot(i) = y_plot(i) + Q(j, j) * prod_term;
end
end
% Graficar los resultados
plot(x, y, 'ro', 'MarkerSize', 8, 'LineWidth', 2); hold on;
plot(x_plot, y_plot, 'b-', 'LineWidth', 2);
xlabel('x'); ylabel('f(x)');
title('Interpolación de Hermite');
legend('Datos', 'Polinomio de Hermite');
grid on;