mathmethods-mcp 0.1.0__py3-none-any.whl

mathmethods/core/root_finding.py

@@ -0,0 +1,339 @@
+"""
+Métodos para búsqueda de raíces
+- Bisección
+- Punto Fijo
+- Newton-Raphson
+- Aitken (Aceleración)
+"""
+import numpy as np
+from typing import Dict, List, Tuple, Callable
+import sympy as sp
+import math
+from .utils import safe_sympify
+
+class RootFindingService:
+    
+    @staticmethod
+    def compilar_funcion(texto_funcion: str, variables: str = 'x') -> Callable:
+        """Convierte string matemático a función callable con NumPy."""
+        try:
+            x = sp.Symbol(variables.split()[0])
+            diccionario_local = {'e': sp.E, 'pi': sp.pi}
+            expr = safe_sympify(texto_funcion, local_dict=diccionario_local, allowed_symbols=variables.split())
+            return sp.lambdify(x, expr, 'numpy')
+        except Exception as e:
+            raise ValueError(f"Error compilando función: {str(e)}")
+    
+    @staticmethod
+    def biseccion(f: Callable, a: float, b: float, 
+                  tol: float = 1e-6, max_iter: int = 100, 
+                  precision: int = 8) -> Dict:
+        """Método de Bisección - acecha cambios de signo."""
+        try:
+            fa = float(f(a))
+            fb = float(f(b))
+        except:
+            raise ValueError("Error al evaluar f(a) o f(b). Asegúrese de que la función es válida en el intervalo.")
+            
+        if not (math.isfinite(fa) and math.isfinite(fb)):
+            raise ValueError("f(a) o f(b) no es finito. La función no está definida o diverge en el intervalo.")
+        if fa * fb >= 0:
+            raise ValueError("f(a) y f(b) deben tener signos opuestos (f(a) * f(b) < 0).")
+        
+        iteraciones = []
+        
+        for i in range(max_iter):
+            c = (a + b) / 2.0
+            try:
+                fc = float(f(c))
+                if math.isnan(fc) or math.isinf(fc):
+                    raise OverflowError("El valor de f(c) divergió a infinito o no existe.")
+            except Exception as e:
+                return {
+                    "metodo": "Bisección", "raiz": None, "iteraciones": iteraciones,
+                    "convergencia": False, "num_iter": i, "error_msg": f"Divergencia matemática: {str(e)}"
+                }
+            
+            # ELIMINAMOS TODOS LOS REDONDEOS ACÁ (Enviamos datos crudos)
+            error_calc = abs(b - a) / 2.0
+            iteraciones.append({
+                "i": i + 1,
+                "a": a,
+                "b": b,
+                "c": c,
+                "f_c": fc,
+                "error": error_calc
+            })
+            
+            if abs(fc) < tol or error_calc < tol:
+                return {
+                    "metodo": "Bisección",
+                    "raiz": round(c, precision), # La respuesta final sí se puede redondear a gusto
+                    "iteraciones": iteraciones,
+                    "convergencia": True,
+                    "num_iter": i + 1
+                }
+            
+            if fa * fc < 0:
+                b = c
+                fb = fc
+            else:
+                a = c
+                fa = fc
+        
+        return {
+            "metodo": "Bisección",
+            "raiz": round((a + b) / 2.0, precision),
+            "iteraciones": iteraciones,
+            "convergencia": False,
+            "num_iter": max_iter,
+            "error_msg": "Se alcanzó el límite de iteraciones sin converger."
+        }
+    
+    @staticmethod
+    def punto_fijo(g: Callable, x0: float, 
+                   tol: float = 1e-6, max_iter: int = 100,
+                   precision: int = 8) -> Dict:
+        """Método de Punto Fijo - x = g(x)."""
+        x = x0
+        iteraciones = []
+        verificacion = RootFindingService._verificar_lipschitz(g, x0)
+        
+        for i in range(max_iter):
+            try:
+                x_new = float(g(x))
+                if math.isnan(x_new) or math.isinf(x_new):
+                    raise OverflowError("La iteración explotó hacia el infinito.")
+            except Exception as e:
+                return {
+                    "metodo": "Punto Fijo",
+                    "raiz": None,
+                    "iteraciones": iteraciones,
+                    "verificacion": verificacion,
+                    "convergencia": False,
+                    "num_iter": i,
+                    "error_msg": f"¡La función diverge! Asegúrate de que |g'(x)| < 1. ({str(e)})"
+                }
+
+            error = abs(x_new - x)
+            
+            # ELIMINAMOS TODOS LOS REDONDEOS ACÁ
+            iteraciones.append({
+                "i": i + 1,
+                "x": x,
+                "g_x": x_new,
+                "error": error
+            })
+            
+            if error < tol:
+                return {
+                    "metodo": "Punto Fijo",
+                    "raiz": round(x_new, precision),
+                    "iteraciones": iteraciones,
+                    "verificacion": verificacion,
+                    "convergencia": True,
+                    "num_iter": i + 1
+                }
+            
+            x = x_new
+        
+        return {
+            "metodo": "Punto Fijo",
+            "raiz": round(x, precision),
+            "iteraciones": iteraciones,
+            "verificacion": verificacion,
+            "convergencia": False,
+            "num_iter": max_iter,
+            "error_msg": "No converge. Revisa si |g'(x)| < 1 en el intervalo."
+        }
+    
+    @staticmethod
+    def _derivada_numerica(f: Callable, x: float, dx: float = 1e-6) -> float:
+        """Aproxima derivada con diferencias centrales."""
+        return (f(x + dx) - f(x - dx)) / (2.0 * dx)
+
+    @staticmethod
+    def _verificar_lipschitz(g: Callable, x0: float, dx: float = 1e-6) -> Dict:
+        """Verifica condición local de contracción en la semilla: |g'(x0)| < 1."""
+        g_prime = float(RootFindingService._derivada_numerica(g, x0, dx))
+        return {
+            "x0": x0,
+            "g_prime": g_prime,
+            "abs_g_prime": abs(g_prime),
+            "cumple": abs(g_prime) < 1,
+        }
+    
+    @staticmethod
+    def newton_raphson(f: Callable, x0: float,
+                       tol: float = 1e-6, max_iter: int = 100,
+                       precision: int = 8) -> Dict:
+        """Método de Newton-Raphson - usa derivada numérica."""
+        x = x0
+        iteraciones = []
+        
+        for i in range(max_iter):
+            try:
+                fx = float(f(x))
+                dfx = float(RootFindingService._derivada_numerica(f, x))
+                
+                if abs(dfx) < 1e-10:
+                    raise ValueError("La derivada se hizo cero (tangente horizontal).")
+                
+                x_new = x - fx / dfx
+                if math.isnan(x_new) or math.isinf(x_new):
+                    raise OverflowError("La iteración divergió a infinito.")
+            except Exception as e:
+                return {
+                    "metodo": "Newton-Raphson",
+                    "raiz": None,
+                    "iteraciones": iteraciones,
+                    "convergencia": False,
+                    "num_iter": i,
+                    "error_msg": f"Falla en la iteración: {str(e)}"
+                }
+                
+            error = abs(x_new - x)
+            
+            # ELIMINAMOS TODOS LOS REDONDEOS ACÁ
+            iteraciones.append({
+                "i": i + 1,
+                "x": x,
+                "f (x)": fx,
+                "f ' (x)": dfx,
+                "Resultado": x_new,
+                "error": error
+            })
+            
+            if error < tol:
+                return {
+                    "metodo": "Newton-Raphson",
+                    "raiz": round(x_new, precision),
+                    "iteraciones": iteraciones,
+                    "convergencia": True,
+                    "num_iter": i + 1
+                }
+            
+            x = x_new
+        
+        return {
+            "metodo": "Newton-Raphson",
+            "raiz": round(x, precision),
+            "iteraciones": iteraciones,
+            "convergencia": False,
+            "num_iter": max_iter,
+            "error_msg": "Se alcanzó el límite de iteraciones sin converger."
+        }
+    
+    @staticmethod
+    def aitken(g: Callable, x0: float,
+               tol: float = 1e-6, max_iter: int = 100,
+               precision: int = 8) -> Dict:
+        """Aceleración de Aitken sobre punto fijo."""
+        x = x0
+        iteraciones = []
+        verificacion = RootFindingService._verificar_lipschitz(g, x0)
+        
+        for i in range(max_iter):
+            try:
+                x1 = float(g(x))
+                x2 = float(g(x1))
+                
+                denominador = x2 - 2*x1 + x
+                if abs(denominador) > 1e-12:
+                    x_acelerado = x - (x1 - x)**2 / denominador
+                else:
+                    x_acelerado = x2
+                    
+                if math.isnan(x_acelerado) or math.isinf(x_acelerado):
+                    raise OverflowError("La aceleración divergió a infinito.")
+            except Exception as e:
+                return {
+                    "metodo": "Aitken",
+                    "raiz": None,
+                    "iteraciones": iteraciones,
+                    "verificacion": verificacion,
+                    "convergencia": False,
+                    "num_iter": i,
+                    "error_msg": f"¡Divergencia detectada! {str(e)}"
+                }
+            
+            error = abs(x_acelerado - x)
+            
+            # ELIMINAMOS TODOS LOS REDONDEOS ACÁ
+            iteraciones.append({
+                "i": i + 1,
+                "x": x,
+                "g_x": x1,
+                "g_g_x": x2,
+                "x_acelerado": x_acelerado,
+                "error": error
+            })
+            
+            if error < tol:
+                return {
+                    "metodo": "Aitken",
+                    "raiz": round(x_acelerado, precision),
+                    "iteraciones": iteraciones,
+                    "verificacion": verificacion,
+                    "convergencia": True,
+                    "num_iter": i + 1
+                }
+            
+            x = x_acelerado
+        
+        return {
+            "metodo": "Aitken",
+            "raiz": round(x, precision),
+            "iteraciones": iteraciones,
+            "verificacion": verificacion,
+            "convergencia": False,
+            "num_iter": max_iter,
+            "error_msg": "No converge."
+        }
+    @staticmethod
+    def comparar_metodos(func_str: str, g_str: str, a: float, b: float, x0: float, 
+                         tol: float = 1e-6, max_iter: int = 100, precision: int = 8) -> Dict:
+        """
+        Orquestador que ejecuta los 4 métodos en paralelo y devuelve un resumen comparativo.
+        """
+        resultados = {
+            "biseccion": None,
+            "punto_fijo": None,
+            "newton_raphson": None,
+            "aitken": None
+        }
+
+        # 1. Bisección
+        try:
+            f_bisec = RootFindingService.compilar_funcion(func_str)
+            resultados["biseccion"] = RootFindingService.biseccion(f_bisec, a, b, tol, max_iter, precision)
+        except Exception as e:
+            resultados["biseccion"] = {"convergencia": False, "error_msg": str(e), "iteraciones": []}
+
+        # 2. Punto Fijo
+        try:
+            g_pf = RootFindingService.compilar_funcion(g_str)
+            resultados["punto_fijo"] = RootFindingService.punto_fijo(g_pf, x0, tol, max_iter, precision)
+        except Exception as e:
+            resultados["punto_fijo"] = {"convergencia": False, "error_msg": str(e), "iteraciones": []}
+
+        # 3. Newton-Raphson
+        try:
+            f_nr = RootFindingService.compilar_funcion(func_str)
+            resultados["newton_raphson"] = RootFindingService.newton_raphson(f_nr, x0, tol, max_iter, precision)
+        except Exception as e:
+            resultados["newton_raphson"] = {"convergencia": False, "error_msg": str(e), "iteraciones": []}
+
+        # 4. Aitken
+        try:
+            g_aitken = RootFindingService.compilar_funcion(g_str)
+            resultados["aitken"] = RootFindingService.aitken(g_aitken, x0, tol, max_iter, precision)
+        except Exception as e:
+            resultados["aitken"] = {"convergencia": False, "error_msg": str(e), "iteraciones": []}
+
+        return {
+            "parametros": {
+                "f(x)": func_str, "g(x)": g_str, "a": a, "b": b, "x0": x0, "tol": tol
+            },
+            "comparativa": resultados
+        }

