Solo para fines didácticos, y como complemento para los ejercicios presentados en la unidad para raíces de ecuaciones, se presentan las instrucciones para las animaciones usadas en la presentación de los conceptos y ejercicios. Los algoritmos para animación NO son necesarios para realizar los ejercicios, que requieren una parte analítica con al menos tres iteraciones en papel y lápiz. Se lo adjunta como una herramienta didáctica de asistencia para las clases.
La gráfica (graf_ani) se crea en una ventana (fig_ani), inicializando con la linea a partir f(x) y configurando los parámetros base para el gráfico.
Se usan procedimientos para crear unatrama() para marca de iteración y en cada cambio se limpia la trama manteniendo la base con limpiatrama().
En caso de requerir un archivo .gif animado se proporciona un nombre de archivo. Para crear el archivo se requiere de la librería 'pillow', a ser instalado.
otros ejemplos de animación en el curso de Fundamentos de Programación:
Movimiento circular – Una partícula, animación con matplotlib-Python
Método de la Bisección y gráfico animado con Python
Instrucciones en Python
# Algoritmo de Bisección, con tabla
# Los valores de [a,b] son aceptables
# y seleccionados desde la gráfica de la función
# error = tolera
import numpy as np
def biseccion(fx,a,b,tolera,iteramax = 50,
vertabla=False, precision=6):
'''Algoritmo de Bisección
Los valores de [a,b] son seleccionados
desde la gráfica de la función
error = tolera
'''
fa = fx(a)
fb = fx(b)
tramo = np.abs(b-a)
itera = 0
cambia = np.sign(fa)*np.sign(fb)
tabla=[]
if cambia<0: # existe cambio de signo f(a) vs f(b)
if vertabla==True:
print('método de Bisección')
print('i', ['a','c','b'],[ 'f(a)', 'f(c)','f(b)'])
print(' ','tramo')
np.set_printoptions(precision)
while (tramo>=tolera and itera<=iteramax):
c = (a+b)/2
fc = fx(c)
cambia = np.sign(fa)*np.sign(fc)
unafila = np.array([a,c,b,fa,fc,fb])
if (cambia<0):
b = c
fb = fc
else:
a = c
fa = fc
tramo = np.abs(b-a)
unafila = np.concatenate([unafila,[tramo]],axis=0)
tabla.append(unafila)
if vertabla==True:
print(itera,unafila[0:3],unafila[3:6])
print(' ',tramo)
itera = itera + 1
respuesta = c
# Valida respuesta
if (itera>=iteramax):
respuesta = np.nan
else:
print(' No existe cambio de signo entre f(a) y f(b)')
print(' f(a) =',fa,', f(b) =',fb)
respuesta=np.nan
tabla = np.array(tabla,dtype=float)
return(respuesta,tabla)
# PROGRAMA ----------------------
# INGRESO
fx = lambda x: x**3 + 4*x**2 - 10
a = 1
b = 2
tolera = 0.001
itera = 0
verdigitos = 4 # ver digitos en tabla
# PROCEDIMIENTO
c,tabla = biseccion(fx,a,b,tolera,
vertabla=True,
precision=verdigitos)
n = len(tabla)
errado = tabla[n-1,6]
# SALIDA
print('Método de la Bisección')
print('iteraciones:',n)
print('raíz en: ',c)
print('errado:',errado)
# GRAFICA ---------------------
import matplotlib.pyplot as plt
muestras = 21 # en intervalo [a,b]
itera_graf = n-1 # iteración en gráfica
titulo = 'Bisección'
xk = np.linspace(a,b,muestras)
fk = fx(xk)
[ai,ci,bi] = tabla[itera_graf,0:3]
[fai,fci,fbi] = tabla[itera_graf,3:6]
plt.plot(xk,fk, label='f(x)')
if itera_graf==(n-1): # iteración final
plt.plot(c,0,'D',color='orange',label='c')
if itera_graf<(n-1): # una iteración en gráfica
titulo = titulo + ', itera='+str(itera_graf)
plt.plot(ai,fai,'o',color='red',label='a')
plt.plot(bi,fbi,'o',color='green',label='b')
plt.plot(ci,fci,'o',color='orange',label='c')
plt.plot([ai,ai],[fai,0],'--',color='red')
plt.plot([bi,bi],[fbi,0],'--',color='green')
plt.plot([ci,ci],[fci,0],'--',color='orange')
plt.axhline(0,color='gray')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title(titulo)
plt.grid()
plt.legend()
#plt.show()
# GRAFICA CON ANIMACION ------------
import matplotlib.animation as animation
xa = tabla[:,0]
ya = tabla[:,3]
xb = tabla[:,2]
yb = tabla[:,5]
xc = tabla[:,1]
yc = tabla[:,4]
# Inicializa parametros de trama/foto
narchivo = 'Bisección' # nombre archivo
retardo = 700 # milisegundos entre tramas
tramas = len(xa)
# GRAFICA animada en fig_ani
fig_ani, graf_ani = plt.subplots()
ymax = np.max(fk)
ymin = np.min(fk)
deltax = np.abs(b-a)
deltay = np.abs(ymax-ymin)
graf_ani.set_xlim([a-0.05*deltax,b+0.05*deltax])
graf_ani.set_ylim([ymin-0.05*deltay,ymax+0.05*deltay])
linea0 = graf_ani.axhline(0, color='k')
# Lineas y puntos base
lineafx,= graf_ani.plot(xk,fk, label='f(x)')
puntoa, = graf_ani.plot(xa[0], ya[0],'o',
color='red', label='a')
puntob, = graf_ani.plot(xb[0], yb[0],'o',
color='green', label='b')
puntoc, = graf_ani.plot(xc[0], yc[0],'o',
color='orange', label='c')
lineaa, = graf_ani.plot([xa[0],xa[0]],
[0,ya[0]],color='red',
linestyle='dashed')
lineab, = graf_ani.plot([xb[0],xb[0]],
[0,yb[0]],color='green',
linestyle='dashed')
lineac, = graf_ani.plot([xc[0],xc[0]],
[0,yc[0]],
color='orange',
linestyle='dashed')
linea_ab, = graf_ani.plot([xa[0],xb[0]],
[0,0],
color='yellow',
linestyle='dotted')
# Configura gr fica
graf_ani.set_title('Bisección')
graf_ani.set_xlabel('x')
graf_ani.set_ylabel('f(x)')
graf_ani.legend()
graf_ani.grid()
# Cada nueva trama
def unatrama(i,xa,ya,xb,yb,xc,yc):
# actualiza cada punto
puntoa.set_xdata([xa[i]])
puntoa.set_ydata([ya[i]])
puntob.set_xdata([xb[i]])
puntob.set_ydata([yb[i]])
puntoc.set_xdata([xc[i]])
puntoc.set_ydata([yc[i]])
# actualiza cada linea
lineaa.set_ydata([ya[i], 0])
lineaa.set_xdata([xa[i], xa[i]])
lineab.set_ydata([yb[i], 0])
lineab.set_xdata([xb[i], xb[i]])
lineac.set_ydata([yc[i], 0])
lineac.set_xdata([xc[i], xc[i]])
linea_ab.set_ydata([0, 0])
linea_ab.set_xdata([xa[i], xb[i]])
return (puntoa, puntob, puntoc, lineaa, lineab, lineac,linea_ab)
# Limpia trama anterior
def limpiatrama():
puntoa.set_ydata(np.ma.array(xa, mask=True))
puntob.set_ydata(np.ma.array(xb, mask=True))
puntoc.set_ydata(np.ma.array(xc, mask=True))
lineaa.set_ydata(np.ma.array([0,0], mask=True))
lineab.set_ydata(np.ma.array([0,0], mask=True))
lineac.set_ydata(np.ma.array([0,0], mask=True))
linea_ab.set_ydata(np.ma.array([0,0], mask=True))
return (puntoa, puntob, puntoc, lineaa, lineab, lineac,linea_ab)
# contador de tramas
i = np.arange(0,tramas,1)
ani = animation.FuncAnimation(fig_ani,unatrama,
i ,
fargs=(xa, ya,
xb, yb,
xc, yc),
init_func=limpiatrama,
interval=retardo,
blit=True)
# Graba Archivo GIFAnimado y video
ani.save(narchivo+'_ani.gif', writer='pillow')
#ani.save(narchivo+'_animado.mp4')
plt.show()
Método de la Posición Falsa y gráfico animado con Python
Instrucciones en Python
# Algoritmo de falsa posicion para raices
# [a,b] se seleccionan de la gráfica de f(x)
import numpy as np
def falsaposicion(fx,a,b,tolera,iteramax = 50,
vertabla=False, precision=6):
'''fx en forma numérica lambda
Los valores de [a,b] son seleccionados
desde la gráfica de la función
error = tolera
'''
fa = fx(a)
fb = fx(b)
tramo = np.abs(b-a)
itera = 0
cambia = np.sign(fa)*np.sign(fb)
tabla=[]
if cambia<0: # existe cambio de signo f(a) vs f(b)
if vertabla==True:
print('método de la Posición Falsa ')
print('i', ['a','c','b'],[ 'f(a)', 'f(c)','f(b)'])
print(' ','tramo')
np.set_printoptions(precision)
while (tramo >= tolera and itera<=iteramax):
c = b - fb*(a-b)/(fa-fb)
fc = fx(c)
cambia = np.sign(fa)*np.sign(fc)
unafila = np.array([a,c,b,fa,fc,fb])
if (cambia > 0): # cambio de signo derecha
tramo = np.abs(c-a)
a = c
fa = fc
else: # cambio de signo izquierda
tramo = np.abs(b-c)
b = c
fb = fc
unafila = np.concatenate([unafila,[tramo]],axis=0)
tabla.append(unafila)
if vertabla==True:
print(itera,unafila[0:3],unafila[3:6])
print(' ',tramo)
itera = itera + 1
respuesta = c
# Valida respuesta
if (itera>=iteramax):
respuesta = np.nan
else:
print(' No existe cambio de signo entre f(a) y f(b)')
print(' f(a) =',fa,', f(b) =',fb)
respuesta=np.nan
tabla = np.array(tabla,dtype=float)
return(respuesta,tabla)
# PROGRAMA ----------------------
# INGRESO
fx = lambda x: x**3 + 4*x**2 - 10
a = 1
b = 2
tolera = 0.0001
verdigitos = 4 # ver digitos en tabla
# PROCEDIMIENTO
c,tabla = falsaposicion(fx,a,b,tolera,
vertabla=True,
precision=verdigitos)
n = len(tabla)
errado = tabla[n-1,6]
# SALIDA
print('Método de la falsa posición')
print('iteraciones:',n)
print('raíz en: ',c)
print('errado:',errado)
# GRAFICA ---------------------
import matplotlib.pyplot as plt
muestras = 21 # en intervalo [a,b]
itera_graf = n-1 # iteración en gráfica
titulo = 'Falsa Posición'
xk = np.linspace(a,b,muestras)
fk = fx(xk)
[ai,ci,bi] = tabla[itera_graf,0:3]
[fai,fci,fbi] = tabla[itera_graf,3:6]
plt.plot(xk,fk, label='f(x)')
if itera_graf==(n-1): # iteración final
plt.plot(c,0,'D',color='orange',label='c')
if itera_graf<(n-1): # una iteración en gráfica
titulo = titulo + ', itera='+str(itera_graf)
plt.plot(ai,fai,'o',color='red',label='a')
plt.plot(bi,fbi,'o',color='green',label='b')
plt.plot(ci,fci,'o',color='orange',label='c')
plt.plot([ci,ci],[fci,0],'--',color='orange')
plt.plot([ai,ai],[fai,0],'--',color='red')
plt.plot([bi,bi],[fbi,0],'--',color='green')
plt.plot([ai,bi],[fai,fbi],color='orange')
plt.axhline(0,color='gray')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title(titulo)
plt.grid()
plt.legend()
plt.tight_layout()
# plt.show()
# GRAFICA CON ANIMACION ------------
#import matplotlib.pyplot as plt
import matplotlib.animation as animation
xa = tabla[:,0]
ya = tabla[:,3]
xc = tabla[:,1]
yc = tabla[:,4]
xb = tabla[:,2]
yb = tabla[:,5]
# Inicializa parametros de trama/foto
narchivo = 'PosicionFalsa' # nombre archivo
retardo = 700 # milisegundos entre tramas
tramas = len(xa)
# GRAFICA animada en fig_ani
fig_ani, graf_ani = plt.subplots()
graf_ani.set_xlim([a,b])
graf_ani.set_ylim([np.min(fk),np.max(fk)])
# Lineas y puntos base
lineafx, = graf_ani.plot(xk,fk,label ='f(x)')
puntoa, = graf_ani.plot(xa[0], ya[0],'o',
color='red', label='a')
puntob, = graf_ani.plot(xb[0], yb[0],'o',
color='green', label='b')
puntoc, = graf_ani.plot(xc[0], yc[0],'o',
color='orange', label='c')
lineaab, = graf_ani.plot([xa[0],xb[0]],[ya[0],yb[0]],
color ='orange',
label='y=mx+b')
lineac0, = graf_ani.plot([xc[0],xc[0]],[0,yc[0]],
color='magenta',
linestyle='dashed')
# Configura gráfica
linea0 = graf_ani.axhline(0, color='k')
graf_ani.set_title('Posición Falsa')
graf_ani.set_xlabel('x')
graf_ani.set_ylabel('f(x)')
graf_ani.legend()
graf_ani.grid()
# Cada nueva trama
def unatrama(i,xa,ya,xc,yc,xb,yb):
# actualiza cada punto, [] porque es solo un valor
puntoa.set_xdata([xa[i]])
puntoa.set_ydata([ya[i]])
puntob.set_xdata([xb[i]])
puntob.set_ydata([yb[i]])
puntoc.set_xdata([xc[i]])
puntoc.set_ydata([yc[i]])
# actualiza cada linea
lineaab.set_ydata([ya[i], yb[i]])
lineaab.set_xdata([xa[i], xb[i]])
lineac0.set_ydata([0, yc[i]])
lineac0.set_xdata([xc[i], xc[i]])
return (puntoa, puntob, puntoc, lineaab,lineac0,)
# Cada nueva trama
def limpiatrama():
puntoa.set_ydata(np.ma.array(xa, mask=True))
puntob.set_ydata(np.ma.array(xb, mask=True))
puntoc.set_ydata(np.ma.array(xc, mask=True))
lineaab.set_ydata(np.ma.array([0,0], mask=True))
lineac0.set_ydata(np.ma.array([0,0], mask=True))
return (puntoa, puntob, puntoc, lineaab,lineac0,)
# contador de tramas
i = np.arange(0, tramas,1)
ani = animation.FuncAnimation(fig_ani,unatrama,
i ,
fargs=(xa, ya,
xc, yc,
xb,yb),
init_func=limpiatrama,
interval=retardo,
blit=True)
# Graba Archivo GIFAnimado y video
ani.save(narchivo+'_ani.gif', writer='pillow')
#ani.save(narchivo+'.mp4')
plt.show()
Método del Punto Fijo y gráfico animado con Python
Instrucciones en Python
# Método de Punto Fijo
# El valor inicial de c se revisa con la gráfica
import numpy as np
def puntofijo(gx,c,tolera,iteramax=50,vertabla=True, precision=6):
"""
g(x) se obtiene al despejar una x de f(x)
máximo de iteraciones predeterminado: iteramax
si no converge hasta iteramax iteraciones
la respuesta es NaN (Not a Number)
"""
itera = 0 # iteración inicial
tramo = 2*tolera # al menos una iteracion
tabla=[]
if vertabla==True:
print('Método del Punto Fijo')
print('i', ['xi','gi','tramo'])
np.set_printoptions(precision)
while (tramo>=tolera and itera<=iteramax):
gc = gx(c)
tramo = abs(gc-c)
unafila = np.array([c,gc,tramo])
tabla.append(unafila)
if vertabla==True:
print(itera,unafila)
c = gc
itera = itera + 1
respuesta = c
# Valida respuesta
if itera>=iteramax:
respuesta = np.nan
print('itera: ',itera,
'No converge,se alcanzó el máximo de iteraciones')
tabla = np.array(tabla,dtype=float)
return(respuesta,tabla)
# PROGRAMA ----------------------
# INGRESO
fx = lambda x: np.exp(-x) - x
gx = lambda x: np.exp(-x)
c = 0 # valor inicial
tolera = 0.001
iteramax = 15
# PROCEDIMIENTO
c,tabla = puntofijo(gx,c,tolera,
iteramax,vertabla=True)
n = len(tabla)
errado = tabla[n-1,2]
# SALIDA
print('Método del Punto Fijo')
print('iteraciones:',n)
print('raíz en: ', c)
print('errado:',errado)
# GRAFICA --------------------
import matplotlib.pyplot as plt
a = 0 # intervalo de gráfica en [a,b]
b = 1
muestras = 21
itera_graf = n-1 # iteración en gráfica
titulo = 'Punto Fijo'
# calcula los puntos para fx y gx
xk = np.linspace(a,b,muestras)
fk = fx(xk)
gk = gx(xk)
plt.plot(xk,fk, label='f(x)',
linestyle='dashed')
plt.plot(xk,gk, label='g(x)')
plt.plot(xk,xk, label='y=x')
if itera_graf==(n-1): # iteración final
plt.plot(c,c,'D',color='orange',label='c')
plt.axvline(c, color='magenta',
linestyle='dotted')
if itera_graf<(n-1): # una iteración en gráfica
[c,gc,tramo] = tabla[itera_graf]
[c1,gc1,tramo1] = tabla[itera_graf+1]
titulo = titulo + ', itera='+str(itera_graf)
plt.plot(c,c,'o',color='red',label='c')
plt.plot(c,gc,'o',color='green',label='g(c)')
plt.plot(gc,gc,'o',color='orange',label='c[i+1]')
dx = c1-c # largo de flecha
dy = gc-c
plt.arrow(c,c, 0,dy,
length_includes_head = True,
head_width = 0.05*abs(dy),
head_length = 0.1*abs(dy))
plt.arrow(c,gc,dx,0,
length_includes_head = True,
head_width = 0.05*abs(dx),
head_length = 0.1*abs(dx))
plt.axhline(0,color='gray')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title(titulo)
plt.grid()
plt.legend()
plt.tight_layout()
#plt.show()
# GRAFICA CON ANIMACION ------------
#import matplotlib.pyplot as plt
import matplotlib.animation as animation
xc = tabla[:,0]
yc = tabla[:,1]
# Inicializa parametros de trama/foto
narchivo = 'PuntoFijo' # nombre archivo
retardo = 700 # milisegundos entre tramas
tramas = len(xc)
# GRAFICA animada en fig_ani
fig_ani, graf_ani = plt.subplots()
dx = np.abs(b-a)
dy = np.abs(gx(b)-gx(a))
graf_ani.set_xlim([a-0.05*dx,b+0.05*dx])
graf_ani.set_ylim([np.min(fk)-0.05*dy,np.max(fk)+0.05*dy])
# Lineas y puntos base
puntoa, = graf_ani.plot(xc[0], yc[0], 'ro')
puntob, = graf_ani.plot(xc[0], xc[0], 'go') # y=x
lineafx, = graf_ani.plot(xk,fk, color='blue',
linestyle='dashed', label='f(x)')
lineagx, = graf_ani.plot(xk,gk, color='orange', label='g(x)')
lineayx, = graf_ani.plot(xk,xk, color='green', label='y=x')
linearaiz = graf_ani.axvline(c, color='magenta',linestyle='dotted')
# Configura gráfica
linea0 = graf_ani.axhline(0, color='k')
graf_ani.set_title('Punto Fijo')
graf_ani.set_xlabel('x')
graf_ani.set_ylabel('f(x)')
graf_ani.legend()
graf_ani.grid()
# Cada nueva trama
def unatrama(i,xc,yc):
# actualiza cada punto, [] porque es solo un valor
puntoa.set_xdata([xc[i]])
puntoa.set_ydata([yc[i]])
puntob.set_xdata([xc[i]]) # y=x
puntob.set_ydata([xc[i]])
# actualiza cada flecha
dx = xc[i+1]-xc[i]
dy = yc[i]-xc[i]
flecha01 = graf_ani.arrow(xc[i],xc[i], 0,dy,
length_includes_head = True,
head_width = 0.05*abs(dy),
head_length = 0.1*abs(dy))
flecha02 = graf_ani.arrow(xc[i],yc[i], dx,0,
length_includes_head = True,
head_width = 0.05*abs(dx),
head_length = 0.1*abs(dx))
return (puntoa, puntob, flecha01, flecha02)
# Limpia trama anterior
def limpiatrama():
puntoa.set_ydata(np.ma.array([xc[0]], mask=True))
puntob.set_ydata(np.ma.array([xc[0]], mask=True))
return (puntoa, puntob)
# contador de tramas
i = np.arange(0, tramas-1,1)
ani = animation.FuncAnimation(fig_ani,unatrama,
i ,
fargs=(xc, yc),
init_func=limpiatrama,
interval=retardo,
blit=True)
# Graba Archivo GIFAnimado y video
ani.save(narchivo+'_ani.gif', writer='pillow')
#ani.save(narchivo+'.mp4')
plt.show()
Método de Newton-Raphson y gráfico animado con Python
# Método de Newton-Raphson
# Requiere fx y dfx
# x0 es el valor inicial para la búsqueda de raíz
import numpy as np
def newton_raphson(fx,dfx,x0, tolera, iteramax=100,
vertabla=False, precision=4):
'''fx y dfx en forma numérica lambda
xi es el punto inicial de búsqueda
si no converge hasta iteramax iteraciones
la respuesta es NaN (Not a Number)
'''
itera=0
xi = x0
tramo = abs(2*tolera)
tabla=[]
if vertabla==True:
print('Método de Newton-Raphson')
print('i', ['xi','fi','dfi', 'xnuevo', 'tramo'])
np.set_printoptions(precision)
while (tramo>=tolera):
fi = fx(xi)
dfi = dfx(xi)
xnuevo = xi - fi/dfi
tramo = abs(xnuevo-xi)
unafila = np.array([xi,fi,dfi,xnuevo,tramo])
tabla.append(unafila)
if vertabla==True:
print(itera,np.array([xi,fi,dfi,xnuevo,tramo]))
xi = xnuevo
itera = itera + 1
if itera>=iteramax:
xi = np.nan
print('itera: ',itera,
'No converge,se alcanzó el máximo de iteraciones')
tabla = np.array(tabla,dtype=float)
return(xi,tabla)
# PROGRAMA -------------------------
# INGRESO
fx = lambda x: x**3 + 4*(x**2) - 10
dfx = lambda x: 3*(x**2) + 8*x
x0 = 2
tolera = 0.001
iteramax = 15
verdigitos = 4 # ver digitos en tabla
# PROCEDIMIENTO
xi,tabla = newton_raphson(fx,dfx,x0,tolera,iteramax,
vertabla=True,
precision=verdigitos)
n = len(tabla)
errado = tabla[n-1,4]
# SALIDA
print('Método de Newton-Raphson')
print('itera : ', n)
print('raíz en: ', xi)
print('errado : ', errado)
# GRAFICA ---------------------
import matplotlib.pyplot as plt
a = 1
b = 2
muestras = 21
itera_graf = 2 #n-1 # iteración en gráfica
titulo = 'Newton-Raphson'
xk = np.linspace(a,b,muestras)
fk = fx(xk)
xa = tabla[:,0]
ya = tabla[:,1]
xb = tabla[:,3]
dfi = tabla[:,2]
# Aproximacion con tangente
b0 = ya[itera_graf] - dfi[itera_graf]*xa[itera_graf]
tangentek = dfi[itera_graf]*xk + b0
ci = -b0/dfi[itera_graf]
plt.plot(xk,fk, label='f(x)')
if itera_graf==(n-1): # iteración final
plt.plot(xi,0, 'o')
if itera_graf<(n-1): # una iteración en gráfica
titulo = titulo+', itera='+str(itera_graf)
plt.ylim([np.min(fk),np.max(fk)])
plt.plot([xa[itera_graf],xa[itera_graf]],[0,ya[itera_graf]],'--',color='red')
plt.plot(xa[itera_graf],ya[itera_graf],'o',color='red',label='xi')
plt.plot(xk,tangentek,color='orange',label='tangente')
plt.plot(ci,0,'o',color='green',label='x[i+1]')
plt.axhline(0)
plt.xlabel('x')
plt.ylabel('f(x)')
plt.grid()
plt.legend()
plt.title(titulo)
plt.tight_layout()
#plt.show()
# GRAFICA CON ANIMACION ------------
#import matplotlib.pyplot as plt
import matplotlib.animation as animation
xa = tabla[:,0]
ya = tabla[:,1]
xb = tabla[:,3]
dfi = tabla[:,2]
# Aproximacion con tangente
b0 = ya[0] - dfi[0]*x0
tangentei = dfi[0]*xk + b0
ci = -b0/dfi[0]
# Inicializa parametros de trama/foto
narchivo = 'NewtonRaphson' # nombre archivo
retardo = 700 # milisegundos entre tramas
tramas = len(xa)
# GRAFICA animada en fig_ani
fig_ani, graf_ani = plt.subplots()
graf_ani.set_xlim([a,b])
graf_ani.set_ylim([np.min(fk),np.max(fk)])
# Lineas y puntos base
lineafx, = graf_ani.plot(xk,fk,label ='f(x)')
puntoa, = graf_ani.plot(xa[0], ya[0],'o',
color='red', label='x[i]')
puntob, = graf_ani.plot(xb[0], 0,'o',
color='green', label='x[i+1]')
lineatanx, = graf_ani.plot(xk,tangentei,
color='orange',label='tangente')
lineaa, = graf_ani.plot([xa[0],xa[0]],
[ya[0],0], color='magenta',
linestyle='dashed')
lineab, = graf_ani.plot([xb[0],xb[0]],
[0,fx(xb[0])], color='magenta',
linestyle='dashed')
# Configura gráfica
linea0 = graf_ani.axhline(0, color='k')
graf_ani.set_title('Newton-Raphson')
graf_ani.set_xlabel('x')
graf_ani.set_ylabel('f(x)')
graf_ani.legend()
graf_ani.grid()
# Cada nueva trama
def unatrama(i,xa,ya,xb,dfi):
# actualiza cada punto, [] porque es solo un valor
puntoa.set_xdata([xa[i]])
puntoa.set_ydata([ya[i]])
puntob.set_xdata([xb[i]])
puntob.set_ydata([0])
# actualiza cada linea
lineaa.set_ydata([ya[i], 0])
lineaa.set_xdata([xa[i], xa[i]])
lineab.set_ydata([0, fx(xb[i])])
lineab.set_xdata([xb[i], xb[i]])
# Aproximacion con tangente
b0 = ya[i] - dfi[i]*xa[i]
tangentei = dfi[i]*xk+b0
lineatanx.set_ydata(tangentei)
return (puntoa, puntob, lineaa, lineab,lineatanx,)
# Limpia trama anterior
def limpiatrama():
puntoa.set_ydata(np.ma.array(xa, mask=True))
puntob.set_ydata(np.ma.array(xb, mask=True))
lineaa.set_ydata(np.ma.array([0,0], mask=True))
lineab.set_ydata(np.ma.array([0,0], mask=True))
lineatanx.set_ydata(np.ma.array(xk, mask=True))
return (puntoa, puntob, lineaa, lineab,lineatanx,)
# contador de tramas
i = np.arange(0,tramas,1)
ani = animation.FuncAnimation(fig_ani,unatrama,
i ,
fargs=(xa, ya,
xb, dfi),
init_func=limpiatrama,
interval=retardo,
blit=True)
# Graba Archivo GIFAnimado y video
ani.save(narchivo+'_ani.gif', writer='pillow')
#ani.save(narchivo+'.mp4')
plt.show()
Método de la Secante y gráfico animado con Python
Instrucciones en Python
# Método de secante
# Los valores de [a,b] son revisados con la gráfica
import numpy as np
def secante_raiz(fx,a,b,tolera, iteramax=50,
vertabla=True, precision=6):
'''fx en forma numérica lambda
Los valores de [a,b] son seleccionados
desde la gráfica de la función
'''
xa = a
xb = b
itera = 0
tramo = np.abs(xb-xa)
tabla=[]
if vertabla==True:
print('Método de la Secante')
print('i','[ x[i-1], xi, x[i+1], f[i-1], fi , tramo]')
np.set_printoptions(precision)
while not(tramo<tolera or itera>iteramax):
fa = fx(xa)
fb = fx(xb)
xc = xb - fb*(xa - xb)/(fa - fb)
tramo = abs(xc - xb)
unafila = np.array([xa,xb,xc,fa,fb,tramo])
tabla.append(unafila)
if vertabla==True:
print(itera,unafila)
xa = xb
xb = xc
itera = itera + 1
if itera>=iteramax:
xc = np.nan
print('itera: ',itera,
'No converge,se alcanzó el máximo de iteraciones')
respuesta = xc
tabla = np.array(tabla,dtype=float)
return(respuesta,tabla)
# INGRESO
fx = lambda x: x**3 + 4*x**2 - 10
a = 1
b = 2
tolera = 0.001
verdigitos = 4 # ver digitos en tabla
iteramax = 50
# PROCEDIMIENTO
xc,tabla = secante_raiz(fx,a,b,tolera,iteramax,
vertabla=True,
precision=verdigitos)
n = len(tabla)
errado = tabla[n-1,5]
# SALIDA
print('Método de la Secante')
print('iteraciones:',n)
print('raíz en: ',xc)
print('errado:',errado)
# GRAFICA ---------------------
import matplotlib.pyplot as plt
a = 1
b = 2
muestras = 21
itera_graf = 0 #n-1 # iteración en gráfica
titulo = 'Método de la Secante'
tramos = 100
[xa,xb,xc] = tabla[itera_graf,0:3]
[fa,fb] = tabla[itera_graf,3:5]
xk = np.linspace(a,b,muestras)
fk = fx(xk)
plt.plot(xk,fk, label='f(x)')
if itera_graf==(n-1): # iteración final
plt.plot(xc,0,'D',color='orange',label='xc')
if itera_graf<(n-1): # una iteración en gráfica
titulo = titulo+', itera='+str(itera_graf)
plt.plot(xa, fa,'o',color='red', label='x[i-1]')
plt.plot(xb, fb,'o',color='green', label='x[i]')
plt.plot(xc, 0,'o',color='orange', label='x[i+1]')
plt.plot([xa,xa],[0,fa],'--',color='red')
plt.plot([xb,xb],[0,fb],'--',color='green')
plt.plot([xa,xb],[fa,fb],color='orange',label='secante ac')
plt.plot([xc,xb],[0,fb],color='orange',label='secante cb')
plt.axhline(0)
plt.xlabel('x')
plt.ylabel('f(x)')
plt.grid()
plt.legend()
plt.title(titulo)
plt.tight_layout()
#plt.show()
# GRÁFICO CON ANIMACION ######
import matplotlib.animation as animation
xa = tabla[:,0]
ya = tabla[:,3]
xb = tabla[:,1]
yb = tabla[:,4]
xc = tabla[:,2]
# Inicializa parametros de trama/foto
narchivo = 'SecanteMetodo' # nombre archivo
retardo = 700 # milisegundos entre tramas
tramas = len(xa)
# GRAFICA animada en fig_ani
fig_ani, graf_ani = plt.subplots()
graf_ani.set_xlim([a,b])
graf_ani.set_ylim([np.min(fk),np.max(fk)])
# Lineas y puntos base
lineafx, = graf_ani.plot(xk,fk,label ='f(x)')
puntoa, = graf_ani.plot(xa[0], ya[0],'o',
color='red', label='x[i-1]')
puntob, = graf_ani.plot(xb[0], yb[0],'o',
color='green', label='x[i]')
puntoc, = graf_ani.plot(xc[0], 0,'o',
color='orange', label='x[i+1]')
lineatan1, = graf_ani.plot([xa[0],xb[0]],
[ya[0],yb[0]],
color='orange',label='secante ac')
lineatan2, = graf_ani.plot([xc[0],xb[0]],
[0,yb[0]],
color='orange',label='secante cb')
linea_a, = graf_ani.plot([xa[0],xa[0]],
[ya[0],0], color='magenta',
linestyle='dashed')
linea_b, = graf_ani.plot([xb[0],xb[0]],
[0,yb[0]], color='magenta',
linestyle='dashed')
# Configura gráfica
linea0 = graf_ani.axhline(0, color='k')
graf_ani.set_title('Método de la Secante')
graf_ani.set_xlabel('x')
graf_ani.set_ylabel('f(x)')
graf_ani.legend()
graf_ani.grid()
# Cada nueva trama
def unatrama(i,xa,ya,xb,yb,xc):
# actualiza cada punto, [] porque es solo un valor
puntoa.set_xdata([xa[i]])
puntoa.set_ydata([ya[i]])
puntob.set_xdata([xb[i]])
puntob.set_ydata([yb[i]])
puntoc.set_xdata([xc[i]])
puntoc.set_ydata([0])
# actualiza cada linea
linea_a.set_ydata([ya[i], 0])
linea_a.set_xdata([xa[i], xa[i]])
linea_b.set_ydata([0, yb[i]])
linea_b.set_xdata([xb[i], xb[i]])
lineatan1.set_ydata([ya[i], 0])
lineatan1.set_xdata([xa[i], xc[i]])
lineatan2.set_ydata([0, yb[i]])
lineatan2.set_xdata([xc[i], xb[i]])
return (puntoa, puntob, puntoc,
linea_a, linea_b,
lineatan1, lineatan2,)
# Limpia trama anterior
def limpiatrama():
puntoa.set_ydata(np.ma.array(xa, mask=True))
puntob.set_ydata(np.ma.array(xb, mask=True))
puntoc.set_ydata(np.ma.array(xc, mask=True))
linea_a.set_ydata(np.ma.array([0,0], mask=True))
linea_b.set_ydata(np.ma.array([0,0], mask=True))
lineatan1.set_ydata(np.ma.array([0,0], mask=True))
lineatan2.set_ydata(np.ma.array([0,0], mask=True))
return (puntoa, puntob, puntoc,
linea_a, linea_b,
lineatan1, lineatan2,)
# contador de tramas
i = np.arange(0,tramas,1)
ani = animation.FuncAnimation(fig_ani,unatrama,
i ,
fargs=(xa, ya,
xb, yb,
xc),
init_func=limpiatrama,
interval=retardo,
blit=True)
# Graba Archivo GIFAnimado y video
ani.save(narchivo+'_ani.gif', writer='pillow')
#ani.save(narchivo+'.mp4')
plt.show()