Bisección

MÉTODO DE BISECCIÓN CON PYTHON

A continuación se muestra la implementación del método numérico de bisección, el cual toma dos intervalos iniciales y los va dividiendo respecto al polinomio ingresado para encontrar una solución para dicho polinomio.

#--------------------------------------------------------------
#   Programa que utiliza el metodo de Biseccion para el calculo
#   de raices de un polinomio de n grado
#
#   PROGRAMA        :       Biseccion.py
#   PROGRAMADOR     :       Cruz Gomez Jovanny Pablo
#   LENGUAJE        :       Python
#   FECHA           :       03 de Marzo de 2012
#---------------------------------------------------------------


import os       
import math


#---------------------------------------------------------------
# Funcion que muestra el titulo del programa
#---------------------------------------------------------------
def titulo():
    os.system("CLS")
    print "Metodo de biseccion\n"


#---------------------------------------------------------------
# Funcion que evalua f(x) con el metodo de Horner
#---------------------------------------------------------------
def f(coeficientes, grado, valor):
    resultado = coeficientes[0]
    i = 1


    while(i <= grado):
        resultado = (resultado * valor) + coeficientes[i]
        i += 1


    return resultado
    
#---------------------------------------------------------------
# FUNCION QUE CALCULA Mx
#---------------------------------------------------------------
def Mx(a, b):
    return (a + b) / 2


#---------------------------------------------------------------
# METODO DE BISECCION
#---------------------------------------------------------------
def biseccion(coeficientes, grado, iInicial, iFinal):
    a = iInicial
    b = iFinal
    nIteraciones = math.ceil((math.log(b - a) - math.log(0.00001)) / math.log(2))


    titulo()


    print "{0}\t{1}\t{2}\t{3}\t{4}".format('n', 'a', 'b', 'Mx', 'f(Mx)f(a)')


    i = 1
    while(i <= nIteraciones):
        x = Mx(a, b)
        Fx = f(coeficientes, grado, x)
        Fa = f(coeficientes, grado, a)


        condicion = Fx * Fa


        print i, "\t{:.4}\t{:.4}\t{:.4}\t{:.4}".format(a, b, x, condicion)


        if(condicion > 0):
            a = x
        elif(condicion < 0):
            b = x
        else:
            x = x


        i += 1
    print "\nLa raiz encontrada es: {0}\n".format(x)


#---------------------------------------------------------------
#Programa principal
#---------------------------------------------------------------


consulta = '1'
while(consulta != '0'):
    os.system("COLOR F0")
    titulo()


    grado = int(raw_input("Grado de ecuacion: "))   
    print                                                  
    iInicial = float(raw_input("Intervalo inicial: "))      
    iFinal = float(raw_input("Intervalo final: "))         


    titulo()


    coeficientes = []       


    i = grado
    while(i >= 0):                                              
        cof = float(raw_input("Ingresa x^{0}: ".format(i)))     
        coeficientes.append(cof)                                
        i -= 1                                                   


    biseccion(coeficientes, grado, iInicial, iFinal)


    print
    consulta = raw_input("Para salir presiona 0, sino otra tecla: ")






El programa anterior puede ser probado con el polinomio:


Polinomio de ejemplo

Donde podemos observar que el grado es 3 (grado = 3). La siguiente imagen muestra la gráfica del polinomio anterior:

Gráfica del polinomio


En la gráfica podemos observar que existe una raíz entre 1 y 2, por lo que el programa de 'Bisección.py' pide al usuario ingresar 2 intervalos; para éste polinomio, los intervalos que tomaremos serán 1 y 2 ya que suponemos que ahí existe una solución.

Inserción del grado de la ecuación y los intervalos

Después de dar ingresar el grado de la ecuación, procedemos a ingresar los coeficientes del polinomio tomado de ejemplo:

Inserción de coeficientes del polinomio

Finalmente es mostrada la tabla de iteraciones y la raíz del polinomio ingresado:

Tabla de resultados para la raíz del polinomio

Podemos concluir que la raíz se encuentra en el punto 1.36522674561. Para comprobar este resultado podemos ir nuevamente a la gráfica y realizar un zoom en el área de la raíz:


Aproximación gráfica de la raíz

Entonces se puede confirmar que el programa funciona correctamente, ya que al realizar un zoom en la gráfica muy cerca de la raíz, observamos la aproximación (en la gráfica la raíz está cerca de 1.3652) que tiene una precisión menos significativa a la que el programa nos mostró.

Cabe mencionar que el programa funciona para cualquier polinomio de n grado.
Los reto a probarlo con un polinomio de grado 20, 30, 50 o cualquier grado =P

Hasta la próxima!


5 comentarios:

  1. Excelente aporte muchas gracias, que gran trabajo.

    ResponderEliminar
  2. Excelente aporte, con él he entendido de manera clara y precisa el tema. Muy buen blog.

    ResponderEliminar
  3. Excelente aporte, con él he entendido de manera clara y precisa el tema. Muy buen blog.

    ResponderEliminar

Visitas