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

પાવર: ** ઓપરેટર, 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() નકારાત્મક મૂલ્યો પર પ્રક્રિયા કરી શકતું નથી, જેના પરિણામે 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

જો બીજી દલીલ અવગણવામાં આવે, તો કુદરતી લઘુગણક નીચે દર્શાવેલ છે.

લઘુગણક

ગણિતમાં, પ્રાકૃતિક લોગરીધમ (નેપિયર નંબર e સાથેનો લઘુગણક), જે લોગ અથવા ln દ્વારા રજૂ થાય છે, તેની ગણતરી 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