Calculatrice de nombre de conditionnement
L'API de nombre de conditionnement prend une matrice carrée et renvoie son nombre de conditionnement en norme 2 : le rapport entre la plus grande et la plus petite valeur singulière de la matrice.
Lancer gratuitement
Ce chiffre unique vous indique combien une petite erreur dans vos données — un arrondi, un bruit de mesure, un coefficient tronqué — peut être amplifiée lors de la résolution d'un système linéaire ou de l'inversion de la matrice. Un nombre de conditionnement proche de 1 signifie que le problème est stable ; un nombre élevé avertit que votre réponse risque d'être dominée par le bruit. Le calcul s'effectue en une seule passe déterministe : la matrice est validée, A-transposée-A est formée et ses valeurs propres sont obtenues par une itération de Jacobi classique, dont les racines carrées sont les valeurs singulières.
Ce qu'un nombre de conditionnement mesure vraiment
Lorsque vous résolvez numériquement un système Ax = b, vous ne travaillez presque jamais avec A et b exacts. Les coefficients proviennent de mesures, de calculs antérieurs ou d'entrées décimales arrondies en chemin. Le nombre de conditionnement de A est le facteur d'amplification, dans le pire des cas, de cette incertitude : si l'entrée varie d'une quantité relative epsilon, la solution peut varier jusqu'à kappa fois epsilon. Avec kappa = 10, une erreur d'un pour cent dans vos données peut produire une erreur de dix pour cent dans la réponse. Avec kappa = 1,000,000, vous pouvez perdre six des seize chiffres décimaux environ qu'un double peut contenir. Le nombre de conditionnement en norme 2 calculé ici, kappa_2, se définit à travers les valeurs singulières de A : la plus grande valeur singulière sigma_max mesure le maximum dont la matrice peut étirer un vecteur, la plus petite sigma_min le maximum dont elle peut le contracter, et leur rapport est kappa_2. Une matrice orthogonale, comme une rotation, a un kappa_2 exactement égal à 1 — le meilleur possible. Une matrice à lignes linéairement dépendantes a sigma_min = 0 et un kappa_2 infini, et c'est pourquoi cette capacité rejette les matrices singulières au lieu d'afficher un nombre énorme et dépourvu de sens.
Comment le nombre est calculé ici
L'algorithme est déterministe et autonome, sans bibliothèque numérique externe. Votre entrée est d'abord normalisée : les coefficients peuvent être envoyés sous forme de tableau de lignes ou de texte brut avec des lignes séparées par des sauts de ligne ou des points-virgules, et des valeurs par des virgules ou des espaces. Chaque coefficient doit être un nombre fini, toutes les lignes doivent avoir la même longueur et la matrice doit être carrée — une matrice 2 par 3 n'a pas de nombre de conditionnement en ce sens, donc la requête est rejetée avec une erreur claire qui nomme le champ fautif. Le code forme ensuite la matrice symétrique G = A^T A et en extrait les valeurs propres par l'itération cyclique classique de Jacobi : une séquence fixe de rotations planes qui annulent les entrées hors diagonale une à une jusqu'à ce que la matrice soit diagonale à la précision de travail. Comme l'ordre des rotations, la convention de signe et le plafond de balayages sont fixés, la même matrice produit toujours la même réponse, bit à bit. Les valeurs propres de G sont les carrés des valeurs singulières de A, donc leurs racines carrées donnent sigma_max et sigma_min, et le rapport, arrondi à douze décimales pour une sortie stable, est le nombre de conditionnement renvoyé. Les matrices dont la plus petite valeur singulière tombe sous un plancher numérique ajusté — environ kappa_2 au-dessus de dix milliards — sont signalées comme numériquement singulières, car la double précision ne peut pas honnêtement les distinguer d'une matrice déficiente en rang.
Lire le résultat et bien l'exploiter
La réponse vous donne quatre choses : le nombre de conditionnement lui-même, sigma_max, sigma_min et un message en langage clair qui classe la matrice. Considérez comme bien conditionnée toute kappa inférieure à environ 10 — les solveurs directs se comporteront bien. Entre cent et un million, prévoyez une perte de précision visible et privilégiez des algorithmes stables : décomposition QR ou LU avec pivot partiel plutôt que la formation d'un inverse explicite, qui élève au carré l'erreur du calcul qui l'alimente. Au-delà d'un million, la lecture honnête est que la réponse dépend davantage du bruit de vos données que du solveur, et la bonne décision est généralement de remettre le problème à l'échelle, de le régulariser ou de reconsidérer si la matrice du modèle est la bonne. Deux habitudes pratiques paient : vérifiez le nombre de conditionnement avant d'accuser un solveur d'une mauvaise réponse, car une matrice mal conditionnée produit des réponses fausses avec un code correct ; et comparez les nombres de conditionnement entre formulations, car le même problème physique écrit avec d'autres unités ou fonctions de base peut différer de plusieurs ordres de grandeur en kappa. Le même code qui s'exécute ici tourne gratuitement dans votre navigateur sur cette page : vous pouvez coller une matrice et voir le résultat avant de payer $0.002 par requête pour l'automatiser.
Cas d’usage
Vérifier un système linéaire avant de le résoudre
Estimez combien de chiffres de la solution sont fiables avant de lancer une résolution LU ou QR sur des coefficients mesurés.
Diagnostiquer une régression qui ne converge pas
Une matrice de conception presque colinéaire se manifeste par un nombre de conditionnement énorme de X-transposée-X bien avant que le solveur n'échoue.
Comparer des discrétisations du même problème
Deux formulations en éléments finis ou en fonctions de base d'un même modèle physique peuvent différer de plusieurs ordres de grandeur en conditionnement ; choisissez la stable.
Questions fréquentes
Combien cela coûte-t-il ?
$0.002 par requête. L'exécution est également gratuite dans votre navigateur sur cette page.
Pourquoi ma matrice a-t-elle été rejetée comme singulière ?
Parce que sa plus petite valeur singulière est numériquement nulle, ce qui rend le nombre de conditionnement infini. Cela couvre aussi les matrices techniquement inversibles mais déficientes en rang en double précision (kappa au-delà d'environ dix milliards).
Pourquoi la matrice doit-elle être carrée ?
Le nombre de conditionnement en norme 2, kappa_2 = sigma_max / sigma_min, se définit à travers les valeurs singulières d'une matrice de coefficients carrée. Pour les problèmes de moindres carrés rectangulaires, conditionnez plutôt la matrice carrée X-transposée-X.
Comment puis-je envoyer la matrice ?
Sous forme de tableau de lignes numériques de même longueur, ou de texte avec des lignes séparées par des sauts de ligne ou des points-virgules et des coefficients par des virgules ou des espaces. Les deux formes donnent des résultats identiques.
Quelle taille de matrice est acceptée ?
Jusqu'à 32 par 32, avec des valeurs absolues de coefficients jusqu'à 1e12. Le calcul est une arithmétique exacte en double précision avec une itération de Jacobi déterministe.
Le résultat est-il reproductible ?
Oui. L'itération de Jacobi utilise un ordre de rotations, une convention de signe et un plafond de balayages fixes, de sorte que la même entrée produit toujours la même sortie, arrondie à douze décimales.
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/condition-number \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"matrix":[[2,1],[1,2]]}'const res = await fetch("https://api.kit.forhosting.com/math/condition-number", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"matrix": [
[
2,
1
],
[
1,
2
]
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/condition-number",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"matrix": [
[
2,
1
],
[
1,
2
]
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/condition-number", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"matrix":[[2,1],[1,2]]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"matrix":[[2,1],[1,2]]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/condition-number", 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
{
"matrix": [
[
2,
1
],
[
1,
2
]
]
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.condition_number",
"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_rows | 32 |
max_cols | 32 |
max_abs | 1000000000000 |
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. |