Komplekse tall i python

Python er et utrolig fleksibelt språk for å jobbe med numeriske data. Evnen til å jobbe med både faktiske og fiktive tall støttes også. Vi må ofte utføre beregninger av numeriske datatyper, inkludert komplekse tall, når vi driver med datavitenskap, dyp læring eller vitenskapelige beregninger. Mer informasjon om imaginære tall og hvordan du bruker dem i Python dekkes i denne økten.

Komplekse tall sees ofte parvis og brukes til å finne de firkantede røttene til de negative tallene. Python kan effektivt håndtere tall og tilhørende funksjoner i tillegg til de reelle tallene ved å bruke "cmath" -filen. Python tilbyr nyttige muligheter for å administrere og endre de komplekse tallene som er verdifulle i mange applikasjoner koblet til matematikk.

Syntaks av det komplekse tallet i Python

Følgende syntaks av det komplekse tallet brukes på Python -språket:

kompleks ([ekte [, imag]])

Det er ikke mye forskjell mellom å lage og jobbe med de komplekse tallene i Python sammenlignet med de andre innebygde datatypene, spesielt de numeriske typene. Det er gjennomførbart siden språket gir dem førsteklasses statsborgerskap. Dette innebærer at det ikke er mye overhead involvert i å uttrykke matematiske beregninger med de komplekse tallene.

På samme måte som du vil kalle funksjonene på de andre tallene i Python, støttes de komplekse tallene i aritmetiske uttrykk. Den produserer vakker syntaks som ligner en matematikk -lærebok på flere måter.

Eksempel 1: Program for å konvertere det komplekse tallet til et reelt tall

“X + yi” er symbolet for et komplekst tall. Ved å bruke den komplekse funksjonen, transformerer Python x og y fra reelle verdier til komplekse (x, y) verdier. Ved hjelp av den virkelige () -funksjonen kan den virkelige delen hentes og Imag () -funksjonen kan brukes til å representere den imaginære delen.

Importer cmath
N1 = 6
N2 = 1
res = kompleks (n1, n2);
print ("Real Complex Number:", End = "")
trykk (res.ekte)
trykk ("Imaginary Complex Number:", End = "")
trykk (res.bilde)

I forrige eksempel importerte vi CMATH -modulen for å jobbe med de komplekse tallene. Deretter erklærte vi to variabler som n1 og n2. Disse variablene er satt med heltallverdiene. Den komplekse funksjonen tar disse to variablene som inngang inne. Den komplekse funksjonen kalles i res -variabelen. Utskriftserklæringen som blir kalt tar de virkelige og Imag -tallene som en parameter med res -variabelen.

De kan se de virkelige og imaginære komplekse tallene i følgende bilde:

Eksempel 2: Program for den komplekse tallfasen

Vinkelen mellom det komplekse tallets representasjonsvektor og den positive virkelige aksen er kjent som det komplekse tallets fase i geometri. Begrepet "argument for et komplekst antall" kan også brukes til å beskrive dette. Fase (), som godtar et komplekst tall som en inngang, returnerer fase.

Importer cmath
A = -5.0
B = 0.0
c = kompleks (a, b);
print ("Fasekompleksnummer:", slutt = "")
trykk (CMATH.fase (c))

Her, etter import av CMATH -modulen, definerte vi de to variablene som A og B. Variabel A initialiseres med den negative numeriske verdien og variabel B initialiseres med den positive numeriske verdien. Vi erklærte en annen variabel som C der den komplekse funksjonen påberopes. For den komplekse funksjonen ga vi variabelen A og B for konvertering i komplekse tall. Deretter trykket vi de komplekse tallene ved å bruke fasefunksjonen.

Fasekompleksnummeret genereres på følgende konsollskjerm:

Eksempel 3: Program for å konvertere det komplekse nummeret til rektangulære koordinater

