Universidad ECCI

Taller Corte I
Métodos Numéricos
Profesor: Mauricio Munar
Jonathan Barahona pineda cod: 45462
Ferney Beltrán cod 46232

1. Punto 1
Se usan los códigos de extensión .m (para ejecutar en Octave o Matlab), el primero de ellos llamado funcion-
punto1.m es para la función a la que se le quiere calcular la raı́z:
Código funcionpunto1.m
function y=funcionpunto1(x)
y=((9.8/15)*x)*(1-exp(-135/x))-35;

1.1. Solución por método de bisección

La solución obtenida por el método de bisección se cálcula con el algoritmo de nombre biseccionpunto1.m:
biseccionpunto1.m
aant=55;cant=62;
bant=62;
Nmax=45;
for i=1:Nmax
fa=funcionpunto1(aant);
fb=funcionpunto1(bant);
c=0.5*(aant+bant);
fc=funcionpunto1(c);
if(fc==0)break;
end
if(sign(fa)~=sign(fc))
anue=aant;
bnue=c;
else
anue=c;
bnue=bant;
end
fprintf(’c(%d)=%.10f\n’,i,c)
fprintf(’ea(%d)=%.10f\n’,i,abs(bnue-anue))
if abs(bnue-anue)<0.0005 break;
end
aant=anue;
bant=bnue;

1
 cant=c;
end
A continuación se presenta la tabla de datos generado por el algoritmo. Se obtiene el siguiente resultado donde
se muestra la iteración, la raı́z y el error absoluto.
c(1)=58.5000000000
ea(1)=3.5000000000
c(2)=60.2500000000
ea(2)=1.7500000000
c(3)=59.3750000000
ea(3)=0.8750000000
c(4)=59.8125000000
ea(4)=0.4375000000
c(5)=60.0312500000
ea(5)=0.2187500000
c(6)=59.9218750000
ea(6)=0.1093750000
c(7)=59.8671875000
ea(7)=0.0546875000
c(8)=59.8398437500
ea(8)=0.0273437500
c(9)=59.8535156250
ea(9)=0.0136718750
c(10)=59.8466796875
ea(10)=0.0068359375
c(11)=59.8432617188
ea(11)=0.0034179688
c(12)=59.8415527344
ea(12)=0.0017089844
c(13)=59.8406982422
ea(13)=0.0008544922
c(14)=59.8411254883
ea(14)=0.0004272461

1.2. Solución por método de Regula-Falsi

En este punto presentamos un código llamado falsi.m para el método de Regula-Falsi. regulafalsipunto1.m
Xi=55;
Xs=62;
delta=0.0005;
Iter=35;

Yi=funcionpunto1(Xi);
Ys=funcionpunto1(Xs);

if Yi==0
fprintf(’\n\nSOLUCION:\n’)
fprintf(’Xi es raiz\n\n’);
else
if Ys==0
fprintf(’\n\nSOLUCION:\n’)
fprintf(’Xs es raiz\n\n’);
else
if Yi*Ys<0

2
 Xm=(Xi)-((funcionpunto1(Xi)*(Xi-Xs))/(funcionpunto1(Xi)-funcionpunto1(Xs)));
Ym=funcionpunto1(Xm);
Error=delta+1;
Cont=1;
Z=[Cont,Xi,Xs,Xm,Ym,Error];

while Ym~=0 & Error>delta & Cont<Iter

if Yi*Ym<0
Xs=Xm;
Ys=Ym;
else
Xi=Xm;
Yi=Ym;
end
Xaux=Xm;
Xm=(Xi)-((funcionpunto1(Xi)*(Xi-Xs))/(funcionpunto1(Xi)-funcionpunto1(Xs)));
Ym=funcionpunto1(Xm);
Error=abs(Xm-Xaux);
Cont=Cont+1;
Z(Cont,1)=Cont;
Z(Cont,2)=Xi;
Z(Cont,3)=Xs;
Z(Cont,4)=Xm;
Z(Cont,5)=Ym;
Z(Cont,6)=Error;
end
if Ym==0
fprintf(’\n\nSOLUCION:\n’)
fprintf(’%.10f es ra~Az\n\n’,Xm);
else
if Error<delta
fprintf(’\n\nSOLUCION:\n’)
fprintf( ’%.10f es una aproximacion a una ra~
Az con una tolerancia %.10f \n\n’,Xm,delta);
else
fprintf(’\n\nSOLUCION:\n’)
fprintf(’Fracaso en %d iteraciones\n\n’,Iter);
end
end
else
fprintf(’\n\nSOLUCION:\n’)
fprintf(’El intervalo es inadecuado\n\n’);
end
end
end
fprintf(’TABLA\n\nIteraciones Xi Xs Xm Ym Error Absoluto\n\n’);
disp(Z);
A continuación se presenta la tabla de datos generado por el algoritmo.
SOLUCION:
59.8410471102 es una aproximacion a una ra~
Az con una tolerancia 0.0005000000

