लॉग और घातांक के नियम: पूरी जानकारी

लॉग का हर नियम घातांक के किसी न किसी नियम को प्रतिबिंबित करता है। जब एक ही आधार (base) की दो घातों को गुणा किया जाता है, तो उनके घातांक जुड़ जाते हैं, इसलिए लॉग जोड़ने का मतलब है इनपुट को गुणा करना। भाग करने पर वे घटते हैं। किसी घात तक उठाने पर वे गुणा होते हैं। चूँकि लघुगणक असल में एक छिपा हुआ घातांक ही है, इसलिए हर घातांक नियम का सीधा लॉग अनुवाद मौजूद होता है, और इन्हें जोड़ों में सीखने से दोनों सेट याद रखना आसान हो जाता है।

मुख्य बिंदु

• गुणनफल नियम: log10(100) + log10(10) = log10(1000) = 3, क्योंकि 2 + 1।
• इसका घातांक रूप: 2³ × 2⁴ = 2⁷ = 128, क्योंकि घातों को गुणा करने पर घातांक जुड़ जाते हैं।
• घात नियम: ln(e³) = 3 × ln(e) = 3।
• आधार परिवर्तन (change of base): log(8, 2) = 3, और किसी भी आधार के लिए log(x) ÷ log(b) काम करता है।

नियमों की चीट शीट

नीचे दी गई जोड़ियाँ वे हैं जो रोज़मर्रा के काम आती हैं। दायीं ओर का हर लॉग नियम, बायीं ओर के घातांक नियम को उल्टा पढ़ने पर बनता है। लॉग और घातांक नियम गाइड में यही तालिका दी गई है, और एक्सपोनेंट्स एक्सप्लेन्ड में यह बताया गया है कि घातांक के नियम कहाँ से आते हैं।

घातांक नियम	लॉग नियम	त्वरित जाँच
aⁿ × aᵐ = aⁿ⁺ᵐ	log_b(xy) = log_b(x) + log_b(y)	log10(100) + log10(10) = 2 + 1 = 3
aⁿ ÷ aᵐ = aⁿ⁻ᵐ	log_b(x ÷ y) = log_b(x) − log_b(y)	log10(1) − log10(100) = 0 − 2 = −2
(aⁿ)ᵐ = aⁿᵐ	log_b(xⁿ) = n × log_b(x)	ln(e³) = 3 × ln(e) = 3
a⁰ = 1	log_b(1) = 0	ln(1) = 0
a⁻ⁿ = 1 ÷ aⁿ	log_b(1 ÷ x) = −log_b(x)	ln(0.5) = −ln(2) = −0.693147

ऊपर दी गई हर पंक्ति को कैलकुलेटर पर उसी तरह दोहराया जा सकता है, जिस तरह डिस्प्ले मान को राउंड करता है। कैलकुलेटर फ़ंक्शन रेफ़रेंस में सही-सही बटन दिए गए हैं।

गुणनफल नियम: गुणनफल का लॉग, लॉग का जोड़ है

यह सबसे उपयोगी लॉग नियम है। log_b(xy) = log_b(x) + log_b(y)। गुणा, जो हाथ से करने में धीमा होता है, जोड़ में बदल जाता है, जो तेज़ होता है। यह क्यों काम करता है इसका कारण: अगर x = b^p और y = b^q हो, तो xy = b^p × b^q = b^(p+q), इसलिए xy का लॉग p + q होता है।

हल किया गया उदाहरण 1। log10(100) = 2 और log10(10) = 1। गुणनफल नियम के अनुसार log10(100 × 10) = log10(1000) = 2 + 1 = 3। लॉग कैलकुलेटर पर जाँचें: log(1000) टाइप करें और यह 3 दिखाएगा। इससे भी बेहतर, log(100) + log(10) टाइप करें, यह भी 3 पर ही आकर टिकता है। दो अलग रास्ते, एक ही जवाब।

इसका घातांक रूप वह है जिससे सबसे पहले सबका सामना होता है: 2³ × 2⁴ = 2⁷ = 128। पूरी गणना: 8 × 16 = 128, और 2⁷ = 128 भी है।

भागफल नियम: भागफल का लॉग, अंतर के बराबर है

भाग, घटाव में बदल जाता है: log_b(x ÷ y) = log_b(x) − log_b(y)। अगर गुणनफल जोड़ में टूटता है, तो भागफल घटाव में टूटता है। घातांक वाला रूप पहले किसी भिन्न (fraction) को ऋणात्मक घातांक में बदल देता है: 2⁵ ÷ 2² = 2³ = 8, क्योंकि 5 में से 2 घटाने पर 3 मिलता है।

