பைத்தானில் அதிவேக மற்றும் மடக்கை செயல்பாடுகளை கணக்கிடுங்கள் (exp, log, log10, log2)

வணிக

கணிதச் செயல்பாடுகளுக்கான பைத்தானின் நிலையான தொகுதியான கணிதத்தைப் பயன்படுத்தி, நீங்கள் அதிவேக மற்றும் மடக்கைச் செயல்பாடுகளைக் கணக்கிடலாம் (இயற்கை மடக்கை, சாதாரண மடக்கை மற்றும் பைனரி மடக்கை).

மாதிரிக் குறியீட்டுடன் பின்வருபவை இங்கே விளக்கப்பட்டுள்ளன.

  • இயற்கை மடக்கையின் அடிப்படை (நேப்பியர் எண்):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**y
  • pow(x, y)
  • math.pow(x, y)
print(2**4)
# 16

print(pow(2, 4))
# 16

print(math.pow(2, 4))
# 16.0

math.pow() வாதத்தை மிதக்கும் புள்ளி வகையாக மாற்றுகிறது. மறுபுறம், பைத்தானின் உள்ளமைக்கப்பட்ட செயல்பாடு pow() ஒவ்வொரு வகைக்கும் வரையறுக்கப்பட்ட __pow()__ ஐப் பயன்படுத்துகிறது.

எடுத்துக்காட்டாக, pow() ஆனது சிக்கலான வகைகளை வாதங்களாகக் குறிப்பிட அனுமதிக்கிறது, ஆனால் math.pow() சிக்கலான வகைகளை மிதவை வகைகளாக மாற்ற முடியாது, இதன் விளைவாக பிழை ஏற்படுகிறது.

print(pow(1 + 1j, 2))
# 2j

# print(math.pow(1 + 1j, 2))
# TypeError: can't convert complex to float

பைதான் உள்ளமைக்கப்பட்ட செயல்பாடு 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() ஆனது வாதங்களை செயலாக்கத்திற்கான மிதக்கும் புள்ளி வகைகளாக மாற்றுகிறது, எனவே மிதவை வகையாக மாற்ற முடியாத வகையைக் குறிப்பிடுவது TypeError க்கு வழிவகுக்கும்.

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

# print(math.sqrt(-3 + 4j))
# TypeError: can't convert complex to float

மேலும், math.sqrt() எதிர்மறை மதிப்புகளைச் செயலாக்க முடியாது, இதன் விளைவாக மதிப்புப் பிழை ஏற்படுகிறது.

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)

சாதாரண மடக்கை (அடிப்படை 10 உடன் மடக்கை) math.log10(x) உடன் கணக்கிடலாம், இது math.log(x, 10) ஐ விட துல்லியமானது.

print(math.log10(100000))
# 5.0

பைனரி மடக்கை

பைனரி மடக்கை (அடிப்படை 2 உடன் மடக்கை) math.log2(x) உடன் கணக்கிடலாம், இது math.log(x, 2) ஐ விட துல்லியமானது.

print(math.log2(1024))
# 10.0
Copied title and URL