MÉTODOS NUMÉRICOS (Octave)

Prof. María Zegarra Garay e -mail: maria_zegarra@hotmail.com

Prof. Elizabeth Puelles Bulnes e -mail: eliza_bulnes@hotmail.com

CONTENIDO:
Método de Newton. Método de la Secante. Método de Regula Falsi.
Análisis de error para Métodos Iterativos y Técnicas de Aceleración.
Convergencia acelerada. Raíces complejas de polinomios. Método de Bairstow.
UNIDAD 2 (continuación)
SOLUCIÓN DE ECUACIONES DE
UNA VARIABLE
0 Método de Newton.
0 Método de la Secante.
0 Método de Regula Falsi.
0 Análisis de error para Métodos Iterativos y Técnicas de Aceleración.
0 Convergencia acelerada.
0 Raíces complejas de polinomios.
0 Método de Bairstow.
• MÉTODO DE NEWTON

3
El Algoritmo de Newton:

5
6
Ejercicio
Hallar la raíz de f(x)=X2-5X+4 por el método de Newton –Raphson.
Solución:

7
Interpretación Geométrica :

8
Convergencia del Método

9
10
11
Usando este gráfico, podemos
elegir un valor inicial adecuado x0
como dato de entrada del
programa computacional a seguir.

12
La Implementación Computacional

A diferencia de los métodos anteriores, presentamos a seguir el programa

computacional del Método de Newton sin usar los comandos directos del
Matlab , sino en un contexto mas general , dado como un archivo de tipo
function y archivos de entrada para la función y su derivada.
%Método de Newton (o Newton Raphson)
%Calcula las raíces de una función f(x)
%fn1 es la función a calcular sus raíces
%dfn1 es la derivada de fn1
%x0 es el valor inicial
%E es el error cometido a cada iteración
%maxit es número máximo de iteraciones que estamos dispuestos
a tolerar

function [xa,iter] = prog_newton(fn1,dfn1,x0,E,maxit)

