Nombre complexe en forme algébrique : parties réelle et imaginaire
Transformez un module et un argument en a + bi : un module de 2 à 60 degrés donne une partie réelle de 1 et une partie imaginaire d'environ 1,732. Indiquez l'angle en radians ou en degrés, sans conversion à part. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Module
- 2 deg
- Argument
- 45
- Partie réelle
- 1,4142135624 deg
- Partie imaginaire
- 1,4142135624
Le convertisseur de nombre complexe vers la forme algébrique prend un nombre complexe donné sous forme polaire, c'est-à-dire par son module et son argument, et renvoie sa forme algébrique : la partie réelle et la partie imaginaire de l'expression équivalente a + bi. Le module doit être un nombre fini et positif ou nul, et l'argument doit être fini ; toute autre valeur est rejetée avec une erreur de validation claire.
Du module et de l'argument vers a + bi
La forme algébrique décrit le même nombre par ses coordonnées : une partie réelle a et une partie imaginaire b, notées a + bi. Passer du polaire à l'algébrique est une application directe de la trigonométrie, car le module est l'hypoténuse d'un triangle rectangle dont les côtés sont exactement les deux parties : la partie réelle vaut donc r fois le cosinus de thêta et la partie imaginaire r fois le sinus de thêta.
Par exemple, un module de 2 avec un argument de 60 degrés donne une partie réelle de 2 fois un demi, soit 1, et une partie imaginaire de 2 fois la racine carrée de trois sur deux, environ 1.732.
Envoyer le module et l'argument à ce convertisseur de nombre complexe vers la forme algébrique renvoie les deux parties en un seul appel, l'étape nécessaire après une multiplication, une division ou un calcul de puissances et de racines en forme polaire, car ces opérations sont simples en coordonnées polaires alors que la plupart des affichages, formules et outils en aval attendent la forme habituelle a + bi. Les deux parties renvoyées sont arrondies à douze décimales pour que les résultats soient identiques à l'octet près d'une machine à l'autre.
Radians ou degrés, un seul appel, sans étape supplémentaire
En mathématiques comme en ingénierie, les angles arrivent dans deux unités différentes, et choisir la mauvaise fausse silencieusement tout le calcul : pi sur quatre radians et 45 degrés désignent la même direction, mais passer 45 à un cosinus qui attend des radians produit un résultat sans signification. Ce convertisseur élimine ce piège en acceptant un champ d'unité explicite.
Comme la conversion, le cosinus et le sinus se déroulent dans la même fonction déterministe, il n'y a qu'un seul point d'arrondi et les exemples de référence publiés vérifient le résultat octet par octet à chaque modification.
Validation, déterminisme et cas d'usage
Un module nul est un cas particulier accepté à dessein : le nombre se réduit à l'origine, le convertisseur renvoie donc 0 + 0i quel que soit l'argument, ce qui garde les traitements complets et prévisibles. Le calcul est une poignée d'opérations en virgule flottante, sans accès réseau, sans aléa et sans horloge : la même entrée donne toujours une sortie identique à l'octet près.
Parmi les utilisateurs typiques figurent les outils d'électrotechnique qui transforment un phaseur donné en amplitude et phase en résistance plus réactance, le code de traitement du signal qui reconvertit un spectre amplitude-phase en bins réels et imaginaires d'une FFT, les systèmes de contrôle qui traduisent entre représentations de la réponse en fréquence, et les étudiants qui vérifient la forme algébrique après avoir appliqué la formule de De Moivre.
Cas d’usage
Électrotechnique et phaseurs
Transformez un phaseur alternatif donné en amplitude et angle de phase en degrés en forme algébrique (résistance plus réactance, ou parties réelle et imaginaire d'une tension) pour les calculs de circuits.
Traitement du signal
Reconstituez les parties réelle et imaginaire d'un bin de FFT à partir d'un spectre amplitude-phase après filtrage ou égalisation, avec l'angle fourni en radians.
Devoirs et enseignement des mathématiques
Vérifiez la forme algébrique d'un nombre complexe après un calcul de puissances ou de racines avec la formule de De Moivre, dont le résultat sort naturellement sous forme polaire.
Questions fréquentes
Combien cela coûte-t-il ?
La même conversion est gratuite dans votre navigateur sur cette page.
Pourquoi un module négatif est-il une erreur ?
En forme polaire, le module est une distance depuis l'origine, il ne peut donc pas être négatif. Si votre calcul a produit une valeur négative, changez-en le signe et ajoutez pi radians (180 degrés) à l'argument.
Quelles entrées sont rejetées ?
Tout ce qui n'est pas un nombre fini : champs manquants, null, booléens, tableaux, chaînes vides ou non numériques, NaN et Infinity, ainsi que tout module négatif. Les chaînes numériques comme "2.5" sont acceptées.
Comment passer de la forme polaire à la forme algébrique ?
La partie réelle vaut le module multiplié par le cosinus de l'angle, et la partie imaginaire le module multiplié par le sinus. Avec un module de 2 et un angle de 60 degrés, on obtient 1 et environ 1,732.
Puis-je saisir l'angle en degrés ?
Oui, il suffit de choisir les degrés. Si vous ne précisez rien, l'angle est lu en radians. Cela évite le piège classique d'un cosinus qui attend des radians et reçoit des degrés.
Pourquoi revenir à la forme algébrique après un calcul en polaire ?
Multiplier, diviser ou élever à une puissance est simple en forme polaire, mais la plupart des affichages, formules et outils attendent la forme a + bi. La conversion ramène le résultat dans ce format familier.
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/math/complex-number-to-rectangular-form \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"modulus":2,"argument":45}'const res = await fetch("https://api.kit.forhosting.com/math/complex-number-to-rectangular-form", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"modulus": 2,
"argument": 45
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/complex-number-to-rectangular-form",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"modulus": 2,
"argument": 45
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/complex-number-to-rectangular-form", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"modulus":2,"argument":45}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"modulus":2,"argument":45}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/complex-number-to-rectangular-form", 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
{
"modulus": 2,
"argument": 45
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.complex_number_to_rectangular_form",
"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.
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
La partie réelle est le module multiplié par le cosinus de l'argument et la partie imaginaire est le module multiplié par le sinus, et l'argument peut être fourni en radians ou en degrés, sans jamais avoir besoin d'une étape de conversion d'unité séparée. La même conversion s'exécute gratuitement dans votre navigateur sur cette page, et le code identique sert l'API payante à $0.002 par requête.
Du module et de l'argument vers a + bi
Un nombre complexe sous forme polaire est décrit par une distance et une direction : le module r indique à quelle distance du centre du plan complexe se trouve le nombre, et l'argument thêta donne l'angle mesuré dans le sens trigonométrique depuis l'axe des réels positifs.
Radians ou degrés, un seul appel, sans étape supplémentaire
Passez "rad" ou omettez le champ et l'argument est lu en radians, l'unité naturelle de la formule d'Euler, des fonctions trigonométriques de tout langage de programmation et de la plupart des mathématiques universitaires. Passez "deg" et l'argument est lu en degrés, l'unité des plans d'ingénierie, des diagrammes de phaseurs, des caps de navigation et des devoirs, et le convertisseur multiplie par pi sur 180 avant de calculer le cosinus et le sinus. L'unité choisie est renvoyée dans la réponse avec le module et l'argument fournis, de sorte qu'un journal ou une ligne de tableur conserve toujours l'interprétation utilisée, et toute autre valeur du champ d'unité est rejetée avec une erreur de validation plutôt que devinée.
Validation, déterminisme et cas d'usage
Le module doit être un nombre fini supérieur ou égal à zéro, car une distance négative n'a pas de sens en forme polaire, et l'argument doit être un nombre fini ; le point d'accès accepte les nombres JSON et les chaînes numériques telles que "2.5" ou "-30", pratique quand les valeurs proviennent de champs de formulaire web, mais il rejette les null, les chaînes vides, les booléens, les tableaux, le texte NaN et toute valeur infinie, en répondant par une erreur d'entrée invalide qui nomme le champ fautif au lieu de produire silencieusement des coordonnées absurdes. Il s'exécute en périphérie en quelques millisecondes, ne conserve rien après la réponse et coûte $0.002 par requête via l'API, tout en restant gratuit en utilisation interactive dans le navigateur.
Questions techniques
Que renvoie exactement le convertisseur ?
La partie réelle, la partie imaginaire, ainsi que le module, l'argument et l'unité renvoyés, le tout arrondi à douze décimales : real = modulus*cos(argument), imag = modulus*sin(argument).
Puis-je donner l'angle en degrés ?
Oui. Passez l'unité "deg" et l'argument est lu en degrés ; passez "rad" ou omettez l'unité et il est lu en radians. Toute autre valeur d'unité est rejetée.
Que se passe-t-il quand le module vaut zéro ?
Le nombre est l'origine quel que soit l'angle : le convertisseur renvoie donc 0 + 0i pour tout argument fini au lieu d'échouer.