Calculateur de propagation d'erreurs
Multipliez 2 ± 0,1 par 3 ± 0,2 et vous obtenez 6 avec une incertitude type composée de 0,5, ainsi que la part apportée par chaque mesure. Sommes, produits, puissances, racines carrées et logarithmes suivent la même règle du premier ordre. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Lorsqu'une grandeur dérivée est calculée à partir d'entrées mesurées, l'erreur-type de chaque entrée contribue à l'incertitude du résultat. La propagation d'erreurs au premier ordre — l'approximation linéaire gaussienne ou GUM — combine ces contributions par les dérivées partielles de la formule. Ce calculateur de propagation d'erreurs accepte une formule algébrique ainsi que des valeurs nommées et leurs erreurs-types, évalue l'expression et renvoie le résultat avec l'incertitude-type combinée sous l'hypothèse habituelle d'entrées indépendantes. Sommes, produits, quotients, puissances et fonctions de laboratoire courantes telles que la racine carrée et le logarithme tiennent dans un même contrat, de sorte que vous n'avez pas à mémoriser une identité particulière pour chaque expérience.
Ce que calcule vraiment la propagation d'erreurs au premier ordre
La propagation d'erreurs répond à une question de laboratoire qu'une calculatrice nue ne pose jamais : si chaque entrée n'est connue que jusqu'à une erreur-type déclarée, quelle est l'incertitude-type du nombre que vous venez de calculer ? La règle gaussienne du premier ordre, qui est aussi le terme linéaire du Guide pour l'expression de l'incertitude de mesure, linéarise la formule autour du point mesuré et additionne les contributions indépendantes en quadrature.
Écrite en toutes lettres, l'incertitude-type combinée est la racine carrée de la somme de chaque dérivée partielle multipliée par l'erreur-type correspondante, le tout au carré. Pour une somme ou une différence les partielles valent plus un ou moins un, si bien que l'incertitude combinée est simplement la racine de la somme des carrés des erreurs d'entrée. Pour un produit ou un quotient la même identité devient la combinaison familière des erreurs relatives.
Pour une puissance, une racine carrée ou un logarithme la partielle n'est plus triviale, c'est pourquoi un moteur de formules général est plus honnête qu'une paire de boutons figés produit et somme. Ce calculateur évalue la formule par différentiation automatique en mode direct, de sorte que chaque opérateur et chaque fonction pris en charge contribue une première dérivée exacte plutôt qu'une estimation par différences finies qui dépendrait d'un pas caché.
Les entrées sont traitées comme non corrélées : il n'y a ni matrice de covariances, ni tirage Monte Carlo, ni terme hessien du second ordre. C'est le modèle indépendant du premier ordre des manuels, celui des laboratoires de licence et de la plupart des colonnes d'incertitude d'un LIMS. Si une erreur-type est négative, la requête est rejetée, car une erreur-type est une largeur non négative, non un résidu signé.
Zéro est admis et signifie que cette entrée est traitée comme exacte. La réponse indique le résultat évalué, l'incertitude combinée, les incertitudes relative et en pour cent facultatives lorsque le résultat n'est pas zéro, et une ventilation par variable des partielles et des contributions à la variance afin que vous voyiez quelle mesure domine le budget.
Contrat d'entrée, formules prises en charge et signalement des erreurs
Au moins une variable est exigée et la liste est plafonnée afin qu'un collage de carnet ne s'emballe pas. La syntaxe prise en charge comprend plus, moins, multiplier, diviser, la puissance en circonflexe ou double étoile, les parenthèses et la multiplication implicite telle que deux pi r ou deux a. Les constantes intégrées sont pi et e.
Les fonctions intégrées sont sqrt, exp, ln, log (népérien), log10, sin, cos, tan, abs, asin, acos, atan et pow, avec des arguments trigonométriques en radians. Un contrôle classique de produit est la formule a fois b avec a égal à deux plus ou moins un dixième et b égal à trois plus ou moins deux dixièmes : le résultat est six et l'incertitude combinée vaut exactement un demi, car les partielles valent trois et deux.
Un contrôle de masse volumique m sur v avec une masse dix plus ou moins un dixième et un volume deux plus ou moins cinq centièmes donne cinq avec une incertitude combinée voisine de cent trente-cinq millièmes.
Quand propager l'incertitude est utile
Les laboratoires de licence en physique, chimie et ingénierie demandent aux étudiants de citer un résultat dérivé avec une incertitude combinée plutôt que de copier seulement la valeur centrale d'une calculatrice. Les plateformes d'enseignement et les générateurs d'examens ont besoin d'un oracle déterministe qui marque une erreur-type négative comme invalide, au lieu de prendre une valeur absolue et de noter en silence une feuille négligée comme correcte.
Les laboratoires d'analyse et d'étalonnage attachent une incertitude du premier ordre à des formules de masse volumique, de résistance, de débit et de rendement dans un LIMS ou des travaux de carnet, sans déployer un système de calcul formel. Les équipes qualité et métrologie comparent quelle entrée domine la contribution à la variance lorsqu'elles décident d'acheter une meilleure balance ou un meilleur thermomètre. Une validation en échec ne consomme pas le solde.
Cas d’usage
Comptes rendus de laboratoire et corrigés
Les étudiants saisissent une formule plus chaque valeur mesurée et son erreur-type afin de vérifier l'incertitude combinée par rapport à la règle du premier ordre des laboratoires de physique et de chimie.
Colonnes d'incertitude dans un LIMS et des carnets
Attachez une incertitude combinée déterministe à des formules de masse volumique, de résistance ou de rendement dans un système d'information de laboratoire et des carnets d'analyse, sans dépendance à un système de calcul formel.
Revues du budget d'incertitude
Examinez les contributions à la variance par variable pour voir quelle mesure domine l'incertitude combinée avant d'acheter un meilleur instrument ou de relancer un essai.
Questions fréquentes
Comment l'incertitude combinée est-elle calculée ?
Les partielles viennent de la différentiation automatique en mode direct de la formule.
Les variables d'entrée sont-elles supposées indépendantes ?
Oui. L'incertitude combinée est la racine de la somme des carrés des termes individuels (partielle × erreur-type). Les entrées corrélées et la propagation Monte Carlo sortent du périmètre de cette page.
Quelles formules et fonctions sont prises en charge ?
Vous pouvez utiliser + − * / ^, les parenthèses, la multiplication implicite, les constantes pi et e, et les fonctions sqrt, exp, ln, log, log10, sin, cos, tan, abs, asin, acos, atan et pow. Les arguments trigonométriques sont en radians.
Comment voir quelle mesure domine l'incertitude ?
Regardez le détail de chaque mesure, qui indique sa dérivée partielle et sa contribution. Dans l'exemple, la seconde apporte 0,4 et la première 0,3 : c'est donc en mesurant mieux la seconde que vous gagnez le plus.
Un écart type peut-il être nul ?
Oui. Zéro signifie que cette mesure est considérée comme exacte et n'ajoute rien à l'incertitude composée. Seuls les écarts types négatifs sont refusés, car un écart type est une largeur et n'a pas de signe.
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/stat/error-propagation \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"formula":"a*b","variables":[{"name":"a","value":2,"std_error":0.1},{"name":"b","value":3,"std_error":0.2}]}'const res = await fetch("https://api.kit.forhosting.com/stat/error-propagation", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"formula": "a*b",
"variables": [
{
"name": "a",
"value": 2,
"std_error": 0.1
},
{
"name": "b",
"value": 3,
"std_error": 0.2
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/stat/error-propagation",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"formula": "a*b",
"variables": [
{
"name": "a",
"value": 2,
"std_error": 0.1
},
{
"name": "b",
"value": 3,
"std_error": 0.2
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/stat/error-propagation", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"formula":"a*b","variables":[{"name":"a","value":2,"std_error":0.1},{"name":"b","value":3,"std_error":0.2}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"formula":"a*b","variables":[{"name":"a","value":2,"std_error":0.1},{"name":"b","value":3,"std_error":0.2}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/stat/error-propagation", 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
{
"formula": "a*b",
"variables": [
{
"name": "a",
"value": 2,
"std_error": 0.1
},
{
"name": "b",
"value": 3,
"std_error": 0.2
}
]
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "stat.error_propagation",
"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
max_formula_len | 400 |
max_variables | 24 |
max_abs | 1000000000000000 |
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
Une erreur-type négative est rejetée avec invalid_input plutôt que d'être prise en valeur absolue en silence.
Contrat d'entrée, formules prises en charge et signalement des erreurs
Envoyez un corps JSON en POST avec deux champs obligatoires. formula est une expression algébrique dont les identifiants correspondent aux noms que vous fournirez ; les alias expression, expr et f sont acceptés. variables est une liste d'enregistrements, chacun avec name, value et std_error, avec les alias vars, inputs et measurements pour la liste et error, se, sigma ou uncertainty pour la cellule d'erreur-type. Champs manquants, formules vides, identifiants inconnus, noms de fonction réservés utilisés comme variables, nombres non finis et tout std_error négatif échouent avec invalid_input en nommant le problème, et ces échecs ne sont pas facturés. En cas de succès, le corps répète la formule, renvoie result et combined_uncertainty comme paire principale, fixe method à first_order_gaussian et independent à true, reformule l'identité de quadrature et énumère chaque entrée avec sa dérivée partielle, sa contribution absolue et sa contribution à la variance. Associez le JSON à votre propre arrondi de chiffres significatifs si un modèle de rapport exige une présentation particulière ; ce point de terminaison conserve douze décimales afin que les références et les pipelines restent stables d'un moteur JavaScript à l'autre.
Où une API de propagation d'erreurs gagne sa place
Comme l'implémentation est du parse de niveau A pur, chaque appel réussi coûte le tarif de base publié $0.002, sans jetons de modèle et sans réseau sortant. Gardez les formules courtes, nommez chaque identifiant et figez dans les tests le result et le combined_uncertainty arrondis, et vous obtiendrez une incertitude reproductible pour les devoirs, les workers de bordure et les scripts de laboratoire, sans réimplémenter la règle linéaire GUM dans chaque langage que vous livrez.
Questions techniques
Combien coûte le calculateur de propagation d'erreurs ?
L'outil du navigateur est gratuit. Les requêtes d'API utilisent le solde prépayé KIT à $0.002 par appel réussi ; une entrée invalide, y compris une erreur-type négative, n'est pas facturée.
Pourquoi les erreurs-types négatives sont-elles rejetées ?
Une erreur-type est une largeur non négative. Une valeur négative est presque toujours une erreur de signe ou un résidu permuté, donc la tâche échoue avec invalid_input au lieu de prendre une valeur absolue.