फ़्लोट में दशमलव स्थानों की संख्या कैसे गिनें?

Question

मैं रूबी 1.8.7 और रेल 2.3.5 का उपयोग कर रहा हूं।

यदि मेरे पास 12.525 की तरह एक फ्लोट है, तो दशमलव स्थान से अंकों की संख्या कैसे प्राप्त हो सकती है? इस मामले में मुझे '3' वापस पाने की उम्मीद है।

theFloat.to_s.split(".")[1].length 

यह बहुत सुंदर नहीं है, लेकिन आप फ्लोट के लिए एक विधि के रूप में यह सम्मिलित कर सकते हैं:

Answer 1

यहां एक बहुत ही सरल दृष्टिकोण है।

def decimals(a) 
    num = 0 
    while(a != a.to_i) 
     num += 1 
     a *= 10 
    end 
    num 
end 

decimals(1.234) # -> 3 
decimals(10/3.0) # -> 16 

Answer 2

इस तरह

class Float 
    def decimalPlaces 
     self.to_s.split(".")[1].length 
    end 
end 

Answer 3

कुछ इस तरह, मुझे लगता है:

n = 12.525 
n.to_s.split('.').last.size 

Answer 4

आप मंजिल घटाना कर सकते हैं और फिर बस गिनती कि कितने वर्ण शेष: इससे पहले कि यह इसके समकक्ष पूर्णांक के बराबर होती है 10 से कितनी बार आप एक से अधिक करने के लिए है संख्या का ट्रैक रखें?

(12.525 - (12.525.floor)) to_s.length -2 => 3

संपादित करें:। नहीं कारणों, नकारात्मक का एक समूह और .९९,९९९ मुद्दों के लिए यह does not काम

Answer 5

आप चाहिए आप जो चाहते हैं उसके साथ बहुत सावधान रहें। Floating point numbers वैज्ञानिक उद्देश्यों के लिए उत्कृष्ट हैं और अधिकतर दैनिक उपयोग के लिए काम करते हैं, लेकिन जब आप "दशमलव स्थान से कितने अंक" जैसे कुछ जानना चाहते हैं, तो वे बहुत बुरी तरह से गिर जाते हैं - अगर केवल about 16 digits total है, जिनमें से सभी शामिल नहीं होंगे आपकी गणना के लिए सटीक डेटा। (या, कुछ पुस्तकालय वास्तव में आउटपुट के लिए संख्या स्वरूपित करते समय सटीक डेटा को फेंक सकते हैं, "आधार संख्याएं अधिक अनुकूल हैं"। जो, अक्सर सच है, इसका मतलब है कि यह थोड़ा खतरनाक हो सकता है । स्वरूपित उत्पादन पर निर्भर)

आप BigDecimal वर्ग के साथ मानक चल बिन्दु संख्या की जगह ले सकता है, तो चल बिन्दु संख्या मनमाना परिशुद्धता प्रदान करने के लिए है, तो आप निरीक्षण कर सकते हैं "कच्चे" संख्या:

> require 'bigdecimal' 
=> true 
> def digits_after_decimal_point(f) 
> sign, digits, base, exponent = f.split 
> return digits.length - exponent 
> end 
> l = %w{1.0, 1.1, 1000000000.1, 1.0000000001} 
=> ["1.0,", "1.1,", "1000000000.1,", "1.0000000001"] 
> list = l.map { |n| BigDecimal(n) } 
=> [#<BigDecimal:7f7a56aa8f70,'0.1E1',9(18)>, #<BigDecimal:7f7a56aa8ef8,'0.11E1',18(18)>, #<BigDecimal:7f7a56aa8ea8,'0.1000000000 1E10',27(27)>, #<BigDecimal:7f7a56aa8e58,'0.1000000000 1E1',27(27)>] 
> list.map { |i| digits_after_decimal_point(i) } 
=> [0, 1, 1, 10] 

के

बेशक, BigDecimal पर जाने से आपके एप्लिकेशन को बहुत धीमा कर दिया जाता है या जो आपको चाहिए, उसके लिए बहुत शक्तिशाली है, यह आपके वास्तविक कोड के लिए आपके कोड को अत्यधिक जटिल बना सकता है। आपको यह तय करना होगा कि आपके आवेदन के लिए सबसे महत्वपूर्ण क्या है।

Answer 6

ऑलेक्ज़ेंडर का उत्तर पूर्णांक के लिए काम नहीं करता है। निम्नलिखित की कोशिश कर सकते हैं:

def decimals(num) 
    if num 
    arr = num.to_s.split('.') 
    case arr.size 
     when 1 
     0 
     when 2 
     arr.last.size 
     else 
     nil 
    end 
    else 
    nil 
    end 
end