Numpy complexe Numpy

Nous savons que les nombres complexes sont ceux représentés par le A + BI conventionnel, où «A» est toujours un nombre réel; «B» est également un nombre réel mais «i» est un composant imaginaire. Une autre chose que nous savons est «i ^ 2 = -1» car aucun des nombres réels ne peut satisfaire cette équation que nous appelons «je» une partie imaginaire. Numpy prend en charge les nombres réels ainsi que les nombres imaginaires. Dans Numpy, les nombres imaginaires sont représentés par «J». Il existe différentes façons de créer et de manipuler des tableaux ayant des nombres complexes comme NP.complex (), np.range (), np.array (), et plus.

Syntaxe

La syntaxe pour créer un tableau contenant des nombres complexes est la suivante:

Méthode 1:

1J * np.Arange (taille)

La syntaxe donnée au-dessus de 1J est la partie imaginaire qui signifie que nous créons un tableau de nombres complexes, où NP.disposition est la fonction fournie par Numpy pour créer un tableau sur une plage spécifiée. La taille, qui indique la taille du tableau, est transmise à la fonction.

Méthode 2:

NP.Array ([re + re * im, re + re * im,…])

Dans cette syntaxe, NP.Arrray est la fonction qui nous permet de créer un tableau mais nous ne pouvons pas y passer la plage. Nous passons simplement des valeurs «n» fois. Dans la fonction, nous avons passé «RE», ce qui indique des nombres réels les ajoutant à «im» un nombre imaginaire en plusieurs de nombre réel. Nous pouvons transmettre des valeurs imaginaires à n fois.

Exemple # 01:

Comme nous le savons, Numpy prend également en charge des nombres complexes et fournit plusieurs variétés de méthodes pour implémenter et manipuler des nombres complexes. Dans l'exemple ci-dessous, nous implémenterons deux façons de créer des tableaux contenant des nombres complexes. Pour implémenter les fonctions Numpy, importez d'abord la bibliothèque Numpy en tant que NP. Ensuite, nous initialiserons un tableau nommé «array_a» auquel nous attribuons la fonction NP.arange () qui contiendra les nombres complexes. Et la gamme du tableau sera «8». Dans la ligne suivante, nous avons créé un autre tableau nommé "Array_B" auquel nous avons passé un tableau de nombres complexes en passant directement les valeurs complexes. En fin de compte, nous avons imprimé le tableau complexe que nous avons créé en utilisant les deux méthodes.

Importer Numpy comme NP
array_a = 1j * np.Arange (8)
array_b = np.Array ([2 + 1j, 3 + 4j, 5 ​​+ 2j, 1 + 6j])
print ("Array complexe à l'aide de la fonction Arange ()", array_a)
imprimer ("tableau complexe à l'aide de NP.array () function ", array_b)

Comme indiqué dans l'extrait ci-dessous est le résultat du code que nous avons exécuté. Nous pouvons voir que nous avons créé deux tableaux qui ont une gamme de nombres complexes de 0J à 7J. Dans l'autre, nous avons passé la gamme aléatoire de nombres complexes de taille 4.

Méthode 3:

NP.complexe (re + re * im)

Dans la syntaxe donnée ci-dessus, np.Complex () est la classe intégrée fournie par le package Python Numpy qui nous permet de stocker des valeurs complexes.

Exemple # 02:

Une autre façon de créer un tableau complexe Numpy est d'utiliser la classe complexe de Numpy (). Class Class () est utilisé pour stocker des nombres complexes et renvoie l'objet complexe que nous pouvons utiliser plusieurs fois dans le code unique. Implémentation maintenant de la classe complexe (), nous importerons d'abord notre package Numpy. Ensuite, nous initialiserons un tableau auquel nous avons passé une classe complexe qui utilise un «*» astérisque pour passer un objet de classe complexe () à laquelle nous avons passé «3 + 1J». En utilisant la fonction arrange (), nous avons créé un tableau de taille 5. Enfin, nous avons juste affiché la sortie du code dans lequel nous avons créé un tableau complexe en utilisant la classe complexe ().

Importer Numpy comme NP
array = np.complexe (3 + 1j) * np.Arange (5)
imprimer ("tableau complexe à l'aide de NP.complex () classe ", array)

