ગણિત, ગાણિતિક કાર્યો માટે પાયથોનના પ્રમાણભૂત મોડ્યુલનો ઉપયોગ કરીને, તમે ત્રિકોણમિતિ કાર્યો (sin, cos, tan) અને વ્યસ્ત ત્રિકોણમિતિ કાર્યો (arcsin, arccos, arctan) ની ગણતરી કરી શકો છો.
નીચેની સામગ્રી અહીં નમૂના કોડ સાથે સમજાવવામાં આવી છે.
- Pi (3.1415926..):
math.pi - કોણ રૂપાંતર (રેડિયન, ડિગ્રી):
math.degrees(),math.radians() - સાઈન, ઈન્વર્સ સાઈન:
math.sin(),math.asin() - કોસાઇન, વ્યસ્ત કોસાઇન:
math.cos(),math.acos() - સ્પર્શક, વ્યસ્ત સ્પર્શક:
math.tan(),math.atan(),math.atan2() - નીચે તફાવતો:
math.atan(),math.atan2()
Pi (3.1415926..):math.pi
Pi એ ગણિતના મોડ્યુલમાં સ્થિર તરીકે પ્રદાન કરવામાં આવે છે. તે નીચે પ્રમાણે વ્યક્ત કરવામાં આવે છે.math.pi
import math
print(math.pi)
# 3.141592653589793
કોણ રૂપાંતર (રેડિયન, ડિગ્રી):math.degrees(),math.radians()
ગણિત મોડ્યુલમાં ત્રિકોણમિતિ અને વ્યસ્ત ત્રિકોણમિતિ વિધેયો કોણના એકમ તરીકે રેડિયનનો ઉપયોગ કરે છે.
રેડિયન (આર્ક ડિગ્રી પદ્ધતિ) અને ડિગ્રી (ડિગ્રી પદ્ધતિ) વચ્ચે કન્વર્ટ કરવા માટે math.degrees() અને math.radians() નો ઉપયોગ કરો.
Math.degrees() રેડિયનમાંથી ડિગ્રીમાં કન્વર્ટ થાય છે અને math.radians() ડિગ્રીમાંથી રેડિયનમાં કન્વર્ટ થાય છે.
print(math.degrees(math.pi))
# 180.0
print(math.radians(180))
# 3.141592653589793
સાઈન, ઈન્વર્સ સાઈન:math.sin(),math.asin()
સાઈન (sin) શોધવાનું કાર્ય math.sin() છે અને inverse sine (arcsin) શોધવાનું કાર્ય math.asin() છે.
ડિગ્રીને રેડિયનમાં કન્વર્ટ કરવા માટે math.radians() નો ઉપયોગ કરીને 30 ડિગ્રીની સાઈન શોધવાનું અહીં ઉદાહરણ છે.
sin30 = math.sin(math.radians(30))
print(sin30)
# 0.49999999999999994
30 ડિગ્રીની સાઈન 0.5 છે, પરંતુ એક ભૂલ છે કારણ કે pi, એક અતાર્કિક સંખ્યા, ચોક્કસ રીતે ગણતરી કરી શકાતી નથી.
જો તમે અંકોની યોગ્ય સંખ્યા પર રાઉન્ડ કરવા માંગો છો, તો રાઉન્ડ() ફંક્શન અથવા ફોર્મેટ() પદ્ધતિ અથવા ફોર્મેટ() ફંક્શનનો ઉપયોગ કરો.
નોંધ કરો કે રાઉન્ડ() નું વળતર મૂલ્ય એક સંખ્યા (int અથવા float) છે, પરંતુ format() નું વળતર મૂલ્ય એક સ્ટ્રિંગ છે. જો તમે અનુગામી ગણતરીઓ માટે તેનો ઉપયોગ કરવા માંગતા હો, તો રાઉન્ડ() નો ઉપયોગ કરો.
print(round(sin30, 3))
print(type(round(sin30, 3)))
# 0.5
# <class 'float'>
print('{:.3}'.format(sin30))
print(type('{:.3}'.format(sin30)))
# 0.5
# <class 'str'>
print(format(sin30, '.3'))
print(type(format(sin30, '.3')))
# 0.5
# <class 'str'>
રાઉન્ડ() ફંક્શન તેની બીજી દલીલ તરીકે દશાંશ સ્થાનોની સંખ્યાને સ્પષ્ટ કરે છે. નોંધ કરો કે આ કડક રીતે ગોળાકાર નથી. વિગતો માટે નીચેનો લેખ જુઓ.
format() પદ્ધતિ અને format() ફંક્શન ફોર્મેટિંગ સ્પષ્ટીકરણ સ્ટ્રિંગમાં દશાંશ સ્થાનોની સંખ્યાનો ઉલ્લેખ કરે છે. વિગતો માટે નીચેનો લેખ જુઓ.
જો તમે સરખામણી કરવા માંગતા હો, તો તમે math.isclose() નો પણ ઉપયોગ કરી શકો છો.
print(math.isclose(sin30, 0.5))
# True
તેવી જ રીતે, અહીં 0.5 ની વ્યસ્ત સાઈન શોધવાનું ઉદાહરણ છે. math.asin() રેડિયન પરત કરે છે, જે math.degrees() સાથે ડિગ્રીમાં રૂપાંતરિત થાય છે.
asin05 = math.degrees(math.asin(0.5))
print(asin05)
# 29.999999999999996
print(round(asin05, 3))
# 30.0
કોસાઇન, વ્યસ્ત કોસાઇન:math.cos(),math.acos()
કોસાઇન (cos) શોધવાનું ફંક્શન છે math.cos(), અને ઇન્વર્સ કોસાઇન (આર્ક કોસાઇન, આર્કોસ) શોધવાનું ફંક્શન છે math.acos().
અહીં 60 ડિગ્રીના કોસાઇન અને 0.5ના વ્યસ્ત કોસાઇન શોધવાનું ઉદાહરણ છે.
print(math.cos(math.radians(60)))
# 0.5000000000000001
print(math.degrees(math.acos(0.5)))
# 59.99999999999999
જો તમે યોગ્ય અંક સુધી રાઉન્ડ કરવા માંગો છો, તો તમે સાઈનની જેમ રાઉન્ડ() અથવા ફોર્મેટ() નો ઉપયોગ કરી શકો છો.
સ્પર્શક, વ્યસ્ત સ્પર્શક:math.tan(),math.atan(),math.atan2()
સ્પર્શક (ટેન) શોધવાનું કાર્ય છે math.tan(), અને વ્યસ્ત સ્પર્શક (આર્કટન) શોધવાનું કાર્ય math.atan() અથવા math.atan2() છે.
Math.atan2() પછીથી વર્ણવેલ છે.
45 ડિગ્રીની સ્પર્શક અને 1 ડિગ્રીની વ્યસ્ત સ્પર્શક શોધવાનું ઉદાહરણ નીચે બતાવેલ છે.
print(math.tan(math.radians(45)))
# 0.9999999999999999
print(math.degrees(math.atan(1)))
# 45.0
math.atan() અને math.atan2() વચ્ચેનો તફાવત
math.atan() અને math.atan2() બંને એવા ફંક્શન છે જે વ્યસ્ત સ્પર્શક પરત કરે છે, પરંતુ તેઓ દલીલોની સંખ્યામાં અને વળતર મૂલ્યોની શ્રેણીમાં અલગ પડે છે.
math.atan(x) પાસે એક દલીલ છે અને રેડિયનમાં આર્કટન(x) પરત કરે છે. વળતર મૂલ્ય -pi \ 2 અને pi \ 2 (-90 થી 90 ડિગ્રી) વચ્ચે હશે.
print(math.degrees(math.atan(0)))
# 0.0
print(math.degrees(math.atan(1)))
# 45.0
print(math.degrees(math.atan(-1)))
# -45.0
print(math.degrees(math.atan(math.inf)))
# 90.0
print(math.degrees(math.atan(-math.inf)))
# -90.0
ઉપરના ઉદાહરણમાં, math.inf અનંતનું પ્રતિનિધિત્વ કરે છે.
math.atan2(y, x) પાસે બે દલીલો છે અને રેડિયનમાં arctan(y \ x) પરત કરે છે. આ કોણ એ કોણ (ઘટાડો) છે જે વેક્ટર મૂળથી કોઓર્ડિનેટ્સ (x, y) સુધી ધ્રુવીય સંકલન સમતલમાં x અક્ષની સકારાત્મક દિશા સાથે બનાવે છે, અને પરત કરેલ મૂલ્ય -pi અને pi (-180) વચ્ચે છે 180 ડિગ્રી સુધી).
બીજા અને ત્રીજા ચતુર્થાંશના ખૂણાઓ પણ યોગ્ય રીતે મેળવી શકાય છે, તેથી ધ્રુવીય સંકલન સમતલને ધ્યાનમાં લેતી વખતે math.atan2() એ math.atan() કરતાં વધુ યોગ્ય છે.
નોંધ કરો કે દલીલોનો ક્રમ y, x છે, x, y નથી.
print(math.degrees(math.atan2(0, 1)))
# 0.0
print(math.degrees(math.atan2(1, 1)))
# 45.0
print(math.degrees(math.atan2(1, 0)))
# 90.0
print(math.degrees(math.atan2(1, -1)))
# 135.0
print(math.degrees(math.atan2(0, -1)))
# 180.0
print(math.degrees(math.atan2(-1, -1)))
# -135.0
print(math.degrees(math.atan2(-1, 0)))
# -90.0
print(math.degrees(math.atan2(-1, 1)))
# -45.0
ઉપરના ઉદાહરણની જેમ, x-અક્ષની નકારાત્મક દિશા (y શૂન્ય છે અને x ઋણ છે) pi (180 ડિગ્રી) છે, પરંતુ જ્યારે y ઋણ શૂન્ય છે, તે -pi (-180 ડિગ્રી) છે. જો તમે નિશાનીને સખત રીતે હેન્ડલ કરવા માંગતા હોવ તો સાવચેત રહો.
print(math.degrees(math.atan2(-0.0, -1)))
# -180.0
નકારાત્મક શૂન્ય નીચેની ક્રિયાઓનું પરિણામ છે
print(-1 / math.inf)
# -0.0
print(-1.0 * 0.0)
# -0.0
પૂર્ણાંકોને નકારાત્મક શૂન્ય તરીકે ગણવામાં આવતા નથી.
print(-0.0)
# -0.0
print(-0)
# 0
જ્યારે x અને y બંને શૂન્ય હોય ત્યારે પણ પરિણામ ચિહ્ન પર આધાર રાખે છે.
print(math.degrees(math.atan2(0.0, 0.0)))
# 0.0
print(math.degrees(math.atan2(-0.0, 0.0)))
# -0.0
print(math.degrees(math.atan2(-0.0, -0.0)))
# -180.0
print(math.degrees(math.atan2(0.0, -0.0)))
# 180.0
એવા અન્ય ઉદાહરણો છે જ્યાં પરિણામની નિશાની નકારાત્મક શૂન્યના આધારે બદલાય છે, જેમ કે math.atan2() તેમજ math.sin(), math.asin(), math.tan(), અને math.atan() .
print(math.sin(0.0))
# 0.0
print(math.sin(-0.0))
# -0.0
print(math.asin(0.0))
# 0.0
print(math.asin(-0.0))
# -0.0
print(math.tan(0.0))
# 0.0
print(math.tan(-0.0))
# -0.0
print(math.atan(0.0))
# 0.0
print(math.atan(-0.0))
# -0.0
print(math.atan2(0.0, 1.0))
# 0.0
print(math.atan2(-0.0, 1.0))
# -0.0
નોંધ કરો કે અત્યાર સુધીના ઉદાહરણો CPython માં પ્રોગ્રામ ચલાવવાના પરિણામો છે. નોંધ કરો કે અન્ય અમલીકરણો અથવા પર્યાવરણો નકારાત્મક શૂન્યને અલગ રીતે હેન્ડલ કરી શકે છે.
