Numpy komplexe Zahl

Wir wissen, dass komplexe Zahlen diejenigen sind, die durch das konventionelle A+Bi dargestellt werden, wobei „A“ immer eine reelle Zahl ist. "B" ist auch eine reelle Zahl, aber "I" ist eine imaginäre Komponente. Eine weitere Sache, die wir wissen, ist „i^2 = -1“, weil keine der realen Zahlen diese Gleichung befriedigen kann, die wir als „I“ als imaginärer Teil bezeichnen. Numpy unterstützt sowohl reelle Zahlen als auch imaginäre Zahlen. In Numpy werden imaginäre Zahlen durch "J" dargestellt. Es gibt verschiedene Möglichkeiten, Arrays mit komplexen Zahlen wie NP zu erstellen und zu manipulieren.Komplex (), NP.Bereich (), NP.Array () und mehr.

Syntax

Die Syntax zum Erstellen eines Arrays, das komplexe Zahlen enthält, lautet wie folgt:

Methode 1:

1J * np.Arange (Größe)

Die oben angegebene Syntax ist der imaginäre Teil, was bedeutet, dass wir eine Reihe komplexer Zahlen erstellen, wobei NP.Die Anordnung ist die Funktion, die von Numpy bereitgestellt wird, um ein Array zu einem bestimmten Bereich zu erstellen. Die Größe, die die Arraygröße anzeigt, wird an die Funktion übergeben.

Methode 2:

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

In dieser Syntax NP.Arrray ist die Funktion, die es uns ermöglicht, ein Array zu erstellen, aber wir können den Bereich nicht übergeben. Wir geben einfach Werte an die „n“ -Zeiten weiter. In der Funktion haben wir "RE" übergeben, was reelle Zahlen anzeigt. Wir können imaginäre Werte an n -mal übergeben.

Beispiel # 01:

Wie wir wissen, unterstützt Numpy auch komplexe Zahlen und bietet mehrere Methodensorten zur Implementierung und Manipulation komplexer Zahlen. Im folgenden Beispiel werden wir zwei Möglichkeiten implementieren, Arrays mit komplexen Zahlen zu erstellen. Um Numpy -Funktionen zu implementieren, importieren wir zuerst die Numpy Library als NP. Dann werden wir ein Array mit dem Namen "Array_A" initialisieren, dem wir die Funktion np zuweisen.Arange (), die die komplexen Zahlen enthalten. Und der Bereich des Arrays wird „8“ sein. In der nächsten Zeile haben wir ein weiteres Array mit dem Namen "Array_B" erstellt, an das wir ein Array komplexer Zahlen übergeben haben, indem wir die komplexen Werte direkt an sie übergeben haben. Am Ende haben wir das komplexe Array gedruckt, das wir mit beiden Methoden erstellt haben.

Numph als NP importieren
Array_a = 1J * np.Arange (8)
array_b = np.Array ([2+1J, 3+4J, 5+2j, 1+6j])
print ("Komplexes Array mit Arange () -Funktion", Array_A)
print ("komplexes Array mit NP.array () function ", array_b)

Wie im folgenden Snippet gezeigt. Wir können sehen, dass wir zwei Arrays erstellt haben, die eine Reihe komplexer Zahlen von 0J bis 7J haben. In der anderen haben wir den zufälligen Bereich der komplexen Anzahl von Größe 4 überschritten.

Methode 3:

np.komplex (re+re*im)

In der oben angegebenen Syntax NP.Komplex () ist die integrierte Klasse, die vom Python-Paket Numpy bereitgestellt wird, mit dem wir komplexe Werte speichern können.

Beispiel # 02:

Eine andere Möglichkeit, ein Numpy -Komplex -Array zu erstellen, ist die Verwendung von Numpy's Complex () Klasse. Komplexe Klasse () wird verwendet, um komplexe Zahlen zu speichern und das komplexe Objekt zurückzugeben, das wir im Einzelcode mehrmals verwenden können. Wenn wir nun die Komplex () -Klasse implementieren, werden wir zuerst unser Numpy -Paket importieren. Dann werden wir ein Array initialisieren, an das wir eine komplexe Klasse bestanden haben, die ein Sternchen „*“ verwendet, um ein Objekt der Komplex () -Klasse zu übergeben, an der wir „3+1j“ bestanden haben. Mit der Funktion arrang () haben wir ein Array der Größe 5 erstellt. Endlich haben wir gerade die Ausgabe des Codes angezeigt, in dem wir ein komplexes Array mit der Komplex () -Klasse erstellt haben.

