Métodos De Aproximación De Raíces Con Python

por | 27 octubre, 2008

Hola, siguiendo con el artículo de La Bisección con Python he añadido dos nuevos métodos para aproximar raíces de funciones. He añadido los métodos del Punto Fijo y el de la Secante. Como el código lo que tiene de nuevo respecto al anterior es aprender en Python a hacer un menú me he decidido a comentarlo un poco.
Quisiera dejar claro que éste artículo no va a tratar sobre una explicación de estos métodos iterativos con profundidad, ya que considero que hay mucho material escrito sobre ello y se puede encontrar fácilmente en cualquier biblioteca pública universitaria de ciencias, en librerías y en artículos gratuitos en formato pdf en la red. Además dichos métodos no contienen ningún misterio.
Bien, pasemos a hablar un poco del código que he realizado, el cual se compone de 6 ficheros con extensión .py. El primero es el archivo principal del proyecto, el cual he llamado Metodos.py y cuyo código es:
[source=’python’]
#!/usr/bin/python
# coding: latin-1

#import os, sys

import Menu
from Numeric import *

Menu.elmenu()
[/source]

Este código no tiene ningún misterio, lo único que hace es cargar python con codificación de latin. Nos importa el fichero Menu.py que hemos implementado nosotros mismos, y de Menu.py llamamos a la función elmenu() con la instrucción Menu.elmenu()
Pasemos a ver el código del fichero Menu.py:
[source=’python’]
#!/usr/bin/python
# coding: latin-1

from math import *

import Biseccion
import PuntoFijo
import Secante

def op1 ():
a = float(input(“Introduce el extremo inferior del intervalo\n”))
b = float(input(“Introduce el extremo superior del intervalo\n”))
TOL = float(input(“Introduce la tolerancia del metodo\n”))
Biseccion.biseccion(a, b, TOL, 100)
Biseccion.dibujar(a, b, TOL, 100)
def op2 ():
po = float(input(“Introduce el valor inicial\n”))
TOL = float(input(“Introduce la tolerancia del metodo\n”))
PuntoFijo.puntofijo(po, TOL, 100)
PuntoFijo.dibujar(po, TOL, 100)
def op3 ():
po = float(input(“Introduce el primer valor inicial\n”))
p1 = float(input(“Introduce el segundo valor inicial\n”))
TOL = float(input(“Introduce la tolerancia del metodo\n”))
Secante.secante(po, p1, TOL, 100)
Secante.dibujar(po, p1, TOL, 100)
def errhandler ():
print “Tu eleccion no ha sido la correcta\n”

#menu es un diccionario que nos ayudara para hacer un menu por terminal
def elmenu ():
menu = {“1”: op1, “2”: op2, “3”: op3}
opcion = raw_input(“Por favor introduce la opcion numerica que desees\n”)
menu.get(opcion, errhandler)()

[/source]

Lo primero que hacemos es importar la librería matemática “math” de Python y los métodos de la Bisección, Punto Fijo y Secante, los cuales los he escrito en tres ficheros .py diferentes, lo hacemos con el trozo de código:
[source=’python’]
from math import *

import Biseccion
import PuntoFijo
import Secante
[/source]

Seguidamente pasamos a definir las cosas que realizarán cada una de las opciones de que se compone nuestro menú, por ejemplo, con la opción 1 pediremos por terminal los valores de a, b y TOL, además mandamos que se ejecuten las funciones bisección y dibujar que se encuentran en Biseccion.py, el trozo de código correspondiente es:
[source=’python’]
def op1 ():
a = float(input(“Introduce el extremo inferior del intervalo\n”))
b = float(input(“Introduce el extremo superior del intervalo\n”))
TOL = float(input(“Introduce la tolerancia del metodo\n”))
Biseccion.biseccion(a, b, TOL, 100)
Biseccion.dibujar(a, b, TOL, 100)
[/source]
De igual forma se procede con op2() y op3(), sólo hay que tener en cuenta de anteponer la palabra clave def. He añadido una opción de salida del menú en caso de error:
[source=’python’]
def errhandler ():
print “Tu eleccion no ha sido la correcta\n”
[/source]
Finalmente definimos la función elmenu(), la cual es la que hemos llamado en Metodos.py. Esta función se compone de un diccionario llamado menu, así pues, un menú en Python lo podemos definir mediante un diccionario como el que se ha definido en este caso. Luego la función se compone de una toma de las distintas opciones del menú mediante raw_input y menu.get. El trozo de código es:
[source=’python’]
def elmenu ():
menu = {“1”: op1, “2”: op2, “3”: op3}
opcion = raw_input(“Por favor introduce la opcion numerica que desees\n”)
menu.get(opcion, errhandler)()
[/source]
Seguidamente viene el código de Biseccion.py, el cual es:
[source=’python’]
#!/usr/bin/python

