ForHosting KIT · Mathématiques

Calculateur de convolution

Faites glisser une suite sur l'autre et additionnez les produits à chaque position : [1; 2; 3] avec [0,5; 0,5] donne [0,5; 1,5; 2,5; 1,5]. Tous les chevauchements partiels sont conservés, le résultat compte donc n + m − 1 valeurs. 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

Exemple résolu

Si vous saisissez

Premier texte: 1, 2, 3
Second texte: 0,5, 0,5

Vous obtenez

Longueur de a: 3
Longueur de b: 2
Longueur: 4
Séquence: 0,5, 1,5, 2,5, 1,5

La convolution discrète est l'opération fondamentale du traitement du signal et des mathématiques appliquées : elle fait glisser une suite finie sur une autre et, à chaque recouvrement, multiplie les valeurs alignées puis additionne les produits. Étant données deux suites a de longueur n et b de longueur m, ce calculateur renvoie leur convolution linéaire complète, une nouvelle suite de longueur n plus m moins un dont la k-ième valeur est la somme des a[i] fois b[j] sur chaque paire d'indices vérifiant i plus j égal à k. C'est le même calcul qui sous-tend le filtrage FIR, les moyennes mobiles, la multiplication de polynômes et les distributions de probabilité des sommes de dés indépendants. Les deux suites doivent contenir au moins une valeur et chaque valeur doit être un nombre fini ; les suites vides et les entrées non finies comme NaN ou Infinity sont rejetées avec une erreur de validation claire.

Ce que signifie la convolution discrète et comment elle se calcule

La convolution répond à une question simple : si vous inversez une suite, la faites glisser sur l'autre et, à chaque alignement, multipliez les paires qui se recouvrent puis additionnez les produits, quel nombre lit-on à chaque position ? Formellement, pour des suites a de longueur n et b de longueur m, la convolution c égale à a étoile b est la suite de longueur n plus m moins un définie par c[k] égal à la somme des a[i] fois b[k moins i] sur chaque i valide.

Un exemple concret rend cela tangible : convoluer [1, 2, 3] avec [0.5, 0.5] donne [0.5, 1.5, 2.5, 1.5], car chaque échantillon de sortie est la moyenne d'un échantillon d'entrée et de son voisin, avec des poids réduits de moitié aux bords. Ce mode « complet », celui que renvoie cet outil, conserve tous les recouvrements partiels, y compris les positions à contact unique aux deux extrémités.

L'algorithme direct utilisé ici effectue n fois m étapes de multiplication-accumulation, ce qui est instantané pour les suites rencontrées dans l'enseignement, la conception de filtres et l'analyse de données. Il est utile de savoir que la convolution est commutative, donc a étoile b égale b étoile a, et associative, de sorte que des lissages enchaînés peuvent être réordonnés sans changer le résultat. L'opération se distribue aussi sur l'addition, raison pour laquelle la théorie des systèmes linéaires s'appuie tant sur elle.

Entrées, limites et règles de validation

Le calculateur accepte deux champs, a et b, chacun un tableau non vide de nombres. Les valeurs peuvent être entières, décimales ou négatives, et les chaînes numériques en notation scientifique comme 1.5e-3 sont converties en toute sécurité. Deux règles strictes protègent le contrat.

Premièrement, aucune suite ne peut être vide : une entrée de longueur nulle n'a pas de convolution et est rejetée au lieu d'être traitée silencieusement comme une impulsion nulle. Deuxièmement, chaque élément doit être un nombre fini ; NaN, Infinity et les valeurs qui déborderaient vers des résultats non finis pendant l'accumulation sont refusés avec un message nommant le champ et l'indice fautifs.

Chaque suite est limitée à 4096 éléments, ce qui maintient la boucle directe O(n·m) confortablement dans le budget de calcul tout en couvrant tous les usages pédagogiques et d'ingénierie réalistes.

Où la convolution est utilisée en pratique

La convolution apparaît dans bien plus d'endroits que son nom ne le suggère. En traitement numérique du signal, c'est la manière d'appliquer un filtre à réponse impulsionnelle finie : le noyau b contient les poids des coefficients et la sortie est le signal filtré, de sorte qu'une moyenne mobile de largeur trois est simplement la convolution avec [1/3, 1/3, 1/3].

