Professional Documents
Culture Documents
org/home/Alberto_Fernandez/19/print
Supongamos que en la iteración n -ésima el intervalo calculado es [a n , bn ]. La aproximación de f es la recta que pasa por (a n , f(a n )) y (bn , f(bn )) . Así que el siguiente punto es el punto de corte dado por:
bn − a n
x n+1 = bn − f(bn ) .
f(bn ) − f(a n )
La única diferencia entre el método de la secante y el de la regula falsi es la forma en que generan el nuevo intervalo en cada iteración. El método de la secante siempre utiliza los dos últimos puntos calculados
como extremos del nuevo intervalo, esto es, [a n+1 , bn+1 ] = I(x n , x n+1 ) . El método de la regula falsi utiliza el último punto calculado x n+1 junto con el anteriormente calculado donde f tome un signo distinto a
f(x n+1 ) , esto es, si f(a n )f(x n+1 ) < 0 será [a n+1 , bn+1 ] = I(a n , x n+1 ) , en caso contrario tendremos [a n+1 , bn+1 ] = I(bn , x n+1 ) .
Nótese que el método de la secante podría diverger, mientras que el de la regula falsi siempre converge. No obstante, cuando el primero converge lo suele hacer más rápido que el segundo.
En las siguientes figuras se ilustran ambos métodos, el de la secante en la izquierda y el de la regula falsi a la derecha:
a2
x 3
x 0 x 2
x 1 a 0= a1 b1= b2 b0
f(x) f(x)
1. El valor de |f(x n )| es suficientemente pequeño, esto es, |f(x n )| < ϵ para un ϵ > 0 prefijado.
2. La diferencia entre dos aproximaciones sucesivas es suficientemente pequeña, esto es, |x n − x n−1 | < ϵ para un ϵ > 0 prefijado.
3. Cuando se excede un número de iteraciones que se juzga razonable.
def regulaFalsi(f,a,b,nMaxIt=50,prec=1e-12):
# Metodo de la regula falsi
"""
Entrada:
f-> función a evaluar
a-> límite inferior del intervalo
b-> límite superior del intervalo
Nmax-> Nº máximo de iteraciones
prec-> Precisión desead
Salida:
raiz o None (null)
"""
x=None
a,b,fa,fb = n(a),n(b),n(f(a)),n(f(b))
if (fa*fb > 0): # comprobamos que el intervalo inicial contiene una raiz
print "Los signos de la función en los extremos del intervalo deben diferir."
return None
else:
html('<TABLE border="1" STYLE="align:center;color:blue">')
html('<THEAD><TR><TH COLSPAN="4"><CENTER>Método de la Regula Falsi')
html('<TR><TH>Iteración<TH>$x$<TH>$f(x)$<TH>${\epsilon_{abs}}$<TBODY>')
for i in range(nMaxIt): # iteraciones del metodo de regula falsi
x = b-fb*(b-a)/(fb-fa)
fx = n(f(x))
if (fa*fx < 0):
dx = b-x
b = x
fb = fx
else:
dx = x-a
a = x
fa = fx
html('<TR><TD>' + (i+1).str() + '<TD>' + x.str() + '<TD>' + fx.str() + '<TD>' + dx.str())
if (abs(fx)==0. or abs(dx)<prec):
html('</TABLE>')
return x
html('</TABLE>')
print "Se ha alcanzado el numero maximo de iteraciones."
return None
Ejemplo.
Calcular el valor de √ 2 con 5 decimales.
f(x) = x 2 − 2 = 0
f(x)=x^2-2
show(plot(f,0,2),figsize=4)
x=regulaFalsi(f,0,2,50,10^-12)
print x
1 de 7 28/10/2012 21:08
ecuaciones no lineales II-Otros métodos -- Sage http://nt.sagenb.org/home/Alberto_Fernandez/19/print
1.41421356237305
Ejemplo.
Calcular una solución de la ecuación cos(x) = x en el intervalo [−π, π] con una precisión de doce decimales.
g(x)=cos(x)-x
show(plot(g,-pi,pi),figsize=4)
x=regulaFalsi(g,-n(pi),n(pi),50,10^-12)
print x
0.739085133215159
def secante(f, a, b, nMaxIt=50, prec = 1e-12):
# Metodo de la secante
"""
Entrada:
f -> función a evaluar
a -> límite inferior del intervalo
b -> límite superior del intervalo
nMaXIt -> Nº máximo de iteraciones
prec -> Precisión desead
Salida:
raiz o None (null)
"""
x = None
x0, x1, f0, f1 = n(a), n(b), n(f(a)), n(f(b))
#Imprime cabecera de la tabla de salida
html('<TABLE border="1" STYLE="align:center;color:blue"><THEAD><TR><TH COLSPAN="4"><CENTER>Método de la Secante<TR>')
html('<TH>Iteración<TH>$x$<TH>$f(x)$<TH>${\epsilon_{abs}}$<TBODY>')
if (f0*f1 > 0): # comprobamos que el intervalo inicial contiene una raiz
print "Los signos de la función en los extremos del intervalo deben diferir."
return None
2 de 7 28/10/2012 21:08
ecuaciones no lineales II-Otros métodos -- Sage http://nt.sagenb.org/home/Alberto_Fernandez/19/print
else:
if (abs(f0) < abs(f1)): # tomamos como valor inicial el que tiene menor imágen
x0, x1 = n(b), n(a)
f0, f1 = f1, f0
for i in range(nMaxIt): # iteraciones del metodo de la secante
dx = -f1*(x1-x0)/(f1-f0) # incremento respecto a la ultima iteracion
x0,f0 = x1,f1
x1 += dx
f1 = n(f(x1))
#Imprime salida de cada iteración
html('<TR><TD>' + (i+1).str() + '<TD>' + x1.str() + '<TD>' + f1.str() + '<TD>' + dx.str())
if (abs(f1)==0. or abs(dx)<prec):
html('</TABLE>')
return x1
html('</TABLE>')
print "Se ha alcanzado el numero máximo de iteraciones."
return None
f(x)=x^2-2
show(plot(f,0,2),figsize=4)
x=secante(f,0,2,50,10^-12)
print('la raiz buscada es: %s'%x)
Método de la Secante
Iteración x f(x) ϵ abs
1 1.00000000000000 -1.00000000000000 -1.00000000000000
2 1.33333333333333 -0.222222222222222 0.333333333333333
3 1.42857142857143 0.0408163265306123 0.0952380952380953
4 1.41379310344828 -0.00118906064209301 -0.0147783251231527
5 1.41421143847487 -6.00728683886054e-6 0.000418335026594247
6 1.41421356268887 8.93145557512298e-10 2.12421399959116e-6
7 1.41421356237309 -8.88178419700125e-16 -3.15774877227030e-10
8 1.41421356237309 -4.44089209850063e-16 3.14018499258801e-16
Método de la Secante
Iteración x f(x) ϵ abs
1 -1.00000000000000 1.54030230586814 2.14159265358979
2 4.48603534890210 -4.71046101822236 5.48603534890210
3 0.351859358587624 0.586874160838208 -4.13417599031448
4 0.809870978215503 -0.120279102179200 0.458011619627880
5 0.731968168064536 0.0118922803237040 -0.0779028101509678
6 0.738977567820941 0.000180018461826914 0.00700939975640530
7 0.739085302891874 -2.83972999226556e-7 0.000107735070933240
8 0.739085133211130 6.74493794150521e-12 -1.69680743603311e-7
9 0.739085133215161 0.000000000000000 4.03016802692972e-12
0.739085133215161
Método de Newton-Raphson
Tal vez sea el método más conocido para la resolución de ecuaciones no lineales. Se distingue de todos los anteriores en que además de evaluar f requiere evaluar la derivada de la función f ′ .
Igual que en el método de la secante o la regula falsi, este método consiste en aproximar la función f por una recta en la región de interés. En la iteración n -ésima, se calcula el punto de corte con el eje X de la
tangente a f en x n−1 , constituyendo este punto de corte la nueva aproximación de la raíz x n . Así, podemos escribir la recurrencia de la sucesión de aproximaciones que se obtienen con este método como:
f(x n )
x n+1 = x n − , n ≥ 0.
f ′ (x n )
Al ser una recurrencia de una generación, la sucesión queda determinada a partir del valor x 0 .
La idea del método de Newton-Raphson surge al notar que en un entorno suficientemente pequeño de un punto x , la función f y la recta tangente a la gráfica de f en ese punto son muy similares. Obviamente, esto
es cierto siempre y cuando la función sea lo suficientemente suave (en general, continua y con derivada continua). Esta idea de sustituir funciones por sus tangentes para reemplazar problemas no lineales por
lineales es una de las más importantes en todas las matemáticas.
3 de 7 28/10/2012 21:08
ecuaciones no lineales II-Otros métodos -- Sage http://nt.sagenb.org/home/Alberto_Fernandez/19/print
Los problemas que podemos encontrar al ejecutar el método de Newton-Raphson son los siguientes, pudiendo ocurrir:
1. x n no está en el dominio de f .
2. La función no es derivable en x n .
3. La tangente en x n es horizontal, esto es, f ′ (x n ) = 0 .
Para evitar estos problemas, el método de Newton-Raphson se suele implementar de forma que se pare si la iteración se sale de un intervalo prescrito. Así, si escogemos dicho intervalo tal que tanto la función como
su derivada estén bien definidas en todos sus puntos, evitaremos los dos primeros problemas. El tercero podremos evitarlo siempre y cuando la raíz que buscamos sea simple y, para ello, basta con coger el intervalo
suficientemente pequeño (en el caso de raíces múltiples, se puede demostrar que el método también converge, pero lo hace más lentamente).
Salvo lo dicho en el párrafo anterior, los criterios de parada del método son los mismos que para los métodos anteriores.
A continuación implementaremos el método de Newton-Raphson en su versión clásica y en una versión que combina las iteraciones del método de Newton-Raphson con las del método de bisección.
f(x)=exp(x)*sin(x)
f.diff()
x |--> e^x*sin(x) + e^x*cos(x)
def newton(f,x0,nMaxIt=50,prec=10e-12):
# Metodo de Newton para hallar una raiz
"""
Entrada:
f -> función a evaluar
x0 -> punto inicial próximo a la raiz
nMaXIt -> Nº máximo de iteraciones
prec -> Precisión desead
Salida:
raiz o None (null)
"""
#Imprime cabecera de la tabla de salida
html('<TABLE border="1" STYLE="align:center;color:blue"><THEAD><TR><TH COLSPAN="4"><CENTER>Método de Newton-Raphson<TR>')
html('<TH>Iteración<TH>$x$<TH>$f(x)$<TH>${\epsilon_{abs}}$<TBODY>')
dx = 0
df = f.diff() # calculamos la derivada de f
x = n(x0) # tomamos como primer punto el punto medio del intervalo
for i in range(nMaxIt): # iteraciones del metodo de Newton
fx = n(f(x))
dfx = n(df(x))
#Imprime salida de cada iteración
dx = -fx/dfx # incremento respecto del ultimo valor
x += dx # nuevo valor
html('<TR><TD>' + (i+1).str() + '<TD>' + x.str() + '<TD>' + fx.str() + '<TD>' + dx.str())
if (abs(fx)==0. or abs(dx)<prec): # criterios de convergencia
html('</TABLE>')
return x
html('</TABLE>')
print("Se ha alcanzado el numero de iteraciones maximo.")
return None
f(x)=x-cos(x)
plot(f,-pi,pi)
newton(f,0.)
Método de Newton-Raphson
Iteración x f(x) ϵ abs
1 1.00000000000000 -1.00000000000000 1.00000000000000
2 0.750363867840244 0.459697694131860 -0.249636132159756
3 0.739112890911362 0.0189230738221174 -0.0112509769288822
4 0.739085133385284 0.0000464558989907715 -0.0000277575260776869
4 de 7 28/10/2012 21:08
ecuaciones no lineales II-Otros métodos -- Sage http://nt.sagenb.org/home/Alberto_Fernandez/19/print
Método de Newton-Raphson
Iteración x f(x) ϵ abs
5 0.739085133215161 2.84720580445708e-10 -1.70123407014033e-10
6 0.739085133215161 0.000000000000000 -0.000000000000000
0.739085133215161
def newtonBis(f,a,b,Nmax=50,prec=10e-12):
# Metodo de Newton para hallar una raiz en un intervalo (a,b),
# si la iteracion sale del intervalo se sustituye por una iteracion del
# metodo de biseccion
fa = f(n(a))
fb = f(n(b))
if (fa*fb > 0): # comprobamos que el intervalo inicial contiene una raiz
return "Los signos de la función en los extremos del intervalo deben diferir."
elif (fa==0.): # si f(a)=0 devolvemos a
return a
elif (fb==0.): # si f(b)=0 devolvemos b
return b
else:
df = f.diff() # calculamos la derivada de f
x = n((a+b)/2) # tomamos como primer punto el punto medio del intervalo
En la iteración de punto fijo se obtiene la siguiente aproximación x n+1 como una función de la anterior x n , de forma que podamos escribir:
x n+1 = g(x n ),
donde g(x) es una función adecuada denominada función de iteración, que no debe confundirse con la función f cuyas raíces queremos hallar. Así que de manera general, podemos decir que una iteración de punto
fijo es aquella que define la sucesión de aproximaciones a través de una recurrencia de una generación.
Una condición necesaria que debe cumplir la función de iteración g, supuesta continua, para poder resolver nuestro problema con éxito es que g(x ∗ ) = x ∗ , siendo x ∗ la raíz de f (se dice que x ∗ es un punto fijo de
g). En efecto:
El método de Newton-Raphson antes descrito es un ejemplo de iteración de punto fijo con la función de iteración g(x) = x − f(x)/f ′ (x) .
Como veremos en el siguiente teorema, la convergencia del método de punto fijo no está garantizada y depende, entre otras cosas, de la forma de g. Así mismo, la velocidad de convergencia también depende de la
forma de g.
Supongamos que g es una función definida y con derivada continua en un entorno de la raíz x ∗, con g(x ∗ ) = x ∗ . Si
|g ′ (x ∗ )| < 1,
exite un entorno de x tal que contiene a la sucesión {x n } definida por x n+1 = g(x n ) con x 0 en dicho entorno y con lim x n = x ∗ . Además, si los errores e n = x n − x ∗ son no nulos, los cocientes
∗
|g ′ (x ∗ )| > 1,
las únicas sucesiones de la forma x n+1 = g(x n ) que convergen a x son aquellas cuyos términos son , de uno en adelante, constatemente iguales a x ∗.
∗
def puntofijo(g,x0,nMaxIt=50,prec=1e-9):
# Metodo de punto fijo para resolver x=g(x)
"""
Entrada:
g -> función a evaluar
x0 -> punto inicial próximo a la raiz
5 de 7 28/10/2012 21:08
ecuaciones no lineales II-Otros métodos -- Sage http://nt.sagenb.org/home/Alberto_Fernandez/19/print
g(x)=cos(x)
show(puntofijo(g,.5,100,1e-12))
Método del punto fijo
Iteración x ϵ abs
1 0.877582561890373 0.377582561890373
2 0.639012494165259 -0.238570067725114
3 0.802685100682335 0.163672606517076
4 0.694778026788006 -0.107907073894329
5 0.768195831282016 0.0734178044940099
6 0.719165445942419 -0.0490303853395970
7 0.752355759421527 0.0331903134791079
8 0.730081063137823 -0.0222746962837037
9 0.745120341351440 0.0150392782136168
10 0.735006309014843 -0.0101140323365970
11 0.741826522643246 0.00682021362840279
12 0.737235725442231 -0.00459079720101452
13 0.740329651878263 0.00309392643603179
14 0.738246238332233 -0.00208341354602970
15 0.739649962769661 0.00140372443742776
16 0.738704539356983 -0.000945423412677893
17 0.739341452281210 0.000636912924226740
18 0.738912449332103 -0.000429002949106971
19 0.739201444135799 0.000288994803695930
20 0.739006779780813 -0.000194664354986052
21 0.739137910762293 0.000131130981479877
22 0.739049580595209 -0.0000883301670843162
23 0.739109081420527 0.0000595008253181373
24 0.739069001204012 -0.0000400802165151370
25 0.739095999835755 0.0000269986317431581
26 0.739077813285175 -0.0000181865505795020
27 0.739090063988251 0.0000122507030757557
28 0.739081811778109 -8.25221014155719e-6
29 0.739087370571036 5.55879292640782e-6
30 0.739083626103480 -3.74446755602165e-6
31 0.739086148422879 2.52231939901204e-6
32 0.739084449358649 -1.69906423008737e-6
33 0.739085593868961 1.14451031185681e-6
34 0.739084822913141 -7.70955819295871e-7
35 0.739085342238298 5.19325156767003e-7
36 0.739084992414645 -3.49823653267300e-7
37 0.739085228060074 2.35645429724762e-7
38 0.739085069326482 -1.58733592048321e-7
39 0.739085176251341 1.06924858855884e-7
40 0.739085104225471 -7.20258702679999e-8
41 0.739085152742964 4.85174929121257e-8
42 0.739085120060997 -3.26819666884859e-8
43 0.739085142075963 2.20149660723479e-8
44 0.739085127246417 -1.48295459245773e-8
45 0.739085137235778 9.98936044993570e-9
46 0.739085130506825 -6.72895328346357e-9
47 0.739085135039528 4.53270387890115e-9
48 0.739085131986245 -3.05328384797576e-9
49 0.739085134042973 2.05672867625850e-9
50 0.739085132657536 -1.38543720940021e-9
51 0.739085133590783 9.33247257250969e-10
52 0.739085132962137 -6.28646579237113e-10
53 0.739085133385601 4.23463819565484e-10
54 0.739085133100350 -2.85250267850756e-10
55 0.739085133292498 1.92147964206413e-10
56 0.739085133163065 -1.29433130879875e-10
57 0.739085133250253 8.71877015029554e-11
58 0.739085133191522 -5.87306869803683e-11
59 0.739085133231084 3.95616872594928e-11
60 0.739085133204435 -2.66492383715899e-11
61 0.739085133222386 1.79513071074666e-11
62 0.739085133210294 -1.20922161173098e-11
63 0.739085133218439 8.14537326476739e-12
64 0.739085133212952 -5.48683320999999e-12
6 de 7 28/10/2012 21:08
ecuaciones no lineales II-Otros métodos -- Sage http://nt.sagenb.org/home/Alberto_Fernandez/19/print
0.739085133215467
show(newton(g-x,0.5))
show(secante(g-x,0.,1))
show(regulaFalsi(g-x,0.,1))
Método de Newton-Raphson
Iteración x f(x) ϵ abs
1 0.755222417105636 0.377582561890373 0.255222417105636
2 0.739141666149879 -0.0271033118574673 -0.0160807509557572
3 0.739085133920807 -0.0000946153806177241 -0.0000565322290724224
4 0.739085133215161 -1.18097787105143e-9 -7.05646141453566e-10
5 0.739085133215161 0.000000000000000 0.000000000000000
0.739085133215161
Método de la Secante
Iteración x f(x) ϵ abs
1 0.685073357326045 0.0892992764818600 -0.314926642673955
2 0.736298997613654 0.00466003903814260 0.0512256402876089
3 0.739119361911629 -0.0000572859911061041 0.00282036429797522
4 0.739085112127464 3.52926228242012e-8 -0.0000342497841653953
5 0.739085133215001 2.66786592817425e-13 2.10875373984547e-8
6 0.739085133215161 0.000000000000000 1.59407670128663e-13
0.739085133215161
0.739085133215155
7 de 7 28/10/2012 21:08