Vé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.
Espace de développement avec IA
Solutions exactes de systèmes linéaires
Résolvez un système linéaire carré entier de huit équations au plus avec des fractions exactes.
● ● ●PivotQuartz●
Méthodes de travail · Solutions exactes de systèmes linéaires ×
from fractions import Fraction
def solve_linear(matrix, rhs):
matrix, rhs = [tuple(row) for row in matrix], tuple(rhs)
n = len(matrix)
if not 1 <= n <= 8 or len(rhs) != n or any(len(row) != n for row in matrix):
raise ValueError("system.shape")
if any(type(v) is not int or abs(v) > 1000000 for row in matrix for v in row) or any(type(v) is not int or abs(v) > 1000000 for v in rhs):
raise ValueError("coefficient.range")
a = [[Fraction(v) for v in row] + [Fraction(rhs[i])] for i, row in enumerate(matrix)]
for col in range(n):
pivot = next((r for r in range(col, n) if a[r][col]), None)
if pivot is None:
raise ValueError("system.singular")
a[col], a[pivot] = a[pivot], a[col]
scale = a[col][col]
a[col] = [v / scale for v in a[col]]
for r in range(n):
if r != col:
factor = a[r][col]
a[r] = [x - factor * y for x, y in zip(a[r], a[col])]
return [row[-1] for row in a]✳Résolvez un système linéaire carré entier de huit équations au plus avec des fractions exactes.
✓ ModificationsVérifiez avant d’appliquer ↗
Illustration de l’espace de travail
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
Testez un échange de lignes nécessaire et une solution fractionnaire, en rejetant les systèmes singuliers ou les dimensions incompatibles sans modifier les entrées.
Méthodes de travail
from fractions import Fraction
def solve_linear(matrix, rhs):
matrix, rhs = [tuple(row) for row in matrix], tuple(rhs)
n = len(matrix)
if not 1 <= n <= 8 or len(rhs) != n or any(len(row) != n for row in matrix):
raise ValueError("system.shape")
if any(type(v) is not int or abs(v) > 1000000 for row in matrix for v in row) or any(type(v) is not int or abs(v) > 1000000 for v in rhs):
raise ValueError("coefficient.range")
a = [[Fraction(v) for v in row] + [Fraction(rhs[i])] for i, row in enumerate(matrix)]
for col in range(n):
pivot = next((r for r in range(col, n) if a[r][col]), None)
if pivot is None:
raise ValueError("system.singular")
a[col], a[pivot] = a[pivot], a[col]
scale = a[col][col]
a[col] = [v / scale for v in a[col]]
for r in range(n):
if r != col:
factor = a[r][col]
a[r] = [x - factor * y for x, y in zip(a[r], a[col])]
return [row[-1] for row in a]Évaluez les refactorisations numériques au regard de leurs appelants
PivotQuartz est un espace de programmation sous Windows pour développer le code numérique d’une application avec des critères d’acceptation explicites. Ouvrez le dossier du projet et identifiez la fonction, sa représentation d’entrée et le consommateur du résultat. Le modèle connecté peut discuter d’une modification dans ce contexte pendant que vous vérifiez si la proposition préserve les hypothèses de l’appelant.
Une demande de revue de linear.py pourrait comparer un résultat fractionnaire exact à ce que l’application doit afficher ou sérialiser. Fournissez un petit système à solution connue et un cas singulier qui doit être rejeté. Demandez comment la refactorisation proposée traite les deux chemins avant d’accepter des changements de calcul ou de types de résultats.
Ce processus réunit correction et intégration dans la même discussion. Effectuez des contrôles indépendants des résultats dans votre environnement de développement, puis examinez les erreurs et le format de sortie via l’appelant. Convertir les fractions en valeurs flottantes peut être un choix délibéré de l’application, mais mérite une limite explicite plutôt que d’apparaître accessoirement lors d’un nettoyage.
Choisissez un modèle d’IA sans censure lorsqu’il est disponible via un point de terminaison compatible OpenAI ou Anthropic pris en charge, avec les identifiants requis. Les restrictions du fournisseur restent applicables, et le modèle et le serveur déterminent les outils pris en charge et la capacité de contexte. PivotQuartz fournit l’espace de revue du code source ; les résultats attendus de votre projet apportent les éléments permettant d’accepter une modification.
Avant d’accepter une refactorisation numérique
- Un système singulier doit-il renvoyer une estimation ?
Seulement si votre application exige explicitement une approximation au sens défini. L’exemple rejette les systèmes singuliers. Examinez la gestion de cet échec par l’appelant et séparez tout passage à une approximation d’une refactorisation destinée à préserver les résultats exacts.
- Comment vérifier indépendamment la solution renvoyée ?
Substituez-la dans les équations originales par un calcul indépendant adapté et comparez au second membre fourni. Incluez un cas nécessitant un échange de lignes. Vérifiez aussi la représentation de sortie : une valeur correcte peut ne pas respecter le type attendu par l’appelant.
- Où convertir les fractions en texte d’affichage ?
C’est généralement à la couche de présentation de prendre explicitement cette décision. Examinez la structure actuelle du projet et définissez le format requis par son consommateur. Évitez d’introduire un arrondi dans une fonction interne, sauf s’il fait partie du contrat numérique convenu.
- Quel contexte source aide le modèle à examiner les erreurs de dimensions ?
Fournissez la routine, le code construisant ses entrées et la gestion des erreurs par l’appelant. Incluez un cas de dimensions incompatibles. Un test du seul calcul interne ne peut établir que les données mal formées de l’application reçoivent la réponse attendue par l’interface.
PivotQuartz · Mis à jour 2026-10-25
