मैं पूर्ण परिशुद्धता में स्थानीय जावा फ्लोटिंग पॉइंट मानों को आउटपुट कैसे कर सकता हूं?

Question

यदि मैं toString विधि का उपयोग करके दो बार प्रारूपित करता हूं, तो मुझे डबल की पूर्ण सटीकता मिलती है। उदाहरण के लिए (का उपयोग कर स्काला वाक्य रचना):

java.text.MessageFormat.format ("{0}", Math.PI.toString) 

स्ट्रिंग वाली में परिणाम होगा:

3.141592653589793 

हालांकि, इस मूल्य स्थानीय नहीं है। अगर मैं एक बॉक्स्ड Double के रूप में दोहरी मूल्य गुजरते हैं जो प्रकार है:

java.text.MessageFormat.format ("{0}", Math.PI.asInstanceOf[AnyRef]) 

(AnyRefस्काला प्रकार है कि में Object के बराबर है जावा है), तो परिणाम छोटा कर दिया साथ एक स्थानीय स्ट्रिंग है परिशुद्धता:

3.142 

परिणाम एक ही है, भले ही मैं प्रारूप स्ट्रिंग के लिए एक संकेत के और अधिक जोड़ने:

java.text.MessageFormat.format ("{0,number}", Math.PI.asInstanceOf[AnyRef]) 

मैं एक कस्टम प्रारूप को निर्दिष्ट करके पूर्ण परिशुद्धता प्राप्त कर सकते हैं:

java.text.MessageFormat.format ("{0,number,#.###############}", Math.PI.asInstanceOf[AnyRef]) 

लेकिन इस डबल के परिमाण और परिशुद्धता के कुछ ज्ञान की आवश्यकता है। मैं किसी भी डबल मूल्य (न केवल पाई) मुद्रण कर रहा हूँ, और मूल्य से भरा परिशुद्धता बनाए रखने के लिए चाहते हैं, तो इस दृष्टिकोण का मतलब है मैं गतिशील प्रारूप स्ट्रिंग बदलना होगा - और यह कि वास्तव में यदि सुविधाजनक नहीं है (के रूप में मेरा मामला) स्वरूप स्ट्रिंग वास्तव में संसाधन बंडल से प्राप्त की जाती है।

उदाहरण के लिए, 1.0e37 का एक डबल मान मानें। पहले स्ट्रिंग में कनवर्ट करना और "{0}" का प्रयोग प्रारूप स्ट्रिंग के परिणाम के रूप में उपयुक्त है, लेकिन अनौपचारिक, स्ट्रिंग मान 1.0E37। अगर मैं "{0, संख्या}" का एक प्रारूप तार के साथ एक बॉक्स्ड Double के रूप में इस पारित तो मैं हास्यास्पद मूल्य 10,000,000,000,000,000,000,000,000,000,000,000,000 मिलता है।

संक्षेप में, मुझे एक प्रारूप स्ट्रिंग नहीं मिल रही है जो पहले एक स्ट्रिंग में कनवर्ट किए बिना डबल की पूरी परिशुद्धता को सुरक्षित रखती है - और ऐसा कुछ है जो मैं प्लेग से बचना पसंद करूंगा। क्या कोई संख्या प्रारूप स्ट्रिंग है जो स्थानीय मान के रूप में डबल की पूर्ण परिशुद्धता को आउटपुट करता है?

अद्यतन:

बस स्पष्ट करने के लिए कारण है कि मैं तार को युगल में परिवर्तित करने के लिए नहीं पसंद करेंगे:

• toString रिटर्न, अब तक मैं बताने के लिए, एक वैध कर सकती हूं रूप में जावा डबल शाब्दिक मूल्य। एक स्ट्रिंग के रूप में, परिणाम MessageFormat.format पर पारित होने पर स्थानीयकरण नहीं किया जाता है। उदाहरण के लिए, मैं कहता हूं कि मैं मूल्य 1234.567 के स्थानीयकृत रूप को आउटपुट करना चाहता हूं। toString"1234.567" लौटाएगा, और MessageFormat.format इसे छोड़ देगा। ठीक। मेरे पास मेरा सटीक आउटपुट है। हालांकि, जर्मनी में, यह "1.234,567" के रूप में दिखाई देने पर अधिक समझ में आ जाएगा। यहां तक ​​कि यूएस/यूके में भी, यह "1,234.567" के रूप में दिखाई देने पर अच्छा लगेगा।
• मैं बॉक्सिंग पार कर लेते हैं Integer, Boolean, या MessageFormat.format के लिए किसी भी अन्य गैर फ्लोटिंग प्वाइंट आदिम प्रकार (एक सरल "{n}" प्रारूप के साथ), तो मैं अच्छी तरह से स्थानीय मिलता है, पूर्ण परिशुद्धता उत्पादन। मुझे इसकी आवश्यकता नहीं है - और नहीं करना चाहिए, क्योंकि मैं स्थानीय आउटपुट खो दूंगा - इन मानों को पहले स्ट्रिंग में कनवर्ट करें। इसका मतलब है कि मुझे डबल्स (और फ्लोट्स और BigDecimal एस) का अलग-अलग व्यवहार करना होगा और MessageFormat.format पर उन्हें पास करने से पहले उन्हें तारों में परिवर्तित करना होगा। (इसके अलावा, मुझे हर बार ऐसा करना याद रखना है।)

Answer 1

जावा में डबल प्रारूप 64 बिट्स द्वारा दर्शाया गया है, 52 बिट्स का उपयोग मंटिसा के लिए किया जाता है। लॉग इन करें (2) = 15,65355977। इसका मतलब है कि डबल की सटीकता लगभग 15-16 अंक है।

तो मुझे लगता है कि परिणाम 3.141592653589793 बहुत कुछ है जो आप डबल से प्राप्त करने में सक्षम हैं।

Answer 2

संदेशफॉर्मैट स्थानीयकृत प्रतिनिधित्व का उपयोग करता है, हजारों विभाजक, शायद दशमलव कॉमा और इसी तरह। आपके उपयोग में यह आपके प्लेटफ़ॉर्म के डिफ़ॉल्ट लोकेल का उपयोग करता है।

कुछ को सार्वभौमिक प्रोग्रामर के नोटेशन, valueOf/toString से अलग रखना चाहिए।

double और precision का उपयोग ऑक्सीमोरोन का थोड़ा सा है, क्योंकि दशमलव प्रतिनिधित्व 2 की शक्तियों के योग का अनुमान है जो एक डबल आंतरिक है।

और पूरी जानकारी रखने के लिए आप एक शाब्दिक रूप में कच्चे बिट्स संग्रहीत कर सकती है, Double.doubleToRawLongBits का उपयोग कर वापस लौटते longBitsToDouble पर।

double x = Math.PI; 
String repr = String.format("%016x", Double.doubleToRawLongBits(x)); 
x = Double.longBitsToDouble(Long.valueOf(repr, 16));