Nombres imaginaires dans des tableaux NumPy

Python note la partie imaginaire d’un littéral complexe avec j, comme dans 2j. Les tableaux NumPy peuvent stocker ces valeurs complexes, effectuer des opérations élément par élément et exposer les composantes réelle et imaginaire de chaque valeur. Utilisez des littéraux complexes lorsque les valeurs sont déjà connues ; choisissez un dtype complexe à la création d’un tableau à partir de données réelles si celui-ci doit ensuite contenir des résultats complexes.

Créer des tableaux NumPy avec des nombres complexes

Un nombre imaginaire n’a pas de composante réelle, tandis qu’un nombre complexe associe une composante réelle à une composante imaginaire. Le suffixe j de Python indique la partie imaginaire : 2j est donc purement imaginaire, tandis que 1 + 2j possède les deux composantes. NumPy déduit un type d’élément complexe lorsqu’un tableau est construit à partir de littéraux complexes. C’est utile lorsque les données initiales comprennent déjà les deux composantes.

Exécutez cet exemple :

import numpy as np

values = np.array([1 + 2j, 3 + 4j, 5 + 6j])
print(values)

[1.+2.j 3.+4.j 5.+6.j]

Le tableau contient trois valeurs. Dans chaque élément affiché, le nombre avant le signe est la composante réelle, et le nombre associé à j est la composante imaginaire. L’affichage compact de NumPy représente les valeurs ; il ne change pas la notation j de Python. Conservez le suffixe j sur le terme imaginaire lorsque vous écrivez un littéral. Écrire 1 + 2 à la place produirait un nombre réel ordinaire, car aucun des deux termes n’est indiqué comme imaginaire.

Choisir un dtype complexe lors de l’initialisation d’un tableau

Lorsqu’un tableau commence par des nombres réels, mais doit conserver ensuite des résultats complexes, choisissez un dtype complexe dès son initialisation. Par exemple, np.ones(3, dtype=complex) crée trois éléments complexes initialisés à partir de nombres réels égaux à un. Si NumPy déduit le type à partir de données uniquement réelles, le tableau obtenu a un dtype réel ; l’affectation de valeurs complexes dans un tableau réel ne peut pas conserver leurs composantes imaginaires. Définir le type dès le départ évite cette perte et précise l’usage prévu du tableau.

Ce choix concerne le type des éléments du tableau ; il ne s’agit pas d’une opération distincte pour ajouter une partie imaginaire. Une valeur complexe peut avoir une composante imaginaire nulle tout en appartenant à un tableau de type complexe. À l’inverse, une valeur d’apparence réelle telle que 1.0 ne rend pas à elle seule un tableau complexe. Utilisez dtype=complex lorsque les données sources sont réelles, mais que des calculs ou des affectations ultérieurs nécessitent des nombres complexes. Si les valeurs initiales comportent déjà des composantes imaginaires, utilisez directement des littéraux complexes ; NumPy peut déduire le type complexe à partir de ces valeurs.

Effectuer des opérations arithmétiques sur des tableaux complexes

Lorsque deux tableaux ont des formes compatibles, NumPy applique les opérateurs arithmétiques usuels élément par élément. L’exemple complet suivant crée deux tableaux et calcule leur somme, leur différence, leur produit et leur quotient. Chaque résultat est un nouveau tableau, et la division complexe suit les règles habituelles des nombres complexes. Les entrées sont choisies délibérément pour que les éléments du dénominateur soient non nuls.

Les libellés affichés dans l’exemple — « Addition », « Subtraction », « Multiplication » et « Division » — restent en anglais. Ils désignent respectivement la somme, la différence, le produit et le quotient des deux tableaux.

import numpy as np

left = np.array([1 + 2j, 3 + 4j])
right = np.array([2 + 3j, 4 + 5j])

added = left + right
subtracted = left - right
multiplied = left * right
divided = left / right

print("Addition:", added)
print("Subtraction:", subtracted)
print("Multiplication:", multiplied)
print("Division:", divided)

Addition: [3.+5.j 7.+9.j]
Subtraction: [-1.-1.j -1.-1.j]
Multiplication: [-4. +7.j -8.+31.j]
Division: [0.61538462+0.07692308j 0.7804878 +0.02439024j]

Les tableaux ont la même forme : les éléments correspondants sont donc associés. Le premier élément de left est combiné au premier élément de right, et il en va de même pour le deuxième. Il s’agit d’opérations élément par élément, et non d’une multiplication matricielle. Pour les produits matriciels, utilisez plutôt une opération matricielle adaptée. La division demande de vérifier les dénominateurs : un dénominateur nul ne donne pas de quotient fini. Choisissez donc des entrées adaptées au calcul que vous souhaitez effectuer.

Accéder aux parties réelle et imaginaire

Pour un tableau NumPy complexe, .real et .imag donnent respectivement des vues des tableaux de composantes réelles et imaginaires. Ces attributs sont utiles lorsqu’un calcul ultérieur ne nécessite qu’une seule composante, ou lorsque vous souhaitez examiner séparément les deux parties. Les tableaux de composantes conservent les mêmes positions que le tableau source : l’indice k de chacun correspond à l’indice k du tableau complexe d’origine.

import numpy as np

values = np.array([1 + 2j, 3 + 4j, 5 + 6j])
real_parts = values.real
imaginary_parts = values.imag

print("Real parts:", real_parts)
print("Imaginary parts:", imaginary_parts)

Pour les valeurs de cet exemple, les composantes réelles sont 1, 3 et 5 ; les composantes imaginaires sont 2, 4 et 6. Ces attributs séparent les composantes des valeurs existantes sans modifier le tableau complexe d’origine. Pour construire un tableau complexe à partir de tableaux réel et imaginaire distincts, combinez-les avec real_parts + 1j * imaginary_parts ; veillez à ce que les entrées correspondantes aient des formes compatibles. La construction à partir de littéraux, le choix explicite d’un dtype complexe, les opérateurs élément par élément et l’accès aux composantes couvrent les étapes courantes pour utiliser des valeurs imaginaires dans des tableaux NumPy.