Décomposition de Cholesky
Décomposez une matrice symétrique définie positive en un triangle inférieur L fois sa transposée : l'exemple classique 3×3 dont la première ligne est 4, 12, −16 donne un L avec 2, 1 et 3 sur la diagonale. Utile pour résoudre des systèmes et simuler. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Tout se passe dans votre navigateur : gratuit, sans envoi de vos données.
Cholesky est la méthode standard pour résoudre des systèmes linéaires, générer des échantillons aléatoires corrélés et tester si une matrice est seulement définie positive : quand la factorisation existe, la matrice l'est par construction. Envoyez votre matrice sous forme de tableau de lignes et recevez le facteur, l'entrée renvoyée et la méthode utilisée, en un seul appel déterministe.
Ce que la décomposition de Cholesky vous donne vraiment
Toute matrice symétrique définie positive A peut s'écrire comme le produit d'une matrice triangulaire inférieure et de sa propre transposée : A = L·Lᵀ. Ce facteur L est, en quelque sorte, la racine carrée de la matrice — et une fois que vous l'avez, plusieurs problèmes coûteux deviennent bon marché. Résoudre A·x = b n'exige plus d'élimination générale : vous résolvez L·y = b par substitution avant, puis Lᵀ·x = y par substitution arrière, toutes deux en temps quadratique.
Inverser la matrice, calculer son déterminant (le produit des carrés des entrées diagonales de L) et blanchir ou corréler des vecteurs aléatoires se ramènent à des opérations sur le triangle. La calculatrice de décomposition de Cholesky renvoie exactement ce facteur : une matrice triangulaire inférieure n×n avec des entrées positives sur la diagonale et des zéros au-dessus.
Comme le calcul est une arithmétique flottante déterministe à arrondi fixe, la même entrée produit toujours une sortie identique octet par octet, ce qui rend le résultat sûr à mettre en cache, comparer et archiver.
Comment la factorisation est calculée et vérifiée
Le point de terminaison exécute l'algorithme de Cholesky-Banachiewicz, une procédure ligne par ligne qui construit L directement à partir de la définition A = L·Lᵀ. Pour chaque position diagonale, il prend l'entrée correspondante de A, soustrait la norme au carré de la ligne du facteur déjà calculée et prend la racine carrée ; pour chaque position sous la diagonale, il soustrait le produit scalaire des deux lignes partielles et divise par l'entrée diagonale déjà connue.
Cette unique racine carrée est aussi le test définitif de positivité : la quantité sous le radical est positive à chaque ligne si et seulement si la matrice est définie positive. Avant tout cela, l'entrée est validée : ce doit être un tableau carré d'au plus 50 lignes, chaque entrée doit être un nombre fini dans la limite de magnitude déclarée, et les entrées miroir doivent concorder dans une tolérance relative, car une matrice non symétrique n'a tout simplement pas de factorisation de Cholesky.
Où elle s'inscrit dans le travail réel
Les deux terrains classiques de Cholesky sont la statistique et le calcul numérique. En statistique, tirer des échantillons d'une loi normale multivariée de matrice de covariance Σ revient à multiplier un vecteur de normales standard indépendantes par le facteur de Cholesky de Σ — les moteurs de Monte Carlo font cela des millions de fois et ont besoin du facteur calculé une fois, correctement, à l'avance.
En calcul numérique, les problèmes de moindres carrés, les filtres de Kalman et les optimiseurs de points intérieurs résolvent des systèmes symétriques définis positifs à chaque itération, et Cholesky est environ deux fois plus rapide que la LU générale parce qu'il exploite la symétrie et se passe de pivotement.
Cas d’usage
Validez une matrice de covariance avant échantillonnage
Vérifiez qu'une matrice de covariance ou de corrélation estimée est vraiment définie positive — et obtenez le facteur nécessaire aux tirages de Monte Carlo corrélés — avant qu'elle ne contamine une simulation.
Résolvez un système symétrique sans bibliothèque
Obtenez L une fois, puis résolvez A·x = b avec deux substitutions triangulaires dans votre propre code, dans n'importe quel langage, sans lier LAPACK ni NumPy.
Recoupez votre propre code d'algèbre linéaire
Comparez le facteur produit par votre implémentation à un résultat déterministe indépendant pour détecter les erreurs d'indexation et d'arrondi.
Questions fréquentes
Combien coûte le service ?
L'exécution est aussi gratuite dans votre navigateur sur cette page, avec le même code.
Quelles matrices sont acceptées ?
Des matrices carrées jusqu'à 50×50, symétriques dans une tolérance relative, avec des entrées finies jusqu'à 1e15 en magnitude. Les entrées non carrées, non symétriques ou non définies positives sont rejetées avec un message d'erreur précis.
Qu'est-ce qui est renvoyé exactement ?
Le facteur triangulaire inférieur L tel que A = L·Lᵀ, arrondi à la précision choisie (10 décimales par défaut), plus la matrice d'entrée, la dimension, le nom de la méthode et la formule utilisée.
Ma matrice est-elle stockée ?
Non. Elle est traitée en mémoire puis écartée ; seule la réponse calculée quitte la fonction.
Quelle est la précision du résultat ?
Le facteur est calculé en virgule flottante double précision et arrondi au nombre de décimales demandé. Pour des matrices bien conditionnées dans la limite de taille, le résultat arrondi satisfait A ≈ L·Lᵀ à cette précision.
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/cholesky-decomposition \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"matrix":[[4,12,-16],[12,37,-43],[-16,-43,98]]}'const res = await fetch("https://api.kit.forhosting.com/math/cholesky-decomposition", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"matrix": [
[
4,
12,
-16
],
[
12,
37,
-43
],
[
-16,
-43,
98
]
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/cholesky-decomposition",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"matrix": [
[
4,
12,
-16
],
[
12,
37,
-43
],
[
-16,
-43,
98
]
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/cholesky-decomposition", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"matrix":[[4,12,-16],[12,37,-43],[-16,-43,98]]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"matrix":[[4,12,-16],[12,37,-43],[-16,-43,98]]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/cholesky-decomposition", 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": [
[
4,
12,
-16
],
[
12,
37,
-43
],
[
-16,
-43,
98
]
]
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.cholesky_decomposition",
"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_n | 50 |
max_abs_entry | 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
L'API de décomposition de Cholesky prend une matrice symétrique définie positive et renvoie son facteur triangulaire inférieur : l'unique matrice L à diagonale positive telle que A = L·Lᵀ. Si la matrice n'est pas symétrique, pas carrée ou pas définie positive, l'API vous dit exactement pourquoi au lieu de renvoyer une réponse fausse mais présentable.
Ce que la décomposition de Cholesky vous donne vraiment
Vous envoyez la matrice comme un tableau JSON de lignes, éventuellement avec une précision entre 0 et 15 décimales, et la réponse contient le facteur arrondi à cette précision, la matrice envoyée, la dimension et le nom de l'algorithme.
Comment la factorisation est calculée et vérifiée
Si un pivot est nul ou négatif, le calcul s'arrête et l'API signale que la matrice n'est pas définie positive, en nommant la ligne où l'échec s'est produit. Les erreurs sont renvoyées sous forme de réponses invalid_input structurées, jamais comme du bruit numérique.
Où elle s'inscrit dans le travail réel
Cette API est la version en un appel de cette étape : utile pour vérifier qu'une matrice de covariance est valide avant d'alimenter un échantillonneur, quand un pipeline a besoin du facteur sans lier une bibliothèque d'algèbre linéaire, ou pour obtenir un second avis sur un résultat produit par votre propre code. Elle s'exécute à la périphérie sans rien conserver ensuite, coûte $0.002 par requête, et le même code identique tourne gratuitement dans votre navigateur sur cette page : collez une matrice, voyez le facteur, et ne payez que lorsque vous automatisez l'appel.
Questions techniques
Que se passe-t-il si ma matrice n'est pas définie positive ?
La requête échoue avec une erreur invalid_input indiquant que la matrice n'est pas définie positive et nommant la ligne où le pivot a échoué. Aucun facteur partiel n'est renvoyé.