हल किया गया उदाहरण 2। log10(1) − log10(100), 1 ÷ 100 = 0.01 के लॉग के बराबर होना चाहिए। इससे 0 − 2 = −2 मिलता है, और वाकई log10(0.01) = −2 है क्योंकि 10⁻² = 0.01। पुष्टि के लिए log(0.01) टाइप करें। ध्यान दें कि 1 से छोटी संख्या का लॉग ऋणात्मक होता है, ठीक वैसे ही जैसे ऋणात्मक घातांक से भिन्न (fraction) मिलती है।

घात नियम: घातांक आगे आ जाता है

log_b(xⁿ) = n × log_b(x)। लॉग के अंदर मौजूद कोई भी घातांक, आगे एक गुणक बन जाता है। यही वह नियम है जिससे किसी घातांक को हल किया जा सकता है: log(5^10), 10 × log(5) बन जाता है।

हल किया गया उदाहरण 3। ln(e^3), नेचुरल लॉग कैलकुलेटर की उस परिपाटी का उपयोग करता है जहाँ ln का आधार e होता है। घात नियम इसे 3 × ln(e) में बदल देता है, और चूँकि ln(e) = 1, इसलिए जवाब ठीक 3 आता है। ln(e^3) और 3 * ln(e) टाइप करें, दोनों 3 ही लौटाते हैं। घातांक की ओर, (2³)² = 2⁶ = 64।

आधार परिवर्तन: किसी भी आधार में लॉग

ये नियम आधारों के बीच केवल एक भाग वाला रूपांतरण देते हैं: log_b(x) = log(x) ÷ log(b)। लॉग कैलकुलेटर आधार के लिए एक दूसरा आर्ग्युमेंट भी स्वीकार करता है, इसलिए अक्सर फ़ॉर्मूले की ज़रूरत ही नहीं पड़ती।

हल किया गया उदाहरण 4। मान लीजिए आपको log2(8) चाहिए। लॉग कैलकुलेटर पर log(8, 2) टाइप करें और यह 3 लौटाएगा, क्योंकि 2³ = 8। या फिर आधार परिवर्तन फ़ॉर्मूला इस्तेमाल करें: log(8) / log(2) भी 3 ही देता है। घातांक की ओर यही संबंध एक और रूप में दिखता है: 2⁴ × 2⁻¹ = 2³ = 8।

कैलकुलेटर पर इन नियमों के साथ काम करना

• पूरा एक्सप्रेशन टाइप करें, फिर = दबाएँ। log(100) + log(10) एक ही बार में हल होकर 3 देता है।
• दूसरे आर्ग्युमेंट के रूप में कोई भी आधार काम करता है: log(x, b)।
• याद रखें कि यहाँ log का आधार 10 है और ln इसका नेचुरल रूप है। एक्सपोनेंट कैलकुलेटर घात वाली तरफ़ से इन्हीं दोनों विचारों को कवर करता है।

अक्सर पूछे जाने वाले सवाल

गुणनफल नियम क्यों सही है?

क्योंकि एक ही आधार की घातों को गुणा करने पर घातांक जुड़ जाते हैं। अगर x = b^p और y = b^q हो, तो xy = b^(p+q), और दोनों पक्षों का लॉग लेने पर log_b(xy) = p + q मिलता है।

क्या ये नियम प्राकृतिक लॉग (natural log) के लिए भी काम करते हैं?

हर नियम हर आधार में काम करता है, e सहित। ln(xy) = ln(x) + ln(y), ln(x ÷ y) = ln(x) − ln(y), और ln(xⁿ) = n × ln(x)। नेचुरल लॉग कैलकुलेटर यही नियम लागू करता है, क्योंकि आधार चाहे जो भी हो, लॉग तो लॉग ही रहता है।

1 का लॉग क्या है?

log_b(1) = 0, हर आधार में, क्योंकि किसी भी आधार को घात 0 तक उठाने पर 1 मिलता है।

अगर बेस की कोई अलग कुंजी न हो तो log2(8) कैसे निकालें?

आधार सीधे सेट करने के लिए log(8, 2) टाइप करें, या फिर आधार परिवर्तन फ़ॉर्मूला log(8) / log(2) इस्तेमाल करें। दोनों से 3 ही मिलता है।