प्रिंटिंग फ्लोट, सटीक संरक्षण

Question

मैं एक प्रोग्राम लिख रहा हूं जो किसी अन्य प्रोग्राम के अंदर फ़्लोटिंग पॉइंट अक्षर का उपयोग करता है।

मूल फ्लोट की परिशुद्धता को संरक्षित करने के लिए मुझे कितने अंक प्रिंट करने की आवश्यकता है?

चूंकि एक फ्लोट में 24 * (log(2)/log(10)) = 7.2247199 सटीक दशमलव अंक हैं, तो मेरा प्रारंभिक विचार यह था कि प्रिंटिंग 8 अंक पर्याप्त होना चाहिए। लेकिन अगर मैं दुर्भाग्यपूर्ण हूं, तो 0.2247199 बाईं ओर और 7 महत्वपूर्ण अंकों के दाईं ओर वितरित हो जाते हैं, इसलिए मुझे शायद 9 दशमलव अंक प्रिंट करना चाहिए।

क्या मेरा विश्लेषण सही है? क्या 9 दशमलव अंक सभी मामलों के लिए पर्याप्त हैं? printf("%.9g", x); की तरह?

क्या कोई मानक फ़ंक्शन है जो उस मान के लिए आवश्यक दशमलव अंकों की न्यूनतम संख्या के साथ एक स्ट्रैट में एक फ्लोट को परिवर्तित करता है, जहां 7 या 8 पर्याप्त हैं, इसलिए मैं अनावश्यक अंकों को मुद्रित नहीं करता हूं?

नोट: मैं हेक्साडेसिमल फ़्लोटिंग पॉइंट अक्षर का उपयोग नहीं कर सकता, क्योंकि मानक सी ++ उनका समर्थन नहीं करता है।

Answer 1

आदेश में गारंटी नहीं है कि एक binary-> decimal-> द्विआधारी गोल यात्रा मूल बाइनरी मान ठीक हो, IEEE 754 की आवश्यकता है

The original binary value will be preserved by converting to decimal and back again using:[10] 

    5 decimal digits for binary16 
    9 decimal digits for binary32 
    17 decimal digits for binary64 
    36 decimal digits for binary128 

For other binary formats the required number of decimal digits is 

    1 + ceiling(p*log10(2)) 

where p is the number of significant bits in the binary format, e.g. 24 bits for binary32. 

सी में, कार्यों आप इन रूपांतरण के लिए उपयोग कर सकते हैं snprintf हैं() और strtof/strtod/strtold()।

बेशक, कुछ मामलों में भी अधिक अंक उपयोगी हो सकते हैं (नहीं, वे हमेशा "शोर" नहीं होते हैं, जैसे कि स्निपिंटफ()) के दशमलव रूपांतरण दिनचर्या के कार्यान्वयन के आधार पर। उदाहरण पर विचार करें printing dyadic fractions।

Answer 2

जावा में उपयोग किए जाने वाले फ़्लोटिंग-पॉइंट-टू-दशमलव रूपांतरण को अपने पड़ोसियों (अधिक या कम) से संख्या को अलग करने के लिए आवश्यक दशमलव बिंदु से कम दशमलव अंकों की कम से कम संख्या का उत्पादन करने की गारंटी है। FloatingDecimal(float) निर्माता और toJavaFormatString() विधि के लिए http://www.docjar.com/html/api/sun/misc/FloatingDecimal.java.html वेतन ध्यान:

आप यहाँ से एल्गोरिथ्म कॉपी कर सकते हैं।

Answer 3

आप sprintf का उपयोग कर सकते हैं। मुझे यकीन है कि यह आपके सवाल का जवाब है कि क्या वास्तव में हालांकि नहीं हूँ, लेकिन वैसे भी, यहाँ नमूना कोड

#include <stdio.h> 
int main(void) 
{ 
float d_n = 123.45; 
char s_cp[13] = { '\0' }; 
char s_cnp[4] = { '\0' }; 
/* 
* with sprintf you need to make sure there's enough space 
* declared in the array 
*/ 
sprintf(s_cp, "%.2f", d_n); 
printf("%s\n", s_cp); 
/* 
* snprinft allows to control how much is read into array. 
* it might have portable issues if you are not using C99 
*/ 
snprintf(s_cnp, sizeof s_cnp - 1 , "%f", d_n); 
printf("%s\n", s_cnp); 
getchar(); 
return 0; 
} 
/* output : 
* 123.45 
* 123 
*/ 

है

Answer 4

24 * (लॉग (2)/लॉग (10)) = 7,2247199

यह समस्या के लिए सुंदर प्रतिनिधि है। 0.0000001 अंकों की सटीकता के साथ महत्वपूर्ण अंकों की संख्या व्यक्त करने के लिए यह कोई समझ नहीं आता है। आप एक मशीन नहीं, मानव के लाभ के लिए संख्याओं को टेक्स्ट में परिवर्तित कर रहे हैं। एक इंसान कम परवाह नहीं कर सका, और भी बहुत पसंद करते हैं, अगर आप ने लिखा