import Evaluar
from pylab import *
from Numeric import *

def biseccion(a, b, TOL, N):
Evaluar.dicc_seguro[‘x’]=a
fa = eval(Evaluar.funcion, {“__builtins__”:None}, Evaluar.dicc_seguro)
vectorx = zeros(N, Float64)
vectory = zeros(N, Float64)

i = 1
while i<=N : p = (a+b)/2.0 vectorx[i-1] = p Evaluar.dicc_seguro['x']=p fp = eval(Evaluar.funcion, {"__builtins__":None}, Evaluar.dicc_seguro) vectory[i-1]=fp if (fp == 0.0) or ( (b-a)/2.0)0 :
a = p
else :
b = p
print “La raiz buscada es: “,p, “con”, i-1,”iteraciones”
return [vectorx, vectory]

def dibujar(a,b,TOL, N):
x = arange(a,b,0.1)
vectores=biseccion(a, b, TOL, N)

subplot(211)
plot(x, eval(Evaluar.funcion), linewidth=1.0)
xlabel(‘Abcisa’)
ylabel(‘Ordenada’)
title(‘Metodo Biseccion con f(x)=’ + Evaluar.funcion)
grid(True)
axhline(linewidth=1, color=’r’)
axvline(linewidth=1, color=’r’)

subplot(212)
plot(vectores[0], vectores[1], ‘k.’)
xlabel(‘Abcisa’)
ylabel(‘Ordenada’)
grid(True)
axhline(linewidth=1, color=’r’)
axvline(linewidth=1, color=’r’)

show()
[/source]
Este código ya lo expliqué en el anterior artículo, se compone de dos funciones, en una de ellas realizamos el método de la bisección y en la otra función dibujamos la gráfica de la función y sus aproximaciones.
De igual forma he escrito el método del punto fijo con PuntoFijo.py
[source=’python’]
#!/usr/bin/python

import Evaluar
from pylab import *
from Numeric import *

def puntofijo(po,TOL, N):
vectorx = zeros(N, Float64)
vectory = zeros(N, Float64)

i = 1
while i<=N : vectorx[i-1] = po Evaluar.dicc_seguro['x']=po fp = eval(Evaluar.funcion, {"__builtins__":None}, Evaluar.dicc_seguro) vectory[i-1]=fp if fabs(po-fp)Programa Python 

Saludos :-h

5 pensamientos en “Métodos De Aproximación De Raíces Con Python

  1. Macarse

    Cristobal:
    Me gustaría agregarle a tus métodos de raices el método de Newton.
    Una vez terminado me gustaría mandartelo al mail, pero no lo encuentro en todo el sitio

    Saludos.

  2. Cristobal

    Macarse mi e-mail es lopeztobal arroba gmail punto com
    Escribelo bien, aquí no lo pongo bien para no tener spam.
    El de Newton no lo agregué por falta de tiempo, quiero hacer el de Müller, que casi nadie lo conoce, pero me temo que no va a ser hasta el verano.

  3. Rokelinda

    Hola, me intesa el método de bisección, pero especificamente para coseno de x, con limites a=0 y b=2pi. El asunto es que no debo especificar el número de repeticiones, es decir que se debe detener sólo con la tolerancia. Espero puedas responder pronto.

  4. Ademir

    Hola amigo tengo una consulta respecto al modulo pylab, quiero saber donde se encuentra ese modulo, ya que me sale un error de compilacion indicando que ese modulo no existe.

  5. Tobal Autor

    @Ademir->No especificas en qué distro lo estás realizando, pero el paquete a instalar es matplotlib, se encuentra en las principales distros linuxeras

Los comentarios están cerrados.