Python၊ ရှုပ်ထွေးသောနံပါတ်များဖြင့် လုပ်ဆောင်ရန် ရှုပ်ထွေးသောအမျိုးအစားများ (ပကတိတန်ဖိုးများ၊ ကျဆင်းခြင်း၊ ဝင်ရိုးစွန်းအသွင်ပြောင်းခြင်း စသည်)

Python တွင် ရှုပ်ထွေးသော နံပါတ်များကို ကိုင်တွယ်ရန်အတွက် စံအမျိုးအစားတစ်ခု၊ COMPLEX အမျိုးအစား ရှိသည်။ ရိုးရှင်းသော တွက်ချက်မှုများ ပြုလုပ်လိုပါက မည်သည့် module များကိုမဆို တင်သွင်းရန် မလိုအပ်သော်လည်း စံစာကြည့်တိုက် cmath ကို တင်သွင်းပါက၊ ရှုပ်ထွေးသော ဂဏန်းများနှင့် သက်ဆိုင်သော သင်္ချာလုပ်ဆောင်ချက်များ (exponential, logarithmic, trigonometric, etc.) ကို အသုံးပြုနိုင်သည်။

• cmath — Mathematical functions for complex numbers — Python 3.10.4 Documentation

အောက်ပါအကြောင်းအရာများကို နမူနာကုဒ်ဖြင့် ဤနေရာတွင် ရှင်းပြထားပါသည်။

• ရှုပ်ထွေးသော ကိန်းရှင်များကို ဖန်တီးပါ။
• အစစ်အမှန်နှင့် စိတ်ကူးယဉ် အစိတ်အပိုင်းများကို ရယူပါ။:real,imagဂုဏ်ရည်
• ပေါင်းစပ်ရှုပ်ထွေးသောနံပါတ်များကိုရယူပါ။:conjugate()နည်းလမ်း
• ပကတိတန်ဖိုး (ပြင်းအား) ကို ရယူပါ:abs()လုပ်ဆောင်ချက် (ဥပမာ သင်္ချာ၊ ပရိုဂရမ်းမင်း၊ ပရိုဂရမ်)
• ငြင်းပယ်ခြင်း (အဆင့်) ကိုရယူပါ။:math,cmathမော်ဂျူး
• ဝင်ရိုးစွန်း ပေါင်းစပ် အသွင်ပြောင်းခြင်း (ဝင်ရိုးစွန်းပုံစံ ကိုယ်စားပြုမှု):math,cmathမော်ဂျူး
• ရှုပ်ထွေးသော ဂဏန်းများ (စတုရန်းပုံ၊ ပါဝါ၊ နှစ်ထပ်ကိန်းများ) တွက်ချက်ခြင်း

ရှုပ်ထွေးသော ကိန်းရှင်များကို ဖန်တီးပါ။

j ဖြင့် စိတ်ကူးယဉ်ယူနစ်ကို အမှတ်အသားပြုပြီး အောက်ပါတို့ကိုရေးပါ၊ ၎င်းသည် i မဟုတ်ကြောင်း သတိပြုပါ။

c = 3 + 4j

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

စိတ်ကူးယဉ်အပိုင်းသည် 1 ဖြစ်ပါက ၎င်းကို ချန်လှပ်ထားခြင်းဖြင့် NameError ဖြစ်နိုင်ပါသည်။ j လို့အမည်ပေးထားတဲ့ variable ကို ဦးစွာသတ်မှတ်ပါက၊ ၎င်းကို ထိုကိန်းရှင်ဟု ယူဆပါသည်။

1j
ဤနည်းဖြင့် အတိအလင်း ဖော်ပြရမည်။

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

c = 3 + 1j

print(c)
# (3+1j)

အစစ်အမှန်အပိုင်းသည် 0 ဖြစ်ပါက ချန်လှပ်နိုင်သည်။

c = 3j

print(c)
# 3j

0 ၏ စိတ်ကူးယဉ်အစိတ်အပိုင်းတစ်ခုဖြင့် တန်ဖိုးတစ်ခုကို ရှုပ်ထွေးရှုပ်ထွေးသောအမျိုးအစားအဖြစ် သတ်မှတ်လိုပါက 0 ကို အတိအလင်းရေးပါ။ အောက်တွင်ဖော်ပြထားသည့်အတိုင်း၊ ရှုပ်ထွေးသောအမျိုးအစားနှင့် ကိန်းပြည့်အမျိုးအစား သို့မဟုတ် Floating-Point အမျိုးအစားကြားတွင် လုပ်ဆောင်ချက်များကို လုပ်ဆောင်နိုင်သည်။

c = 3 + 0j

print(c)
# (3+0j)

အစစ်အမှန်နှင့် စိတ်ကူးယဉ် အစိတ်အပိုင်းများကို Float-point float အမျိုးအစားအဖြစ် သတ်မှတ်နိုင်ပါသည်။ Exponential notation ကိုလည်း လက်ခံနိုင်သည်။

c = 1.2e3 + 3j

print(c)
# (1200+3j)

၎င်းကို “ complex (အစစ်အမှန်အပိုင်း၊ စိတ်ကူးယဉ်အပိုင်း)” တွင်ကဲ့သို့ “ complex” ၏ constructor မှလည်း ထုတ်လုပ်နိုင်သည်။

c = complex(3, 4)

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

ရှုပ်ထွေးသောကိန်းဂဏန်းများ၏ အစစ်အမှန်နှင့် စိတ်ကူးယဉ်အစိတ်အပိုင်းများကို ရယူပါ။:real,imagဂုဏ်ရည်

