Guía de sustentación del código

Cómo está armado el proyecto

1. Leer la función que escribe el usuario

a) Una expresión regular separa nombre, variable y fórmula

patron = r'^\s*([A-Za-z]\w*)\s*\(\s*([A-Za-z]\w*)\s*\)\s*=\s*(.+)$'
match = re.match(patron, entrada)

([A-Za-z]\w*)

Grupo 1: el nombre de la función (la "f" de "f(x)"). Letra inicial, luego letras/números/guión bajo.

\(...\)

Los paréntesis literales alrededor de la variable — grupo 2, misma regla que el nombre.

=\s*(.+)$

Todo lo que sigue al "=" hasta el final del texto es el grupo 3: la expresión a derivar/resolver.

b) sympy interpreta la expresión, pero con una lista blanca

Esta es la parte que más suele llamar la atención al profesor: por qué hay un diccionario que parece "vacío a propósito".

_GLOBAL_DICT_SEGURO = {
    "__builtins__": {},
    "Integer": sp.Integer,
    "Float": sp.Float,
    "Rational": sp.Rational,
    "Symbol": sp.Symbol,
}

Después, si sobra algún símbolo que no sea la variable declarada (por ejemplo escribiste "y" sin querer), interpretar_funcion lo detecta con funcion.free_symbols - {variable} y tira un error claro en vez de dejar pasar una función mal escrita.

2. Criterio de la primera y segunda derivada

1. Derivar f(x) para obtener f'(x).
2. Igualar a cero y resolver f'(x) = 0 → esas soluciones son los puntos críticos.
3. Derivar otra vez para obtener f''(x) (mide la concavidad).
4. Evaluar el signo de f''(c) en cada punto crítico c:
   f''(c) > 0 → mínimo f''(c) < 0 → máximo f''(c) = 0 → indeterminado

El código, paso por paso

a, b = leer_intervalo(a, b)   # (None, None) si no se dio intervalo
nombre, x, f = interpretar_funcion(funcion_txt)

# Paso 1: derivar la función.
f1 = sp.diff(f, x)

# Paso 2: igualar la primera derivada a cero y resolver -> puntos críticos.
if a is None:
    criticos = sp.solve(sp.Eq(f1, 0), x)
    criticos_reales = [c for c in criticos if getattr(c, "is_real", True)]
else:
    criticos_reales = criticos_en_intervalo(f1, x, a, b)
# Paso 3: derivar otra vez, para poder evaluar la concavidad.
f2 = sp.diff(f1, x)

sp.diff(f, x)

Deriva simbólicamente — no es una aproximación numérica, es la derivada exacta que da sympy.

sp.solve(sp.Eq(f1, 0), x)

Resuelve la ecuación f'(x) = 0 y devuelve todas las soluciones (pueden ser reales, complejas, o ninguna).

[c for c in criticos if ...]

Lista por comprensión equivalente a un for que arma una lista nueva: recorre cada solución c y se queda solo con las que son reales (getattr(c, "is_real", True) — si sympy no puede decidirlo, la deja pasar por defecto).

Con un intervalo [a, b]: criticos_en_intervalo

Vive en su propio archivo, logica/busqueda_en_intervalo.py, para no recargar el método.

soluciones = sp.solveset(sp.Eq(f1, 0), x, sp.Interval(a, b))
if isinstance(soluciones, sp.FiniteSet):
    ...  # todas las soluciones exactas dentro de [a, b]
return _criticos_numericos(f1, x, a, b)   # plan B

sp.solveset(..., Interval)

A diferencia de solve, devuelve todas las soluciones que caben en el intervalo (por ejemplo π/2, 3π/2 y 5π/2 para sin(x) en [0, 10]).

_criticos_numericos

Bucle for Plan B si sympy no logra una solución exacta (ej. x·sin(x)): se recorre el intervalo en 4000 puntos, se detecta dónde f' cambia de signo y se afina cada raíz por bisección (partir el tramo a la mitad 60 veces). No detecta raíces dobles.

TOLERANCIA_CERO

Los puntos hallados numéricamente tienen decimales; ahí un f'' menor que 1e-7 en valor absoluto cuenta como 0 (indeterminado), por el error de redondeo.

puntos = []
puntos_para_grafica = []
etiquetas_para_grafica = []
for c in criticos_reales:
    puntos.append(_construir_punto_critico(c, f, f2, x, x_tex))

    coordenadas = _coordenadas_para_grafica(c, f, x)
    if coordenadas is not None:
        puntos_para_grafica.append(coordenadas)
        etiquetas_para_grafica.append(f"({coordenadas[0]:.2f}, {coordenadas[1]:.2f})")