Ved hjelp av polar () -funksjonen som returnerer et par (R, pH) som indikerer modulen R og fasevinkel -pH, konverteres polare data. ABS () og fase er begge funksjoner som kan brukes til å vise modulen ().

Rekt (R, pH), der R er modulen og pH er fasevinkelen, oversetter et komplekst heltall til rektangulære koordinater. Det gir tilbake et tall som tilsvarer R * (matematikk.cos (pH) + matematikk.sin (ph)*1j).

Importer cmath
Importer matematikk
i = 3.0
J = 3.0
z = kompleks (i, j);
C = CMATH.Polar (z)
Print ("Polar Complex Number Modulus and Argument:", End = "")
trykk (c)
C = CMATH.Rekt (4.242640687119285, 0.7853981633974483)
Print ("Rectangular Complex Number:", End = "")
trykk (c)

Vi inkluderte CMath og Math -modulen for den komplekse nummeroperasjonen. Deretter erklærte vi de to variablene I og J som har reelle tall. De reelle tallene sendes til den komplekse funksjonen og den komplekse funksjonen er definert i variabelen Z. Vi kalte polarfunksjonen for å konvertere de komplekse tallene til polar. Etter det har vi den rect () -funksjonen for konvertering av det komplekse tallet til de rektangulære koordinatene.

Resultatene fra de polare og rektangulære komplekstallene vises som følger:

Eksempel 4: Program for trigonometriske funksjonskompleksnumre

Her forklarer vi det komplekse antallet trigonometriske funksjoner:

1. Sin (): Det komplekse tallet som er gitt som et argument og returnert av denne funksjonen er sinus.
2. COS (): Når et komplekst tall blir levert som et argument, returnerer denne metoden sin kosinus.
3. Tan (): Det komplekse tallet som er spesifisert som et argument mottar tangenten fra denne funksjonen.

Importer cmath
P = 4.0
Q = 4.0
r = kompleks (p, q);
print ("Sine Complex Number:", End = "")
trykk (CMATH.sin (r))
Print ("Cosine Complex Number:", End = "")
trykk (CMATH.cos (r))
Print ("Tangent Complex Number:", End = "")
trykk (CMATH.tan (r))

Vi passerte ganske enkelt det definerte reelle tallet i den komplekse funksjonen. Deretter sendes de komplekse tallene i de trigonometriske funksjonene. Utskriftsuttalelsen viser de trigonometriske komplekse tallene.

Utgangen oppnådd fra det forrige Python -skriptet er som følger:

Eksempel 5: Program for eksponent- og loggkompleksnummer

Her diskuterte vi noen operasjoner av det komplekse antallet som inkluderer Exp () -funksjonen og log () -funksjonen.

exp (): Det komplekse tallet som er angitt i argumentets eksponent blir returnert av denne funksjonen.

Logg (A, B): Når begge inngangene til denne funksjonen er spesifisert, gir den det logaritmiske resultatet av “A” med “Base B”. Den naturlige loggen til “A” produseres i fravær av et baseargument.

Importer cmath
Importer matematikk
u = 8.0
v = 8.0
w = kompleks (u, v);
Print ("Log10 Complex Number:", End = "")
trykk (CMATH.Log10 (W))
print ("Square root complex number:", end = "")
trykk (CMATH.SQRT (W))

Vi passerte de spesifiserte reelle tallene i den komplekse funksjonen. Deretter trykket vi log10 for det komplekse nummeret ved å påkalle log10 -funksjonen i utskriftserklæringen. Vi trykte også kvadratroten av de komplekse tallene.

Utfallet av det forrige skriptet er som følger:

Konklusjon

Metodene som Python muliggjør implementering og lagring av numeriske data er komplekse tall. Det blir sett på som avgjørende for Python -programmeringen. Det er mange måter å administrere de komplekse tallene ved å bruke Python -programmeringsspråket. Vi dekket noen få av disse metodene i denne artikkelen.