आपकी समस्या को अंडर-निर्दिष्ट किया गया है, आपको वापस कदम रखने और कुछ प्रश्न पूछने की आवश्यकता है।
- आपके इनपुट किस प्रकार के हैं?
- आप अपने आउटपुट के लिए क्या प्रकार चाहते हैं?
- 1 से कम परिणामों के लिए, आप वास्तव में क्या चाहते हैं? क्या आप 10 की वास्तविक शक्तियों या 10 की शक्तियों के फ्लोटिंग पॉइंट सन्निकटन चाहते हैं? आप जानते हैं कि 10 की नकारात्मक शक्तियाँ फ्लोटिंग पॉइंट में बिल्कुल व्यक्त नहीं की जा सकती हैं? चलो अब मान लेते हैं कि आप 10 की शक्तियों के फ्लोटिंग पॉइंट सन्निकटन चाहते हैं।
- यदि इनपुट बिल्कुल 10 की शक्ति है (या 10 की शक्ति का निकटतम फ्लोटिंग पॉइंट सन्निकटन), तो क्या आउटपुट इनपुट के समान होना चाहिए? या यह 10 अप की अगली शक्ति होनी चाहिए? "10 -> 10" या "10 -> 100"? अब पूर्व के लिए मान लेते हैं।
- क्या आपके इनपुट मान प्रश्न के प्रकारों का कोई संभावित मूल्य हो सकता है? या वे अधिक विवश हैं।
एक अन्य उत्तर में यह लघुगणक लेने का प्रस्ताव किया गया था, फिर राउंड अप (सीलिंग फंक्शन), फिर एक्सप्रेशन किया गया।
def nextpow10(n):
return 10 ** math.ceil(math.log10(n))
दुर्भाग्य से यह गोलाई त्रुटियों से ग्रस्त है। सबसे पहले n जो भी डेटा टाइप होता है उससे डबल सटीक फ़्लोटिंग पॉइंट नंबर, संभावित रूप से राउंडिंग एरर को शुरू करने से परिवर्तित किया जाता है, फिर लॉगरिदम की गणना की जाती है, जो संभवतः अपने आंतरिक गणना और इसके परिणाम दोनों में अधिक राउंडिंग त्रुटियों को पेश करता है।
जैसे कि मुझे एक उदाहरण खोजने में देर नहीं लगी, जहां इसने गलत परिणाम दिया।
>>> import math
>>> from numpy import nextafter
>>> n = 1
>>> while (10 ** math.ceil(math.log10(nextafter(n,math.inf)))) > n:
... n *= 10
...
>>> n
10
>>> nextafter(n,math.inf)
10.000000000000002
>>> 10 ** math.ceil(math.log10(10.000000000000002))
10
दूसरी दिशा में विफल होना सैद्धांतिक रूप से भी संभव है, हालांकि यह भड़काने के लिए बहुत कठिन प्रतीत होता है।
इसलिए फ्लोट और किलों के लिए एक मजबूत समाधान के लिए हमें यह मानने की आवश्यकता है कि हमारे लघुगणक का मूल्य केवल अनुमानित है, और इसलिए हमें कुछ संभावनाओं का परीक्षण करना चाहिए। की तर्ज पर कुछ
def nextpow10(n):
p = round(math.log10(n))
r = 10 ** p
if r < n:
r = 10 ** (p+1)
return r;
मेरा मानना है कि इस कोड को सभी समझदार वास्तविक दुनिया के परिमाणों में सभी तर्कों के लिए सही परिणाम देना चाहिए। यह बहुत छोटे या बहुत बड़ी संख्या में गैर पूर्णांक और गैर-फ़्लोटिंग बिंदु प्रकारों के कारण टूट जाएगा क्योंकि उन्हें फ़्लोटिंग पॉइंट में परिवर्तित किया जा सकता है। अजगर विशेष मामलों में अतिप्रवाह को रोकने के प्रयास में लॉग 10 फ़ंक्शन के लिए पूर्णांक तर्क देता है, लेकिन फिर भी पर्याप्त रूप से बड़े पैमाने पर पूर्णांक के साथ गोलाई त्रुटियों के कारण गलत परिणामों को मजबूर करना संभव हो सकता है।
दो कार्यान्वयन का परीक्षण करने के लिए मैंने निम्नलिखित परीक्षण कार्यक्रम का उपयोग किया।
n = -323 # 10**-324 == 0
while n < 1000:
v = 10 ** n
if v != nextpow10(v): print(str(v)+" bad")
try:
v = min(nextafter(v,math.inf),v+1)
except:
v += 1
if v > nextpow10(v): print(str(v)+" bad")
n += 1
यह भोले-भाले क्रियान्वयन में बहुत सारी विफलताएं पाता है, लेकिन बेहतर क्रियान्वयन में कोई नहीं।
10ऊपर से उन समाधानों की तरह काम करता है , यह उदाहरण के साथ कुछ की आवश्यकता होगीlog10।