Division par un polynôme unitaire
Divisez des polynômes entiers d’au plus 21 coefficients par un diviseur unitaire.
def divide_monic(dividend, divisor):
for row in (dividend, divisor):
if type(row) not in (list, tuple) or len(row) > 21:
raise ValueError("at most 21 coefficients")
if any(type(x) is not int for x in row): raise ValueError("integers")
def trim(row):
row = list(row)
while row and row[0] == 0: row.pop(0)
return row
a, b = trim(dividend), trim(divisor)
if not b or b[0] != 1: raise ValueError("monic divisor")
quotient = [0] * max(0, len(a) - len(b) + 1)
while a and len(a) >= len(b):
degree, factor = len(a) - len(b), a[0]
quotient[len(quotient)-1-degree] = factor
a = trim([x-factor*y for x,y in zip(a,b)] + a[len(b):])
return trim(quotient), aVérifiez avant d’appliquer
Comparez le comportement observé au résultat attendu. Si une vérification échoue, cherchez la cause avant de poursuivre les modifications.
Modèles
Configurez un endpoint compatible OpenAI ou Anthropic avec son URL de base et une clé API si nécessaire. Testez la connexion. Un serveur local doit fonctionner ; les outils distants peuvent transmettre des données séparément.
Projet
Vérifiez le polynôme nul et un diviseur constant, en rejetant coefficients non entiers ou diviseur non unitaire et en contrôlant l’identité quotient-reste.
def divide_monic(dividend, divisor):
for row in (dividend, divisor):
if type(row) not in (list, tuple) or len(row) > 21:
raise ValueError("at most 21 coefficients")
if any(type(x) is not int for x in row): raise ValueError("integers")
def trim(row):
row = list(row)
while row and row[0] == 0: row.pop(0)
return row
a, b = trim(dividend), trim(divisor)
if not b or b[0] != 1: raise ValueError("monic divisor")
quotient = [0] * max(0, len(a) - len(b) + 1)
while a and len(a) >= len(b):
degree, factor = len(a) - len(b), a[0]
quotient[len(quotient)-1-degree] = factor
a = trim([x-factor*y for x,y in zip(a,b)] + a[len(b):])
return trim(quotient), aGardez les hypothèses mathématiques visibles pendant les modifications
MonicVale est un espace de programmation sous Windows pour discuter des fonctions mathématiques utilitaires dans le contexte de leur application. Commencez par le dossier du projet et identifiez les hypothèses de la fonction. Demandez à l’assistant de les examiner dans le code avant de demander une refactorisation. Une proposition utile explique quels comportements restent inchangés et quelles entrées demeurent hors du contrat pris en charge.
Une tâche portant sur polynomial.py pourrait examiner la division dont le diviseur doit être unitaire. Fournissez des exemples d’ordre des coefficients, de zéros en tête, ainsi que le quotient et le reste attendus. Demandez comment l’implémentation actuelle représente ces résultats, puis examinez toute simplification proposée au regard de cette représentation. La conversation reste ainsi ancrée dans le comportement du logiciel, sans substituer une explication mathématique générale à une revue de l’implémentation.
Après modification, exécutez les vérifications du projet et comparez les sorties à des exemples calculés indépendamment. Examinez aussi les rejets, notamment lorsqu’un appelant peut fournir un diviseur non pris en charge. MonicVale se connecte aux points de terminaison compatibles OpenAI ou Anthropic pris en charge, avec les identifiants nécessaires. Les modèles sans restrictions ne sont disponibles que si le point de terminaison choisi les propose ; restrictions, capacité de contexte et outils dépendent toujours de ce service. Utilisez cet espace pour garder ensemble hypothèses et résultats observés au moment de décider si la modification est prête.
Hypothèses d’une fonction mathématique utilitaire
Pourquoi préciser l’ordre des coefficients avant une modification ?
Une même liste peut décrire des polynômes différents selon la convention. Précisez l’ordre des coefficients et la représentation de zéro dans votre projet, puis vérifiez les appelants et les valeurs renvoyées selon cette convention avant d’accepter une refactorisation proposée par le modèle.
Une fonction doit-elle adapter silencieusement les diviseurs non pris en charge ?
Seulement si vous changez délibérément son contrat et en examinez les conséquences. Une fonction limitée aux diviseurs unitaires doit signaler les entrées non prises en charge de manière cohérente ; sa généralisation peut nécessiter d’autres hypothèses arithmétiques et des tests supplémentaires dans tout le code appelant.
Que dois-je vérifier concernant le reste ?
Vérifiez la représentation attendue par l’appelant et la relation mathématique sur des exemples pris en charge. Incluez des cas sans reste et avec un reste non nul, afin que la proposition ne soit pas validée uniquement sur une division facile.
Une fonction mathématique plus courte est-elle plus fiable ?
Pas nécessairement. Vérifiez que la version raccourcie conserve la validation, les conventions de sortie et le comportement aux limites. Demandez la raison de chaque simplification et testez le contrat ; la brièveté ne prouve pas qu’une hypothèse mathématique reste valide.
MonicVale · Mis à jour 2026-10-25