Raízes quadráticas estáveis
Calcule raízes reais quadráticas com coeficientes escalados e uma fórmula resistente ao cancelamento.
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
Configure um endpoint compatível com OpenAI ou Anthropic com a URL base e uma chave API, quando necessária. Teste a conexão. O servidor local precisa estar em execução; ferramentas remotas podem transmitir dados separadamente.
Projeto
Teste raiz dupla e raízes distantes, rejeitando coeficiente principal zero ou resultados não representáveis e retornando nenhuma raiz para discriminante negativo.
Revise antes de aplicar
Compare o comportamento real com o resultado esperado. Se uma verificação falhar, investigue a causa antes de fazer outras alterações.
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 rootsRevise o comportamento numérico além do caso comum
RootEquinox é um ambiente de programação com IA para Windows destinado a desenvolvedores que precisam examinar como uma implementação numérica se comporta fora de seus exemplos confortáveis. Comece pelos arquivos do projeto e descreva o intervalo de entradas esperado pela aplicação. Peça ao modelo conectado que inspecione tanto o cálculo quanto a resposta do chamador quando um resultado não puder ser representado como pretendido.
Uma rotina de raízes quadráticas fornece uma tarefa concreta. Coeficientes de magnitudes muito distantes podem revelar comportamentos que um pequeno exemplo escolar não mostra; leve casos representativos à conversa antes de pedir uma edição. Discuta raízes repetidas, coeficientes principais rejeitados e como a função informa um resultado não suportado. Essas perguntas conectam uma mudança proposta de fórmula ao contrato de software ao redor.
Inspecione o código resultante e execute as verificações do projeto com os casos originais, incluindo verificações de resíduos quando apropriado. Evite tratar um número exibido plausível como evidência suficiente de que a implementação atende aos limites. RootEquinox funciona com endpoints suportados compatíveis com OpenAI ou da Anthropic, usando credenciais quando exigidas. Um modelo sem restrições é uma opção onde o serviço configurado fornecer um, enquanto ferramentas e limites de contexto dependem do servidor. O objetivo é uma alteração numérica avaliável por casos explícitos, com o comportamento de rejeição revisado tão cuidadosamente quanto as saídas bem-sucedidas.
Avalie uma alteração numérica
O que deve acompanhar o relato de um resultado impreciso?
Forneça os coeficientes de entrada, o comportamento esperado e detalhes suficientes para reproduzir a discrepância. Inclua como o chamador usa o resultado. Isso dá ao assistente um problema concreto de software, em vez de um convite para substituir a fórmula sem evidências.
Por que inspecionar caminhos de rejeição em código numérico?
Os chamadores precisam de uma resposta definida quando a entrada é inválida ou um resultado útil não pode ser representado. Revise esses caminhos junto com o cálculo para que a alteração não substitua uma falha clara por uma saída enganosa ou uma exceção inesperada.
Uma verificação de resíduo prova que toda raiz é precisa?
Ela contribui com evidências sobre os valores retornados, mas não é uma prova universal. Use-a com casos de referência e verificações de limites de entrada e revise as premissas de tolerância, em vez de aceitar um único resíduo pequeno como validação completa.
Devo aceitar uma reescrita que passa nos exemplos comuns?
Somente após conferir os casos difíceis que motivaram a tarefa. Preserve nos testes do projeto escalas muito distantes, raízes repetidas e entradas inválidas especificadas. Revise qualquer mudança no comportamento de falha antes de aceitar a substituição.
RootEquinox · Atualizado 2026-10-25