Raíces cuadráticas estables
Calcula raíces reales cuadráticas con coeficientes escalados y una fórmula resistente a la cancelación.
from math import isfinite, sqrt, copysign
def real_roots(a, b, c):
original = (a, b, c)
if not all(type(v) in (int, float) and isfinite(v) for v in original) or a == 0:
raise ValueError("finite quadratic coefficients")
if c == 0:
other = -b / a
if not isfinite(other) or (b != 0 and other == 0):
raise ValueError("unrepresentable root")
return [0.0] if b == 0 else sorted((0.0, other))
scale = max(map(abs, original))
a, b, c = (v / scale for v in original)
if any(v != 0 and s == 0 for v, s in zip(original, (a,b,c))):
raise ValueError("coefficient underflow")
d = b*b - 4*a*c
if d < 0: return []
if d == 0: roots = [-b / (2*a)]
else:
q = -0.5 * (b + copysign(sqrt(d), b))
if q == 0: raise ValueError("root underflow")
roots = sorted((q/a, c/q))
if not all(map(isfinite, roots)) or (original[2] != 0 and 0 in roots):
raise ValueError("unrepresentable roots")
return rootsModelos
Configura un endpoint compatible con OpenAI o Anthropic usando la URL base y, si hace falta, una clave API. Prueba la conexión. Un servidor local debe estar en ejecución; las herramientas remotas pueden enviar datos por separado.
Proyecto
Prueba una raíz doble y raíces muy separadas, rechazando un coeficiente principal cero o resultados no representables y devolviendo ninguna raíz para un discriminante negativo.
Revisa antes de aplicar
Compara el comportamiento real con el resultado esperado. Si una prueba falla, investiga la causa antes de hacer más cambios.
from math import isfinite, sqrt, copysign
def real_roots(a, b, c):
original = (a, b, c)
if not all(type(v) in (int, float) and isfinite(v) for v in original) or a == 0:
raise ValueError("finite quadratic coefficients")
if c == 0:
other = -b / a
if not isfinite(other) or (b != 0 and other == 0):
raise ValueError("unrepresentable root")
return [0.0] if b == 0 else sorted((0.0, other))
scale = max(map(abs, original))
a, b, c = (v / scale for v in original)
if any(v != 0 and s == 0 for v, s in zip(original, (a,b,c))):
raise ValueError("coefficient underflow")
d = b*b - 4*a*c
if d < 0: return []
if d == 0: roots = [-b / (2*a)]
else:
q = -0.5 * (b + copysign(sqrt(d), b))
if q == 0: raise ValueError("root underflow")
roots = sorted((q/a, c/q))
if not all(map(isfinite, roots)) or (original[2] != 0 and 0 in roots):
raise ValueError("unrepresentable roots")
return rootsRevisa el comportamiento numérico más allá del caso habitual
RootEquinox es un entorno de programación con IA para Windows destinado a desarrolladores que necesitan examinar cómo se comporta una implementación numérica fuera de sus ejemplos sencillos. Empieza con los archivos del proyecto y describe el intervalo de entradas que espera la aplicación. Pide al modelo conectado que inspeccione tanto el cálculo como la respuesta del código que lo llama cuando un resultado no puede representarse como se pretende.
Una rutina de raíces cuadráticas proporciona una tarea concreta. Coeficientes de magnitudes muy distintas pueden revelar comportamientos que no muestra un pequeño ejemplo académico, por lo que conviene aportar casos representativos antes de solicitar una modificación. Analiza las raíces repetidas, los coeficientes principales rechazados y cómo comunica la función un resultado no admitido. Estas preguntas vinculan un posible cambio de fórmula con el contrato de software que lo rodea.
Inspecciona el código resultante y ejecuta las comprobaciones del proyecto con los casos originales, incluidas comprobaciones de residuos cuando proceda. Evita considerar un número mostrado plausible como evidencia suficiente de que la implementación cumple sus límites. RootEquinox funciona con servicios compatibles con OpenAI o Anthropic admitidos, con credenciales cuando se requieran. Un modelo sin restricciones es una opción cuando el servicio configurado lo proporciona, mientras que las herramientas y los límites de contexto dependen del servidor. El objetivo es un cambio numérico que puedas evaluar frente a casos explícitos, revisando el comportamiento de rechazo con tanto cuidado como las salidas correctas.
Evaluar un parche numérico
¿Qué debe acompañar a un informe de resultado inexacto?
Proporciona los coeficientes de entrada, el comportamiento esperado y detalles suficientes para reproducir la discrepancia. Incluye cómo usa el resultado el código que llama a la función. Así, el asistente recibe un problema concreto de software y no una invitación a sustituir la fórmula sin evidencia.
¿Por qué inspeccionar los recorridos de rechazo del código numérico?
El código que llama a la función necesita una respuesta definida cuando la entrada no es válida o no puede representarse un resultado útil. Revisa esos recorridos junto con el cálculo para que un parche no sustituya un fallo claro por una salida engañosa o una excepción inesperada.
¿Una comprobación de residuos puede demostrar que todas las raíces son precisas?
Aporta evidencia sobre los valores devueltos, pero no es una prueba universal. Úsala junto con casos de referencia y comprobaciones de límites de entrada, y revisa los supuestos de tolerancia en vez de aceptar un único residuo pequeño como validación completa.
¿Debo aceptar una reescritura que supera ejemplos habituales?
Solo después de comprobar los casos difíciles que motivaron la tarea. Conserva en las pruebas del proyecto las escalas muy distintas, las raíces repetidas y las entradas no válidas especificadas. Revisa cualquier cambio en el comportamiento ante fallos antes de aceptar la alternativa.
RootEquinox · Actualizado 2026-10-25