ගණිතමය ශ්‍රිත සඳහා Python හි සම්මත මොඩියුලය භාවිතා කරමින්, ඔබට ඝාතීය සහ ලඝුගණක ශ්‍රිත (ස්වාභාවික ලඝුගණකය, සාමාන්‍ය ලඝුගණකය සහ ද්විමය ලඝුගණකය) ගණනය කළ හැක.
නියැදි කේතය සමඟ පහත විස්තර මෙහි විස්තර කෙරේ.
- ස්වාභාවික ලඝුගණකයේ පදනම (නේපියර් අංකය):
math.e - බලය::
**ක්රියාකරු,pow(),math.pow() - වර්ග මූල (මූල):
math.sqrt() - ඝාතීය ශ්‍රිතය (ස්වාභාවික ඝාතීය ශ්‍රිතය):
math.exp() - ලඝුගණක ශ්‍රිතයක්:
math.log(),math.log10(),math.log2()
ස්වාභාවික ලඝුගණකයේ පදනම (නේපියර් අංකය):math.e
ස්වාභාවික ලඝුගණකයේ පාදය (නේපියර් අංකය) ගණිත මොඩියුලයේ නියතයක් ලෙස සපයා ඇත, math.e මගින් දැක්වේ.
import math
print(math.e)
# 2.718281828459045
බලය: ** ක්රියාකරු, pow(), math.pow():**ක්රියාකරු,pow(),math.pow()
බලයන් ගණනය කිරීම සඳහා, ** ක්රියාකරු, බිල්ට්-ඉන් ශ්‍රිතය pow() හෝ math.pow() භාවිතා කරන්න.
x හි y වර්ග පහත පරිදි ලබා ගනී
x**ypow(x, y)math.pow(x, y)
print(2**4)
# 16
print(pow(2, 4))
# 16
print(math.pow(2, 4))
# 16.0
math.pow() තර්කය පාවෙන ලක්ෂ්‍ය වර්ගයකට පරිවර්තනය කරයි. අනෙක් අතට, Python හි බිල්ට්-ඉන් ශ්‍රිතය pow() එක් එක් වර්ගය සඳහා අර්ථ දක්වා ඇති __pow()__ භාවිතා කරයි.
උදාහරණයක් ලෙස, pow() මඟින් සංකීර්ණ වර්ග තර්ක ලෙස සඳහන් කිරීමට ඉඩ සලසයි, නමුත් math.pow() හට සංකීර්ණ වර්ග පාවෙන වර්ග බවට පරිවර්තනය කළ නොහැක, එහි ප්‍රතිඵලයක් ලෙස දෝෂයක් ඇතිවේ.
print(pow(1 + 1j, 2))
# 2j
# print(math.pow(1 + 1j, 2))
# TypeError: can't convert complex to float
Python බිල්ට්-ඉන් ශ්‍රිතය pow() තුන්වන තර්කයක්, pow(x, y, z) වලට ඉඩ සලසයි, එය z හි ඉතිරි (ඉතිරි) x හි y-බලය වෙත ආපසු ලබා දෙයි. එය pow(x, y) % z ලෙස ගණනය කිරීමම වේ, නමුත් pow(x, y, z) වඩා කාර්යක්ෂම වේ.
print(pow(2, 4, 5))
# 1
වර්ග මූල (මූල):math.sqrt()
** හෝ math.sqrt() භාවිතයෙන් වර්ගමූල (මූල) **0.5 ලෙස සැකසිය හැක.
print(2**0.5)
# 1.4142135623730951
print(math.sqrt(2))
# 1.4142135623730951
print(2**0.5 == math.sqrt(2))
# True
math.pow() මෙන්, math.sqrt() විසින් සැකසුම සඳහා තර්ක පාවෙන ලක්ෂ්‍ය වර්ග බවට පරිවර්තනය කරයි, එබැවින් float වර්ගයකට පරිවර්තනය කළ නොහැකි වර්ගයක් සඳහන් කිරීම TypeError වලට හේතු වේ.
print((-3 + 4j)**0.5)
# (1.0000000000000002+2j)
# print(math.sqrt(-3 + 4j))
# TypeError: can't convert complex to float
එසේම, math.sqrt() සෘණ අගයන් සැකසීමට නොහැකි වන අතර, එහි ප්‍රතිඵලයක් ලෙස ValueError එකක් ඇතිවේ.
print((-1)**0.5)
# (6.123233995736766e-17+1j)
# print(math.sqrt(-1))
# ValueError: math domain error
සංකීර්ණ සංඛ්යා සමඟ කටයුතු කරන විට, ** ක්රියාකරු භාවිතා කරන උදාහරණය දෝෂයක් පෙන්නුම් කරයි, නමුත් cmath මොඩියුලය වඩාත් නිවැරදි අගයක් ලබා දෙයි. සෘණ අගයන් ද හැසිරවිය හැක.
import cmath
print(cmath.sqrt(-3 + 4j))
# (1+2j)
print(cmath.sqrt(-1))
# 1j
ඝාතීය ශ්‍රිතය (ස්වාභාවික ඝාතීය ශ්‍රිතය):math.exp()
ස්වාභාවික ලඝුගණකයේ පාදයේ බලය ගණනය කිරීම සඳහා (නේපියර් අංකය) e, math.exp() භාවිතා කරන්න.
math.exp(x) e හි x වර්ග ලබා දෙයි.
math.exp(x) “math.e ** x” ට සමාන නොවන අතර math.exp(x) වඩාත් නිවැරදි වේ.
print(math.exp(2))
# 7.38905609893065
print(math.exp(2) == math.e**2)
# False
ලඝුගණක ශ්‍රිතයක්:math.log(),math.log10(),math.log2()
ලඝුගණක ශ්‍රිතය ගණනය කිරීම සඳහා, math.log(),math.log10(),math.log2() භාවිතා කරන්න.
math.log(x, y) x හි ලඝුගණකය y පදනම ලෙස ලබා දෙයි.
print(math.log(25, 5))
# 2.0
දෙවන තර්කය ඉවත් කර ඇත්නම්, ස්වභාවික ලඝුගණකය පහත දැක්වේ.
ලඝුගණකය
ගණිතයේ දී, log හෝ ln මගින් නිරූපණය වන ස්වභාවික ලඝුගණකය (නේපියර් අංකය e පදනම ලෙස ලඝුගණකය), math.log(x) මගින් ගණනය කළ හැක.
print(math.log(math.e))
# 1.0
ලඝුගණකය (පදනම 10)
math.log(x, 10) ට වඩා නිවැරදි වන math.log10(x) සමඟ සාමාන්‍ය ලඝුගණකය (10 පාදය සහිත ලඝුගණකය) ගණනය කළ හැක.
print(math.log10(100000))
# 5.0
ද්විමය ලඝුගණකය
ද්විමය ලඝුගණකය (පාදම 2 සහිත ලඝුගණකය) math.log2(x) සමඟ ගණනය කළ හැක, එය math.log(x, 2) ට වඩා නිවැරදිය.
print(math.log2(1024))
# 10.0
