Syntax
Syntaxen för att skapa en matris som innehåller komplexa tal är följande:
Metod 1:
1j * np. ordna ( storlek )Syntaxen som anges ovan 1j är den imaginära delen vilket betyder att vi skapar en array av komplexa tal, där np.arrang är funktionen som tillhandahålls av NumPy för att skapa en array till ett specificerat intervall. Storlek, som anger arraystorleken, skickas till funktionen.
Metod 2:
t.ex. array ( [ Re+Re*Im , Re+Re*Im , … ] )I denna syntax är np.arrray funktionen som gör att vi kan skapa en array men vi kan inte skicka intervallet till det. Vi skickar helt enkelt värden till det 'n' gånger. I funktionen passerade vi 'Re' som indikerar reella tal och adderar dem till 'Im' ett imaginärt tal i multipel av ett reellt tal. Vi kan överföra imaginära värden till n gånger.
Exempel # 01:
Som vi vet stöder NumPy också komplexa tal och tillhandahåller flera olika metoder för att implementera och manipulera komplexa tal. I exemplet nedan kommer vi att implementera två sätt att skapa arrayer som innehåller komplexa tal. För att implementera NumPy-funktioner, låt oss först importera NumPy-biblioteket som np. Sedan kommer vi att initiera en array som heter 'array_a' som vi tilldelar funktionen np.arange() som kommer att innehålla de komplexa talen. Och intervallet för arrayen kommer att vara '8'. På nästa rad skapade vi en annan array som heter 'array_b' till vilken vi skickade en array av komplexa tal genom att skicka de komplexa värdena direkt till den. Till slut skrev vi ut den komplexa array som vi skapade med båda metoderna.
importera numpy som t.ex.
array_a = 1j * np. ordna ( 8 )
array_b = t.ex. array ( [ två +1d , 3 +4j , 5 +2j , 1 +6j ] )
skriva ut ( 'komplex array som använder funktionen arange()' , array_a )
skriva ut ( 'komplex array med funktionen np.array()' , array_b )
Som visas i utdraget nedan är resultatet av koden vi har kört. Vi kan se att vi har skapat två arrayer som har ett intervall av komplexa tal från 0j till 7j. I den andra har vi passerat det slumpmässiga intervallet av komplexa tal av storlek 4.
Metod 3:
t.ex. komplex ( Re+Re*Im )I syntaxen ovan är np.complex() den inbyggda klassen som tillhandahålls av Python-paketet NumPy som gör det möjligt för oss att lagra komplexa värden.
Exempel # 02:
Ett annat sätt att skapa en NumPy-komplex array är att använda NumPys komplex()-klass. Complex class() används för att lagra komplexa tal och returnerar det komplexa objektet som vi kan använda flera gånger inom den enskilda koden. När vi nu implementerar klassen complex() kommer vi först att importera vårt Numpy-paket. Sedan kommer vi att initiera en array till vilken vi skickade en komplex klass som använder en asterisk '*' för att skicka ett objekt av klassen komplex() till vilket vi skickade '3+1j'. Med hjälp av arrange()-funktionen skapade vi en array med storlek 5. Äntligen visade vi bara utdata från koden där vi skapade en komplex array med klassen complex().
importera numpy som t.ex.array = t.ex. komplex ( 3 +1d ) *t.ex. ordna ( 5 )
skriva ut ( 'komplex array som använder klassen np.complex()' , array )
Som visas i figuren nedan har vi skapat en array av komplexa tal. Men en sak till som vi kan lägga märke till i figuren är att det konstanta värdet inte exekveras i följd eftersom vi har skickat '3+1j' till en komplex()-klass vilket betyder att ett nummer tre kommer att läggas till varje nästa konstantvärde.
Metod 4:
t.ex. ettor ( form , dtype = Ingen , ordning = 'C' , * , tycka om = Ingen )I den här metoden np.ones() specificerar vi en array av komplexa tal med hjälp av parametern dtype i NumPy arrayen. Np.ones() används för att returnera en ny array som innehåller 1:or. Till funktionen np.ones() skickade vi fyra parametrar 'shape', som används för att definiera formen på arrayen om det är '2', '3' eller annat. 'dtype' är datatypen. I vårt fall kommer vi att använda en komplex datatyp. 'Orden' definierar om arrayen är endimensionell, två eller flerdimensionell.
Exempel # 03:
Låt oss implementera metoden ones() för att få en bättre uppfattning om hur det fungerar när du använder komplexa tal. För att implementera denna metod, låt oss först importera våra NumPy-paket som tillhandahålls av Python. Därefter kommer vi att skapa en array till vilken vi skickar funktionen np.ones() som vi skickade två parametrar till. Den första är '4' vilket betyder att arraystorleken kommer att vara 4 och den andra är 'dtype' som är komplex. Det betyder att vi kommer att skapa en array av datatypskomplexa tal. Att multiplicera funktionen ones() med värdet '2' betyder att vårt reella tal blir '2'. Till slut skrev vi ut arrayen som vi skapade med hjälp av print statement.
importera numpy som t.ex.array = t.ex. ettor ( 4 , dtype = komplex ) * två
skriva ut ( 'komplex array som använder np.ones()-funktionen' , array )
Som visas nedan exekveras utgången av vår kod framgångsrikt där vi har en endimensionell array som innehåller 4 komplexa värden med ett reellt tal 2.
Exempel # 04:
Låt oss nu implementera ett annat exempel där vi kommer att skapa en array av komplexa tal och kommer att skriva ut de imaginära och reella delarna av de komplexa talen. Vi kommer först att importera NumPy-biblioteket och sedan skapa en array till vilken vi skickade '6' komplexa värden till en array som heter 'array' som är '56+0j, 27+0j, 68+0j, 49+0j, 120+0j , 4+0j”. På nästa rad skrev vi helt enkelt ut arrayen. Nu skriver vi ut imaginära och verkliga värden för den komplexa matrisen.
Numpy har en inbyggd funktion för båda operationerna som visas nedan. Den första som får den imaginära delen är 'array_name.imag' där värdet före punkten är den array från vilken vi måste få den imaginära delen. Och den andra som får den riktiga delen är 'array_name.real'. I vårt fall är namnet på en array 'array' så vi skickade utskriftssatsen, arraynamnet och nyckelordet för att få båda elementen.
importera numpy som t.ex.array = t.ex. array ( [ 56 .+ 0 . j , 27 .+ 0 . j , 68 .+ 0 . j , 49 .+ 0 . j , 120 .+ 0 . j , 3 + 4 . j ] )
skriva ut ( 'Original array:x' , array )
skriva ut ( 'Verklig del av arrayen:' )
skriva ut ( array . verklig )
skriva ut ( 'Imaginär del av arrayen:' )
skriva ut ( array . bild )
Som visas i utdraget nedan, utgången där den imaginära och den verkliga delen av den komplexa arrayen exekveras framgångsrikt. Där de verkliga delarna är '56', '27', '68', '120' och '3'. Och de imaginära delarna är '0:or'.
Slutsats
I den här artikeln har vi kort diskuterat komplexa tal och hur vi kan skapa komplexa arrayer med hjälp av NumPys inbyggda funktioner. Vi beskrev flera funktioner som gör det möjligt för oss att skapa komplexa arrayer genom att implementera flera exempel för att förstå bättre.