Universidad Técnica Federico Santa María

Departamento de Matemática
Laboratorio de Computación para las Aplicaciones de la Matemática en Ingeniería

LABORATORIO DE ANÁLISIS NUMÉRICO - MAT270

Laboratorio Mat 270 ­ Análisis 
Numérico
SEPTIMA SESIÓN
 Aproximación de soluciones
ecuaciones y sistemas
de ecuaciones algebraicas no lineales.
Semana del Lunes 3 al 10 de Junio de 2016

Coordinador Académico del Laboratorio: Jaime Figueroa (jaime.figueroa@usm.cl)

Ayudante Coordinador y de Software : Hernán Caviedes
(hernan.caviedes@alumnos.usm.cl)
Sitio Web :
http://lab.mat.utfsm.cl
Horario de Atención de alumnos : A través de Internet a los ayudantes
coordinadores.
JFN/WBD

Sugerencias:
 Cualquier consulta plantearla a su ayudante de sala o al ayudante coordinador.
2.1 Método General de Punto Fijo
Definición

Punto fijo de una función g  x  es toda abcisa donde g intersecta la identidad.

Método de punto fijo o de Iteración Simple

Es el método para determinar un punto fijo de g  x  y se define:

x n1  g  x n  , n  0, 1, 2, 

x 0 : punto de partida cercano al punto fijo.

Observación

Toda ecuación no lineal f  x   0 es equivalente a un problema de punto fijo del tipo g  x   x para
g  x   x  d  x  f  x  en que d  x   0 para todo x .

El método de la cuerda de Newton es un método de punto fijo del tipo anterior en que:

1
d  x  
f '  x0 

El método de Newton es un método de punto del tipo señalado en que:

1
d  x  
f  xn 

Lo interesante del problema de punto fijo es que deja libre la posibilidad de

encontrar una función d  x  que en el hecho acelere el proceso. Más adelante se
señalan métodos de convergencia cúbica los cuales son métodos de punto fijo con
diferentes funciones d  x  .

Ejercicio

El algoritmo de punto fijo puede ser muy rápido. He aquí un ejemplo de ello:
g  x  x 
 x sin  x 2 
e  x 12  e x �� 
2� cos  x    1  x  �
x �2 2
sin  x 2 

clear
gi=inline('[x+(exp(-x)*(-12-exp(x)*x*sin(x^2))/
(2*x^2*cos(x^2)+(1+x)*sin(x^2))),x]');
fplot(gi,[1.8 2.5]); grid on;
axis([1.8 2.2 1.8 2.2])

La abcisa del punto de intersección está cerca de x =2.1.

Ahora calculemos las iteraciones de punto fijo con punto inicial x0  2 y obtengamos el
punto fijo con 25 D.S.
g=inline('x+((exp(-x)*(-12-exp(x)*x*sin(x^2))/
(2*x^2*cos(x^2)+(1+x)*sin(x^2))))');
a=2;
tol=0.5*10^(-25);
digits(25);
for i=1:100,
b=g(a);
iteraciones=[vpa(a),vpa(b)]
if (abs(a-b) <= tol),
break;
end
a=b;
end
x=vpa(b)

Se ha logrado la precisión deseada en sólo 4 iteraciones.

Ejercicio:

Visualización de como opera el método en forma geométrica en el caso convergente.

Usemos un caso particular para visualizar. El punto fijo es el corte de la grafica de la

función con la identidad.

Utilicemos ahora g  x   0.8  x  0.3

clear
x=-4:8;
plot(x,0.8*x+0.3,'r',x,x,'b'),
grid on;
title('La identidad en azul')
Ilustraremos de manera gráfica cómo las iteraciones van progresando hasta alcanzar el
punto fijo. La siguiente función permite la formación de la "escalera" que es clásica
cuando la sucesión converge monótonamente.

function anima(g,x0)

xn=x0;
figure(1);
fplot(g,[-4 8]); grid on;
hold on;
fplot(@(x)x,[-4 8],'r');
for i=1:15,
xn1=g(xn);
plot([xn xn1],[xn1 xn1],'k');
pause(0.25);
xn=xn1;
xn1 = g(xn);
plot([xn xn],[xn xn1],'k');
pause(0.25);
end
hold off;

Cree esta función.

