Numpy kompleks nummer

Vi vet at komplekse tall er de som er representert av den konvensjonelle A+Bi, der “A” alltid er et reelt tall; “B” er også et reelt tall, men "jeg" er en tenkt komponent. En ting vi vet er “i^2 = -1” fordi ingen av de reelle tallene kan tilfredsstille denne ligningen som vi kaller “i” en tenkt del. Numpy støtter reelle tall så vel som imaginære tall. I Numpy er imaginære tall representert av “J”. Det er forskjellige måter å lage og manipulere matriser med komplekse tall som NP.Kompleks (), NP.rekkevidde (), NP.matrise (), og mer.

Syntaks

Syntaksen for å lage en matrise som inneholder komplekse tall er som følger:

Metode 1:

1j * np.Arange (størrelse)

Syntaksen gitt over 1J er den imaginære delen som betyr at vi lager en rekke komplekse tall, der NP.Arrangen er funksjonen som er gitt av Numpy for å lage en matrise til et spesifisert område. Størrelse, som indikerer matrisestørrelsen, sendes til funksjonen.

Metode 2:

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

I denne syntaksen, NP.Array er funksjonen som gjør at vi kan lage en matrise, men vi kan ikke gi rekkevidden til den. Vi overfører ganske enkelt verdier til det “n” ganger. I funksjonen passerte vi “re” som indikerer reelle tall som la dem til “im” et tenkt tall i flere av et reelt tall. Vi kan gi imaginære verdier til n ganger.

Eksempel # 01:

Som vi vet støtter Numpy også komplekse tall og gir flere varianter av metoder for å implementere og manipulere komplekse tall. I eksemplet nedenfor vil vi implementere to måter å lage matriser som inneholder komplekse tall. For å implementere Numpy -funksjoner, la oss importere Numpy -biblioteket først som NP. Deretter vil vi initialisere en matrise som heter “Array_a” som vi tildeler funksjonen NP.Arange () som vil inneholde de komplekse tallene. Og rekkevidden til matrisen vil være "8". I neste linje opprettet vi en annen matrise som heter “Array_b” som vi passerte en rekke komplekse tall ved å sende de komplekse verdiene direkte til den. Til slutt trykket vi den komplekse matrisen som vi opprettet ved hjelp av begge metodene.

Importer numpy som NP
array_a = 1j * np.Arange (8)
Array_B = NP.Array ([2+1j, 3+4j, 5+2j, 1+6j])
print ("Complex Array ved bruk av Arange () -funksjon", Array_A)
print ("kompleks matrise ved hjelp av np.matrise () funksjon ", array_b)

Som vist i utdraget nedenfor er resultatet av koden vi har utført. Vi kan se at vi har laget to matriser som har en rekke komplekse tall fra 0J til 7J. I den andre har vi passert det tilfeldige spekteret av komplekse antall størrelse 4.

Metode 3:

np.Kompleks (re+re*im)

I syntaksen gitt ovenfor, NP.Complex () er den innebygde klassen som er levert av Python-pakken Numpy som gjør at vi kan lagre komplekse verdier.

Eksempel # 02:

En annen måte å lage et Numpy Complex -matrise er å bruke Numpys kompleks () -klasse. Kompleks klasse () brukes til å lagre komplekse tall og returnerer det komplekse objektet som vi kan bruke flere ganger i enkeltkoden. Nå implementerer kompleks () -klassen, vil vi først importere Numpy -pakken. Deretter vil vi initialisere en rekke som vi passerte en kompleks klasse som bruker en stjerne “*” for å passere et objekt av kompleks () klasse som vi passerte “3+1J”. Ved hjelp av Arrange () -funksjonen opprettet vi en rekke størrelse 5. Til slutt viste vi nettopp utdataene fra koden vi opprettet en kompleks matrise ved hjelp av kompleks () -klassen.