format long
n=0;
disp('n xa Error');
13
disp('n xa Error');
for k=1:maxit
xa=x0-feval(fn1,x0)/feval(dfn1,x0);
fprintf('%d \t%1.9f \t\t%6.9f\n',n, xa, E)
n = n+1;
if(abs(xa-x0)<= E)
iter=k;
disp('El Metodo es convergente y la solucion
aproximada es:')
return;
end
x0=xa;
end
disp('Se ha excedido el maximo numero de iteraciones')
iter=maxit;
disp('El Metodo no es convergente')
end

14
function [y] = fn1(x)
y=(1-cos(x))^2 + (sin(x))^2 -0.25;
return;

function [y] = dfn1(x) %derivada de la funcion fn1(x)

y=2*(1-cos(x))*sin(x) + 2*sin(x)*cos(x);
return;

Luego, ejecutando la función en la ventana del command windows , tenemos,

>> [xa,iter]=prog_newton(@fn1,@dfn1,0.5,0.00001,6)
n xa Error
0 0.505386784 0.000010000
1 0.505360511 0.000010000
2 0.505360510 0.000010000
El Metodo es convergente y la solucion aproximada es:
xa =
0.505360510284157
iter =
3
15
 •MÉTODO DE LA SECANTE
Este método es una derivación del método del punto fijo.
Consideremos la siguiente aproximación para la derivada de f ,

Por otra parte, el método del punto fijo establece el siguiente algoritmo:

Luego de estas dos expresiones se tiene:

Algoritmo del Método de la secante

Donde el Criterio de Parada será cuando para alguna iteración , se
verifique:
o una vez que

Ejercicio: Encuentre la raíz o raíces de la función:

f(x) = X3 + 2X + 10X -20
Solución:
Para iniciar el proceso iterativo se necesitan dos puntos iniciales, el
siguiente gráfico nos sugiere tomar por ejemplo 𝑥0 =0 y 𝑥1 =1, por
estar visiblemente cerca de la raíz.
Continuar con las iteraciones…………………………………………
%MÉTODO DE LA SECANTE
cf=input('Ingrese funcion:')
f=inline(cf);
xo=input('Ingrese primer valor:');
x1=input('Ingrese segundo valor:');
tol=input('Ingrese la tolerancia:');
error=100;
n=0;
fprintf(' n xo x1 error\n');
fprintf(' %i %4.5f %4.5f ------- \n',n,xo,x1);
while(error>tol)
n=n+1;
x2=x1-(x1-xo)*f(x1)/(f(x1)-f(xo));
%error=abs(f(x2));
format short
error=abs(x1-xo);
fprintf(' %i %4.5f %4.5f %4.5f\n',n,xo,x1,error);
xo=x1;
x1=x2;
end
La salida de los datos es:

Observe que se verifica el

error:
error= 𝑥𝑖+1 − 𝑥𝑖 < 0.001 = 𝜖
•MÉTODO DE LA FALSA POSICIÓN
O REGULA FALSI
Este método puede interpretarse como
una generalización del método de la
bisección.
Consideremos 𝑓ϵ 𝐶 𝑎, 𝑏 y L la recta
que pasa por los puntos:
𝑎, 𝑓 𝑎 , (𝑏, 𝑓(𝑏)),
esto es,
L : 𝑦 − 𝑓 𝑎 = 𝑓 𝑏𝑏−𝑎
−𝑓 𝑎
(𝑥 − 𝑎)

Como interesa hallar la raíz de 𝑓

tomaremos el punto 𝑥, 𝑦 = (𝑥, 0)
Entonces despejando x, se tiene
la expresión para la raíz x como:

𝑓 𝑎 (𝑏 − 𝑎)
𝑥=𝑎−
𝑓(𝑏) − 𝑓(𝑎)
Luego se procede como en el método de la bisección, se toma:
a1 = a , b1 = c si f(a) f(c)<0
a1 = c , b1 = b si f(c) f(b)<0
Siendo “c” las sucesivas aproximaciones a la raíz exacta; en el gráfico “c” se ha representado por
x1 , x2 , etc.
La siguiente iteración se obtendrá aplicando la misma estrategia al intervalo [a1 , b1 ] y así
sucesivamente.
El criterio de parada, más usual es parar las iteraciones cuando
| xn – xn-1 |< є |xn-1 | siendo є>0 la tolerancia admisible en el error relativo
y también debe verificarse
|f(xn)|< є
Y no detener el proceso si falla alguno de estos dos criterios.
Implementación Computacional
PROGRAMA PRINCIPAL
function [tabla] = regla_falsa (a,b,nmax,tole)
x0 = input('ingrese extremo inferior del intervalo: ');
xf = input('ingrese extremo superior del intervalo: ');
nmax = input('ingrese numero maximo de iteraciones: ');
tole = input('ingrese la tolerancia deseada: ');
i=0;
h=1000;
error1=1000;
q=4;
while i<nmax & h>tole & error1>tole %aca se puede ver que se ponen 3
%condiciones para que siga el ciclo y para meterse al proceso el
%contador debe aumentar por que no vamos a estar en la iteracion 0 sino en la 1
i=i+1;
error2=error1;
tabla(i,1)=i;
x=xf-(fun(xf)*(xf-x0))/(fun(xf)-fun(x0));% ya no es la mitad del intervalo
%[a,b] sino el PUNTO donde la recta corta con el eje x y se pone fun por que la funcion se llama fun
tabla(i,2)=x;
y=fun(x);%el coge esa x y la revisa en la funcion fun.m que este habilitada y eso es lo que llama y
 tabla(i,3)=y;
h=abs(y);% esto es para que en cada iteracion el fx se actualice,y se hace
%inmediatamente despues de haber evaluado la funcion
error1=abs(x-q);
tabla(i,4)=error1;% siempre el error en biseccion va a ser la mitad del
%error de la iteracion anterior y siempre el primer error va a estar malo,
%solo me fijo del segundo en adelante
convergencia=(error1/error2);
tabla(i,5)=convergencia;
if fun(x0)*fun(x)<0; % quiere decir que si estas dos funciones el resultado
%es - entonces b pierde el puesto por que el cambio quedo entre a y x
xf=x;
else
x0=x; % o pierde el puesto el uno o pierde el puesto el otro por eso
%ya no se pone una nueva condicion
endif
q=x;% este es para que la q que se use en el error sea la x de la iteracion anterior
endwhile
format short
fprintf('La raiz es %g, El error es %g, en %g Iteraciones.\n',x',error1', i')
endfunction
Ejercicio: Aproxime la raíz de f(x)=x-exp(1/x), hasta que el error
relativo porcentual sea menor al 1%.
Solución: Comience por hallar el intervalo [a, b] inicial, donde
se halle una raíz.
Del gráfico se puede tomar el intervalo inicial:
[a, b]=[1, 2].
Luego se crea un archivo para la función f(x),
de nombre: fun, pues en Programa Principal
aparece esta función con ese nombre
function [funcion1] = fun(x)
funcion1=x-exp(1/x);
endfunction