Python සතුව සංකීර්ණ සංඛ්‍යා හැසිරවීමට සම්මත වර්ගයක් ඇත, එනම් COMPLEX වර්ගය. ඔබට සරල ගණනය කිරීම් කිරීමට අවශ්‍ය නම්, ඔබට කිසිදු මොඩියුලයක් ආනයනය කිරීමට අවශ්‍ය නැත, නමුත් ඔබ සම්මත පුස්තකාල cmath ආනයනය කරන්නේ නම්, ඔබට සංකීර්ණ සංඛ්‍යා වලට අනුරූප වන ගණිතමය ශ්‍රිත (ඝාතීය, ලඝුගණක, ත්‍රිකෝණමිතික, ආදිය) භාවිතා කළ හැකිය.
නියැදි කේතය සමඟ පහත අන්තර්ගතයන් මෙහි විස්තර කර ඇත.
- සංකීර්ණ විචල්‍යයන් ජනනය කරන්න
- සැබෑ සහ මනඃකල්පිත කොටස් ලබා ගන්න:
real,imagගුණාංගය - සංයුජ සංකීර්ණ සංඛ්‍යා ලබා ගන්න:
conjugate()ක්රමය - නිරපේක්ෂ අගය ලබා ගන්න (විශාලත්වය):
abs()ශ්‍රිතය (උදා. ගණිතය, ක්‍රමලේඛනය, ක්‍රමලේඛනය) - declination (අදියර) ලබා ගන්න:
math,cmathමොඩියුලය - ධ්‍රැවීය ඛණ්ඩාංක පරිවර්තනය (ධ්‍රැව ආකෘති නිරූපණය):
math,cmathමොඩියුලය - සංකීර්ණ සංඛ්‍යා ගණනය කිරීම (චතුරශ්‍රය, බල, වර්ග මුල්)
- සංකීර්ණ විචල්‍යයන් ජනනය කරන්න
- සංකීර්ණ සංඛ්‍යාවල සැබෑ සහ මනඃකල්පිත කොටස් ලබා ගන්න: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 නමින් විචල්‍යයක් පළමුව අර්ථ දැක්වුවහොත් එය එම විචල්‍යය ලෙස සැලකේ.
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 පැහැදිලිව ලියන්න. පහත විස්තර කර ඇති පරිදි, සංකීර්ණ වර්ගය සහ පූර්ණ සංඛ්‍යා වර්ගය හෝ පාවෙන ලක්ෂ්‍ය වර්ගය අතර මෙහෙයුම් සිදු කළ හැක.
c = 3 + 0j
print(c)
# (3+0j)
සැබෑ සහ මනඃකල්පිත කොටස් පාවෙන ලක්ෂ්‍ය පාවෙන වර්ගය ලෙස දැක්විය හැක. ඝාතීය අංකනය ද පිළිගත හැකිය.
c = 1.2e3 + 3j
print(c)
# (1200+3j)
එය “සංකීර්ණ (සැබෑ කොටස, මනඃකල්පිත කොටස)” ලෙස, “සංකීර්ණ” වර්ගයේ ඉදිකිරීම්කරුවෙකු විසින් ද ජනනය කළ හැක.
c = complex(3, 4)
print(c)
print(type(c))
# (3+4j)
# <class 'complex'>
සංකීර්ණ සංඛ්‍යාවල සැබෑ සහ මනඃකල්පිත කොටස් ලබා ගන්න:real,imagගුණාංගය
සංකීර්ණ සංකීර්ණ වර්ගයක සැබෑ සහ මනඃකල්පිත කොටස් පිළිවෙලින් සැබෑ සහ රූප ගුණාංග සමඟ ලබා ගත හැකිය. දෙකම floating-point float වර්ග.
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()
සංයුජ සංකීර්ණ සංඛ්‍යා ලබාගැනීමට, සංයුජ() ක්රමය භාවිතා කරන්න.
c = 3 + 4j
print(c.conjugate())
# (3-4j)
සංකීර්ණ සංඛ්‍යාවක නිරපේක්ෂ අගය (විශාලත්වය) ලබා ගන්න:abs()
සංකීර්ණ සංඛ්‍යාවක නිරපේක්ෂ අගය (විශාලත්වය) ලබා ගැනීම සඳහා, abs() හි ඇති ශ්‍රිතය භාවිතා කරන්න.
c = 3 + 4j
print(abs(c))
# 5.0
c = 1 + 1j
print(abs(c))
# 1.4142135623730951
සංකීර්ණ සංඛ්‍යාවක පරිහානිය (අදියර) ලබා ගන්න:math,cmathමොඩියුලය
සංකීර්ණ සංඛ්‍යාවක පරිහානිය (අදියර) ලබා ගැනීමට, ගණිතය හෝ cmath මොඩියුලය භාවිතා කරන්න.
cmath මොඩියුලය සංකීර්ණ සංඛ්‍යා සඳහා ගණිතමය ශ්‍රිත මොඩියුලයකි.
එය අර්ථ දක්වා ඇති පරිදි ප්‍රතිලෝම ස්පර්ශක ශ්‍රිතය 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() භාවිතයෙන් ඒවා (නිරපේක්ෂ අගය, 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
ධ්‍රැවීය ඛණ්ඩාංක සිට කාටිසියානු ඛණ්ඩාංක බවට පරිවර්තනය කිරීම 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() මගින් නිරපේක්ෂ අගයන් සහ 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
සංකීර්ණ සංඛ්‍යා ගණනය කිරීම (චතුරශ්‍රය, බල, වර්ග මුල්)
සාමාන්‍ය අංක ගණිත ක්‍රියාකරුවන් භාවිතයෙන් අංක ගණිත මෙහෙයුම් හතරක් සහ බල ගණනය කිරීම් සිදු කළ හැක.
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 සමඟ ගණනය කළ හැක, නමුත් එය දෝෂයක් හඳුන්වා දෙයි. 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)
