Python, mga kumplikadong uri upang gumana sa mga kumplikadong numero (mga ganap na halaga, declination, polar transformations, atbp.)

Negosyo

Ang Python ay may karaniwang uri para sa paghawak ng mga kumplikadong numero, ang uri ng COMPLEX. Kung gusto mo lang gumawa ng mga simpleng kalkulasyon, hindi mo kailangang mag-import ng anumang mga module, ngunit kung mag-import ka ng karaniwang library cmath, maaari mo ring gamitin ang mga function ng matematika (exponential, logarithmic, trigonometric, atbp.) na naaayon sa mga kumplikadong numero.

Ang mga sumusunod na nilalaman ay ipinaliwanag dito kasama ang sample code.

  • Bumuo ng mga kumplikadong variable
  • Kumuha ng tunay at haka-haka na mga bahagi:real,imagkatangian
  • Kumuha ng conjugate complex number:conjugate()paraan
  • Kumuha ng ganap na halaga (magnitude):abs()function (hal. matematika, programming, programing)
  • Kunin ang declination (phase):math,cmathmodyul
  • Pagbabago ng polar coordinate (representasyon ng polar form):math,cmathmodyul
  • Pagkalkula ng mga kumplikadong numero (quadrature, powers, square roots)

Bumuo ng mga kumplikadong variable

Ibigay ang imaginary unit sa pamamagitan ng j at isulat ang sumusunod, tandaan na hindi ito i.

c = 3 + 4j

print(c)
print(type(c))
# (3+4j)
# <class 'complex'>

Kung ang haka-haka na bahagi ay 1, ang pagtanggal dito ay magreresulta sa isang NameError. Kung ang isang variable na pinangalanang j ay unang tinukoy, ito ay itinuturing na variable na iyon.

1j
Dapat itong tahasang ipahayag sa ganitong paraan.

# c = 3 + j
# NameError: name 'j' is not defined

c = 3 + 1j

print(c)
# (3+1j)

Kung ang tunay na bahagi ay 0, maaari itong alisin.

c = 3j

print(c)
# 3j

Kung gusto mong tukuyin ang isang halaga na may isang haka-haka na bahagi ng 0 bilang isang kumplikadong kumplikadong uri, isulat ang 0 nang tahasan. Gaya ng inilarawan sa ibaba, maaaring isagawa ang mga operasyon sa pagitan ng kumplikadong uri at uri ng integer o uri ng floating-point.

c = 3 + 0j

print(c)
# (3+0j)

Ang tunay at haka-haka na mga bahagi ay maaaring tukuyin bilang floating-point float type. Katanggap-tanggap din ang exponential notation.

c = 1.2e3 + 3j

print(c)
# (1200+3j)

Maaari din itong mabuo ng isang constructor ng uri ng “complex”, tulad ng sa “complex(real part, imaginary part)”.

c = complex(3, 4)

print(c)
print(type(c))
# (3+4j)
# <class 'complex'>

Kumuha ng mga tunay at haka-haka na bahagi ng mga kumplikadong numero:real,imagkatangian

Ang tunay at haka-haka na mga bahagi ng isang kumplikadong kumplikadong uri ay maaaring makuha gamit ang tunay at larawang mga katangian, ayon sa pagkakabanggit. Parehong floating-point float na mga uri.

c = 3 + 4j

print(c.real)
print(type(c.real))
# 3.0
# <class 'float'>

print(c.imag)
print(type(c.imag))
# 4.0
# <class 'float'>

Ito ay read only at hindi na mababago.

# c.real = 5.5
# AttributeError: readonly attribute

Kumuha ng conjugate complex number:conjugate()

Para makakuha ng conjugate complex number, gamitin ang conjugate() method.

c = 3 + 4j

print(c.conjugate())
# (3-4j)

Kunin ang absolute value (magnitude) ng isang complex number:abs()

Upang makuha ang absolute value (magnitude) ng isang complex number, gamitin ang built-in na function abs().

