Pythoni kompleksarvud: matemaatiliste operatsioonide ja polaarse kuju valdamine

Matemaatika ja teadusliku arvutamise valdkonnas on kompleksarvud fundamentaalsed. Need laiendavad reaalarvude kontseptsiooni, lisades imaginaarse komponendi, mida tähistatakse ühikuga i, kus i² = -1. Python, mitmekülgne programmeerimiskeel, mida kasutatakse laialdaselt globaalsetes tööstusharudes ja akadeemilistes distsipliinides, pakub tugevat tuge kompleksarvudele, muutes keerulised matemaatilised operatsioonid kättesaadavaks ja tõhusaks.

See põhjalik juhend süveneb Pythoni kompleksarvude käsitlemisse, uurides nii nende tavalist algebralist esitust kui ka nende võimsat polaarset kuju. Me käsitleme olulisi matemaatilisi operatsioone ja näitame, kuidas kasutada polaarset koordinaatsüsteemi, et paremini mõista ja manipuleerida kompleksarvudega erinevates rakendustes, alates signaalitöötlusest kuni kvantmehaanikani.

Kompleksarvude mõistmine Pythonis

Kompleksarvu väljendatakse tavaliselt ristkülikukujulises (või Cartesiuse) vormis kui a + bi, kus a on reaalarv ja b on imaginaararv. Python toetab algselt kompleksarve, kasutades seda a + bj tähistust, kus j-d kasutatakse i asemel, et vältida segadust elektrotehnika kontekstis vooluga. Pythoni kompleksarvu tüüp toimib aga identselt, olenemata sellest, kas kasutate oma koodis imaginaarühikuna j või i.

Kompleksarvude loomine Pythonis

Kompleksarvu loomine Pythonis on lihtne. Saate kasutada sisseehitatud funktsiooni complex() või otse süntaksit a + bj.

• Kasutades funktsiooni complex():

Funktsioon complex() saab võtta kaks argumenti: reaalarv ja imaginaararv. Kui on antud ainult üks argument, käsitletakse seda reaalarvuna ja imaginaararvu vaikimisi väärtus on null. Kui argumente ei ole antud, loob see 0j.

            # Kompleksarvude loomine complex() abil
complex_num1 = complex(3, 5)  # Reaalarv 3, imaginaararv 5
print(f"Kompleksarv 1: {complex_num1}")

complex_num2 = complex(7)     # Reaalarv 7, imaginaararv 0
print(f"Kompleksarv 2: {complex_num2}")

complex_num3 = complex(0, -2) # Reaalarv 0, imaginaararv -2
print(f"Kompleksarv 3: {complex_num3}")

complex_num4 = complex()      # Reaalarv 0, imaginaararv 0
print(f"Kompleksarv 4: {complex_num4}")

            

              
                Copy
              
            
          

• Kasutades süntaksit a + bj:

See on tavalisem ja sageli loetavam viis kompleksarvude määratlemiseks Pythonis.

            # Kompleksarvude loomine a + bj süntaksiga
complex_num_a = 4 + 6j
print(f"Kompleksarv A: {complex_num_a}")

complex_num_b = -2 - 3j
print(f"Kompleksarv B: {complex_num_b}")

complex_num_c = 9j       # Reaalarv on 0
print(f"Kompleksarv C: {complex_num_c}")

complex_num_d = 1 + 1j   # Ekvivalentne 1 + j
print(f"Kompleksarv D: {complex_num_d}")

            

              
                Copy
              
            
          

Reaalarvu ja imaginaararvu osadele juurdepääs

Kui teil on kompleksarvu objekt, saate selle reaalarvule ja imaginaararvu komponendile hõlpsasti juurde pääseda, kasutades vastavalt atribuute .real ja .imag. Need atribuudid tagastavad alati ujukomaarvud.

            my_complex = 5.5 + 2.3j

print(f"Kompleksarv on: {my_complex}")
print(f"Reaalarv: {my_complex.real}")
print(f"Imaginaararv: {my_complex.imag}")

            

              
                Copy
              
            
          

Kompleksarvude tüüp

Pythoni kompleksarvu tüüp on eraldiseisev. Saate selle tüüpi kontrollida funktsiooniga type().

            z = 3 + 4j
print(f"z tüüp: {type(z)}")

            

              
                Copy
              
            
          

Matemaatilised operatsioonid kompleksarvudega ristkülikukujulises vormis

Python toetab standardseid aritmeetilisi operatsioone otse kompleksarvudega, muutes matemaatilised arvutused intuitiivseks. Nende operatsioonide tulemused on ka kompleksarvud.