TABLA

Iteraciones Xi Xs Xm Ym Error Absoluto

3
 1.0000e+00 5.5000e+01 6.2000e+01 5.9911e+01 3.0171e-02 1.0005e+00
2.0000e+00 5.5000e+01 5.9911e+01 5.9843e+01 9.7498e-04 6.7858e-02
3.0000e+00 5.5000e+01 5.9843e+01 5.9841e+01 3.1487e-05 2.1919e-03
4.0000e+00 5.5000e+01 5.9841e+01 5.9841e+01 1.0169e-06 7.0785e-05

1.3. Comparación
Viendo el resultados de los dos programas anteriores, Se puede evidenciar que ambos metodos convergen y se
obtiene la raı́z de la función en el internvalo. Además, también se ve que el método de la Regula-Falsi encuentra
mucho más rápido la raı́z, pues solo necesita 4 iteraciones mientras que el método de bisección lo hace en 14
iteraciones. Se concluye que el segundo método posee una mayor velocidad de convergencia.

2. Punto 2
De acuerdo al enunciado del problema, para aplicar el método de Newton-Raphson, se precisa de la función y
la derivada de la función, pero no me fue es posible determinar la función, ya que se precisaba resolver la ecuación
diferencial no lineal de primer orden, además se entiende que la solución en estado estable de una ecuación diferencial
son las soluciones constantes, es decir las que tienen derivada nula, puesto que en el método se precisa dividir por
la derivada, esta no se puede tomar nula; es ası́ que si se toma como la derivada de la funcion, la planteada en el
enunciado, entonces no se puede obtener la función, y por otro lado si se tiene la función constante entonces no se
tiene la derivada no nula para el método.

2.1. Método del punto fijo

Por otro, la segunda parte del ejercicio usa en efecto la derivada nula para despejar la función c(t):
 2
W − Qc
c(t) =
KV

funcionpunto2a.m
function y=funcionpunto2a(x)
y=(((10^6)-((10^5)*x))/(0.25*(10^6)))^2;
funcionpunto2a.m
clc
clear
x0=4;
epsilon=5*10^-4;
n=20;
for i=1:n
xn=x0;
x0=funcionpunto2a(x0);
if(abs(xn-x0)<epsilon)
fprintf(’la raiz se obtuvo en la %d-esima iteracion y es %f’,i,funcionpunto2a(x0))
fprintf(’\n\n’)
return
else
fprintf(’x_%d = %f, x_%d = %f \n’,i-1,xn,i,funcionpunto2a(x0))
fprintf(’\n\n’);
end
end
fprintf(’\n\n’);

4
 Se obtienen los siguientes resultados.

x_0 = 4.000000, x_1 = 2.876416

x_1 = 5.760000, x_2 = 8.119272
x_2 = 2.876416, x_3 = 0.565942
x_3 = 8.119272, x_4 = 14.240232
x_4 = 0.565942, x_5 = 2.876730
x_5 = 14.240232, x_6 = 8.118555
x_6 = 2.876730, x_7 = 0.566373
x_7 = 8.118555, x_8 = 14.238930
x_8 = 0.566373, x_9 = 2.874964
x_9 = 14.238930, x_10 = 8.122582
x_10 = 2.874964, x_11 = 0.563952
x_11 = 8.122582, x_12 = 14.246240
x_12 = 0.563952, x_13 = 2.884889
x_13 = 14.246240, x_14 = 8.099968
x_14 = 2.884889, x_15 = 0.577619
x_15 = 8.099968, x_16 = 14.205001
x_16 = 0.577619, x_17 = 2.829126
x_17 = 14.205001, x_18 = 8.227430
x_18 = 2.829126, x_19 = 0.502721
x_19 = 8.227430, x_20 = 14.431731
Se puede evidenciar que el método no converge para esta función
Función segunda forma la función c(t):
√
W − KV c
c(t) =
Q
funcionpunto2b.m
function y=funcionpunto2b(x)
y=(((10^6)-((0.25*10^6)*(sqrt(x))))/(10^5));
En este caso se obtiene la raı́z buscada
x_0 = 3.500000, x_1 = 4.232132
x_1 = 5.322928, x_2 = 4.856963
x_2 = 4.232132, x_3 = 4.490370
x_3 = 4.856963, x_4 = 4.702377
x_4 = 4.490370, x_5 = 4.578759
x_5 = 4.702377, x_6 = 4.650491
x_6 = 4.578759, x_7 = 4.608751
x_7 = 4.650491, x_8 = 4.633000
x_8 = 4.608751, x_9 = 4.618899
x_9 = 4.633000, x_10 = 4.627094
x_10 = 4.618899, x_11 = 4.622330
x_11 = 4.627094, x_12 = 4.625099
x_12 = 4.622330, x_13 = 4.623489
x_13 = 4.625099, x_14 = 4.624425
x_14 = 4.623489, x_15 = 4.623881
x_15 = 4.624425, x_16 = 4.624197

