ForHosting KIT · Mathématiques

Calculateur de Gram-Schmidt

Saisissez des vecteurs indépendants et obtenez une base orthonormée du même espace : (1, 1, 0), (1, 0, 1) et (0, 0, 3) deviennent trois vecteurs unitaires orthogonaux, le premier étant votre premier vecteur ramené à la norme 1. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Le procédé de Gram-Schmidt prend un ensemble de vecteurs linéairement indépendants et renvoie une base orthonormée : le même nombre de vecteurs, chacun de norme unitaire, chacun perpendiculaire à tous les autres, engendrant exactement le même sous-espace que les vecteurs d'origine. Si les vecteurs sont linéairement dépendants, le calculateur le signale au lieu de renvoyer une réponse fausse.

Ce que le procédé de Gram-Schmidt fait réellement

Les bases orthonormées simplifient presque tous les calculs d'algèbre linéaire : les projections deviennent des produits scalaires, les coordonnées deviennent triviales et les erreurs numériques restent faibles. Le procédé de Gram-Schmidt en construit une à partir de tout ensemble indépendant. Il prend le premier vecteur et le normalise ; c'est le premier vecteur de base.

Pour chaque vecteur suivant, il soustrait la partie dirigée selon chaque vecteur de base déjà trouvé — la projection, calculée comme un produit scalaire — puis normalise ce qui reste. Ce reste est, par construction, perpendiculaire à tout ce qui précède. Répétez pour tous les vecteurs et vous obtenez une base orthonormée du même espace engendré.

Le calculateur de cette page applique exactement cette procédure classique : vous fournissez des vecteurs sous forme de tableaux de nombres, tous de même dimension, et vous recevez les vecteurs orthonormés dans l'ordre correspondant. Le premier vecteur de sortie est simplement votre premier vecteur d'entrée normalisé ; chaque sortie suivante est la composante réellement nouvelle de votre entrée, ramenée à la norme unitaire.

Comme tout le calcul n'est que de l'arithmétique en double précision, la même entrée produit toujours la même sortie, ce qui permet de l'intégrer en toute sécurité dans des pipelines automatisés.

Pourquoi la dépendance linéaire est une erreur, pas un résultat

Gram-Schmidt n'a pas de réponse pertinente quand les vecteurs d'entrée sont linéairement dépendants. Si un vecteur est une combinaison des précédents, soustraire les projections l'élimine entièrement : il ne reste rien à normaliser, et diviser par un reste de norme nulle n'aurait aucun sens. Un calculateur qui ignorerait ce vecteur en silence, ou renverrait une ligne de zéros, vous donnerait une base qui ne correspond pas au nombre de vos entrées et masquerait une erreur de modélisation.

La même vérification intercepte les cas limites évidents : un vecteur nul, un vecteur répété, ou plus de vecteurs que la dimension de l'espace, ce qui est dépendant par simple décompte. La tolérance est numérique plutôt qu'exacte, donc les ensembles presque dépendants issus du bruit de mesure sont aussi signalés. Si vous pensiez l'ensemble indépendant, le message d'erreur indique quel vecteur examiner, ce qui suffit généralement à repérer la ligne dupliquée ou l'erreur de copier-coller dans vos données.

Détails pratiques : format d'entrée, précision et limites

L'entrée est un champ unique, vectors, sous forme de tableau de tableaux de nombres finis — un tableau interne par vecteur, tous de même dimension, jusqu'à 50 vecteurs de dimension 50 au plus. La sortie indique la dimension, le nombre de vecteurs orthonormés produits, et la base elle-même sous forme de tableau de vecteurs unitaires.

Les composantes sont arrondies à six décimales, donc les résultats sont stables d'une machine à l'autre et sûrs à comparer ou à stocker ; chaque vecteur renvoyé a une norme euclidienne de 1 et est orthogonal aux autres à cet arrondi près. Le calcul est en O(n² fois la dimension), soit quelques microsecondes pour ces limites : la latence observée est donc essentiellement le transport, pas l'arithmétique.