ရှုပ်ထွေးရှုပ်ထွေးသော အမျိုးအစားတစ်ခု၏ အစစ်အမှန်နှင့် စိတ်ကူးယဉ် အစိတ်အပိုင်းများကို အစစ်အမှန်နှင့် ပုံသဏ္ဍာန်ဂုဏ်ပုဒ်များဖြင့် အသီးသီး ရရှိနိုင်ပါသည်။ နှစ်ခုစလုံးသည် Floating Point အမျိုးအစားများဖြစ်သည်။

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'>

၎င်းကိုဖတ်ရန်သာဖြစ်ပြီး ပြောင်းလဲ၍မရပါ။

# c.real = 5.5
# AttributeError: readonly attribute

ပေါင်းစပ်ရှုပ်ထွေးသောနံပါတ်များကိုရယူပါ။:conjugate()

ပေါင်းစည်းရှုပ်ထွေးသော နံပါတ်များကို ရယူရန်၊ conjugate() နည်းလမ်းကို အသုံးပြုပါ။

c = 3 + 4j

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

ရှုပ်ထွေးသောနံပါတ်တစ်ခု၏ ပကတိတန်ဖိုး (ပြင်းအား) ကို ရယူပါ။:abs()

ရှုပ်ထွေးသောနံပါတ်တစ်ခု၏ ပကတိတန်ဖိုး (ပြင်းအား) ကိုရယူရန်၊ built-in လုပ်ဆောင်ချက် abs() ကို အသုံးပြုပါ။

c = 3 + 4j

print(abs(c))
# 5.0

c = 1 + 1j

print(abs(c))
# 1.4142135623730951

ရှုပ်ထွေးသောနံပါတ်တစ်ခု၏ ကျဆင်းမှု (အဆင့်) ကို ရယူပါ။:math,cmathမော်ဂျူး

ရှုပ်ထွေးသောနံပါတ်တစ်ခု၏ ကျဆင်းမှု (အဆင့်) ကိုရရှိရန် သင်္ချာ သို့မဟုတ် cmath မော်ဂျူးကို အသုံးပြုပါ။

cmath module သည် ရှုပ်ထွေးသော ဂဏန်းများအတွက် သင်္ချာလုပ်ဆောင်ချက် module တစ်ခုဖြစ်သည်။

• cmath — Mathematical functions for complex numbers — Python 3.10.4 Documentation

သတ်မှတ်ထားသည့်အတိုင်း inverse tangent function math.atan2() ဖြင့် တွက်ချက်နိုင်သည်၊ သို့မဟုတ် declination (phase) ကို ပြန်ပေးသည့် cmath.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

နှစ်ခုစလုံးတွင်၊ ရရှိနိုင်သောထောင့်ယူနစ်သည် ရေဒီယံဖြစ်သည်။ ဒီဂရီအဖြစ်ပြောင်းရန် math.degrees() ကိုသုံးပါ။

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

ရှုပ်ထွေးသော ဂဏန်းများ၏ ဝင်ရိုးစွန်း ပေါင်းစပ် အသွင်ပြောင်းခြင်း (ဝင်ရိုးစွန်း တရားဝင် ကိုယ်စားပြုမှု):math,cmathမော်ဂျူး

အထက်တွင်ဖော်ပြထားသည့်အတိုင်း၊ ရှုပ်ထွေးသောကိန်းတစ်ခု၏ ပကတိတန်ဖိုး (ပြင်းအား) နှင့် ကျဆင်းခြင်း (အဆင့်) ကို ရရှိနိုင်သော်လည်း cmath.polar() ကိုအသုံးပြု၍ ၎င်းတို့ကို (လုံးဝတန်ဖိုး၊ ကျဆင်းခြင်း) 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

ဝင်ရိုးစွန်း သြဒိနိတ်များမှ ကာတီဆီယံ သြဒီနိတ်သို့ ပြောင်းလဲခြင်းကို cmath.rect() ကို အသုံးပြု၍ ပြီးပါပြီ။ cmath.rect(အကြွင်းမဲ့တန်ဖိုး၊ သွေဖည်မှု) နှင့် အလားတူ ငြင်းခုံမှုများကို ညီမျှသော ရှုပ်ထွေးသော ရှုပ်ထွေးသော ရှုပ်ထွေးသော အမျိုးအစား၏ တန်ဖိုးများရရှိရန် အသုံးပြုနိုင်သည်။

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)

အစစ်အမှန်နှင့် စိတ်ကူးယဉ်အစိတ်အပိုင်းများသည် အကြွင်းမဲ့တန်ဖိုးများနှင့် ကျဆင်းခြင်းထောင့်များမှ cosine math.cos() နှင့် sine math.sin() တို့မှ တွက်ချက်ထားသော ရလဒ်များနှင့် ညီမျှသည်။

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

ရှုပ်ထွေးသော ဂဏန်းများ (စတုရန်းပုံ၊ ပါဝါ၊ နှစ်ထပ်ကိန်းများ) တွက်ချက်ခြင်း

ဂဏန်းသင်္ချာလုပ်ငန်းလေးခုနှင့် ပါဝါတွက်ချက်မှုများကို ပုံမှန်ဂဏန်းသင်္ချာအော်ပရေတာများကို အသုံးပြု၍ လုပ်ဆောင်နိုင်သည်။

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)

Square root ကို **0.5 ဖြင့် တွက်ချက်နိုင်သော်လည်း ၎င်းသည် error ကိုတင်ပြပါသည်။ အတိအကျတန်ဖိုးကိုတွက်ချက်ရန် cmath.sqrt() ကိုသုံးနိုင်သည်။

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

၎င်းသည် ရှုပ်ထွေးသောအမျိုးအစားများ၊ int အမျိုးအစားများနှင့် float အမျိုးအစားများဖြင့် ဂဏန်းသင်္ချာလုပ်ဆောင်မှုများကို လုပ်ဆောင်နိုင်သည်။

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

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