Syntaxe
La syntaxe de création d'un tableau contenant des nombres complexes est la suivante :
Méthode 1 :
1j * np. arranger ( Taille )La syntaxe donnée ci-dessus 1j est la partie imaginaire, ce qui signifie que nous créons un tableau de nombres complexes, où np.arrang est la fonction fournie par NumPy pour créer un tableau dans une plage spécifiée. La taille, qui indique la taille du tableau, est transmise à la fonction.
Méthode 2 :
par exemple. déployer ( [ Ré+Ré*Je , Ré+Ré*Je , … ] )Dans cette syntaxe, np.arrray est la fonction qui nous permet de créer un tableau mais nous ne pouvons pas lui transmettre la plage. Nous lui passons simplement des valeurs 'n' fois. Dans la fonction, nous avons passé 'Re' qui indique des nombres réels en les ajoutant à 'Im' un nombre imaginaire en multiple d'un nombre réel. On peut passer des valeurs imaginaires à n fois.
Exemple #01 :
Comme nous le savons, NumPy prend également en charge les 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 allons implémenter deux manières de créer des tableaux contenant des nombres complexes. Pour implémenter les fonctions NumPy, importons d'abord la bibliothèque NumPy en tant que np. Ensuite, nous allons initialiser un tableau nommé « array_a » auquel nous assignons la fonction np.arange() qui contiendra les nombres complexes. Et la plage 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 lui 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 par exemple.
tableau_a = 1j * np. arranger ( 8 )
tableau_b = par exemple. déployer ( [ deux +1j , 3 +4j , 5 +2j , 1 +6j ] )
imprimer ( 'tableau complexe utilisant la fonction arange()' , tableau_a )
imprimer ( 'tableau complexe utilisant la fonction np.array()' , tableau_b )
Comme le montre 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 plage de nombres complexes de 0j à 7j. Dans l'autre, nous avons passé le domaine aléatoire des nombres complexes de taille 4.
Méthode 3 :
par exemple. complexe ( Ré+Ré*Je )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 consiste à utiliser la classe complex() de NumPy. La classe complexe () est utilisée pour stocker des nombres complexes et renvoie l'objet complexe que nous pouvons utiliser plusieurs fois dans le code unique. Implémentant maintenant la classe complex (), nous allons d'abord importer notre package Numpy. Ensuite, nous allons initialiser un tableau auquel nous avons passé une classe complexe qui utilise un astérisque « * » pour passer un objet de la classe complex() à laquelle nous avons passé « 3+1j ». En utilisant la fonction arrange(), nous avons créé un tableau de taille 5. Enfin, nous venons d'afficher la sortie du code dans lequel nous avons créé un tableau complexe en utilisant la classe complex().
importer numpy comme par exemple.déployer = par exemple. complexe ( 3 +1j ) *par exemple. arranger ( 5 )
imprimer ( 'tableau complexe utilisant la classe np.complex()' , déployer )
Comme le montre la figure ci-dessous, nous avons créé un tableau de nombres complexes. Mais une autre chose que nous pouvons remarquer dans la figure est que la valeur constante n'est pas exécutée consécutivement car nous avons passé '3 + 1j' à une classe complex (), ce qui signifie qu'un nombre trois sera ajouté à chaque valeur constante suivante.
Méthode 4 :
par exemple. ceux ( forme , dtype = Aucun , ordre = 'C' , * , Comme = Aucun )Dans cette méthode np.ones(), nous spécifions un tableau de nombres complexes à l'aide du paramètre dtype dans le tableau NumPy. Np.ones() est utilisé pour renvoyer un nouveau tableau contenant des 1. A la fonction np.ones(), nous avons passé quatre paramètres « shape », qui servent à définir la forme du tableau qu'il soit « 2 », « 3 » ou autre. 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, bidimensionnel ou multidimensionnel.
Exemple #03 :
Implémentons la méthode ones() pour avoir une meilleure idée de son fonctionnement lors de l'utilisation de nombres complexes. Pour implémenter cette méthode, importons d'abord nos packages de NumPy fournis par Python. Ensuite, nous allons créer un tableau auquel nous passerons la fonction np.ones() à laquelle nous avons passé deux paramètres. Le premier est '4' ce qui signifie que la taille du tableau sera de 4 et le second est 'dtype' qui est complexe. Cela signifie que nous allons créer un tableau de nombres complexes de types de données. Multiplier la fonction ones () avec la valeur '2' signifie que notre nombre réel sera '2'. À la fin, nous avons imprimé le tableau que nous avons créé à l'aide de l'instruction print.
importer numpy comme par exemple.déployer = par exemple. ceux ( 4 , dtype = complexe ) * deux
imprimer ( 'tableau complexe utilisant la fonction np.ones()' , déployer )
Comme indiqué ci-dessous, la sortie de notre code est exécutée avec succès dans laquelle nous avons un tableau unidimensionnel contenant 4 valeurs complexes avec un nombre réel 2.
Exemple #04 :
Implémentons maintenant un autre exemple dans lequel nous allons créer un tableau de nombres complexes et imprimer les parties imaginaires et réelles des nombres complexes. Nous allons d'abord importer la bibliothèque NumPy, puis créer un tableau auquel nous avons passé '6' valeurs complexes à 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 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 partie réelle est 'array_name.real'. Dans notre cas, le nom d'un tableau est 'tableau', nous avons donc passé l'instruction d'impression, le nom du tableau et le mot-clé pour obtenir les deux éléments.
importer numpy comme par exemple.déployer = par exemple. déployer ( [ 56 .+ 0 . j , 27 .+ 0 . j , 68 .+ 0 . j , 49 .+ 0 . j , 120 .+ 0 . j , 3 + 4 . j ] )
imprimer ( 'Tableau d'origine :x' , déployer )
imprimer ( 'Partie réelle du tableau :' )
imprimer ( déployer . réel )
imprimer ( 'Partie imaginaire du tableau :' )
imprimer ( déployer . image )
Comme indiqué dans l'extrait ci-dessous, la sortie dans laquelle la partie imaginaire et la partie réelle du tableau complexe sont exécutées avec succès. Où les parties réelles sont « 56 », « 27 », « 68 », « 120 » et « 3 ». Et les parties imaginaires sont des '0'.
Conclusion
Dans cet article, nous avons brièvement discuté des nombres complexes et de la manière dont nous pouvons créer des tableaux complexes à l'aide des 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.