Interpolation linéaire bornée aux extrémités
Interpole entre des nœuds strictement croissants et ramène les requêtes extérieures aux extrémités.
from math import isfinite
def interpolate(points, query):
def valid(x):
return type(x) in (int, float) and abs(x) <= 10**12 and isfinite(x)
if type(points) is not list or len(points) < 2 or not valid(query):
raise ValueError("knots.input")
if any(type(p) not in (list, tuple) or len(p) != 2 or
not all(valid(v) for v in p) for p in points):
raise ValueError("knots.point")
if any(a[0] >= b[0] for a,b in zip(points, points[1:])):
raise ValueError("knots.order")
if query <= points[0][0]:
return points[0][1]
for (x0,y0),(x1,y1) in zip(points, points[1:]):
if query <= x1:
t = (query-x0)/(x1-x0)
return (1-t)*y0+t*y1
return points[-1][1]| Projet | Vérifie les nœuds exacts et refuse les coordonnées répétées, valeurs non finies ou amplitudes supérieures à mille milliards avant le mélange linéaire. |
|---|---|
| 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. |
| 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. |
from math import isfinite
def interpolate(points, query):
def valid(x):
return type(x) in (int, float) and abs(x) <= 10**12 and isfinite(x)
if type(points) is not list or len(points) < 2 or not valid(query):
raise ValueError("knots.input")
if any(type(p) not in (list, tuple) or len(p) != 2 or
not all(valid(v) for v in p) for p in points):
raise ValueError("knots.point")
if any(a[0] >= b[0] for a,b in zip(points, points[1:])):
raise ValueError("knots.order")
if query <= points[0][0]:
return points[0][1]
for (x0,y0),(x1,y1) in zip(points, points[1:]):
if query <= x1:
t = (query-x0)/(x1-x0)
return (1-t)*y0+t*y1
return points[-1][1]Préservez la cohérence des calculs avec leurs appelants
KnotVista offre à la maintenance numérique un espace de programmation Windows et une conversation avec un modèle sur vos fichiers. Partez des attentes du code consommateur envers le calcul, notamment le domaine des entrées et le comportement aux limites. Vous définissez ainsi un objectif de revue utile avant de demander à l’assistant de simplifier une implémentation ou de modifier son traitement des données inhabituelles.
L’exemple d’interpolation par morceaux fournit une tâche concrète pour le projet. Vous pouvez demander au modèle d’examiner les points d’échantillonnage ordonnés et le traitement des requêtes au-delà de leurs extrémités. Incluez le code qui prépare ces points et consomme le résultat pour distinguer une politique de bord délibérée d’une conséquence accidentelle de la boucle.
Évaluez une modification proposée sur les points exacts, les requêtes entre les points et les valeurs hors de l’intervalle pris en charge. Examinez aussi comment un ordre invalide est signalé à l’appelant. Exécutez vous-même les cas de test numériques du projet et comparez-les au comportement convenu ; une visualisation d’apparence régulière ne suffit pas à montrer si la politique de bord ou le traitement des entrées rejetées a changé.
Un modèle d’IA sans restrictions peut être utilisé s’il est disponible via un point de terminaison compatible OpenAI ou Anthropic pris en charge. Fournissez les identifiants requis et vérifiez les outils et la capacité de contexte de cette connexion. Le modèle et le fournisseur déterminent toujours les restrictions de réponse ; le contrat mathématique de l’application découle de vos exigences et du code que vous acceptez.
Questions utiles pour la maintenance numérique
- Que préciser pour une requête hors de l’intervalle des échantillons ?
Énoncez explicitement la politique aux extrémités, par exemple conserver la valeur de l’extrémité la plus proche si telle est votre exigence. Incluez les résultats attendus de part et d’autre de l’intervalle afin que l’assistant ne substitue pas une autre politique d’extrapolation.
- Pourquoi inclure le code qui prépare les points d’échantillonnage ?
Il détermine l’ordre, les positions en double et les valeurs numériques acceptées avant l’interpolation. Une modification locale peut sembler correcte tout en contredisant ces hypothèses. Demandez au modèle d’examiner la préparation avant de déplacer la validation ou le tri.
- Puis-je approuver une modification en vérifiant seulement un graphique ?
Un graphique aide à observer le comportement visible, mais des changements subtils aux limites peuvent sembler identiques. Comparez des cas numériques explicites aux points, entre eux et hors de l’intervalle. Vérifiez le signalement des erreurs autant que les résultats réussis.
- Comment transmettre à l’interface le rejet d’un jeu de données ?
Définissez si l’appelant doit afficher une erreur, omettre le résultat ou appliquer une autre règle existante. Examinez ce chemin avec le calcul. Évitez de substituer silencieusement une valeur plausible sauf si le contrat de l’application le prévoit délibérément.
KnotVista · Mis à jour 2026-10-25