c = 3 + 4j

print(abs(c))
# 5.0

c = 1 + 1j

print(abs(c))
# 1.4142135623730951

Kunin ang declination (phase) ng isang complex number:math,cmathmodyul

Upang makuha ang declination (phase) ng isang complex number, gamitin ang math o cmath module.

Ang cmath module ay isang mathematical function module para sa mga kumplikadong numero.

Maaari itong kalkulahin gamit ang inverse tangent function na math.atan2() gaya ng tinukoy, o gumamit ng cmath.phase(), na nagbabalik ng declination (phase).

import cmath
import math

c = 1 + 1j

print(math.atan2(c.imag, c.real))
# 0.7853981633974483

print(cmath.phase(c))
# 0.7853981633974483

print(cmath.phase(c) == math.atan2(c.imag, c.real))
# True

Sa parehong mga kaso, ang yunit ng anggulo na maaaring makuha ay radians. Para mag-convert sa degrees, gamitin ang math.degrees().

print(math.degrees(cmath.phase(c)))
# 45.0

Pagbabago ng polar coordinate ng mga kumplikadong numero (polar na pormal na representasyon):math,cmathmodyul

Gaya ng nabanggit sa itaas, maaaring makuha ang absolute value (magnitude) at declination (phase) ng isang complex number, ngunit gamit ang cmath.polar(), maaari silang makuha nang magkasama bilang isang (absolute value, declination) tuple.

c = 1 + 1j

print(cmath.polar(c))
print(type(cmath.polar(c)))
# (1.4142135623730951, 0.7853981633974483)
# <class 'tuple'>

print(cmath.polar(c)[0] == abs(c))
# True

print(cmath.polar(c)[1] == cmath.phase(c))
# True

Ginagawa ang conversion mula sa mga polar coordinates patungo sa Cartesian coordinates gamit ang cmath.rect(). cmath.rect(absolute value, deviation) at mga katulad na argumento ay maaaring gamitin upang makakuha ng mga value ng katumbas na complex complex complex na uri.

print(cmath.rect(1, 1))
# (0.5403023058681398+0.8414709848078965j)

print(cmath.rect(1, 0))
# (1+0j)

print(cmath.rect(cmath.polar(c)[0], cmath.polar(c)[1]))
# (1.0000000000000002+1j)

Ang tunay at haka-haka na mga bahagi ay katumbas ng mga resultang kinakalkula ng cosine math.cos() at sine math.sin() mula sa mga absolute value at anggulo ng declination.

r = 2
ph = math.pi

print(cmath.rect(r, ph).real == r * math.cos(ph))
# True

print(cmath.rect(r, ph).imag == r * math.sin(ph))
# True

Pagkalkula ng mga kumplikadong numero (quadrature, powers, square roots)

Apat na pagpapatakbo ng arithmetic at pagkalkula ng kapangyarihan ang maaaring isagawa gamit ang karaniwang mga operator ng arithmetic.

c1 = 3 + 4j
c2 = 2 - 1j

print(c1 + c2)
# (5+3j)

print(c1 - c2)
# (1+5j)

print(c1 * c2)
# (10+5j)

print(c1 / c2)
# (0.4+2.2j)

print(c1 ** 3)
# (-117+44j)

Maaaring kalkulahin ang square root gamit ang **0.5, ngunit ito ay nagpapakilala ng error. cmath.sqrt() ay maaaring gamitin upang kalkulahin ang eksaktong halaga.

print((-3 + 4j) ** 0.5)
# (1.0000000000000002+2j)

print((-1) ** 0.5)
# (6.123233995736766e-17+1j)

print(cmath.sqrt(-3 + 4j))
# (1+2j)

print(cmath.sqrt(-1))
# 1j

Maaari rin itong magsagawa ng mga pagpapatakbo ng arithmetic na may mga kumplikadong uri, uri ng int, at mga uri ng float.

print(c1 + 3)
# (6+4j)

print(c1 * 0.5)
# (1.5+2j)