la raiz se obtuvo en la 17-esima iteracion y es 4.624013

De estos resultados se ve que por medio del mismo método la convergencia o no del algoritmo depende además
de la forma en que se introduzca la función a la que se desea calcular la raiz.

5
3. Punto 3
3.1. Método de Jacobi
Se presenta un código en MATLAB llamado punto3Jacobi.m, en este código se presenta el método de Jacobi.

punto3Jacobi.m
clc
clear
A=[4 -1 0 -1 0 0; -1 4 -1 0 -1 0; 0 -1 4 0 0 -1;
-1 0 0 1 -1 0; 0 -1 0 -1 4 -1; 0 0 -1 0 -1 4];
B=[0; 5; 0; 6; -2; 6];
punto_inicial=[0; 0; 0; 0; 0; 0];
error=5*10^(-4);
cont_iteraciones=10;
s=size(A);
num_ecuaciones=s(1);
for k=1:num_ecuaciones
B(k)=B(k)/A(k,k);
A(k,:)=A(k,:)/A(k,k);
A(k,k)=0;
end
M=-A;
x_ant=punto_inicial;
x_sig=M*x_ant+B;
deltax_n=x_sig-x_ant;
while norm(deltax_n,inf) > error
x_sig=M*x_ant+B;
deltax_n=x_sig-x_ant;
x_ant=x_sig;
cont_iteraciones=cont_iteraciones+1;
end
solucion=x_sig
num_iteraciones=cont_iteraciones
Se obtienen los siguientes resultados.
solucion =

5.4724
4.5800
2.0105
17.3095
5.8379
3.4620

num_iteraciones = 58

3.2. Método de Gauss-Seidel

Se presenta un código en MATLAB llamado punto3GaussSeidel.m, en este código se presenta el método de
Gauss-Seidel.

punto3GaussSeidel.m

6
clc
clear
A=[4 -1 0 -1 0 0; -1 4 -1 0 -1 0; 0 -1 4 0 0 -1;
-1 0 0 1 -1 0; 0 -1 0 -1 4 -1; 0 0 -1 0 -1 4];
B=[0; 5; 0; 6; -2; 6];
punto_inicial=[0; 0; 0; 0; 0; 0];
error=5*10^(-4);
D=diag(diag(A));
U=triu(A)-D;
L=tril(A)-D;
M=-inv(D+L)*U;
N=inv(D+L)*B;
cont=1;
xant=punto_inicial;
xsig=M*xant+N;
while norm(xsig-xant,inf)>error
cont=cont+1;
xant=xsig;
xsig=M*xant+N;
end
sol=xsig
niteraciones=cont
error=norm(xsig-xant,inf)
Se obtuvieron los siguientes resultados.
sol =

5.4728
4.5804
2.0107
17.3111
5.8384
3.4623

niteraciones = 27
error = 3.4934e-04

3.3. Método SOR

Se presenta un código en MATLAB llamado sor.m, en este código se presenta el método de SOR.

punto3sor.m
function [x] = punto3sor()
n=6;
A=[4 -1 0 -1 0 0; -1 4 -1 0 -1 0; 0 -1 4 0 0 -1;
-1 0 0 1 -1 0; 0 -1 0 -1 4 -1; 0 0 -1 0 -1 4];
b=[0; 5; 0; 6; -2; 6];
maxiter=30;
x0=[0; 0; 0; 0; 0; 0];
w=0.9;
tol= 0.0005;
[m n]= size(A);
if m~=n
fprintf(’Matriz del sistema no cuadrada’);

7
 end
if m~= length(b)
fprintf(’sistema no coherente’);
end
x=zeros(size(b));
x2=x;
if any(abs(diag(A))<eps)
fprintf(’Metodo no valido. Elemento diagonal nulo’);
end
for k=1:maxiter
for i=1:n
tem=(b(i)-sum(A(i,[1:i-1 i+1:n])*x0([1:i-1 i+1:n]’)))/A(i,i);
x(i)=tem*w + (1-w)*x0(i);
x0(i)=x(i);
end
if norm(x-x2)< tol
fprintf(’\n SOR CONVERGE en %d iteraciones\n’,k);
return
end
x2=x;
end

Se obtienen los siguientes resultados

ans =

5.4720
4.5799
2.0105
17.3093
5.8378
3.4620

3.4. Comparación
De acuerdo a los resultados anteriores obtenemos que los 3 métodos convergen, pero los mejores métodos son los
de Gauss-Seidel y SOR ya que convergen en 27 y 28 iteraciones respectivamente, mientras que el método de Jacobi
lo hace en 58 iteraciones.