Liitmine ja lahutamine

Kompleksarvude liitmine või lahutamine hõlmab nende vastavate reaalarvude ja imaginaararvude osade liitmist või lahutamist.

Valem:

(a + bi) + (c + di) = (a + c) + (b + d)i

(a + bi) - (c + di) = (a - c) + (b - d)i

            z1 = 2 + 3j
z2 = 1 - 5j

# Liitmine
sum_result = z1 + z2
print(f"{z1} + {z2} = {sum_result}")

# Lahutamine
diff_result = z1 - z2
print(f"{z1} - {z2} = {diff_result}")

            

              
                Copy
              
            
          

Korrutamine

Kompleksarvude korrutamine järgib jaotusomadust, mäletades, et j² = -1.

Valem:

(a + bi) * (c + di) = ac + adi + bci + bdi² = (ac - bd) + (ad + bc)i

            z1 = 2 + 3j
z2 = 1 - 5j

# Korrutamine
prod_result = z1 * z2
print(f"{z1} * {z2} = {prod_result}")

            

              
                Copy
              
            
          

Jagamine

Kompleksarvude jagamine hõlmab lugeja ja nimetaja korrutamist nimetaja konjugaadiga, et nimetaja ratsionaliseerida.

Valem:

(a + bi) / (c + di) = ((a + bi) * (c - di)) / ((c + di) * (c - di)) = ((ac + bd) + (bc - ad)i) / (c² + d²)

            z1 = 2 + 3j
z2 = 1 - 5j

# Jagamine
div_result = z1 / z2
print(f"{z1} / {z2} = {div_result}")

# Nulliga jagamine tekitab ZeroDivisionError
# zero_complex = 0 + 0j
# print(z1 / zero_complex)

            

              
                Copy
              
            
          

Konjugaat

Kompleksarvu a + bj konjugaat on a - bj. Pythonis tagastab meetod .conjugate() komplekskonjugaadi.

            z = 4 + 7j
conjugate_z = z.conjugate()
print(f"Arvu {z} konjugaat on {conjugate_z}")

            

              
                Copy
              
            
          

Suurus (absoluutväärtus)

Kompleksarvu a + bj suurus või absoluutväärtus on selle kaugus alguspunktist kompleksarvude tasandil, arvutatuna kui sqrt(a² + b²). Pythoni sisseehitatud funktsioon abs() arvutab selle.

Valem:

|a + bi| = sqrt(a² + b²)

            z = 3 + 4j
magnitude_z = abs(z)
print(f"Arvu {z} suurus on {magnitude_z}")

            

              
                Copy
              
            
          

Kompleksarvu astendamine

Toetatud on ka kompleksarvu astmesse tõstmine. Täisarvuliste astmete puhul on see lihtne. Murruliste või kompleksarvuliste astmete puhul võivad tulemused olla mitmeväärtuselised ja neid käsitletakse tavaliselt logaritmide abil.

            z = 1 + 1j

# Kompleksarvu ruutu tõstmine
squared_z = z ** 2
print(f"{z} ruudus on {squared_z}")

# Kõrgemale astmele tõstmine
cubed_z = z ** 3
print(f"{z} kuubis on {cubed_z}")

# Murruline aste (võib viia mitme tulemuseni)
# Python tagastab tavaliselt põhiväärtuse
sqrt_z = z ** 0.5
print(f"Arvu {z} ruutjuur on (põhiväärtus) {sqrt_z}")

            

              
                Copy
              
            
          

Polaarse kuju jõud

Kuigi ristkülikukujuline vorm (a + bj) on põhilise aritmeetika jaoks intuitiivne, pakub polaarne vorm olulisi eeliseid pöörde, korrutamise, jagamise ja astendamise mõistmiseks, eriti inseneriteaduses ja füüsikas.

Kompleksarvu saab esitada ka polaarsel kujul kui r(cos θ + i sin θ) või kompaktselt Euleri valemi abil, re^iθ. Siin:

• r (moodul): Suurus või kaugus alguspunktist (sama mis varem arvutatud absoluutväärtus).
• θ (argument): Nurk (radiaanides), mille sirglõik alguspunktist kompleksarvuni moodustab positiivse reaalteljega.

Ristkülikukujulisest polaarseks muundamine

Antud kompleksarv z = a + bj, saame selle teisendada polaarseks kujuks:

• Moodul (r): r = abs(z)
• Argument (θ): θ = atan2(b, a). Funktsioon atan2(y, x) moodulist math (või cmath) on ülioluline, kuna see määrab nurga õigesti kõigis neljas kvadrandis, erinevalt lihtsast atan(b/a)-st.

Pythoni moodul cmath pakub funktsioone polaarkoordinaatidega otse töötamiseks.

            import cmath

z_rect = 3 + 4j

# Teisenda polaarkoordinaatideks
polar_coords = cmath.polar(z_rect)
radius = polar_coords[0]     # See on 'r'
angle_radians = polar_coords[1] # See on 'theta'

print(f"Ristkülikukujuline: {z_rect}")
print(f"Polaarne: Raadius = {radius:.2f}, Nurk (radiaanides) = {angle_radians:.2f}")

# Kraadide saamiseks teisendage radiaanid kraadideks
angle_degrees = cmath.degrees(angle_radians)
print(f"Polaarne: Nurk (kraadides) = {angle_degrees:.2f}")

            

              
                Copy
              
            
          

Polaarsest ristkülikukujuliseks teisendamine

Antud kompleksarv polaarsel kujul r(cos θ + i sin θ) või re^iθ, saame selle tagasi teisendada ristkülikukujuliseks:

• Reaalarv (a): a = r * cos(θ)
• Imaginaararv (b): b = r * sin(θ)

Pythoni moodulil cmath on selleks funktsioon cmath.rect().

            import cmath

radius = 5.0
angle_radians = 0.927 # Ligikaudu 53.13 kraadi

# Teisenda polaarsest ristkülikukujuliseks koordinaatideks
rectangular_coords = cmath.rect(radius, angle_radians)

print(f"Polaarne: Raadius = {radius}, Nurk (radiaanides) = {angle_radians:.2f}")
print(f"Ristkülikukujuline: {rectangular_coords}")

# Kraadide kasutamine funktsiooniga cmath.rect ei ole otsene; teisendage kraadid esmalt radiaanideks
angle_degrees_example = 45.0
angle_radians_example = cmath.radians(angle_degrees_example)
rect_from_deg = cmath.rect(1.0, angle_radians_example)
print(f"Polaarne (45 kraadi): {rect_from_deg}")

            

              
                Copy
              
            
          

Operatsioonid polaarvormis

Korrutamine polaarvormis

Kahe kompleksarvu korrutamiseks polaarvormis korrutate nende moodulid ja liidate nende argumendid.

Valem:

Kui z1 = r1(cos θ1 + i sin θ1) ja z2 = r2(cos θ2 + i sin θ2), siis

z1 * z2 = (r1 * r2) * [cos(θ1 + θ2) + i sin(θ1 + θ2)]

Pythoni moodulil cmath puudub otsene korrutamisfunktsioon, mis võtaks polaarsed sisendid ja väljastaks polaarsed tulemused ühe sammuna. Tavaliselt teisendaksite ristkülikukujuliseks, korrutaksite ja seejärel teisendaksite vajadusel tagasi või rakendaksite loogikat käsitsi.

            import cmath

z1_rect = 2 + 3j
z2_rect = 1 - 5j

# Teisenda polaarseteks
r1, theta1 = cmath.polar(z1_rect)
r2, theta2 = cmath.polar(z2_rect)

# Teosta korrutamine polaardomeenis
product_r = r1 * r2
product_theta = theta1 + theta2

# Teisenda tulemus tagasi ristkülikukujuliseks
product_rect_polar_method = cmath.rect(product_r, product_theta)

# Võrdluseks, otsene korrutamine ristkülikukujulises vormis
product_rect_direct = z1_rect * z2_rect

print(f"z1 = {z1_rect}, Polaarne: r={r1:.2f}, theta={cmath.degrees(theta1):.2f} deg")
print(f"z2 = {z2_rect}, Polaarne: r={r2:.2f}, theta={cmath.degrees(theta2):.2f} deg")
print(f"Korrutis (polaarne meetod): {product_rect_polar_method}")
print(f"Korrutis (otsene meetod): {product_rect_direct}")

# Märkus: Võivad esineda väikesed ujukoma erinevused

            

              
                Copy
              
            
          

Jagamine polaarvormis

Kahe kompleksarvu jagamiseks polaarvormis jagate nende moodulid ja lahutate nende argumendid (lugeja argument miinus nimetaja argument).

Valem:

Kui z1 = r1(cos θ1 + i sin θ1) ja z2 = r2(cos θ2 + i sin θ2), siis

