Syntaks
Syntaksen for å lage en matrise som inneholder komplekse tall er som følger:
Metode 1:
1j * np. ordne ( størrelse )Syntaksen gitt over 1j er den imaginære delen som betyr at vi lager en matrise med komplekse tall, der np.arrang er funksjonen som leveres av NumPy for å lage en matrise til et spesifisert område. Størrelse, som indikerer matrisestørrelsen, sendes til funksjonen.
Metode 2:
f.eks. array ( [ Re+Re*Im , Re+Re*Im , … ] )I denne syntaksen er np.arrray funksjonen som gjør oss i stand til å lage en matrise, men vi kan ikke overføre rekkevidden til den. Vi sender rett og slett verdier til det 'n' ganger. I funksjonen passerte vi 'Re' som indikerer reelle tall som legger dem til 'Im' et imaginært tall i multiplum av et reelt tall. Vi kan overføre 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 først importere NumPy-biblioteket som np. Deretter vil vi initialisere en matrise kalt 'array_a' som vi tilordner 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 kalt 'array_b' som vi sendte en matrise med komplekse tall til ved å sende de komplekse verdiene direkte til den. Til slutt skrev vi ut den komplekse matrisen som vi laget ved å bruke begge metodene.
import nusset som f.eks.
array_a = 1j * np. ordne ( 8 )
array_b = f.eks. array ( [ to +1d , 3 +4j , 5 +2j , 1 +6j ] )
skrive ut ( 'kompleks matrise som bruker arange()-funksjonen' , array_a )
skrive ut ( 'kompleks array som bruker np.array()-funksjonen' , 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 området med komplekse tall av størrelse 4.
Metode 3:
f.eks. kompleks ( Re+Re*Im )I syntaksen gitt ovenfor er np.complex() den innebygde klassen som leveres av Python-pakken NumPy som gjør det mulig for oss å lagre komplekse verdier.
Eksempel #02:
En annen måte å lage en NumPy kompleks matrise på er å bruke NumPy sin complex() klasse. Complex class() brukes til å lagre komplekse tall og returnerer det komplekse objektet som vi kan bruke flere ganger innenfor enkeltkoden. Når vi nå implementerer complex()-klassen, vil vi først importere Numpy-pakken vår. Deretter vil vi initialisere en matrise som vi sendte en kompleks klasse til som bruker en stjerne '*' for å sende et objekt av kompleks()-klassen som vi sendte '3+1j' til. Ved å bruke funksjonen arrange() opprettet vi en matrise med størrelse 5. Til slutt viste vi bare utdataene til koden der vi laget en kompleks matrise ved å bruke kompleks()-klassen.
import nusset som f.eks.array = f.eks. kompleks ( 3 +1d ) *f.eks. ordne ( 5 )
skrive ut ( 'kompleks array som bruker np.complex()-klassen' , array )
Som vist i figuren nedenfor har vi laget en rekke komplekse tall. Men en ting til vi kan legge merke til i figuren er at konstantverdien ikke blir utført fortløpende fordi vi har sendt '3+1j' til en kompleks()-klasse som betyr at et tall tre vil bli lagt til hver neste konstantverdi.
Metode 4:
f.eks. seg ( form , dtype = Ingen , rekkefølge = 'C' , * , som = Ingen )I denne metoden np.ones(), spesifiserer vi en matrise med komplekse tall ved å bruke parameteren dtype i NumPy-matrisen. Np.ones() brukes til å returnere en ny matrise som inneholder 1s. Til funksjonen np.ones() sendte vi fire parametere “shape”, som brukes til å definere formen på matrisen om den er “2”, “3” eller annet. 'dtype' er datatypen. I vårt tilfelle vil vi bruke en kompleks datatype. 'Rekkefølgen' definerer om matrisen er endimensjonal, to eller flerdimensjonal.
Eksempel # 03:
La oss implementere ones()-metoden for å få en bedre ide om hvordan den fungerer mens du bruker komplekse tall. For å implementere denne metoden, la oss først importere NumPy-pakkene våre som leveres av Python. Deretter vil vi lage en matrise som vi sender funksjonen np.ones() som vi sendte to parametere til. Den første er '4' som betyr at matrisestørrelsen vil være 4 og den andre er 'dtype', som er kompleks. Dette betyr at vi skal lage en rekke datatype komplekse tall. Å multiplisere ener()-funksjonen med verdien '2' betyr at vårt reelle tall vil være '2'. Til slutt skrev vi ut arrayet som vi opprettet ved hjelp av print statement.
import nusset som f.eks.array = f.eks. seg ( 4 , dtype = kompleks ) * to
skrive ut ( 'kompleks array som bruker np.ones()-funksjonen' , array )
Som vist nedenfor, utføres utdataene fra koden vår vellykket der vi har en endimensjonal matrise som inneholder 4 komplekse verdier med et reelt tall 2.
Eksempel # 04:
La oss nå implementere et annet eksempel der vi vil lage en rekke komplekse tall og skrive ut de imaginære og reelle delene av de komplekse tallene. Vi vil først importere NumPy-biblioteket, og deretter lage en matrise som vi sendte '6' komplekse verdier til en matrise kalt '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å skriver vi ut imaginære og virkelige verdier av den komplekse matrisen.
Numpy har en innebygd funksjon for begge operasjonene som er vist nedenfor. Den første som får den imaginære delen er «array_name.imag» hvor verdien før prikken er matrisen som vi må hente den imaginære delen fra. Og den andre som får den virkelige delen er 'array_name.real'. I vårt tilfelle er navnet på en matrise «array», så vi passerte print-setningen, matrisenavnet og nøkkelordet for å få begge elementene.
import nusset som f.eks.array = f.eks. array ( [ 56 .+ 0 . j , 27 .+ 0 . j , 68 .+ 0 . j , 49 .+ 0 . j , 120 .+ 0 . j , 3 + 4 . j ] )
skrive ut ( 'Original array:x' , array )
skrive ut ( 'Ekte del av matrisen:' )
skrive ut ( array . ekte )
skrive ut ( 'Imaginær del av matrisen:' )
skrive ut ( array . imag )
Som vist i utdraget nedenfor, utdata der den imaginære og den virkelige delen av den komplekse matrisen er vellykket utført. 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 å bruke NumPys innebygde funksjoner. Vi beskrev flere funksjoner som gjør oss i stand til å lage komplekse matriser ved å implementere flere eksempler for å forstå bedre.