Este for recorre cada punto crítico encontrado (puede haber 0, 1 o varios) y, por cada uno, hace dos cosas: (1) llama a _construir_punto_critico para clasificarlo como máximo/mínimo/indeterminado, y (2) si el punto se puede convertir a número real (a veces sympy deja una solución en forma simbólica que no se puede graficar), lo guarda para dibujarlo en la gráfica con su etiqueta de coordenadas.

def _clasificar_punto_critico(valor_f2):
    # A partir del signo de f''(c), decide condición / tipo / clasificación.
    if valor_f2.is_positive:
        return "> 0", "Mínimo", "convexa"
    if valor_f2.is_negative:
        return "< 0", "Máximo", "cóncava"
    return "= 0", "Indeterminado", "Convexa y Cóncava"

Acá está el criterio matemático de la segunda derivada, traducido directo a código: dos preguntas en cadena. Si ninguna de las dos es cierta (f'' vale exactamente 0), cae al return final: "Indeterminado". .is_positive / .is_negative son propiedades que sympy calcula sobre la expresión simbólica, no comparaciones numéricas con errores de redondeo.

Ejemplo trabajado

3. Newton-Raphson

1. Empezar en un punto x₀ elegido por el usuario.
2. En cada vuelta, calcular la recta tangente a la curva en ese punto y ver dónde cruza el eje x:
   x_n+1 = x_n − f(x_n) / f'(x_n)
3. Repetir usando ese nuevo punto, hasta que ya casi no cambie (el cambio es menor que el margen de error) o se agote el número máximo de vueltas.

El código, paso por paso

for numero_iteracion in range(1, max_iteraciones + 1):
    valor_f = _valor_numerico(f_lamb, x_actual)
    valor_f1 = _valor_numerico(f1_lamb, x_actual)

    if abs(valor_f1) < 1e-12:
        raise ValueError(
            f"f'(x) se anula en x = {x_actual:.6f}: Newton-Raphson no puede "
            "continuar. Prueba con otro punto inicial."
        )

    x_siguiente = x_actual - valor_f / valor_f1
    error = abs(x_siguiente - x_actual)

    iteraciones.append(IteracionNewton(...))  # fila para la tabla

    x_actual = x_siguiente

    if error < tolerancia:
        convergio = True
        break

Este es el corazón del método. range(1, max_iteraciones + 1) pone un techo (por defecto 100 vueltas) para que nunca quede colgado si la función no converge. Dentro de cada vuelta:

valor_f, valor_f1

Evalúan f y f' en el punto actual — numéricamente (con sp.lambdify, no simbólicamente), porque acá ya no hace falta una fórmula exacta, solo números rápidos.

if abs(valor_f1) < 1e-12

