Numero complesso numpy

Sappiamo che numeri complessi sono quelli rappresentati dalla convenzionale A+BI, in cui "A" è sempre un numero reale; "B" è anche un numero reale ma "io" è un componente immaginario. Un'altra cosa che sappiamo è "I^2 = -1" perché nessuno dei numeri reali può soddisfare questa equazione che chiamiamo "io" una parte immaginaria. Numpy supporta numeri reali e numeri immaginari. In Numpy, i numeri immaginari sono rappresentati da "J". Esistono vari modi per creare e manipolare array con numeri complessi come NP.complesso (), NP.intervallo (), NP.array () e altro ancora.

Sintassi

La sintassi per la creazione di un array che contiene numeri complessi è la seguente:

Metodo 1:

1j * np.Arange (dimensione)

La sintassi indicata sopra 1J è la parte immaginaria, il che significa che stiamo creando una serie di numeri complessi, in cui NP.Arrange è la funzione fornita da Numpy per creare un array a un intervallo specificato. La dimensione, che indica la dimensione dell'array, viene passata alla funzione.

Metodo 2:

np.array ([re+re*im, re+re*im,…])

In questa sintassi, NP.Array è la funzione che ci consente di creare un array ma non possiamo passarci la gamma. Passiamo semplicemente i valori ad esso "n" volte. Nella funzione, abbiamo superato "Re" che indica numeri reali che li aggiungono a "im" un numero immaginario in multiplo di un numero reale. Possiamo passare valori immaginari a n volte.

Esempio # 01:

Come sappiamo, Numpy supporta anche numeri complessi e fornisce molteplici varietà di metodi per implementare e manipolare numeri complessi. Nell'esempio seguente, implementeremo due modi per creare array contenenti numeri complessi. Per implementare le funzioni numpy, importa prima di Numpy Library come NP. Quindi, inizializzeremo un array chiamato "Array_A" a cui assegniamo la funzione NP.Arange () che conterrà i numeri complessi. E la gamma dell'array sarà "8". Nella riga successiva, abbiamo creato un altro array chiamato "Array_B" a cui abbiamo superato un array di numeri complessi passando i valori complessi direttamente ad esso. Alla fine, abbiamo stampato l'array complesso che abbiamo creato usando entrambi i metodi.

Importa Numpy come NP
array_a = 1j * np.Arange (8)
array_b = np.Array ([2+1J, 3+4J, 5+2J, 1+6J])
Print ("Array complesso usando la funzione Arange ()", array_a)
Stampa ("Array complesso che utilizza NP.funzione array () ", array_b)

Come mostrato nello snippet seguente è il risultato del codice che abbiamo eseguito. Possiamo vedere che abbiamo creato due array che hanno una serie di numeri complessi da 0J a 7J. Nell'altro, abbiamo superato l'intervallo casuale di numeri complessi di dimensioni 4.

Metodo 3:

np.complesso (re+re*im)

Nella sintassi sopra indicata, NP.Complex () è la classe integrata fornita dal pacchetto Python Numpy che ci consente di archiviare valori complessi.

Esempio # 02:

Un altro modo per creare un array complesso numpy è usare la classe complessa () di Numpy. Classe complesso () viene utilizzato per archiviare numeri complessi e restituire l'oggetto complesso che possiamo usare più volte all'interno del codice singolo. Ora implementando la classe Complex (), importare prima il nostro pacchetto numpy. Quindi, inizializzeremo un array a cui abbiamo superato una classe complessa che usa un asterisco "*" per passare un oggetto di classe complesso () a cui abbiamo superato "3+1J". Usando la funzione Orgy (), abbiamo creato un array di dimensioni 5. Alla fine, abbiamo appena visualizzato l'output del codice in cui abbiamo creato un array complesso usando la classe complesso ().

Importa Numpy come NP
array = np.Complesso (3+1J) *NP.Arange (5)
Stampa ("Array complesso che utilizza NP.complesso () classe ", array)

