Borne d'erreur de Lagrange
Indiquez une borne M de la dérivée, les nœuds d'interpolation et le point qui vous intéresse, et obtenez l'erreur maximale du polynôme en ce point : avec les nœuds 0, 1 et 2, M égal à 1 et le point 0,5, l'erreur ne dépasse pas 0,0625. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Nœuds
- 0, 1, 2
- M
- 1
- X
- 0,5
- N
- 3
- Degré
- 2
- Produit
- 0,375
- Factorielle
- 6
À partir d'une borne M sur la dérivée n-ième de votre fonction, des positions des nœuds d'interpolation et du point d'évaluation, elle renvoie l'écart maximal entre la fonction réelle et le polynôme interpolant, calculé à l'aide du théorème classique du reste. Un seul appel, un seul nombre, aucune approximation numérique — la borne s'exprime sous forme fermée, le résultat est donc un calcul exact plutôt qu'une estimation obtenue par échantillonnage.
Ce que la borne d'erreur vous indique réellement
Interpoler une fonction à travers un ensemble de nœuds produit un polynôme qui coïncide exactement avec la fonction en ces nœuds, mais ne dit rien par lui-même sur les points intermédiaires.
Le théorème du reste de Lagrange comble cette lacune : si le polynôme passe par n nœuds et que la valeur absolue de la dérivée n-ième de la fonction ne dépasse jamais M sur l'intervalle, alors l'erreur réelle en tout point x est au plus M divisé par n factorielle, multiplié par le produit des distances de x à chaque nœud. Ce point de terminaison évalue directement cette expression.
Vous fournissez la borne M sur la dérivée, les positions des nœuds et le point d'évaluation ; vous obtenez en retour l'erreur maximale que l'interpolation peut présenter en ce point. Il s'agit d'un certificat, et non d'une mesure — il reste valable même dans le pire des cas, ce qui est exactement ce qu'il vous faut avant de faire confiance à une valeur interpolée dans un rapport, un système de contrôle ou une figure publiée.
Comment les nœuds et le point d'évaluation façonnent la borne
Le terme en produit est la partie qui mérite d'être comprise, car il explique où l'interpolation est sûre et où elle est dangereuse. Chaque nœud contribue par un facteur égal à la distance entre votre point d'évaluation et ce nœud : la borne s'annule donc exactement aux nœuds — où le polynôme est exact par construction — et croît à mesure que vous vous éloignez du groupe.
Évaluer à l'intérieur d'un groupe de nœuds resserré et bien réparti maintient le produit petit ; extrapoler au-delà du nœud extrême fait croître tous les facteurs à la fois, et la borne explose en conséquence. La factorielle au dénominateur joue en votre faveur : chaque nœud supplémentaire augmente le degré d'une unité et divise la borne par un facteur de plus, ce qui explique pourquoi l'ajout d'un nœud bien placé peut améliorer spectaculairement la précision.
Utilisez ce point de terminaison pour tester quantitativement cette intuition — déplacez le point, ajoutez ou retirez des nœuds, et observez la réaction de l'erreur maximale avant d'arrêter votre choix de disposition.
Où il s'intègre dans un flux de travail réel
L'usage typique est la vérification, et non la découverte. Vous disposez déjà d'une fonction, d'un ensemble de points d'échantillonnage et d'une raison d'interpoler — une table de correspondance pour un capteur, une reconstruction lisse de données physiques tabulées, un substitut économique à un calcul coûteux. Avant de livrer l'approximation, vous en bornez l'erreur et conservez le résultat dans vos archives.
Les ingénieurs s'en servent pour prouver qu'un contrôleur piloté par table reste dans les tolérances ; les analystes pour justifier la publication de chiffres interpolés ; les étudiants pour vérifier leurs exercices à l'aune du théorème plutôt qu'en espérant. Le calcul est une arithmétique déterministe en forme fermée : pas d'aléa, pas d'échantillonnage, pas d'appels externes — la même entrée produit toujours la même borne.
Cas d’usage
Certifier une approximation par table de correspondance
Prouvez qu'une table de capteur interpolée par des polynômes reste dans la tolérance requise entre les points d'étalonnage.
Déterminer le nombre de nœuds nécessaires
Comparez la borne pour différents nombres et placements de nœuds avant d'engager un budget d'échantillonnage pour une fonction coûteuse.
Vérifier des devoirs d'analyse numérique
Validez vos applications manuelles du théorème du reste de Lagrange par rapport à une implémentation de référence exacte et déterministe.
Questions fréquentes
Combien cela coûte-t-il ?
L'exécution est également gratuite dans votre navigateur sur cette page — le même code s'exécute aux deux endroits.
Qu'est-ce que la valeur M exactement ?
M est une borne supérieure de la valeur absolue de la dérivée n-ième de votre fonction sur l'intervalle, où n est le nombre de nœuds. Pour sin(x), par exemple, toute dérivée est bornée par 1.
Le résultat est-il l'erreur réelle ?
Non — c'est l'erreur maximale possible garantie par le théorème du reste. L'erreur réelle n'est jamais plus grande et est souvent bien plus petite.
Puis-je évaluer en dehors des nœuds ?
Oui, tout point d'évaluation fini est accepté. Attendez-vous à ce que la borne croisse rapidement en extrapolation, car tous les facteurs de distance augmentent en même temps.
Que se passe-t-il avec une liste de nœuds vide ?
Au moins un nœud est requis pour définir l'interpolation.
Y a-t-il une limite au nombre de nœuds ?
Jusqu'à 170 nœuds sont acceptés, car 171! dépasse la plage de la double précision. En pratique, une poignée de nœuds bien placés suffit au théorème.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/math/lagrange-error-bound \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"nodes":[0,1,2],"m":1,"x":0.5}'const res = await fetch("https://api.kit.forhosting.com/math/lagrange-error-bound", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"nodes": [
0,
1,
2
],
"m": 1,
"x": 0.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/lagrange-error-bound",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"nodes": [
0,
1,
2
],
"m": 1,
"x": 0.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/lagrange-error-bound", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"nodes":[0,1,2],"m":1,"x":0.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"nodes":[0,1,2],"m":1,"x":0.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/lagrange-error-bound", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"nodes": [
0,
1,
2
],
"m": 1,
"x": 0.5
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.lagrange_error_bound",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Limites
min_nodes | 1 |
max_nodes | 170 |
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
L'API de borne d'erreur de Lagrange répond à la question que toute interpolation polynomiale laisse en suspens : quelle peut être l'écart maximal du polynôme d'approximation ?
Où il s'intègre dans un flux de travail réel
Il s'exécute sur notre réseau edge mondial à $0.002 par requête, et le même code s'exécute gratuitement dans votre navigateur sur cette page — vous ne payez que lorsque vous l'automatisez dans un pipeline.