Python मध्ये घातांक आणि लॉगरिदमिक फंक्शन्सची गणना करा (exp, log, log10, log2)

व्यवसाय

गणितीय फंक्शन्ससाठी गणित, पायथनचे मानक मॉड्यूल वापरून, तुम्ही घातांक आणि लॉगरिदमिक फंक्शन्स (नैसर्गिक लॉगरिदम, सामान्य लॉगरिथम आणि बायनरी लॉगरिदम) मोजू शकता.

नमुना कोडसह येथे खाली स्पष्ट केले आहे.

  • नैसर्गिक लॉगरिथमचा आधार (नेपियर क्रमांक):math.e
  • शक्ती::**ऑपरेटर,pow(),math.pow()
  • वर्गमूळ (मूळ):math.sqrt()
  • घातांकीय कार्य (नैसर्गिक घातांकीय कार्य):math.exp()
  • लॉगरिदमिक फंक्शन:math.log(),math.log10(),math.log2()

नैसर्गिक लॉगरिथमचा आधार (नेपियर क्रमांक):math.e

नैसर्गिक लॉगरिदमचा आधार (नेपियर क्रमांक) गणित मॉड्यूलमध्ये स्थिरांक म्हणून प्रदान केला जातो, जो गणिताने दर्शविला जातो.

import math

print(math.e)
# 2.718281828459045

पॉवर: ** ऑपरेटर, पॉव(), 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) ला देखील अनुमती देते, जे x च्या y-पॉवरवर z चे उर्वरित (उर्वरित) परत करते. ही गणना 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() नकारात्मक मूल्यांवर प्रक्रिया करू शकत नाही, परिणामी 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()

नैसर्गिक लॉगरिदम (नेपियर क्रमांक) ई च्या पायाची शक्ती मोजण्यासाठी, 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) बेस म्हणून y सह x चा लॉगरिदम मिळवते.

print(math.log(25, 5))
# 2.0

दुसरा युक्तिवाद वगळल्यास, नैसर्गिक लॉगरिदम खाली दर्शविला आहे.

लॉगरिथम

गणितामध्ये, लॉग किंवा 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