24 * (लॉग (2)/लॉग (10)) = 7

8 महत्वपूर्ण अंक सिर्फ प्रदर्शित करने के लिए कोशिश कर रहा है यादृच्छिक शोर अंक उत्पन्न करता है। शून्य-शून्य बाधाओं के साथ 7 7 पहले से ही बहुत अधिक है क्योंकि फ्लोटिंग पॉइंट त्रुटि गणनाओं में जमा होती है। सबसे ऊपर, माप की एक उचित इकाई का उपयोग कर प्रिंट संख्या। लोग मिलीमीटर, ग्राम, पाउंड, इंच, इत्यादि में रुचि रखते हैं। कोई आर्किटेक्ट 1 मिमी से अधिक सटीक रूप से व्यक्त खिड़की के आकार के बारे में परवाह करेगा। कोई खिड़की निर्माण संयंत्र वादा एक खिड़की के आकार के रूप में सटीक आकार दिया जाएगा।

अंतिम लेकिन कम से कम नहीं, आप अपने कार्यक्रम में खिलाए गए नंबरों की सटीकता को अनदेखा नहीं कर सकते हैं। एक अज्ञात यूरोपीय की गति को मापना 7 अंकों तक निगलना संभव नहीं है। यह लगभग 11 मीटर प्रति सेकंड, 2 अंक सबसे अच्छा है। तो उस गति पर गणना करना और परिणामस्वरूप प्रिंट करना अधिक महत्वपूर्ण अंक गैरकानूनी परिणाम उत्पन्न करते हैं जो सटीकता का वादा करते हैं जो वहां नहीं है।

Answer 5

तरह

def f(a): 
    b=0 
    while a != int(a): a*=2; b+=1 
    return a, b 

कुछ (जो अजगर है) आप एक नुकसान से मुक्त रास्ते में अपूर्णांश और प्रतिपादक प्राप्त करने में सक्षम होना चाहिए के साथ

।

सी में, यह शायद

struct float_decomp { 
    float mantissa; 
    int exponent; 
} 

struct float_decomp decomp(float x) 
{ 
    struct float_decomp ret = { .mantissa = x, .exponent = 0}; 
    while x != floor(x) { 
     ret.mantissa *= 2; 
     ret.exponent += 1; 
    } 
    return ret; 
} 

होगा लेकिन ध्यान रखें कि अभी भी नहीं सभी मूल्यों है कि रास्ते में व्यक्त किया जा सकता हो, यह सिर्फ एक त्वरित शॉट जो पता चलना चाहिए, लेकिन शायद सुधार की जरूरत है।

Answer 6

यदि प्रोग्राम कंप्यूटर द्वारा पढ़ा जाने वाला है, तो मैं char* एलियासिंग का उपयोग करने की सरल चाल करूंगा।

• उर्फ ​​float*char* अलियासिंग के माध्यम से एक unsigned में char*
• प्रतिलिपि (या जो भी अहस्ताक्षरित प्रकार पर्याप्त रूप से बड़े है) करने के लिए
• प्रिंट unsigned मूल्य

डिकोडिंग सिर्फ प्रक्रिया विपरीत हो रहा है (और अधिकांश प्लेटफ़ॉर्म पर प्रत्यक्ष reinterpret_cast का उपयोग किया जा सकता है)।

Answer 7

यदि आपके पास सी सी पुस्तकालय है जो सी 99 के अनुरूप है (और यदि आपके फ्लोट प्रकारों का आधार 2 है जो 2 की शक्ति है :) printf प्रारूप वर्ण %a हेक्साडेसिमल रूप में परिशुद्धता की कमी के बिना फ़्लोटिंग पॉइंट मान मुद्रित कर सकता है, और scanf और strod के रूप में उपयोगिताएं उन्हें पढ़ने में सक्षम होंगी।

Answer 8

यदि आप इन कागजात को पढ़ते हैं (नीचे देखें), तो आप पाएंगे कि कुछ एल्गोरिदम हैं जो दशमलव अंकों की न्यूनतम संख्या मुद्रित करते हैं जैसे कि संख्या को अपरिवर्तित (यानी scanf द्वारा) का पुन: व्याख्या किया जा सकता है।

चूंकि ऐसी कई संख्याएं हो सकती हैं, इसलिए एल्गोरिदम मूल बाइनरी अंश (मैंने फ्लोट वैल्यू नामित) में निकटतम दशमलव अंश भी चुना है।

एक अफ़सोस की बात है यह है कि सी

• http://www.cs.indiana.edu/~burger/FP-Printing-PLDI96.pdf
• http://grouper.ieee.org/groups/754/email/pdfq3pavhBfih.pdf
में कोई इस तरह के मानक पुस्तकालय