Importer numpy som NP
Array = NP.Kompleks (3+1j) *NP.Arange (5)
print ("kompleks matrise ved hjelp av np.kompleks () klasse ", matrise)

Som vist på figuren nedenfor, har vi laget en rekke komplekse tall. Men en ting til vi kan legge merke til i figuren, er at den konstante verdien ikke blir utført på en sammenhengende fordi vi har gitt “3+1J” til en kompleks () klasse som betyr at en nummer tre vil bli lagt til hver neste konstante verdier.

Metode 4:

np.de (form, dtype = ingen, orden = 'c', *, som = ingen)

I denne metoden NP.de (), Vi spesifiserer en rekke komplekse tall ved hjelp av dtype -parameteren i Numpy -matrisen. Np.de () brukes til å returnere en ny matrise som inneholder 1s. Til funksjonen NP.de (), vi passerte fire parametere “form”, som brukes til å definere formen på matrisen enten det er “2”, “3” ellers. "DTYPE" er datatypen. I vårt tilfelle vil vi bruke en kompleks datatype. "Ordenen" definerer om matrisen er endimensjonal, to eller flerdimensjonal.

Eksempel # 03:

La oss implementere metoden () for å få en bedre ide om hvordan det fungerer mens vi bruker komplekse tall. For å implementere denne metoden, la oss først importere pakkene våre med Numpy som er levert av Python. Deretter vil vi lage en rekke som vi vil passere NP.en () funksjon som vi passerte to parametere til. Den første er "4", noe som betyr at matrisestørrelsen vil være 4 og den andre er "dtype" som er sammensatt. Dette betyr at vi skal lage en rekke datatypekompleksnumre. Å multiplisere de () -funksjonen med verdien ”2” betyr at vårt virkelige tall vil være “2”. Til slutt skrev vi ut matrisen som vi opprettet ved hjelp av utskriftserklæringen.

Importer numpy som NP
Array = NP.de (4, dtype = kompleks)*2
print ("kompleks matrise ved hjelp av np.Ones () Funksjon ", Array)

Som vist nedenfor, utføres utgangen fra koden vår med hell der vi har en endimensjonal matrise som inneholder 4 komplekse verdier med et reelt nummer 2.

Eksempel # 04:

La oss nå implementere et annet eksempel der vi vil lage en rekke komplekse tall og vil skrive ut de imaginære og virkelige delene av de komplekse tallene. Vi vil først importere Numpy Library, og deretter opprette en matrise som vi passerte “6” komplekse verdier til en matrise som heter “Array” som er “56+0J, 27+0J, 68+0J, 49+0J, 120+0J , 4+0J ”. I neste linje skrev vi ganske enkelt ut matrisen. Nå trykker vi imaginære og virkelige verdier av det komplekse matrisen.

Numpy gir en innebygd funksjon for begge operasjonene som vises nedenfor. Den første som får den imaginære delen er “Array_name.imag ”hvor verdien før prikken er den rekkeen vi må få den imaginære delen. Og den andre som får den virkelige delen er “Array_name.ekte". I vårt tilfelle er navnet på en matrise "matrise", så vi passerte utskriftserklæringen, matrisenavnet og nøkkelordet for å få begge elementene.

Importer numpy som NP
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)
trykk ("Ekte del av matrisen:")
trykk (matrise.ekte)
trykk ("imaginær del av matrisen:")
trykk (matrise.bilde)

Som vist i utdraget nedenfor, utføres utgangen der den imaginære og den virkelige delen av den komplekse matrisen utføres med suksess. Der de virkelige delene er “56”, “27”, “68”, “120” og “3”. Og de imaginære delene er “0’er”.

Konklusjon

I denne artikkelen har vi kort diskutert komplekse tall og hvordan vi kan lage komplekse matriser ved hjelp av Numpys innebygde funksjoner. Vi beskrev flere funksjoner som gjør at vi kan lage komplekse matriser ved å implementere flere eksempler for å forstå bedre.