Calcolatore di Gram-Schmidt
Inserisca vettori indipendenti e ottenga una base ortonormale dello stesso spazio: (1, 1, 0), (1, 0, 1) e (0, 0, 3) diventano tre vettori unitari ortogonali, e il primo è il suo primo vettore portato a lunghezza 1. Se sono dipendenti, glielo segnala. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Il procedimento di Gram-Schmidt prende un insieme di vettori linearmente indipendenti e restituisce una base ortonormale: lo stesso numero di vettori, ciascuno di lunghezza unitaria e perpendicolare a tutti gli altri, che genera esattamente lo stesso sottospazio degli originali. Se i vettori sono linearmente dipendenti, il calcolatore lo segnala invece di restituire una risposta sbagliata.
Cosa fa davvero il procedimento di Gram-Schmidt
Le basi ortonormali semplificano quasi ogni calcolo dell'algebra lineare: le proiezioni diventano prodotti scalari, le coordinate diventano banali e gli errori numerici restano piccoli. Il procedimento di Gram-Schmidt ne costruisce una a partire da qualsiasi insieme indipendente. Prende il primo vettore e lo riscala a lunghezza unitaria: quello è il primo vettore della base.
Per ogni vettore successivo, sottrae la parte che punta lungo ciascun vettore della base già trovato — la proiezione, calcolata come prodotto scalare — e poi riscala ciò che resta. Ciò che resta è, per costruzione, perpendicolare a tutto quanto lo precede. Ripetendo per tutti i vettori si ottiene una base ortonormale dello stesso sottospazio.
Il calcolatore di questa pagina esegue esattamente questo procedimento classico: Lei fornisce i vettori come array di numeri, tutti della stessa dimensione, e riceve i vettori ortonormali nell'ordine corrispondente. Il primo vettore in uscita è semplicemente il primo vettore in ingresso normalizzato; ogni uscita successiva è la componente davvero nuova del Suo input, resa di lunghezza unitaria. Poiché l'intero calcolo è pura aritmetica in doppia precisione, lo stesso input produce sempre lo stesso output, ed è questo che lo rende sicuro da integrare in pipeline automatizzate.
Perché la dipendenza lineare è un errore, non un risultato
Gram-Schmidt non ha una risposta sensata quando i vettori in ingresso sono linearmente dipendenti. Se un vettore è una combinazione di quelli che lo precedono, sottrarre le proiezioni lo annulla del tutto: non resta nulla da normalizzare, e dividere per un resto di lunghezza zero non avrebbe senso. Un calcolatore che scartasse silenziosamente quel vettore, o restituisse una riga di zeri, Le consegnerebbe una base che non corrisponde al numero dei Suoi input e nasconde un errore di modellazione.
Lo stesso controllo intercetta i casi limite più evidenti: un vettore nullo, un vettore ripetuto, oppure più vettori della dimensione dello spazio, che è dipendente già per semplice conteggio. La tolleranza è numerica e non esatta, quindi vengono segnalati anche gli insiemi quasi dipendenti prodotti dal rumore di misura. Se si aspettava che l'insieme fosse indipendente, il messaggio di errore Le dice quale vettore controllare, il che di solito basta per trovare la riga duplicata o l'errore di copia-incolla nei Suoi dati.
Dettagli pratici: forma dell'input, precisione e limiti
L'input è un unico campo, vectors, fornito come array di array di numeri finiti — un array interno per vettore, tutti della stessa dimensione, fino a 50 vettori di dimensione fino a 50. L'output riporta la dimensione, quanti vettori ortonormali sono stati prodotti e la base stessa come array di vettori unitari.
Le componenti sono arrotondate a sei cifre decimali, quindi i risultati sono stabili tra macchine diverse e sicuri da confrontare o archiviare; ogni vettore restituito ha norma euclidea 1 ed è ortogonale ai compagni a meno di tale arrotondamento. Il calcolo è O(n al quadrato per la dimensione), che con questi limiti equivale a microsecondi di lavoro, quindi la latenza che osserva è essenzialmente dovuta al trasporto, non all'aritmetica.
Un utile controllo preliminare prima di inviare i dati: nessun vettore può essere il vettore nullo, nessuna coppia di vettori può essere uguale e il numero di vettori non può superare la dimensione. Per insiemi fortemente mal condizionati in lavori numerici seri, un Gram-Schmidt modificato o una fattorizzazione QR di Householder offrono maggiore stabilità, ma per le dimensioni che questo calcolatore accetta il procedimento classico è accurato ben oltre i sei decimali che riporta.
Casi d'uso
Ortogonalizzare direzioni in un progetto grafico o di simulazione
Trasformi vettori di riferimento quasi ortogonali in una vera base ortonormale prima di comporre le rotazioni, così la deriva degli arrotondamenti non si accumula.
Preparare una base per un passo di minimi quadrati o di proiezione
Proietti i dati su un sottospazio con semplici prodotti scalari con i vettori della base ortonormale, invece di risolvere un sistema lineare ogni volta.
Verificare compiti ed esempi didattici
Verifichi passo dopo passo un esercizio di Gram-Schmidt svolto a mano e veda esattamente quale vettore rompe l'indipendenza quando l'insieme è dipendente.
Domande frequenti
Quanto costa?
Su questa pagina funziona gratuitamente nel Suo browser con lo stesso codice.
Quanto è preciso il risultato?
Le componenti sono calcolate in doppia precisione e arrotondate a sei decimali. Ogni vettore in uscita ha norma unitaria ed è ortogonale agli altri a meno di tale arrotondamento.
L'ordine dei vettori in ingresso conta?
Sì. Il primo vettore in uscita è il primo ingresso normalizzato; le uscite successive sono i resti ortogonalizzati nello stesso ordine, quindi permutare l'input dà una base ortonormale diversa (ma ugualmente valida).
Cosa succede se i miei vettori sono linearmente dipendenti?
Il calcolatore si ferma e indica quale vettore non aggiunge una direzione nuova, invece di scartarlo o restituire una riga di zeri. Un vettore nullo, uno ripetuto o più vettori della dimensione contano come dipendenti.
A cosa serve una base ortonormale?
Semplifica quasi tutta l'algebra lineare: le proiezioni diventano prodotti scalari, le coordinate si ricavano in modo diretto e gli errori numerici restano piccoli.
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/gram-schmidt \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"vectors":[[1,1,0],[1,0,1],[0,0,3]]}'const res = await fetch("https://api.kit.forhosting.com/math/gram-schmidt", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"vectors": [
[
1,
1,
0
],
[
1,
0,
1
],
[
0,
0,
3
]
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/gram-schmidt",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"vectors": [
[
1,
1,
0
],
[
1,
0,
1
],
[
0,
0,
3
]
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/gram-schmidt", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"vectors":[[1,1,0],[1,0,1],[0,0,3]]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"vectors":[[1,1,0],[1,0,1],[0,0,3]]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/gram-schmidt", 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
{
"vectors": [
[
1,
1,
0
],
[
1,
0,
1
],
[
0,
0,
3
]
]
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.gram_schmidt",
"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_vectors | 50 |
max_dimension | 50 |
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
Incolli qui i Suoi vettori e ottenga la base ortonormale calcolata passo dopo passo nel browser, oppure chiami l'API per ortogonalizzare insiemi di vettori in uno script, in un foglio di calcolo o in un flusso numerico.
Perché la dipendenza lineare è un errore, non un risultato
Questo endpoint tratta la dipendenza come una violazione del contratto: verifica, in ordine, se ogni vettore contribuisce con una nuova direzione, e se il vettore k appartiene allo spazio generato dai precedenti risponde con un errore invalid_input che indica il vettore incriminato — e una chiamata con errore non viene addebitata.
Domande tecniche
Quale input si aspetta?
Un campo vectors: un array di array di numeri finiti, un array interno per vettore, tutti della stessa dimensione — fino a 50 vettori di dimensione fino a 50.
Cosa succede se i miei vettori sono linearmente dipendenti?
La richiesta fallisce con un errore invalid_input che indica il primo vettore appartenente allo spazio generato dai precedenti. Le chiamate con errore non vengono addebitate.
Posso usarlo con vettori complessi?
No. Sono accettati solo vettori reali; gli elementi devono essere numeri JSON finiti.