for conta=1:2;cd d:
func = 'function anima(g,x0)\n\nxn=x0;\nfigure(1);\nfplot(g,[-4 8]);
grid on;\nhold on;\nfplot(''x'',[-4 8],''r'');\nfor
i=1:15,\n\txn1=g(xn);\n\tplot([xn xn1],[xn1
xn1],''k'');\n\tpause(0.25);\n\txn=xn1;\n\txn1 = g(xn);\n\tplot([xn xn],
[xn xn1],''k'');\n\tpause(0.25);\nend\nhold off;';
a='anima.m';
if (~exist(a,'file')),
fid=fopen(a,'w');
func = strrep(func,'%','%%');
fprintf(fid,func);
fclose(fid);
disp('La funcion ha sido creada')
end
end

CASO 1: Ahora visualizamos el progreso con punto inicial x0  7 .

Para ver la animación, entramos los siguientes comandos:

g=inline('0.8*x+0.3');
x0=7;
lim=[-4 8];
anima(g,x0);
CASO 2: Ahora visualizamos el progreso con punto inicial x0  4 . Al final anime para
verlo globalmente.
x0=-4;
anima(g,x0);

Usemos otro caso particular para visualizar: g  x   0.8  x  3

El punto fijo es el corte de la grafica de la función con la identidad.

g=inline('-0.8*x+3');
x0=-4;
lim=[-4 8];
anima(g,x0);

Ejercicio.

Visualización de cómo opera el método en forma geométrica en el caso divergente.

Usemos un caso particular para visualizar: g  x   1.2  x  0.2

Ahora visualizamos "la huida" que se produce con el punto inicial x0  2 .

g=inline('1.2*x-0.2');
x0=2;
lim=[-4 8];
anima(g,x0);

Ahora visualizamos "la huida" que se produce con el punto inicial x 0  0.5 .
x0=0.5;
lim=[-4 8];
anima(g,x0);

Ejercicio

Trate usted de visualizar la convergencia o divergencia para el caso siguiente en que si, por ejemplo

parte de x0  4 ocurre "un salto" a los positivos para una posterior convergencia por descenso:
g  x   0.1  x 2  1

Ejercicio: “g” con poca pendiente.

Cuanto más horizontal, más rápido opera.

g=inline('0.2*x+1');
x0=600;
lim=[-4 8];

anima(g,x0);

También se puede probar con x0=60.

2.2 Métodos de convergencia cuadrática

2.2.1 Método de Newton

Ejemplo

Considere el problema de evaluar el trabajo realizado por una fuerza a lo largo de una
trayectoria curva parametrizada por v  t    x  t  , y  t   , donde x  t   3 �
cos  t  e
y t  2�
sin  2 �
t

clear
t=linspace(0,2);
x=3*cos(t);
y=2*sin(2*t);
plot(x,y);
grid on;
axis([-1.5 3.5 -1.5 2.5]);

La fuerza que actúa a lo largo de esa trayectoria está definida por F  { x ,1  y } . El

2 2

diferencial de trabajo está dado por: dW  F  t  �

dv , calculemos este diferencial:

