Decomposizione di Cholesky
Scomponga una matrice simmetrica definita positiva in un triangolo inferiore L per la sua trasposta: il classico esempio 3×3 con prima riga 4, 12, −16 dà una L con 2, 1 e 3 sulla diagonale. Utile per risolvere sistemi e generare campioni. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Funziona nel tuo browser: gratis, senza registrazione, i file non escono dal tuo dispositivo.
Cholesky è il metodo standard per risolvere sistemi lineari, generare campioni casuali correlati e verificare se una matrice è affatto definita positiva: quando la fattorizzazione esiste, la matrice lo è per costruzione. Invii la sua matrice come array di righe e riceva il fattore, l'input riportato e il metodo usato, in una sola chiamata deterministica.
Cosa le dà davvero la decomposizione di Cholesky
Ogni matrice simmetrica definita positiva A può essere scritta come prodotto di una matrice triangolare inferiore e della sua stessa trasposta: A = L·Lᵀ. Questo fattore L è, per così dire, la radice quadrata della matrice — e una volta che ce l'ha, diversi problemi costosi diventano economici. Risolvere A·x = b non richiede più l'eliminazione generale: risolve L·y = b per sostituzione in avanti e poi Lᵀ·x = y per sostituzione all'indietro, entrambe in tempo quadratico.
Invertire la matrice, calcolarne il determinante (il prodotto dei quadrati delle entrate diagonali di L) e sbiancare o correlare vettori casuali si riducono a operazioni sul triangolo. La calcolatrice di decomposizione di Cholesky restituisce esattamente quel fattore: una matrice triangolare inferiore n×n con entrate positive sulla diagonale e zeri sopra di essa. Poiché il calcolo è aritmetica in virgola mobile deterministica con arrotondamento fisso, lo stesso input produce sempre un output identico byte per byte, il che rende sicuro memorizzare, confrontare e archiviare il risultato.
Come la fattorizzazione viene calcolata e verificata
Per ogni posizione diagonale prende l'entrata corrispondente di A, sottrae la norma al quadrato della riga del fattore già calcolata ed estrae la radice quadrata; per ogni posizione sotto la diagonale sottrae il prodotto scalare delle due righe parziali e divide per l'entrata diagonale già nota. Quell'unica radice quadrata è anche il test definitivo di positività: la quantità sotto il radicale è positiva a ogni riga se e solo se la matrice è definita positiva.
Prima di tutto questo, l'input viene validato: deve essere un array quadrato di al massimo 50 righe, ogni entrata deve essere un numero finito entro il tetto di magnitudine dichiarato e le entrate speculari devono coincidere entro una tolleranza relativa, perché una matrice non simmetrica non ha affatto una fattorizzazione di Cholesky.
Dove si inserisce nel lavoro reale
Le due case classiche di Cholesky sono la statistica e il calcolo numerico. In statistica, estrarre campioni da una distribuzione normale multivariata con matrice di covarianza Σ significa moltiplicare un vettore di normali standard indipendenti per il fattore di Cholesky di Σ — i motori Monte Carlo lo fanno milioni di volte e hanno bisogno del fattore calcolato una volta, correttamente, in anticipo.
Nel calcolo numerico, i problemi ai minimi quadrati, i filtri di Kalman e gli ottimizzatori a punti interni risolvono sistemi simmetrici definiti positivi a ogni iterazione, e Cholesky è circa due volte più veloce della LU generale perché sfrutta la simmetria e non richiede pivoting.
Casi d'uso
Convalidi una matrice di covarianza prima del campionamento
Verifichi che una matrice di covarianza o correlazione stimata sia davvero definita positiva — e ottenga il fattore necessario per le estrazioni Monte Carlo correlate — prima che contamini una simulazione.
Risolva un sistema simmetrico senza libreria
Ottenga L una volta e poi risolva A·x = b con due sostituzioni triangolari nel suo codice, in qualsiasi linguaggio, senza collegare LAPACK o NumPy.
Verifichi il suo codice di algebra lineare
Confronti il fattore prodotto dalla sua implementazione con un risultato deterministico indipendente per individuare errori di indicizzazione e arrotondamento.
Domande frequenti
Quanto costa?
È anche gratis eseguirlo nel suo browser su questa pagina, con lo stesso codice.
Quali matrici sono accettate?
Matrici quadrate fino a 50×50, simmetriche entro una tolleranza relativa, con entrate finite fino a 1e15 in magnitudine. Gli input non quadrati, non simmetrici o non definiti positivi vengono rifiutati con un messaggio di errore specifico.
Cosa viene restituito esattamente?
Il fattore triangolare inferiore L tale che A = L·Lᵀ, arrotondato alla precisione scelta (10 decimali di default), insieme alla matrice di input, alla dimensione, al nome del metodo e alla formula usata.
La mia matrice viene memorizzata?
No. Viene elaborata in memoria e scartata; solo la risposta calcolata lascia la funzione.
Quanto è accurato il risultato?
Il fattore è calcolato in virgola mobile a doppia precisione e arrotondato al numero di decimali richiesto. Per matrici ben condizionate entro il limite di dimensione, il risultato arrotondato soddisfa A ≈ L·Lᵀ a quella precisione.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo 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)Esempio di richiesta
{
"matrix": [
[
4,
12,
-16
],
[
12,
37,
-43
],
[
-16,
-43,
98
]
]
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.cholesky_decomposition",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Limiti
max_n | 50 |
max_abs_entry | 1000000000000000 |
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
L'API di decomposizione di Cholesky prende una matrice simmetrica definita positiva e restituisce il suo fattore triangolare inferiore: l'unica matrice L con diagonale positiva tale che A = L·Lᵀ. Se la matrice non è simmetrica, non è quadrata o non è definita positiva, l'API le dice esattamente perché invece di restituire una risposta sbagliata dall'aspetto plausibile.
Cosa le dà davvero la decomposizione di Cholesky
Lei invia la matrice come array JSON di righe, opzionalmente con una precisione tra 0 e 15 decimali, e la risposta contiene il fattore arrotondato a quella precisione, la matrice inviata, la dimensione e il nome dell'algoritmo.
Come la fattorizzazione viene calcolata e verificata
L'endpoint esegue l'algoritmo di Cholesky-Banachiewicz, una procedura riga per riga che costruisce L direttamente dalla definizione A = L·Lᵀ. Se un pivot risulta nullo o negativo, il calcolo si ferma e l'API segnala che la matrice non è definita positiva, indicando la riga dove è fallita. Gli errori vengono restituiti come risposte invalid_input strutturate, mai come spazzatura numerica.
Dove si inserisce nel lavoro reale
Questa API è la versione a una chiamata di quel passaggio: utile quando vuole verificare che una matrice di covarianza sia valida prima di alimentare un campionatore, quando una pipeline ha bisogno del fattore senza collegare una libreria di algebra lineare, o quando desidera una seconda opinione su un risultato prodotto dal suo codice. Gira sull'edge senza conservare nulla dopo, costa $0.002 a richiesta, e lo stesso identico codice gira gratis nel suo browser su questa pagina: incolli una matrice, veda il fattore e paghi solo quando automatizza la chiamata.
Domande tecniche
E se la mia matrice non è definita positiva?
La richiesta fallisce con un errore invalid_input che indica che la matrice non è definita positiva e nomina la riga dove il pivot è fallito. Non viene restituito alcun fattore parziale.