Script de Métodos Numéricos

Documentación detalla el funcionamiento de el script en Python que proporciona una interfaz de línea de comandos para encontrar raíces de funciones utilizando diversos métodos numéricos.

Descripción General

El script implementa una calculadora interactiva que permite elegir entre dos categorías principales de métodos para encontrar raíces:

1. Métodos de Bracketing (o Cerrados): Requieren un intervalo inicial [a, b] que contenga la raíz.
2. Métodos Abiertos: Requieren una o más datos de entrada, pero no necesariamente un intervalo que contenga la raíz.

Dependencias

Para este script, necesitas las siguientes librerías de Python:

• os: Dependencia directa para tener la pantalla limpia en la interacción con el usuario _cls().
• SciPy: Import directo para el método de Brent (brentq). Disclaimer, subí el markdown incorrecto y bueno, scipy está incluido, pero no se usa en nada, olvidé quitar la dependencia por lo que tiene que ser instalado, ups

Puedes instalar estas dependencias usando pip:

pip install os scipy

Instrucciones de uso

1. Guarda el código con el nombre que quieras
2. Abre una terminal o línea de comandos.
3. Navega hasta el directorio donde guardaste el archivo.
4. Ejecuta el script con el siguiente comando:

python "nombre-del-script"

En caso de que se copiara el código, caso contrario el nombre sería local_code.py como en este repositorio

Estructura

El código está organizado principalmente en tres clases y un conjunto de funciones.

• mainClass: Es la clase principal y punto de entrada, gestiona el menú principal.
• bracketingMethods: Contiene la lógica y los menús para los métodos de Bisección y False position.
• openMethods: Contiene la lógica y los menús para los métodos de fixed point, Newton-Raphson, Secante y Brent.
• Funciones paralelas: _cls, _inv, mainMenu y la variable m0 que se encargan de la interfaz de usuario.

---

Funciones y Clases Detalladas

Funciones Auxiliares

• _cls(): Limpia la pantalla de la consola, soy de windows pero se supone que funciona en unix
• _inv(a): Muestra un mensaje de error estandarizado cuando el usuario introduce una opción inválida.
• m0: Bello banner del menú.
• mainMenu(data): Es la función central para mostrar menús. Recibe una lista de strings (data), la imprime línea por línea y solicita al usuario una elección numérica.

class mainClass

Esta es la clase que inicia la aplicación.

• __init__(self): Inicializa la clase con las cadenas de texto para su menú.
• menuDisplay(self): Muestra el menú principal para elegir entre "Métodos de Bracketing" y "Métodos Abiertos". Basado en la elección del usuario, crea una instancia de la clase correspondiente (bracketingMethods u openMethods) e inicia su propio ciclo de menú.
• start(self): Es el método de entrada que simplemente llama a menuDisplay() para comenzar el programa.

class bracketingMethods

Implementa los métodos que necesitan un intervalo que encierre la raíz.

• bisection(self, f, a, b, max_iter=100):

  • Propósito: Encuentra la raíz de una función usando el método de bisección.
  • Funcionamiento: Divide repetidamente el intervalo a la mitad, seleccionando el subintervalo donde la función cambia de signo. Converge de forma lenta pero segura.
  • Parámetros: Función f, extremos a y b, número máximo de iteraciones.
  • Retorno: Aproximación de la raíz o None si hay error.

• regula_falsi(self, func, a, b, max_iter=100):

  • Propósito: Encuentra la raíz usando el método de la falsa posición (Regula Falsi).
  • Funcionamiento: Similar a bisección, pero en lugar de usar el punto medio, utiliza interpolación lineal para estimar la raíz. Generalmente converge más rápido que bisección.
  • Parámetros: Función func, extremos a y b, número máximo de iteraciones.
  • Retorno: Aproximación de la raíz o None si hay error.

• get_function_input(self): Solicita al usuario que ingrese una función matemática como string y la convierte en una función lambda evaluable. Incluye validación de sintaxis.

• get_parameters(self): Solicita los parámetros necesarios para métodos de bracketing: extremos del intervalo a y b, y número máximo de iteraciones.

• run_method(self, method_name): Función coordinadora que obtiene la función, los parámetros y ejecuta el método especificado, mostrando resultados formateados.

• menuDisplay(self): Gestiona el submenú de métodos de bracketing.

• start(self): Inicia el flujo de la clase.

class openMethods

Implementa los métodos que se basan en uno o dos puntos iniciales.

• fixed_point(self, g, x0, max_iter=100):

  • Propósito: Encuentra el punto fijo de una función usando iteración directa.
  • Funcionamiento: Aplica repetidamente la función g(x) comenzando desde x0. Converge si |g'(x)| < 1 cerca de la raíz.
  • Parámetros: Función g(x) (ecuación despejada como x = g(x)), punto inicial x0, iteraciones máximas.