En probabilités, la distribution de la somme de deux variables aléatoires discrètes indépendantes est la convolution de leurs fonctions de masse ; convoluer la distribution uniforme d'un dé avec elle-même produit la célèbre distribution triangulaire de deux dés. En algèbre, multiplier deux polynômes revient exactement à convoluer leurs listes de coefficients, ce qui fait de cet outil un vérificateur rapide pour les devoirs symboliques. En traitement d'images, les noyaux bidimensionnels séparables s'appliquent comme deux convolutions unidimensionnelles successives.

Même l'écho et la réverbération en audio sont des convolutions avec une réponse impulsionnelle enregistrée dans une salle réelle. Partout où la sortie d'un système est une superposition décalée et mise à l'échelle de son entrée, la convolution est l'opération qui la décrit.

Cas d’usage

Appliquer un filtre FIR à un signal échantillonné

Saisissez vos échantillons comme suite a et les poids des coefficients du filtre comme suite b pour obtenir la sortie filtrée. Un noyau de lissage comme [0.25, 0.5, 0.25] supprime le bruit haute fréquence sans aucune bibliothèque de traitement du signal.

Distribution de la somme de dés

Convolvez la fonction de masse d'un dé équilibré avec elle-même pour obtenir les probabilités exactes de la somme de deux dés, puis convolvez à nouveau pour trois dés. Chaque étape est un appel avec des nombres finis et vérifiables.

Multiplier des polynômes avec vérification manuelle

Comme la multiplication de polynômes est la convolution des listes de coefficients, saisissez les coefficients des deux facteurs et comparez la suite de sortie avec votre développement symbolique pour repérer instantanément les erreurs de signe et d'alignement.

Questions fréquentes

Quelle est la longueur de la suite convoluée ?

Si la suite a contient n valeurs et la suite b en contient m, la convolution complète en contient n + m - 1.

L'ordre des deux suites a-t-il une importance ?

Par convention, le signal le plus long va dans a et le noyau le plus court dans b.

Pourquoi mon entrée a-t-elle été rejetée ?

Les deux règles strictes sont : aucune suite ne peut être vide et chaque élément doit être un nombre fini. NaN, Infinity ou les résultats qui débordent pendant l'accumulation sont rejetés avec une erreur nommant le champ et l'indice de la valeur fautive.

S'agit-il d'une convolution circulaire ou linéaire ?

Cet outil calcule la convolution linéaire complète avec remplissage de zéros aux deux extrémités, le même résultat que la sommation directe. Il n'enroule pas les suites comme le fait la convolution circulaire (cyclique).

Existe-t-il une limite de taille ?

Chaque suite peut contenir jusqu'à 4096 nombres finis.

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

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/convolution \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"a":[1,2,3],"b":[0.5,0.5]}'

const res = await fetch("https://api.kit.forhosting.com/math/convolution", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "a": [
      1,
      2,
      3
    ],
    "b": [
      0.5,
      0.5
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/math/convolution",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "a": [
        1,
        2,
        3
    ],
    "b": [
        0.5,
        0.5
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/convolution", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"a":[1,2,3],"b":[0.5,0.5]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"a":[1,2,3],"b":[0.5,0.5]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/convolution", 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
  ],
  "b": [
    0.5,
    0.5
  ]
}

Exemple de réponse

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

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'outil gratuit du navigateur et l'API payante exécutent la même fonction pure, de sorte que les résultats ne divergent jamais d'un canal à l'autre.

Entrées, limites et règles de validation

L'objet de sortie rapporte length_a, length_b, la longueur de sortie et la suite convoluée elle-même sous la clé sequence, afin que les scripts puissent vérifier les tailles sans les recalculer.

Où la convolution est utilisée en pratique

La voie API coûte $0.002 par requête, tandis que l'outil du navigateur exécute les mêmes mathématiques gratuitement.

Questions techniques

Combien coûte l'API ?

Le calculateur du navigateur est gratuit et illimité. Appeler la même capacité via l'API coûte $0.002 par requête ; les deux canaux exécutent la même fonction déterministe.

Consulter la documentation complète du KIT →

Lancer gratuitement

Exemple résolu

Ce que signifie la convolution discrète et comment elle se calcule

Entrées, limites et règles de validation

Où la convolution est utilisée en pratique

Cas d’usage

Appliquer un filtre FIR à un signal échantillonné

Distribution de la somme de dés

Multiplier des polynômes avec vérification manuelle

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

Entrées, limites et règles de validation

Où la convolution est utilisée en pratique

Questions techniques

merci