Comme le montre la figure ci-dessous, nous avons créé un tableau de nombres complexes. Mais une autre chose que nous pouvons remarquer sur la figure est que la valeur constante n'est pas exécutée consécutivement parce que nous avons passé «3 + 1j» à une classe complexe (), ce qui signifie qu'un numéro trois sera ajouté à toutes les prochaines valeurs constantes.

Méthode 4:

NP.ceux (forme, dtype = aucun, ordre = 'c', *, comme = aucun)

Dans cette méthode NP.Ones (), nous spécifions un tableau de nombres complexes en utilisant le paramètre DTYPE dans le tableau Numpy. NP.One () est utilisé pour retourner un nouveau tableau contenant 1. À la fonction np.Ones (), nous avons passé quatre paramètres «forme», qui est utilisé pour définir la forme du tableau, qu'il soit «2», «3» ou bien. Le «dtype» est le type de données. Dans notre cas, nous utiliserons un type de données complexe. «L'ordre» définit si le tableau est unidimensionnel, deux ou multidimensionnels.

Exemple # 03:

Laissez-nous implémenter la méthode Ones () pour avoir une meilleure idée de son fonctionnement tout en utilisant des nombres complexes. Pour implémenter cette méthode, importez d'abord nos packages de Numpy qui sont fournis par Python. Ensuite, nous créerons un tableau auquel nous passerons le NP.une fonction () à laquelle nous avons passé deux paramètres. Le premier est «4», ce qui signifie que la taille du tableau sera 4 et la seconde est «dtype» qui est complexe. Cela signifie que nous allons créer un tableau de nombres complexes de type de données. Multiplier la fonction U 1 () avec la valeur "2" signifie que notre nombre réel sera "2". En fin de compte, nous avons imprimé le tableau que nous avons créé en utilisant l'instruction PRINT.

Importer Numpy comme NP
array = np.ceux (4, dtype = complexe) * 2
imprimer ("tableau complexe à l'aide de NP.une fonction () ", array)

Comme indiqué ci-dessous, la sortie de notre code est exécutée avec succès dans laquelle nous avons un tableau unidimensionnel qui contient 4 valeurs complexes avec un nombre réel 2.

Exemple # 04:

Laissez-nous maintenant un autre exemple dans lequel nous allons créer un tableau de nombres complexes et imprimerons les parties imaginaires et réelles des nombres complexes. Nous importerons d'abord la bibliothèque Numpy, puis créerons un tableau auxquels nous avons transmis des valeurs complexes «6» à un tableau nommé «tableau» qui est «56 + 0j, 27 + 0j, 68 + 0j, 49 + 0j, 120 + 0j , 4 + 0j ”. Dans la ligne suivante, nous avons simplement imprimé le tableau. Maintenant, nous imprimons les valeurs imaginaires et réelles du tableau complexe.

Numpy fournit une fonction intégrée pour les deux opérations qui sont présentées ci-dessous. Le premier à obtenir la partie imaginaire est «array_name.Imag ”où la valeur avant le point est le tableau à partir duquel nous devons obtenir la partie imaginaire. Et le second pour obtenir la vraie partie est "array_name.réel". Dans notre cas, le nom d'un tableau est «tableau», nous avons donc réussi l'instruction d'impression, le nom du tableau et le mot-clé pour obtenir les deux éléments.

Importer Numpy comme NP
array = np.Array ([56.+0.J, 27.+0.J, 68.+0.J, 49.+0.J, 120.+0.J, 3 + 4.J])
Print ("Array Original: X", tableau)
Print ("Partie réelle du tableau:")
imprimer (tableau.réel)
Imprimer ("partie imaginaire du tableau:")
imprimer (tableau.imaginer

Comme le montre l'extrait ci-dessous, la sortie dans laquelle l'imaginaire et la partie réelle du tableau complexe sont exécutées avec succès. Où les vrais parties sont «56», «27», «68», «120» et «3». Et les parties imaginaires sont «0».

Conclusion

Dans cet article, nous avons brièvement discuté des nombres complexes et comment nous pouvons créer des tableaux complexes en utilisant les fonctions intégrées de Numpy. Nous avons décrit plusieurs fonctions qui nous permettent de créer des tableaux complexes en implémentant plusieurs exemples pour mieux comprendre.