Come mostrato nella figura seguente, abbiamo creato una serie di numeri complessi. Ma un'altra cosa che possiamo notare nella figura è che il valore costante non viene eseguito consecutivamente perché abbiamo superato "3+1J" a una classe complessa () che significa che un numero tre verrà aggiunto a tutti i prossimi valori costanti.

Metodo 4:

np.quelli (forma, dtype = nessuno, ordine = 'c', *, like = nessuno)

In questo metodo NP.One (), specifichiamo un array di numeri complessi usando il parametro dType nell'array numpy. Np.One () viene utilizzato per restituire un nuovo array che contiene 1s. Alla funzione np.One (), abbiamo superato quattro parametri "forma", che viene utilizzato per definire la forma dell'array, sia che si tratti di "2", "3" o altro. Il "dType" è il tipo di dati. Nel nostro caso utilizzeremo un tipo di dati complesso. L '"ordine" definisce se l'array è monodimensionale, due o multidimensionali.

Esempio # 03:

Facciamo implementare il metodo One () per avere un'idea migliore di come funziona mentre utilizzano numeri complessi. Per implementare questo metodo, per prima importare i nostri pacchetti di numpy forniti da Python. Successivamente, creeremo un array a cui passeremo il NP.One () funzione a cui abbiamo superato due parametri. Il primo è "4" che significa che la dimensione dell'array sarà 4 e la seconda è "dtype" che è complessa. Ciò significa che creeremo una matrice di numeri complessi del tipo di dati. Moltiplicare la funzione di One () con il valore "2" significa che il nostro numero reale sarà "2". Alla fine, abbiamo stampato l'array che abbiamo creato usando l'istruzione di stampa.

Importa Numpy come NP
array = np.quelli (4, dtype = complesso)*2
Stampa ("Array complesso che utilizza NP.One () funzione ", array)

Come mostrato di seguito, l'output del nostro codice viene eseguito correttamente in cui abbiamo un array unidimensionale che contiene 4 valori complessi con un numero reale 2.

Esempio # 04:

Implessiamo ora un altro esempio in cui creeremo una serie di numeri complessi e stamperemo le parti immaginarie e reali dei numeri complessi. Prima importamo la libreria numpy, quindi creeremo un array a cui abbiamo superato i valori complessi "6" su un array chiamato "Array" che è "56+0J, 27+0J, 68+0J, 49+0J, 120+0J , 4+0J ". Nella riga successiva, abbiamo semplicemente stampato l'array. Ora, stampiamo valori immaginari e reali dell'array complesso.

Numpy fornisce una funzione integrata per entrambe le operazioni mostrate di seguito. Il primo ad ottenere la parte immaginaria è "Array_name.Imaging "dove il valore prima del punto è l'array da cui dobbiamo ottenere la parte immaginaria. E il secondo per ottenere la parte reale è "Array_name.vero". Nel nostro caso, il nome di un array è "array", quindi abbiamo superato l'istruzione di stampa, il nome dell'array e la parola chiave per ottenere entrambi gli elementi.

Importa Numpy come NP
array = np.array ([56.+0.J, 27.+0.J, 68.+0.J, 49.+0.J, 120.+0.J, 3 + 4.J])
Stampa ("Array originale: x", array)
stampa ("parte reale dell'array:")
Stampa (array.vero)
stampa ("parte immaginaria dell'array:")
Stampa (array.Imag)

Come mostrato nello snippet di seguito, l'output in cui viene eseguita con successo la parte immaginaria e reale dell'array complesso. Dove le parti reali sono "56", "27", "68", "120" e "3". E le parti immaginarie sono "0".

Conclusione

In questo articolo, abbiamo discusso brevemente di numeri complessi e come possiamo creare array complessi usando le funzioni integrate di Numpy. Abbiamo descritto molteplici funzioni che ci consentono di creare array complessi implementando più esempi per capire meglio.