z1 / z2 = (r1 / r2) * [cos(θ1 - θ2) + i sin(θ1 - θ2)]

            import cmath

z1_rect = 2 + 3j
z2_rect = 1 - 5j

# Teisenda polaarseteks
r1, theta1 = cmath.polar(z1_rect)
r2, theta2 = cmath.polar(z2_rect)

# Teosta jagamine polaardomeenis
quotient_r = r1 / r2
quotient_theta = theta1 - theta2

# Teisenda tulemus tagasi ristkülikukujuliseks
quotient_rect_polar_method = cmath.rect(quotient_r, quotient_theta)

# Võrdluseks, otsene jagamine ristkülikukujulises vormis
quotient_rect_direct = z1_rect / z2_rect

print(f"Jagatis (polaarne meetod): {quotient_rect_polar_method}")
print(f"Jagatis (otsene meetod): {quotient_rect_direct}")

            

              
                Copy
              
            
          

Astendamine (De Moivre'i teoreem)

Kompleksarvu astendamine polaarvormis täisarvulise astmega n lihtsustatakse De Moivre'i teoreemiga:

Valem:

[r(cos θ + i sin θ)]ⁿ = rⁿ(cos(nθ) + i sin(nθ))

See teoreem on uskumatult kasulik kompleksarvude juurte arvutamiseks ja polünoomvõrrandite lahendamiseks. Kompleksarvuliste astmete puhul laiendatakse seda logaritmide abil.

            import cmath

z_rect = 1 + 1j

# Teisenda polaarseteks
r, theta = cmath.polar(z_rect)

n = 5  # aste

# Arvuta z^n De Moivre'i teoreemi abil
hesized_r = r ** n
hesized_theta = n * theta

# Teisenda tulemus tagasi ristkülikukujuliseks
hesized_rect_polar_method = cmath.rect(hesized_r, hesized_theta)

# Võrdluseks, otsene astendamine Pythonis
hesized_rect_direct = z_rect ** n

print(f"z = {z_rect}, Polaarne: r={r:.2f}, theta={cmath.degrees(theta):.2f} deg")
print(f"{z_rect}^{n} (polaarne meetod): {hesized_rect_polar_method}")
print(f"{z_rect}^{n} (otsene meetod): {hesized_rect_direct}")

# Juurte arvutamine (nt kuupjuur, n=1/3)
n_root = 1/3

r_root = r ** n_root
theta_root_principal = n_root * theta

# Põhijuur
principal_root = cmath.rect(r_root, theta_root_principal)
print(f"Arvu {z_rect} peamine kuupjuur: {principal_root}")

# Märkus: Juurte puhul on 'n' erinevat väärtust. De Moivre'i teoreem otse rakendatuna
# annab tavaliselt põhijuure. Kõigi juurte leidmiseks lisaksite nurgale kordarve 2*pi/n.

for k in range(3):
    current_angle = (theta + 2 * cmath.pi * k) / 3
    root_k = cmath.rect(r_root, current_angle)
    print(f"Kuupjuur {k+1}: {root_k}")

            

              
                Copy
              
            
          

Levinud kompleksarvu funktsioonid moodulis cmath

Moodul cmath pakub palju täiustatud matemaatilisi funktsioone, mis töötavad kompleksarvudega, sealhulgas trigonomeetrilised, hüperboolsed ja logaritmilised funktsioonid.

• cmath.sqrt(z): Arvutab kompleksarvu ruutjuure. Tagastab peamise ruutjuure.
• cmath.exp(z): Arvutab e astmes z.
• cmath.log(z[, base]): Arvutab z logaritmi. Kui base on määratud, arvutab see logaritmi selle alusega. Muidu arvutab see naturaallogaritmi.
• cmath.sin(z), cmath.cos(z), cmath.tan(z): Trigonomeetrilised funktsioonid kompleksarvude jaoks.
• cmath.sinh(z), cmath.cosh(z), cmath.tanh(z): Hüperboolsed funktsioonid kompleksarvude jaoks.

            import cmath

z = 1 + 1j

# Ruutjuur
print(f"sqrt({z}) = {cmath.sqrt(z)}")

# Eksponent
print(f"exp({z}) = {cmath.exp(z)}")

# Naturaallogaritm
print(f"log({z}) = {cmath.log(z)}")

# Siinus
print(f"sin({z}) = {cmath.sin(z)}")

            

              
                Copy
              
            
          

Kompleksarvude rakendused

Kompleksarvud ja nende polaarne esitus on asendamatud paljudes teadus- ja insenerivaldkondades:

• Elektrotehnika: Kasutatakse laialdaselt vahelduvvooluahelate analüüsis, impedantsis ja signaalitöötluses. Polaarne vorm on loomulik vahelduvvoolude ja pingete suuruse ja faasi kirjeldamiseks.
• Signaalitöötlus: Fourier' teisendused, mis lagundavad signaale nende koostisosa sagedusteks, tuginevad suuresti komplekseksponentidele (e^iωt), mis on loomulikult väljendatud polaarvormis.
• Kvantmehaanika: Kvantmehaanika põhivõrrandid, nagu Schrödinger'i võrrand, hõlmavad kompleksseid lainefunktsioone.
• Juhtimissüsteemid: Süsteemi stabiilsuse ja sagedusvastuse analüüsimine hõlmab sageli kompleksarve Laplace'i domeenis.
• Vedelikudünaamika: Teatud vedelikumehaanika probleeme saab lihtsustada kompleksse potentsiaaliteooria abil.
• Fraktaalgeomeetria: Fraktaale nagu Mandelbroti hulk genereeritakse kompleksfunktsioonide itereerimisega.

Globaalne näide: Fourier' teisendus helitöötluses

Mõelge helisignaali töötlusele kogu maailmas. Helilaine analüüsimisel kasutavad insenerid ja andmeteadlased diskreetset Fourier' teisendust (DFT) või selle tõhusat rakendamist, kiiret Fourier' teisendust (FFT). DFT teisendab ajadomeeni signaali (kuidas helirõhk aja jooksul muutub) selle sagedusdomeeni esituseks. See esitus on rida kompleksarve, kus iga kompleksarv vastab kindlale sagedusele. Kompleksarvu suurus näitab selle sageduskomponendi amplituudi (valjust) ja selle argument (nurk) näitab selle faasi. See võimaldab selliseid ülesandeid nagu müra vähendamine, ekvaliseerimine ja muusika süntees, mis on standardsed kogu globaalses helitootmises ja -analüüsis.

Parimad tavad kompleksarvude kasutamiseks Pythonis

• Valige õige vorm: Põhilise aritmeetika (liitmine, lahutamine) jaoks on ristkülikukujuline vorm sageli lihtsam. Korrutamise, jagamise ja astendamise/juurte puhul, eriti kui on tegemist nurkade ja pöörlemistega, on polaarvorm (või cmath funktsioonide kasutamine, mis seda abstraheerivad) tavaliselt tõhusam ja kontseptuaalselt selgem.
• Kasutage cmath: Kasutage alati moodulit cmath kompleksarvude matemaatika jaoks, mis ületab põhilist aritmeetikat. See käsitleb äärmusjuhtumeid ja pakub täiustatud funktsioone usaldusväärselt.
• Olge teadlik ujukoma täpsusest: Nagu kõigi ujukomaarvutuste puhul, võivad ka kompleksarve hõlmavatel tulemustel olla väikesed täpsusvead. Olge ettevaatlik kompleksarvude täpse võrdsuse võrdlemisel.
• Mõista radiaane: Pythoni moodulite math ja cmath trigonomeetrilised funktsioonid töötavad radiaanidega. Veenduge, et teie nurgad oleksid õiges ühikus.
• Kasutage nurkade jaoks funktsiooni `atan2`: Argumendi käsitsi arvutamisel reaalarvu ja imaginaararvu osade põhjal kasutage math.atan2(imaginary, real) või cmath.phase(complex_number), et määrata täpselt kvadrant.

Järeldus

Pythoni sisseehitatud tugi kompleksarvudele, mida täiendab võimas moodul cmath, pakub põhjalikku tööriistakomplekti paljude matemaatiliste ja teaduslike väljakutsete lahendamiseks. Olenemata sellest, kas teete lihtsaid algebralisi manipulatsioone või süvenete polaarkoordinaatide elegantsesse maailma selliste toimingute jaoks nagu pööramine ja skaleerimine, annab Python teile selguse ja tõhususe.

Mõistes ristkülikukujuliste ja polaarsete vormide vastastikust mõju ning rakendades mõistlikult standardteegi pakutavaid funktsioone, saavad arendajad ja teadlased kogu maailmas avada uusi võimalusi valdkondades alates telekommunikatsioonist ja lennundusest kuni finantsmodelleerimise ja kvantarvutusteni. Nende kontseptsioonide valdamine suurendab kahtlemata teie probleemide lahendamise võimalusi üha keerukamas ja omavahel seotud maailmas.