Calculateur de multiplication matricielle
Multipliez une matrice 2 × 3 par une matrice 3 × 2 et obtenez un produit 2 × 2 : les lignes 1, 2, 3 et 4, 5, 6 fois les lignes 7, 8 ; 9, 10 ; 11, 12 donnent 58, 64 et 139, 154. 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.
Ce calculateur de multiplication matricielle multiplie deux matrices réelles et renvoie la matrice produit complète lorsque les formes sont compatibles. Vous fournissez une matrice de gauche A à m lignes et n colonnes et une matrice de droite B à n lignes et p colonnes ; le moteur forme C égal à A fois B, de taille m par p, selon la définition standard où chaque entrée C[i][j] est la somme sur k de A[i][k] fois B[k][j]. Une vérification classique est la matrice deux par trois de lignes [1, 2, 3] et [4, 5, 6] multipliée par la matrice trois par deux de lignes [7, 8], [9, 10] et [11, 12], qui donne [[58, 64], [139, 154]]. Le chemin de calcul est une arithmétique purement déterministe : aucun appel réseau, aucun échantillonnage et aucun raccourci dépendant de la date.
Comment les matrices sont lues et comment le produit reste fini et reproductible
Chaque matrice est un tableau de lignes, et chaque ligne est un tableau de nombres décimaux finis ; la notation scientifique est autorisée, tandis que les chaînes vides, les objets et les jetons non numériques sont rejetés avec un chemin de champ clair, pour qu'une mauvaise cellule ne se transforme pas en mauvaise entrée du produit. Une précision optionnelle entre zéro et quinze décimales arrondit chaque entrée publiée du produit pour un affichage stable ; la valeur par défaut est dix.
Le calcul utilise la triple boucle imbriquée du manuel : pour chaque indice de ligne i et de colonne j en sortie, on accumule la somme de A[i][k] fois B[k][j] pour k allant de zéro à n moins un. Les sommes intermédiaires qui deviennent non finies sont rejetées plutôt que renvoyées sous forme d'Infinity ou de NaN.
Où le produit matriciel intervient dans les études, le code et la modélisation
Les élèves rencontrent la multiplication matricielle lorsqu'une unité d'algèbre linéaire introduit les applications linéaires, lorsqu'un manuel leur demande de multiplier à la main de petites matrices à coefficients entiers, ou lorsqu'ils ont besoin d'une seconde méthode pour vérifier un devoir après avoir développé chaque produit scalaire ligne-colonne. Les enseignants peuvent pré-générer des corrigés pour de petits produits entiers sans se fier à des applications de calcul opaques qui cachent les dimensions intermédiaires ou autorisent silencieusement des formes incompatibles.
Les développeurs appellent le même contrat depuis des scripts pour amorcer des vecteurs de test déterministes destinés à des transformations graphiques, à de petites couches de réseau de neurones écrites à la main, à des blocs de contraintes qui composent des applications affines, ou à des plateformes pédagogiques qui doivent afficher la matrice produit aux côtés des facteurs.
La pratique des concours a souvent besoin d'un produit matriciel rapide et hors ligne, afin que les solutions puissent être vérifiées sans écrire une bibliothèque d'algèbre linéaire complète sous la pression du temps. Les analystes et ingénieurs utilisent des produits à deux facteurs lorsqu'un petit modèle se réduit à la composition d'applications linéaires, et qu'ils préfèrent un chemin explicite et documenté plutôt qu'un appel BLAS opaque pour des matrices tenant en quelques dizaines de lignes.
Associez-le aux solveurs de systèmes 3×3 ou à d'autres points de terminaison d'algèbre lorsque vous construisez un petit laboratoire d'outils d'algèbre linéaire gratuits et déterministes, et aux outils de combinatoire lorsque vous avez besoin de comptages discrets connexes plutôt que d'arithmétique matricielle continue.
Cas d’usage
Devoirs et corrigés d'examen
Multipliez des matrices A et B de manuel, vérifiez la forme du produit m×p, et validez chaque entrée par rapport aux sommes ligne-colonne calculées à la main.
Données de référence déterministes pour l'intégration continue
Générez des matrices produit reproductibles pour les tests unitaires, sans maintenir à la main les développements de triple boucle ou les vérifications de dimension.
Vérifications de petites transformations et de modèles
Composez de petites applications linéaires ou transformations de caractéristiques lorsque les deux facteurs tiennent dans les limites publiées de lignes et de colonnes.
Questions fréquentes
Combien coûte le calculateur de multiplication matricielle ?
Il est gratuit dans votre navigateur sur cette page.
Quand deux matrices sont-elles compatibles pour la multiplication ?
Le nombre de colonnes de la première matrice doit égaler le nombre de lignes de la seconde.
Quelle est la forme du produit ?
Si A est m×n et B est n×p, le produit C est m×p. Chaque C[i][j] est la somme sur k de A[i][k] fois B[k][j].
La multiplication matricielle est-elle commutative ?
Non, en général. Même lorsque A×B et B×A existent tous deux, ils ne sont pas nécessairement égaux. Cet outil calcule toujours A×B dans cet ordre.
Quelles tailles de matrices sont prises en charge ?
Chaque facteur peut avoir jusqu'à 50 lignes et 50 colonnes, chaque entrée restant dans le plafond de grandeur publié. Les formes plus grandes sont rejetées.
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/algebra/matrix-multiply \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"a":[[1,2,3],[4,5,6]],"b":[[7,8],[9,10],[11,12]]}'const res = await fetch("https://api.kit.forhosting.com/algebra/matrix-multiply", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"a": [
[
1,
2,
3
],
[
4,
5,
6
]
],
"b": [
[
7,
8
],
[
9,
10
],
[
11,
12
]
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/algebra/matrix-multiply",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"a": [
[
1,
2,
3
],
[
4,
5,
6
]
],
"b": [
[
7,
8
],
[
9,
10
],
[
11,
12
]
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/matrix-multiply", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"a":[[1,2,3],[4,5,6]],"b":[[7,8],[9,10],[11,12]]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"a":[[1,2,3],[4,5,6]],"b":[[7,8],[9,10],[11,12]]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/matrix-multiply", 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
{
"a": [
[
1,
2,
3
],
[
4,
5,
6
]
],
"b": [
[
7,
8
],
[
9,
10
],
[
11,
12
]
]
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.matrix_multiply",
"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 | 50 |
max_cols | 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
Si le nombre de colonnes de la première matrice n'est pas égal au nombre de lignes de la seconde, la requête est rejetée avec un message clair invalid_input, plutôt que d'inventer un produit complété ou tronqué. Utilisez-le gratuitement dans le navigateur pour vos devoirs, votre préparation aux examens et vos katas de programmation, ou appelez l'API à $0.002 par requête réussie lorsque vous avez besoin de données de référence de produits matriciels reproductibles en intégration continue, en démonstration pédagogique ou pour des vérifications de notes automatisées.
Ce que signifie la multiplication matricielle et ce que contient la réponse
La multiplication matricielle combine un facteur de gauche A de forme m par n avec un facteur de droite B de forme n par p pour donner un produit C de forme m par p. La compatibilité est stricte : les dimensions internes doivent correspondre, si bien que le nombre de colonnes de A doit égaler le nombre de lignes de B ; sinon, aucun produit n'est défini selon les règles usuelles de l'algèbre linéaire. Chaque entrée de C est un produit scalaire d'une ligne de A avec une colonne de B, ce qui explique pourquoi l'opération est associative dans le cas compatible à plusieurs facteurs, mais non commutative en général — A fois B n'a pas besoin d'être égal à B fois A, même lorsque les deux produits existent. Ce calculateur renvoie la matrice produit avec chaque entrée arrondie à la précision demandée, les facteurs A et B en écho, les quatre nombres de forme rows_a, cols_a, rows_b et cols_b, les dimensions du produit, la précision utilisée, une courte chaîne formula documentant la règle de la triple boucle, ainsi que les maxima publiés afin que les clients puissent valider avant d'envoyer un lot. Il n'existe aucune multiplication aléatoire approximative présentée comme exacte, ni de complément silencieux de dimensions internes inégales : le moteur construit soit le produit exact en virgule flottante dans la plage prise en charge, soit rejette l'entrée avec invalid_input. Les cas rejetés incluent l'absence de A ou de B, des lignes qui ne sont pas des tableaux, des matrices non rectangulaires irrégulières, des lignes vides, des cellules non finies, des grandeurs supérieures au plafond publié, des matrices plus grandes que les limites de lignes ou de colonnes, et toute paire dont les colonnes de la première ne correspondent pas aux lignes de la seconde. Si vous avez besoin de déterminants, d'inverses, de décompositions en valeurs propres ou d'un solveur linéaire 3×3, utilisez les outils dédiés à cela ; cette page ne répond qu'au produit de deux matrices, avec une sortie en virgule flottante arrondie adaptée aux fiches d'exercices, aux tests unitaires et aux clients de l'API qui ne doivent pas inventer un résultat incompatible en forme.
Comment les matrices sont lues et comment le produit reste fini et reproductible
Les champs privilégiés sont a pour la matrice de gauche et b pour la matrice de droite, mais les alias matrix_a, left et A pour le premier facteur, et matrix_b, right et B pour le second, sont acceptés, afin que les feuilles de calcul, les chaînes de requête et les formulaires typés puissent réutiliser le même contrat. Le moteur impose des maxima stricts de cinquante lignes et cinquante colonnes pour chaque facteur, ainsi qu'un plafond de grandeur pour chaque entrée, afin que les exécutions en périphérie de Worker et dans le navigateur gratuit restent dans un budget numérique prévisible, même si la triple boucle est cubique par rapport à la dimension interne partagée. Associez l'exécution gratuite dans le navigateur sur cette page à l'API payante lorsque vous avez besoin du même résultat mathématique au sein d'un pipeline automatisé, sans réimplémenter vous-même les vérifications de dimension et la triple boucle.
Où le produit matriciel intervient dans les études, le code et la modélisation
Sur cette page, le travail s'exécute entièrement dans votre navigateur ; via l'API, chaque produit réussi coûte $0.002, la validation échouée n'est pas facturée, et rien n'est conservé après le renvoi de la réponse. Cette séparation — exploration interactive gratuite et API payante identique — correspond au reste du catalogue de niveau A de KIT, et vous permet de passer d'une démonstration en classe à un pipeline automatisé sans changer le résultat mathématique.