Numph als NP importieren
Array = np.Komplex (3+1j) *np.Arange (5)
print ("komplexes Array mit NP.Komplex () Klasse ", Array)

Wie in der folgenden Abbildung gezeigt, haben wir eine Reihe komplexer Zahlen erstellt. Aber noch eine Sache, die wir in der Abbildung bemerken können, ist, dass der konstante Wert nicht nacheinander ausgeführt wird, da wir „3+1j“ an eine Komplexklasse () übergeben haben, was bedeutet.

Methode 4:

np.EINS (Form, dType = Keine, order = 'c', *, wie = keine)

In dieser Methode NP.One () geben wir ein Array komplexer Zahlen an, unter Verwendung des DTYPE -Parameters im Numpy -Array. Np.Eins () wird verwendet, um ein neues Array zurückzugeben, das 1s enthält. Zur Funktion np.One () haben wir vier Parameter „Form“ übergeben, die verwendet werden, um die Form des Arrays zu definieren, ob es sich um „2“, „3“ oder sonst handelt. Der "DTYPE" ist der Datentyp. In unserem Fall werden wir einen komplexen Datentyp verwenden. Die „Reihenfolge“ definiert, ob das Array eindimensional, zwei oder mehrdimensional ist.

Beispiel # 03:

Implementieren wir die Methode () (), um eine bessere Vorstellung davon zu erhalten, wie sie funktioniert, während sie komplexe Zahlen verwenden. Um diese Methode zu implementieren, importieren wir zunächst unsere von Python bereitgestellten Pakete von Numpy, die bereitgestellt werden. Als nächstes werden wir ein Array erstellen, an das wir die NP übergeben werden.One () Funktion, an die wir zwei Parameter bestanden haben. Der erste ist „4“, was bedeutet. Dies bedeutet, dass wir eine Reihe von Datentyp -komplexen Zahlen erstellen werden. Multiplizieren Sie die Funktion () mit dem Wert "2" bedeutet, dass unsere reelle Zahl "2" lautet. Am Ende haben wir das Array, das wir mit der Print -Anweisung erstellt haben, gedruckt.

Numph als NP importieren
Array = np.Einen (4, dType = komplex)*2
print ("komplexes Array mit NP.One () Funktion ", Array)

Wie unten gezeigt, wird die Ausgabe unseres Codes erfolgreich ausgeführt, in dem wir ein eindimensionales Array haben, das 4 komplexe Werte mit einer reellen Zahl 2 enthält.

Beispiel # 04:

Implementieren wir nun ein weiteres Beispiel, in dem wir eine Reihe komplexer Zahlen erstellen und die imaginären und realen Teile der komplexen Zahlen drucken. Wir werden zuerst die Numpy -Bibliothek importieren und dann ein Array erstellen, an das wir "6" -Komplexwerte an ein Array mit dem Namen "Array" übergeben haben, das "56+0J, 27+0J, 68+0J, 49+0J, 120+0J ist , 4+0J ”. In der nächsten Zeile haben wir einfach das Array gedruckt. Jetzt drucken wir imaginären und realen Werte des komplexen Arrays.

Numpy bietet eine integrierte Funktion für beide Operationen, die unten gezeigt werden. Der erste, der den imaginären Teil bekommt, ist „Array_Name.Bild ”, wobei der Wert vor dem Punkt das Array ist, aus dem wir den imaginären Teil erhalten müssen. Und der zweite, der den eigentlichen Teil bekommt, ist „Array_Name.real". In unserem Fall lautet der Name eines Arrays „Array“.

Numph als NP importieren
Array = np.Array ([56).+0.J, 27.+0.J, 68.+0.J, 49.+0.J, 120.+0.J, 3 + 4.J])
print ("Original Array: x", Array)
print ("Real Teil des Arrays:")
Druck (Array.real)
print ("imaginärer Teil des Arrays:")
Druck (Array.Bild)

Wie im folgenden Ausschnitt gezeigt. Wo die wirklichen Teile „56“, „27“, „68“, „120“ und „3“ sind. Und die imaginären Teile sind "0er".

Abschluss

In diesem Artikel haben wir kurz komplexe Zahlen diskutiert und wie wir komplexe Arrays mit den integrierten Funktionen von Numpy erstellen können. Wir haben mehrere Funktionen beschrieben, mit denen wir komplexe Arrays erstellen können, indem mehrere Beispiele implementiert werden, um besser zu verstehen.