clear
syms t s g
x=t+3*cos(t);
y=2*sin(2*t)-t;
f=[-x^2 2-y^2]
dv=[diff(x);diff(y)]
dW=mtimes(f,dv)
Esta función se integra entre t  0 y t  2 . La función que define el trabajo realizado
desde t  0 hasta t  s está dada por, además se realizan evaluaciones de la funcion de
trabajo desde 0 hasta 2 en Dx  0.5 .
g=int(dW,0,s)
h=inline('-3*s^2*cos(s)-9*s*cos(s)^2-9*cos(s)^3+4*sin(2*s)-
8/3*sin(2*s)^3-4*s*cos(2*s)^2+2*s-2*s^2*sin(2*s)+9','s');
digits(25);
vpa(h(2))
for i=0:0.5:2
h(i)
end

Usemos el algoritmo de Newton para encontrar en valor en el cual la función de trabajo

es igual a 10, por lo tanto, lo que estamos buscando es el límite superior de la integral.

La ecuación a resolver será entonces f  x   10  0 , en donde f '  x   dW .

clear
syms s
k=-3*s^2*cos(s)-9*s*cos(s)^2-9*cos(s)^3+4*sin(2*s)-8/3*sin(2*s)^3-
4*s*cos(2*s)^2+2*s-2*s^2*sin(2*s)+9-10;
dW=-(s+3*cos(s))^2*(1-3*sin(s))+(2-(2*sin(2*s)-s)^2)*(4*cos(2*s)-1);
s0=1;
digits(30)
for i=1:5
s=s0;
s1=s0-vpa(eval(k))/vpa(eval(dW));
s0=vpa(s1);
end
s=vpa(s0)

2.2.2 El Método de Newton Aplicado a un Problema con Tangencia

Un problema f  x   0 en que la función tiene dos ceros, uno tangente y el otro

transversal.
Ingresamos la ecuacion f  x   0 y se grafica. Claramente se distinguen dos soluciones.
clear
format long
f = inline('(x-sqrt(2)).^2.*(x-sqrt(7))');
figure(1);
fplot(f, [0 5]); grid on;
axis([0 5 -0.6 0.4])
xlabel('x'); ylabel('f(x)');

Aplicación del método de Newton (la curva identidad esta en rojo, la función de iteración
en otro color)

La derivada de la función es:

h=inline('2 + 2*sqrt(14) - 4*sqrt(2)*x - 2*sqrt(7)*x + 3*x.^2')

Se calcula la función de iteración de Newton.

Observe en el dibujo que el corte cerca de x  2.6 de la función de iteración con la

identidad es con esta última horizontal. Esto indicará la convergencia cuadrática del
método de Newton.

Se obtendrá la tabla con las Aproximaciones de la solución y el Error entre dos

aproximaciones consecutivas.
x=2.6:0.01:2.7;
g=x-f(x)./h(x);
figure(1);
plot(x,g,x,x,'r'); grid on;
axis([2.6 2.7 2.6 2.7])
aux = 3;
for i=1:10,
sig=aux-f(aux)/h(aux);
df = sig - aux;
Tabla(i,:) = [sig,df];
aux = sig;
end
Tabla
aux

Por el contrario, el corte de la identidad con la función de iteración de Newton cerca de

x  1.4 no es con esta última horizontal. Esto explica que la convergencia solo es lineal.
Se escribirá la tabla de las Aproximaciones y el Error entre dos aproximaciones
consecutivos.
aux = 2;
for i=1:10,
sig=aux-f(aux)/h(aux);
df = sig - aux;
Tabla(i,:) = [sig,df];
aux = sig;
end
Tabla
aux
f  x
Cambio del problema:  0 (curva en negro, el problema original en azul)
f '  x

Ante la convergencia lineal del método de Newton anterior, procede a reemplazar el

problema por otro que nos entregue la misma solución.

f  x
Se calcula la raíz doble de la ecuación f  x   0 a partir de la ecuación: 0
f '  x
Visualicemos el corte de la identidad con la función de iteración de Newton de esta
última ecuación. El trazado de ésta es horizontal lo cual explica la rapidez al menos
cuadrática de convergencia.
x=1.3:0.01:1.5;
u=f(x)./h(x);
figure(1);
plot(x,f(x),'b',x,u,'k'); grid on;

2.3 Método de convergencia cúbica de Bailey.

Métodos local y cúbicamente convergentes

El algoritmo siguiente es localmente y al menos cúbicamente convergente a la solución

x  a de la ecuación f  x   0 siempre que f  4  sea continua y que f '  a   0

f  xn  f ' '  xn   f  xn  
2

x n 1  xn     ; n  1, 2, 
f '  xn  2 f '  xn   f '  xn  

El método de Bailey es localmente y al menos cúbicamente convergente a la solución

x  a de la ecuación f  x   0
f  xn 
f '  xn 
x n 1  x n  ; n  1, 2, 
f  xn  f ' '  xn 
1
2 f '  x n  
2

Consideremos la siguiente ecuación f  x   0 en que intervienen funciones de Bessel de

primera especie.
Se recuerda que estas funciones se aplican en vibraciones de membranas circulares,
corrientes parásitas, problemas de difusión, etc.
clear
syms x;
digits(100);
f=besselj(4,x)-besselj(3,x)*besselj(2,x);
figure(1);
ezplot(f,[0 2]);
grid on;

Se calcula la derivada y la segunda derivada de f(x):

h=diff(f)
m=diff(f,2)
Se procede al cálculo de las aproximaciones con el método. En este caso se probará el
método de Bailey.
Solo se imprimirá el error entre dos términos consecutivos para observar como disminuye
el error con la convergencia.
gg = x - (f/h)/(1 - (f*m)/(2*h^2))

figure(1);
ezplot(x,[0.7 1.6])
hold on;
h=findobj(gcf,'type','Line');
set(h,'color','r');
ezplot(gg,[0.7 1.6])
hold off;
grid on;

aux=1;
for k=1:10,
x=vpa(aux);dos = vpa(eval(gg));
dif = vpa(dos - aux);
aux = vpa(dos);
iter(k,:) = vpa([dos dif]);
end
iter

Observe como el numero de decimales de precisión se "triplica".

Comparemos con el método de Newton:
g = x - f/h;
aux=1;
for k=1:10,
x=vpa(aux);
dos = vpa(eval(g));
dif = vpa(dos - aux);
aux = vpa(dos);
iter(k,:) = vpa([dos dif]);
end
iter

En ese caso el número de decimales de precisión sólo se duplica.

Problema.

Experimente con el otro algoritmo citado anteriormente y observe su característica cúbica.

2.4 Como Aproximar derivadas correctamente
(Sobre todo cuando se dispone sólo de tabla de datos)
Veremos cual es la forma correcta de aproximar la primera derivada de f  x   x en
7

x  3.
clear
syms x h y
digits(50);
f=inline('x^7','x');
figure(1);
ezplot(f,[1.99 2.01]);
grid on;
xlabel('X');
ylabel('f(x)=x^7');
x=3;
vpa(limit((f(x+h)-f(x))/h,h,0.01)) %Límite por la derecha
vpa(limit((f(x)-f(x-h))/h,h,0.01)) %Límite por la Izquierda
vpa(limit((f(x+h/2)-f(x-h/2))/h,h,0.01)) %Diferencia Central
w=inline('7*y^6','y');
vpa(w(3))

La Diferencia Central es la que dá una mayor cantidad de cifras significativas.

Ahora calculemos la segunda derivada de f  x   x en x  3 .

7

clear r
vpa(limit((f(x+h)-2*f(x)+f(x-h))/h^2,h,0.001))
w=inline('42*y^5','y');
vpa(w(3))

4 SISTEMAS DE ECUACIONES NO LINEALES

4.1 Método de Newton

Ejemplo.

En la sección anterior dimos gráficamente, aunque no numéricamente, con puntos de partidas para las dos soluciones que se ven ex

 x - 1 2 +  y - 2 2 = 4
 x - 3 2   y - 4  2 = 9

Un punto de partida es:  0, 3.7  y el otro:  2.7, 1 .

Apliquemos el método de Newton para obtener los puntos de corte realizando dos iteraciones.

Primero necesitamos definir las funciones que permitan escribir el sistema en la forma f1  0 , f 2  0

clear
syms x y
f1 = (x - 1)^2 + (y - 2)^2 - 4;
f2 = (x - 3)^2 + (y - 4)^2 - 9;
g=f1^2 + f2^2
Observemos que los puntos de partida son buenos puntos

p0 = [0; 3.7]
x=p0(1); y=p0(2);
a = eval(f1);
b = eval(f2);
eval(g)
valor=[a; b]

Veamos el otro:

q0 = [2.7; 1];
x=q0(1);
y=q0(2);
eval(f1)
eval(f2)

Hagamos las primeras iteraciones Newton con el primer punto. Necesitamos la matriz Jacobiana

jac = jacobian([f1;f2])

Primera iteración. Primero calculamos la inversa y después la iteración.

x=p0(1); y=p0(2);
matriz = eval(inv(jac))
p1 = p0 - matriz*valor

x=p1(1); y=p1(2);
valor = [eval(f1); eval(f2)]
eval(g)

Segunda Iteracion

matriz = eval(inv(jac))
p2 = p1 - matriz*valor

Comprebemos que descendimos

x=p2(1); y=p2(2);
eval(f1)
eval(f2)
eval(g)

Ejemplo
Resolvamos el problema de calcular los coeficientes y nodos de la formula de aproximación gaussiana propuesto en la sección ante

Habíamos establecido el sistema de ecuaciones no lineales a resolver: F  0 en que F esta dado por:
syms x1 x2 x3 w1 w2 w3 x;
X=[x1 x2 x3 w1 w2 w3];
F=[ X(4) + X(5) + X(6) - 2;
X(4)*X(1) + X(5)*X(2) + X(6)*X(3) - int(x,x,-1,1);
X(4)*X(1)^2 + X(5)*X(2)^2 + X(6)*X(3)^2 - int(x^2,x,-1,1);
X(4)*X(1)^3 + X(5)*X(2)^3 + X(6)*X(3)^3 - int(x^3,x,-1,1);
X(4)*X(1)^4 + X(5)*X(2)^4 + X(6)*X(3)^4 - int(x^4,x,-1,1);
X(4)*X(1)^5 + X(5)*X(2)^5 + X(6)*X(3)^5 - int(x^5,x,-1,1)]

De la sección anterior tenemos una idea para el punto de partida

A=[0.7, 0, -0.7, 0.6, 0.7, 0.6];

v=A

Lo que se necesita ahora es la función de iteración del algoritmo de Newton:

G  X - J(X) -1 F(X)

Fundamentalmente se necesita la matriz jacobiana de F.

La inversa se hará numéricamente para cada iteración.

J=jacobian(F,X)

Primera Iteración.
Examinemos la matriz jacobiana

x1=v(1); x2=v(2); x3=v(3); w1=v(4); w2=v(5); w3=v(6);

Jv = eval(J)
det(Jv)

La matriz no es singular, entonces el resultado de la primera iteración es:

B = A' - inv(Jv)*eval(F)

Realicemos 10 iteraciones más

for i=1:10,
v=B;
x1=v(1); x2=v(2); x3=v(3); w1=v(4); w2=v(5); w3=v(6);
Jv = eval(J);
det(Jv);
B = B - inv(Jv)*eval(F);
[v B]
end
Ejercicio.

Aproximar el otro punto de corte del ejemplo anterior.

Problema

Considere las superficies de dos cerros los cuales se cortan en una quebrada por donde circula un río.
¿Como determinar la curva que traza el río?

x=-3:0.25:3;
y=-3:0.25:3;
[X Y]=meshgrid(x,y);
cerro1 = 5-(X.^2+Y.^2);
cerro2 = 10-((X-1).^2+3*Y.^2);
figure(1); surf(X,Y,cerro1)
hold on; surf(X,Y,cerro2); hold off;

2.5 Método de la bisección y Regula Falsi (una mirada rápida a

estos métodos medievales).(Opcional)
2
Ilustremos este sencillo método con la ecuación: f(x) = 0 donde f(x) =x -2. Su
solución positiva es 21/2 .
Clear
f=inline('x.^2-2');
figure(1);fplot(f,[1 2]);grid on

Se propone una manera de programar n iteraciones con la bisección a partir de [a,b].

Concretamente probemos con a = 1 , b = 2 , n = 10:

a=1;
b=2;
for i=1:10
med=(b+a)/2;
if f(a)*f(med)<0
a=a;
b=med;
elseif f(med)*f(b)<0
a=med;
b=b;
elseif f(med)==0
solucion=med;
end
end
solucion=med
ErrorRelativo=abs(2^(1/2)-solucion)/2^(1/2)
Hagamos lo mismo que se hizo con la bisección, ahora utilizando el método de la Regla
Falsa. Se propone una manera de programar n iteraciones con del método de Regula Falsi
en el intervalo [a,b]. Utilicemos los mismos valores anteriores (a = 1 , b = 2 , n = 10):

a=1;
b=2;
for i=1:10
med=(a*f(b)-b*f(a))/(f(b)-f(a));
if f(a)*f(med)<0
a=a;
b=med;
elseif f(med)*f(b)<0
a=med;
b=b;
elseif f(med)==0
solucion=med;
end
end
solucion=med
ErrorRelativo=abs(2^(1/2)-solucion)/2^(1/2)

Conclusión: notablemente es superior Regula Falsi.

2.6 Método de la cuerda de Newton (Opcional)

Es un método que es localmente pero linealmente convergente para determinar una solución x  a de una
ecuación f  x   0 en que f una vez continuamente derivable con f '  a   0 .

Descripción:

x 0 punto de partida cercano a la solución xa

f  xn 
x n 1  x n  ; n  1, 2, 
f '  x0 

Observe que el denominador es constante

Geométricamente:

"la aproximación x  x n 1 es la abcisa donde la paralela a la tangente por  x0 , f  x 0   que pasan por
 xn , f  xn   corta a la horizontal".

Ejemplo
 
Apliquemos 2 iteraciones del método a la función f  x   cos x   x . Un buen punto de partida es x 
4

clear
syms x
f=cos(x)-x;
g=diff(f);
x=pi/4;
df=eval(g);
x1(1)=x;
f1(1)=eval(f);
for i=1:2
x=x-eval(f)/df
x1(i+1)=x;
f1(i+1)=eval(f);
end

Graficamente
ezplot(f,[-3 3])
hold on
grid on
for i=1:3
syms x
y1=df*(x-x1(i))+f1(i);
x=-1:0.05:x1(i);
ezplot(y1,[-3 3])
h=findobj(gcf,'type','Line');
set(h,'color','b');
end
hold off

Problema
Ponga a prueba este método, por ejemplo con el problema de aproximar la solucion de la
ecuacion f(t) = 2 donde :

t
f  t    1  1  2 x  dx  [ 1 , 2 ]
2

¿Podrá aplicarlo y obtener, por ejemplo una aproximacion cercana a

t=1.54310650104542043816000249088664767044733651536080561362611206757490
114987?.