• newton_raphson(self, f, df, x0, max_iter=100):

  • Propósito: Encuentra la raíz usando el método de Newton-Raphson.
  • Funcionamiento: Usa la tangente de la función para aproximar la raíz. Formula: x₁ = x₀ - f(x₀)/f'(x₀). Converge cuadráticamente cuando está cerca de la raíz.
  • Parámetros: Función f, derivada df, punto inicial x0, iteraciones máximas.
  • Validación: Verifica que la derivada no sea cercana a cero para evitar divisiones inválidas.

• secant(self, f, x0, x1, max_iter=100):

  • Propósito: Encuentra la raíz usando el método de la secante.
  • Funcionamiento: Similar a Newton-Raphson pero aproxima la derivada usando dos puntos. No requiere calcular la derivada analítica. Formula: x₂ = x₁ - f(x₁)(x₁-x₀)/(f(x₁)-f(x₀)).
  • Parámetros: Función f, dos puntos iniciales x0 y x1, iteraciones máximas.

• brent(self, f, a, b):

  • Propósito: Encuentra la raíz usando el algoritmo de Brent (implementación de SciPy).
  • Funcionamiento: Combina bisección, secante e interpolación cuadrática inversa para garantizar convergencia robusta y rápida. Es uno de los métodos más eficientes.
  • Parámetros: Función f, extremos del intervalo a y b.

• get_function_input(self): Solicita la función a evaluar.

• get_derivative_input(self): Solicita la derivada de la función (para Newton-Raphson).

• get_g_function_input(self): Solicita la función g(x) para el método de punto fijo.

• run_fixed_point(self), run_newton_raphson(self), run_secant(self), run_brent(self): Funciones coordinadoras que solicitan las entradas necesarias para cada método específico y ejecutan el algoritmo correspondiente.

• start(self) y menuDisplay(self): Gestionan el submenú de los métodos abiertos.

---

Ejemplos de Uso

Ejemplo 1: Método de Bisección

Problema: Encontrar la raíz de f(x) = x³ - 9x - 5 en el intervalo [3, 4]

Entrada:

Seleccionar: [0] - Métodos de bracketing
Seleccionar: [0] - Bisección
f(x) = x**3 - 9*x - 5
Extremo izquierdo (a): 3
Extremo derecho (b): 4
Máximo de iteraciones: 100

Salida esperada:

======================================================================
 Función: f(x) = x**3 - 9*x - 5
 Intervalo: [3, 4]
======================================================================
 [!] Mejor aproximación: x = 3.53208888

Ejemplo 2: Método de Newton-Raphson

Problema: Encontrar la raíz de f(x) = x² - 4 con derivada f'(x) = 2x, comenzando en x₀ = 1

Entrada:

Seleccionar: [1] - Métodos abiertos
Seleccionar: [1] - Newton-Raphson
f(x) = x**2 - 4
f'(x) = 2*x
Valor inicial (x0): 1
Máximo de iteraciones: 100

Salida esperada:

======================================================================
 Función: f(x) = x**2 - 4
 Derivada: f'(x) = 2*x
 Valor inicial: x0 = 1
======================================================================
 Iteración inicial: x0 = 1
 [!] Última aproximación: x = 2.00000000

Ejemplo 3: Método de la Secante

Problema: Encontrar la raíz de f(x) = sin(x) - x/2 con puntos iniciales x₀ = 1.5, x₁ = 2

Entrada:

Seleccionar: [1] - Métodos abiertos
Seleccionar: [2] - Secant
f(x) = np.sin(x) - x/2
Primer valor inicial (x0): 1.5
Segundo valor inicial (x1): 2
Máximo de iteraciones: 100

Salida esperada:

======================================================================
 Función: f(x) = np.sin(x) - x/2
 Valores iniciales: x0 = 1.5, x1 = 2
======================================================================
 Iteraciones iniciales: x0 = 1.5, x1 = 2
 [!] Última aproximación: x = 1.89549427

Ejemplo 4: Algoritmo de Brent

Problema: Encontrar la raíz de f(x) = x² - 4 en el intervalo [0, 3]

Entrada:

Seleccionar: [1] - Métodos abiertos
Seleccionar: [3] - Algoritmo de Brent
f(x) = x**2 - 4
Extremo izquierdo (a): 0
Extremo derecho (b): 3

Salida esperada:

======================================================================
 Función: f(x) = x**2 - 4
 Intervalo: [0, 3]
======================================================================
 [!] Última aproximación: x = 2.00000000

Gemini 2.5 Pro se utilizo para dar correción ortografica y ayuda de formato solo en el markdown