mathmethods/core/utils.py

@@ -0,0 +1,226 @@
+import numpy as np
+from typing import Callable, Tuple, List, Dict, Any
+import sympy as sp
+import re
+from sympy.parsing.sympy_parser import parse_expr, standard_transformations, implicit_multiplication_application
+
+# ==========================================================================
+# SECURE EXPRESSION PARSING
+# --------------------------------------------------------------------------
+# SymPy's ``sympify`` and ``parse_expr`` evaluate strings with ``eval`` under
+# the hood and allow attribute access and ``__import__`` on recent versions
+# (verified: sympify("__import__('os').system(...)") executes the command).
+# Every user-supplied expression must go through ``safe_sympify`` /
+# ``safe_parse_expr`` which run a strict lexical gate BEFORE parsing:
+#   * length cap (denial-of-service mitigation)
+#   * identifier whitelist (variables + known functions + constants)
+#   * no "." or "__" (blocks attribute access)
+#   * integer-digit cap (blocks memory-exhausting eager evaluation)
+# ==========================================================================
+
+MAX_EXPRESSION_LENGTH = 200
+MAX_INTEGER_DIGITS = 6
+
+ALLOWED_FUNCTIONS = frozenset(
+    {
+        # trigonometric
+        "sin", "cos", "tan", "cot", "sec", "csc",
+        "asin", "acos", "atan", "acot", "asec", "acsc", "atan2",
+        "sinh", "cosh", "tanh", "coth", "sech", "csch",
+        "asinh", "acosh", "atanh",
+        # exponential / logarithmic / roots
+        "exp", "log", "ln", "sqrt", "cbrt", "root",
+        # absolute value / sign / rounding
+        "Abs", "sign", "floor", "ceiling", "frac",
+        # gamma family
+        "gamma", "loggamma", "factorial", "binomial", "subfactorial",
+        # special functions
+        "erf", "erfc", "erfi",
+        "Min", "Max",
+    }
+)
+
+_LOGIC_KEYWORDS = frozenset({"and", "or", "not"})
+_CONSTANTS = frozenset({"e", "E", "pi"})
+
+_IDENTIFIER_RE = re.compile(r"[^\W\d_]\w*", re.UNICODE)
+_NUMBER_RE = re.compile(r"(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?")
+_SINGLE_VAR = re.compile(r"(?<![A-Za-z0-9_])[eE]\^")
+_ALLOWED_PUNCTUATION = set("()+-,*/%<>!=:")
+
+
+def normalize_expr(expr: str) -> str:
+    """Normalize common math notations to SymPy syntax.
+
+    ``e^x`` / ``e^(-x)`` become ``E**x`` / ``E**(-x)`` (fixes the old
+    unbalanced ``exp(`` replacement), ``sen`` becomes ``sin`` and every
+    remaining ``^`` becomes ``**``.
+    """
+    out = expr.replace("sen", "sin")
+    out = _SINGLE_VAR.sub("E**", out)
+    out = out.replace("^", "**")
+    return out
+
+
+def _check_lexical(expr: str, allowed_identifiers) -> None:
+    """Reject any token that is not a number, allowed variable/constant or
+    allowed function, and any attribute access (``.`` / ``__``)."""
+    allowed_words = (
+        set(allowed_identifiers)
+        | ALLOWED_FUNCTIONS
+        | _CONSTANTS
+        | _LOGIC_KEYWORDS
+    )
+
+    i, n = 0, len(expr)
+    while i < n:
+        ch = expr[i]
+        if ch.isspace():
+            i += 1
+            continue
+
+        number = _NUMBER_RE.match(expr, i)
+        if number:
+            text = number.group()
+            int_part = text.split(".")[0].split("e")[0].split("E")[0].lstrip("+-")
+            if len(int_part) > MAX_INTEGER_DIGITS:
+                raise ValueError(
+                    f"Integer literal too large ({len(int_part)} digits, max {MAX_INTEGER_DIGITS})."
+                )
+            i = number.end()
+            continue
+
+        ident = _IDENTIFIER_RE.match(expr, i)
+        if ident:
+            token = ident.group()
+            if token not in allowed_words:
+                raise ValueError(f"Unknown or forbidden token: {token}")
+            i = ident.end()
+            continue
+
+        if ch in _ALLOWED_PUNCTUATION:
+            i += 1
+            continue
+        if ch == ".":
+            raise ValueError("Attribute access is not allowed.")
+        if ch == "_":
+            raise ValueError("Underscore identifiers are not allowed.")
+        raise ValueError(f"Invalid character: {ch!r}")
+
+
+def safe_sympify(expr_str: str, local_dict: Dict = None, allowed_symbols=()) -> sp.Expr:
+    """Lexically vetted ``sp.sympify``. ``allowed_symbols`` lists the variable
+    names the expression may reference (plus the constants e/pi/E)."""
+    if not expr_str or not expr_str.strip():
+        raise ValueError("Expression cannot be empty.")
+    if len(expr_str) > MAX_EXPRESSION_LENGTH:
+        raise ValueError(
+            f"Expression too long ({len(expr_str)} chars, max {MAX_EXPRESSION_LENGTH})."
+        )
+    normalized = normalize_expr(expr_str)
+    _check_lexical(normalized, allowed_symbols)
+    try:
+        return sp.sympify(normalized, locals=local_dict)
+    except Exception as e:
+        raise ValueError(f"Invalid math expression: {str(e)}") from e
+
+
+def safe_parse_expr(expr_str: str, local_dict: Dict = None, allowed_symbols=(),
+                    transformations: Tuple = ()) -> sp.Expr:
+    """Lexically vetted ``parse_expr``. ``allowed_symbols`` lists the variable
+    names the expression may reference (plus the constants e/pi/E)."""
+    if not expr_str or not expr_str.strip():
+        raise ValueError("Expression cannot be empty.")
+    if len(expr_str) > MAX_EXPRESSION_LENGTH:
+        raise ValueError(
+            f"Expression too long ({len(expr_str)} chars, max {MAX_EXPRESSION_LENGTH})."
+        )
+    normalized = normalize_expr(expr_str)
+    _check_lexical(normalized, allowed_symbols)
+    try:
+        return parse_expr(normalized, local_dict=local_dict, transformations=transformations)
+    except Exception as e:
+        raise ValueError(f"Invalid math expression: {str(e)}") from e
+
+
+# ==========================================================================
+# Legacy helpers (kept for backwards compatibility)
+# ==========================================================================
+
+def parse_function(func_str: str) -> Callable:
+    """
+    Convierte string a función vectorizada NumPy.
+    Ejemplo: "sin(x) + x**2" -> función callable
+    """
+    try:
+        x = sp.Symbol('x')
+        expr = safe_parse_expr(
+            func_str,
+            local_dict={'e': sp.E, 'pi': sp.pi},
+            allowed_symbols=['x'],
+            transformations=(standard_transformations + (implicit_multiplication_application,))
+        )
+        f_numpy = sp.lambdify(x, expr, modules=['numpy'])
+        return f_numpy
+    except Exception as e:
+        raise ValueError(f"Error al parsear función: {str(e)}")
+
+
+def numerical_derivative(f: Callable, x: float, order: int = 1, h: float = 1e-6) -> float:
+    """
+    Calcula derivada numérica usando diferencias centrales.
+    order: 1 (primera derivada), 2 (segunda), 3 (tercera), 4 (cuarta)
+    """
+    if order == 1:
+        return (f(x + h) - f(x - h)) / (2 * h)
+    elif order == 2:
+        return (f(x + h) - 2 * f(x) + f(x - h)) / (h**2)
+    elif order == 3:
+        return (f(x + 2*h) - 2*f(x + h) + 2*f(x - h) - f(x - 2*h)) / (2 * h**3)
+    elif order == 4:
+        return (f(x + 2*h) - 4*f(x + h) + 6*f(x) - 4*f(x - h) + f(x - 2*h)) / (h**4)
+    else:
+        raise ValueError("Order debe ser 1, 2, 3 o 4")
+
+
+def generate_x_values(a: float, b: float, n: int = 100) -> np.ndarray:
+    """Genera n valores equidistantes entre a y b"""
+    return np.linspace(a, b, n)
+
+
+def safe_eval(f: Callable, x: float | np.ndarray) -> float | np.ndarray:
+    """Evalúa función de forma segura, manejando excepciones"""
+    try:
+        result = f(x)
+        if np.isnan(result) or np.isinf(result):
+            return None
+        return result
+    except:
+        return None
+
+
+def format_number(value: float, precision: int = 6) -> str:
+    """Formatea número con precisión específica"""
+    if value is None or np.isnan(value) or np.isinf(value):
+        return "N/A"
+    return f"{value:.{precision}f}"
+
+
+def create_plotly_json(x_data: List, y_data: List, title: str, x_label: str = "x",
+                       y_label: str = "y", mode: str = "lines") -> Dict[str, Any]:
+    """Crea JSON compatible con Plotly"""
+    return {
+        "data": [{
+            "x": x_data,
+            "y": y_data,
+            "mode": mode,
+            "type": "scatter",
+            "name": title
+        }],
+        "layout": {
+            "title": title,
+            "xaxis": {"title": x_label},
+            "yaxis": {"title": y_label},
+            "hovermode": "closest"
+        }
+    }