Radici quadratiche stabili
Calcola radici reali quadratiche con coefficienti scalati e una formula resistente alla cancellazione.
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 rootsModelli
Configura un endpoint compatibile con OpenAI o Anthropic usando URL di base e chiave API, se necessaria. Prova la connessione. Il server locale deve essere in esecuzione; gli strumenti remoti possono trasmettere dati separatamente.
Progetto
Prova radici doppie e molto distanti, rifiutando coefficiente principale nullo o risultati non rappresentabili e restituendo nessuna radice per discriminante negativo.
Controlla prima di applicare
Confronta il comportamento effettivo con il risultato atteso. Se una verifica fallisce, indaga la causa prima di altre modifiche.
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 rootsEsamina il comportamento numerico oltre il caso ordinario
RootEquinox è un ambiente di programmazione con IA per Windows per sviluppatori che devono esaminare come un’implementazione numerica si comporta oltre i suoi esempi più semplici. Parti dai file del progetto e descrivi l’intervallo di input atteso dall’applicazione. Chiedi al modello collegato di esaminare sia il calcolo sia la risposta del chiamante quando un risultato non può essere rappresentato come previsto.
Una routine per le radici quadratiche fornisce un’attività concreta. Coefficienti di grandezze molto distanti possono rivelare comportamenti che sfuggono a un piccolo esempio scolastico: porta quindi casi rappresentativi nella conversazione prima di chiedere una modifica. Discuti radici ripetute, coefficienti principali rifiutati e come la funzione segnala un risultato non supportato. Queste domande collegano un cambiamento di formula al contratto software circostante.
Esamina il sorgente risultante ed esegui le verifiche del progetto usando i casi originali, incluse verifiche dei residui quando appropriate. Evita di trattare un numero visualizzato plausibile come prova sufficiente che l’implementazione rispetti i suoi limiti. RootEquinox funziona con endpoint supportati compatibili con OpenAI o di Anthropic, usando credenziali quando richieste. Un modello senza restrizioni è un’opzione dove il servizio configurato ne fornisce uno, mentre strumenti e limiti di contesto dipendono dal server. L’obiettivo è una modifica numerica valutabile rispetto a casi espliciti, con il comportamento di rifiuto esaminato con la stessa cura degli output riusciti.
Valutare una modifica numerica
Cosa deve accompagnare la segnalazione di un risultato impreciso?
Fornisci coefficienti di input, comportamento atteso e dettagli sufficienti a riprodurre la discrepanza. Includi come il chiamante usa il risultato. Ciò dà all’assistente un problema software concreto anziché un invito a sostituire la formula senza prove.
Perché esaminare i percorsi di rifiuto nel codice numerico?
I chiamanti necessitano di una risposta definita quando l’input non è valido o un risultato utile non è rappresentabile. Esamina questi percorsi insieme al calcolo, affinché una modifica non sostituisca un errore chiaro con un output fuorviante o un’eccezione inattesa.
Una verifica del residuo può dimostrare che ogni radice è accurata?
Contribuisce a fornire prove sui valori restituiti, ma non è una dimostrazione universale. Usala insieme a casi di riferimento e verifiche ai limiti degli input ed esamina le ipotesi sulle tolleranze anziché accettare un singolo residuo piccolo come validazione completa.
Devo accettare una riscrittura che supera gli esempi ordinari?
Solo dopo aver verificato i casi difficili che hanno motivato l’attività. Conserva nei test del progetto scale molto distanti, radici ripetute e input non validi specificati. Esamina ogni cambiamento del comportamento in caso di errore prima di accettare la sostituzione.
RootEquinox · Aggiornato 2026-10-25