Condición de seguridad: si la tangente queda casi horizontal (f'(x) ≈ 0), dividir por ella dispararía un error de división por cero o un salto absurdo — se corta con un mensaje claro en vez de romper la app.

x_siguiente = ...

Es la fórmula de Newton-Raphson de arriba, escrita tal cual.

if error < tolerancia: break

La condición de parada: en cuanto el cambio entre dos puntos seguidos es menor que el margen de error que puso el usuario, se marca convergio = True y break corta el for ahí mismo — no hace falta llegar a las 100 vueltas.

Ejemplo trabajado

4. Método de la razón dorada (sección áurea)

1. Partir de un intervalo [a, b] elegido por el usuario.
2. Ubicar dos puntos internos: x₁ = (1 − R)·(b − a) + a y x₂ = R·(b − a) + a.
3. Comparar f(x₁) con f(x₂) y quedarse con [a, x₂] o [x₁, b] según la tabla de abajo (el otro tramo no puede contener el óptimo).
4. Repetir hasta que el intervalo sea más angosto que el margen de error.

El código, paso por paso

def es_mejor(valor_1, valor_2):
    """True si el punto 1 es mejor candidato, según se busque min o max."""
    return valor_1 < valor_2 if buscar == "min" else valor_1 > valor_2

Función chica pero clave: es lo que hace que un solo método sirva tanto para buscar mínimo como máximo, sin duplicar código. Es un if/else escrito como expresión (operador ternario): si se busca un mínimo, "mejor" significa "menor"; si se busca un máximo, significa "mayor".

for numero_iteracion in range(1, max_iteraciones + 1):
    # Paso 1: ubicar los dos puntos interiores con la razón áurea R.
    x1 = (1 - RAZON_AUREA) * (b - a) + a
    x2 = RAZON_AUREA * (b - a) + a

    valor_x1 = _valor_numerico(f_lamb, x1)
    valor_x2 = _valor_numerico(f_lamb, x2)

    a_inicio, b_inicio = a, b   # la fila de la tabla muestra a y b ANTES de reemplazar

    # Paso 2: se toma [a, x2] (se reemplaza b) o [x1, b] (se reemplaza a).
    if es_mejor(valor_x1, valor_x2):
        b = x2
    else:
        a = x1

    iteraciones.append(IteracionAurea(...))  # fila para la tabla

    # Paso 3: repetir hasta que el intervalo sea angosto (convergió).
    if (b - a) < tolerancia:
        convergio = True
        break

x1 = (1-R)·(b-a) + a

El punto interior más cercano a a. (Antes estaba escrito como b - R·(b-a): es el mismo valor, ahora en la forma estándar.)

x2 = R·(b-a) + a

El punto interior más cercano a b, simétrico al anterior.

a_inicio, b_inicio

Guardan el intervalo con el que empieza la vuelta: por eso la fila 1 de la tabla muestra el a y el b que ingresó el usuario, y recién la fila 2 muestra el intervalo ya reemplazado.

if es_mejor(...): b = x2

Condición que decide qué extremo del intervalo mover. Achicar el intervalo reasignando a o b es literalmente "descartar" ese pedazo — no se vuelve a mirar en la siguiente vuelta.

if (b - a) < tolerancia

Misma idea de parada que en Newton-Raphson, pero midiendo el ancho del intervalo en vez del cambio entre dos puntos.

Ejemplo trabajado

5. Cómo se dibuja la gráfica

Evaluar la función sin que un solo punto raro rompa todo

def evaluar_en_puntos(f_lamb, xs):
    ys = np.full(xs.shape, np.nan)
    with np.errstate(all="ignore"):
        for i, xv in enumerate(xs):
            try:
                yv = f_lamb(xv)
                yv = complex(yv)
                if abs(yv.imag) < 1e-9 and np.isfinite(yv.real):
                    ys[i] = yv.real
            except Exception:
                pass
    return ys

La gráfica se arma evaluando la función en 800 puntos de x (xs) para saber a qué altura (y) dibujar la curva en cada uno. Este for recorre esos 800 puntos uno por uno, con dos cuidados:

try / except

Si en algún x la función no está definida (ej. ln(x) con x ≤ 0), f_lamb(xv) tira una excepción — se atrapa y ese punto queda como NaN (vacío) en vez de tumbar toda la gráfica.

complex(yv) / .imag

Algunas funciones (raíces de negativos, etc.) devuelven un número complejo en vez de real. Se descarta ese punto salvo que la parte imaginaria sea prácticamente cero (error de redondeo), en cuyo caso se usa la parte real.

Cortar la curva en las asíntotas

# Corta el trazo en las asíntotas: sin esto matplotlib une los dos lados
# con una raya vertical falsa (típico en 1/x o tan(x)).
ys_trazo = ys.copy()
salto = (y_hi - y_lo) * 0.5
d = np.abs(np.diff(ys))
ys_trazo[1:][np.isfinite(d) & (d > salto)] = np.nan

Sin este truco, una función como 1/x se vería con una línea vertical falsa uniendo "-∞" con "+∞" en x = 0. np.diff(ys) calcula cuánto salta la curva de un punto al siguiente; si el salto es más grande que la mitad de todo el alto visible del gráfico, se asume que es una asíntota y ese tramo se "levanta el lápiz" (se pone en NaN, que matplotlib no dibuja).

Zoom de la gráfica (rueda, botones o intervalo)

Dibujar con matplotlib tarda ~0.2 s, demasiado para hacerlo en cada "clic" de la rueda. Por eso se combinan tres trucos:

Vista previa

Apenas gira la rueda, la imagen que ya está en pantalla se estira horizontalmente para aparentar la nueva ventana, mientras se dibuja la buena.

La última gana

El dibujo corre en segundo plano (asyncio.to_thread); si llegan más giros mientras tanto, las ventanas intermedias se saltan y solo se dibuja la más reciente.

Caché

Se recuerdan las últimas 40 imágenes: volver a "Restablecer" o repetir un zoom es instantáneo.

Preguntas que podría hacer el profesor