सटीक खोए बिना फ्लोट को डबल में बदलें

Question 1

मेरे पास एक आदिम फ्लोट है और मुझे एक आदिम डबल के रूप में आवश्यकता है। बस फ्लोट को डबल करने के लिए मुझे अजीब अतिरिक्त परिशुद्धता देता है। उदाहरण के लिए:

float temp = 14009.35F;
System.out.println(Float.toString(temp)); // Prints 14009.35
System.out.println(Double.toString((double)temp)); // Prints 14009.349609375

हालांकि, अगर कास्टिंग के बजाय, मैं फ्लोट को एक स्ट्रिंग के रूप में आउटपुट करता हूं, और स्ट्रिंग को डबल के रूप में पार्स करता हूं, मुझे वह मिलता है जो मुझे चाहिए:

System.out.println(Double.toString(Double.parseDouble(Float.toString(temp))));
// Prints 14009.35

क्या स्ट्रिंग और वापस जाने की तुलना में बेहतर तरीका है?

Question 2

ऐसा नहीं है कि आप वास्तव में अतिरिक्त सटीकता प्राप्त कर रहे हैं - यह है कि फ्लोट उस संख्या का सही प्रतिनिधित्व नहीं करता है जिसे आप मूल रूप से लक्ष्य कर रहे थे। डबल है मूल नाव सही रूप का प्रतिनिधित्व; toString"अतिरिक्त" डेटा दिखा रहा है जो पहले से मौजूद था।

उदाहरण के लिए (और ये संख्या सही नहीं है, मैं सिर्फ बातें बना रहा हूं) मान लीजिए कि आपके पास था:

float f = 0.1F;
double d = f;

तब इसका मूल्य fठीक 0.100000234523 हो सकता है। dइसका ठीक वैसा ही मूल्य होगा, लेकिन जब आप इसे एक स्ट्रिंग में बदलेंगे तो यह "विश्वास" होगा कि यह एक उच्च परिशुद्धता के लिए सटीक है, इसलिए यह जल्दी से गोल नहीं होगा, और आप "अतिरिक्त अंक" देखेंगे जो पहले से ही थे वहाँ, लेकिन आप से छिपा हुआ।

जब आप एक स्ट्रिंग और बैक में कनवर्ट करते हैं, तो आप एक डबल मान के साथ समाप्त कर रहे हैं, जो मूल फ्लोट की तुलना में स्ट्रिंग मान के करीब है - लेकिन यह केवल अच्छा है यदि आप वास्तव में विश्वास करते हैं कि स्ट्रिंग मूल्य वह है जो आप वास्तव में चाहते थे।

क्या आप सुनिश्चित हैं कि फ़्लोट / डबल इसके बजाय यहाँ उपयोग करने के लिए उपयुक्त प्रकार हैं BigDecimal? यदि आप उन संख्याओं का उपयोग करने का प्रयास कर रहे हैं जिनमें सटीक दशमलव मान (जैसे धन) हैं, तो BigDecimalएक अधिक उपयुक्त प्रकार IMO है।

Question 3

मैं इस समस्या को समझने के लिए बाइनरी प्रतिनिधित्व को आसान बनाता हूं।

float f = 0.27f;
double d2 = (double) f;
double d3 = 0.27d;

System.out.println(Integer.toBinaryString(Float.floatToRawIntBits(f)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d2)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d3)));

आप देख सकते हैं कि फ्लोट को 0 से अंत तक जोड़कर डबल तक विस्तारित किया गया है, लेकिन 0.27 का डबल प्रतिनिधित्व 'अधिक सटीक' है, इसलिए समस्या है।

   111110100010100011110101110001
11111111010001010001111010111000100000000000000000000000000000
11111111010001010001111010111000010100011110101110000101001000

Question 4

यह अनुबंध के कारण है Float.toString(float), जो कहता है:

आंशिक भाग […] के लिए कितने अंक छपे होने चाहिए? भिन्नात्मक भाग का प्रतिनिधित्व करने के लिए कम से कम एक अंक होना चाहिए, और उससे आगे भी, लेकिन केवल कई, अधिक अंकों के रूप में विशिष्ट प्रकार के फ्लोट के आसन्न मूल्यों से तर्क मूल्य को अलग करने की आवश्यकता होती है। यही है, मान लीजिए कि x एक परिमित गैर-बीजरूप तर्क f के लिए इस विधि द्वारा निर्मित दशमलव प्रतिनिधित्व द्वारा दर्शाया गया सटीक गणितीय मान है। तब f को x के निकटतम फ्लोट मान होना चाहिए; या, यदि दो फ्लोट मान समान रूप से x के करीब हैं, तो f उनमें से एक होना चाहिए और f के महत्व का कम से कम महत्वपूर्ण बिट 0 होना चाहिए।

Question 5

मैं आज इस मुद्दे का सामना कर चुका हूं और बिगडेसीमल के लिए रिफ्लेक्टर का उपयोग नहीं कर सकता, क्योंकि परियोजना वास्तव में बहुत बड़ी है। हालांकि मैंने समाधान का उपयोग कर पाया

Float result = new Float(5623.23)
Double doubleResult = new FloatingDecimal(result.floatValue()).doubleValue()

और यह काम करता है।

ध्यान दें कि call.doubleValue () 5623.22998046875 पर कॉल करता है

लेकिन doubleResult.doubleValue () कॉलिंग सही ढंग से 5623.23 पर वापस आती है

लेकिन मुझे पूरी तरह यकीन नहीं है कि इसका सही समाधान है।

Question 6

मुझे निम्नलिखित समाधान मिला:

public static Double getFloatAsDouble(Float fValue) {
    return Double.valueOf(fValue.toString());
}

यदि आप का उपयोग नाव और दोगुना करने के बजाय फ्लोट और डबल निम्नलिखित का उपयोग करें:

public static double getFloatAsDouble(float value) {
    return Double.valueOf(Float.valueOf(value).toString()).doubleValue();
}

Question 7

के BigDecimalबजाय का उपयोग करें float/ double। बहुत सारी संख्याएँ हैं जिन्हें बाइनरी फ़्लोटिंग पॉइंट (उदाहरण के लिए 0.1) के रूप में प्रस्तुत नहीं किया जा सकता है । इसलिए आपको या तो हमेशा परिणाम को ज्ञात सटीकता या उपयोग के लिए गोल करना चाहिए BigDecimal।

अधिक जानकारी के लिए http://en.wikipedia.org/wiki/Floating_point देखें ।

Question 8

स्वभाव से झांकियां, अभेद्य होती हैं और इनमें हमेशा "गोल" वाले गोल होते हैं। यदि परिशुद्धता महत्वपूर्ण है, तो आप दशमलव या बिगडिमल का उपयोग करने के लिए अपने आवेदन को वापस लेने पर विचार कर सकते हैं।

हां, प्रोसेसर सपोर्ट की वजह से फ्लोट कम्प्यूटेशनल रूप से डेसीमल से ज्यादा तेज हैं। हालाँकि, क्या आप तेज या सटीक चाहते हैं?

Question 9

यह जानकारी 48 आइटम के अंतर्गत आती है - जोशुआ बलोच द्वारा प्रभावी जावा 2 संस्करण के सटीक मूल्यों की आवश्यकता होने पर फ्लोट और डबल से बचें। यह पुस्तक अच्छी चीजों से भरी हुई है और निश्चित रूप से देखने लायक है।

Question 10

क्या यह काम करता है?

float flt = 145.664454;

Double dbl = 0.0;
dbl += flt;

Question 11

एक सरल समाधान जो अच्छी तरह से काम करता है, वह है फ्लोट के स्ट्रिंग प्रतिनिधित्व से डबल पार्स करना:

double val = Double.valueOf(String.valueOf(yourFloat));

सुपर कुशल नहीं है, लेकिन यह काम करता है!