Un contrôle utile avant l'envoi : aucun vecteur ne peut être nul, deux vecteurs ne peuvent pas être égaux, et le nombre de vecteurs ne peut pas dépasser la dimension. Pour des ensembles très mal conditionnés dans un travail numérique exigeant, un Gram-Schmidt modifié ou une factorisation QR de Householder offre une stabilité accrue, mais pour les tailles acceptées par ce calculateur, le procédé classique est précis bien au-delà des six décimales affichées.

Cas d’usage

Orthogonaliser des directions dans un projet graphique ou de simulation

Transformez des vecteurs de repère presque orthogonaux en une vraie base orthonormée avant de composer des rotations, afin que la dérive d'arrondi ne s'accumule pas.

Préparer une base pour une étape de moindres carrés ou de projection

Projetez vos données sur un sous-espace par simples produits scalaires avec des vecteurs orthonormés au lieu de résoudre un système linéaire à chaque fois.

Vérifier des devoirs et des exemples de cours

Contrôlez un exercice de Gram-Schmidt fait à la main, étape par étape, et voyez exactement quel vecteur rompt l'indépendance quand l'ensemble est dépendant.

Questions fréquentes

Combien ça coûte ?

Sur cette page, le calcul est gratuit dans votre navigateur avec le même code.

Que se passe-t-il si mes vecteurs sont linéairement dépendants ?

Les appels en erreur ne sont pas facturés.

Quelle est la précision du résultat ?

Les composantes sont calculées en double précision et arrondies à six décimales. Chaque vecteur de sortie a une norme unitaire et est orthogonal aux autres à cet arrondi près.

L'ordre des vecteurs d'entrée a-t-il de l'importance ?

Oui. Le premier vecteur de sortie est le premier vecteur d'entrée normalisé ; les sorties suivantes sont les restes orthogonalisés dans le même ordre, donc permuter l'entrée donne une base orthonormée différente (et tout aussi valide).

À quoi sert une base orthonormée ?

Elle simplifie presque toute l'algèbre linéaire : les projections se ramènent à des produits scalaires, les coordonnées s'obtiennent directement et les erreurs numériques restent faibles.

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

POSThttps://api.kit.forhosting.com/math/gram-schmidt

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/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)

Exemple de requête

{
  "vectors": [
    [
      1,
      1,
      0
    ],
    [
      1,
      0,
      1
    ],
    [
      0,
      0,
      3
    ]
  ]
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "math.gram_schmidt",
  "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

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Limites

`max_vectors`	50
`max_dimension`	50

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

Collez vos vecteurs ici et obtenez la base orthonormée calculée pas à pas dans votre navigateur, ou appelez l'API pour orthogonaliser des ensembles de vecteurs dans un script, un tableur ou un flux de calcul numérique.

Pourquoi la dépendance linéaire est une erreur, pas un résultat

Ce point de terminaison traite la dépendance comme une violation du contrat : il vérifie, dans l'ordre, si chaque vecteur apporte une nouvelle direction, et si le vecteur k appartient à l'espace engendré par les précédents, il répond par une erreur invalid_input nommant le vecteur fautif — et un appel en erreur n'est pas facturé.

Questions techniques

Quelle entrée attend-il ?

Un champ vectors : un tableau de tableaux de nombres finis, un tableau interne par vecteur, tous de même dimension — jusqu'à 50 vecteurs de dimension 50 au plus.

Puis-je l'utiliser avec des vecteurs complexes ?

Non. Seuls les vecteurs réels sont acceptés ; les entrées doivent être des nombres JSON finis.

Consulter la documentation complète du KIT →

Lancer gratuitement

Ce que le procédé de Gram-Schmidt fait réellement

Pourquoi la dépendance linéaire est une erreur, pas un résultat

Détails pratiques : format d'entrée, précision et limites

Cas d’usage

Orthogonaliser des directions dans un projet graphique ou de simulation

Préparer une base pour une étape de moindres carrés ou de projection

Vérifier des devoirs et des exemples de cours

Questions fréquentes

Outils associés

Pour les développeurs — accès API

Endpoint

Appeler depuis votre stack

Exemple de requête

Exemple de réponse

Tarifs

Limites

Erreurs

Notes techniques

Pourquoi la dépendance linéaire est une erreur, pas un résultat

Questions techniques

merci