डिवीजन और फ़्लोटिंग पॉइंट्स

Question

क्या कोई मेरी मदद कर सकता है क्यों x2 प्रिंट शून्य करता है। मुझे लगता है कि फ्लोटिंग पॉइंट प्रस्तुति X1 के कारण गोलाकार है, वांछित रखने का कोई तरीका है।

long double x1, x2; 
x1= 0.087912088; // Note: 360/4095 = 0.087912088 
x2 = 360/4095; 
printf("%Lf, %Lf \n",x1, x2); 

परिणाम:

x1 =0.087912 
x2= 0.000000 

Answer 1

समस्या पूर्णांक काट-छांट है .. आप दो पूर्णांकों => परिणाम विभाजित कर रहे हैं फेंक दिया आंशिक भाग के साथ एक अन्य पूर्णांक हो जाएगा। (इसलिए उदाहरण के लिए जब एक पूर्णांक विभाजन का असली परिणाम 3.9 होगा, तो छिड़काव इसे 3 (यानी यह गोल नहीं करता)) करेगा।

आपके मामले में, अगर आप को यह बदलने के लिए:

x2 = 360/4095.0; /* one of the operands now has a decimal point */ 

आप

0.087912, 0.087912 

आउटपुट के रूप में

मिलेगा। (यानी, वह "पदोन्नत" कर दिया जाएगा फ्लोट करने के लिए/डबल)

अर्थात, और जैसे ही एक या विभाजन ऑपरेटर / की ऑपरेंड के दोनों के रूप में नाव/डबल्स कर रहे हैं, परिणाम भी हो जाएगा। इसलिए मैं

x2 = 360.0/4095.0; 

या

x2 = 360.0/4095; 

करने के लिए x2 बदल गया होगा और इसके बाद के संस्करण एक ही परिणाम प्राप्त होंगे।

जैसा कि @chris द्वारा उल्लिखित है, केवल . का उपयोग करना पर्याप्त है।

आप पहले से ही लंबे डबल्स साथ काम कर रहे .. मैं आंतरिक रूप से नहीं लगता कि जब तक आप कुछ विशेष पुस्तकालय का उपयोग आप कुछ भी बदल सकते हैं, लेकिन आप निश्चित रूप से अधिक अंक प्रदर्शित कर सकते हैं करते हैं:

के बारे में सटीक ऊपर अपने प्रश्न पुन

। उदाहरण के लिए,

printf("%Lf, %.20Lf \n",x1, x2); 

0.087912, 0.08791208791208791895 

अंत में, निकलेगा रूप @ EDA-क्यूए मोर्ट-ओरा-y हमें याद दिलाता है, आप भी मूल्यों कुछ प्रकार पर कास्ट कर सकते हैं, लेकिन यह मायने रखती है जब आप इसे करते हैं। एक साधारण उदाहरण (ध्यान दें कि मानों किसी भी मामले में काम के बाद floatके रूप में अंत के बाद से v एक float है): एक ही प्रकार की वस्तुओं पर

float v = 0; 
        /* values shown are BEFORE assignment */ 
v = (5/2);   /* value is 2 due to integer truncation before assignment */ 
v = (float) (5/2); /* 2.0 as integer division occurs 1st, then cast to float */ 
v = (float) 5/2; /* 2.5 since 5 becomes 5.0 through casting first. */ 

Answer 2

निर्मित ऑपरेटरों काम करते हैं। परिणाम पैरामीटर के समान प्रकार है। इस मामले में विभाजन दो पूर्णांक पर किया जाता है और इस प्रकार परिणाम एक पूर्णांक होता है।

x2 = 360/4096; 
// int/int = int 

इस प्रकार मैं 0 के परिणाम की अपेक्षा करता हूं।

यदि अंतर्निर्मित प्रकार के ऑपरेटरों को अलग किया जाता है तो एक को बढ़ावा दिया जाएगा ताकि उनके पास एक ही प्रकार हो (और परिणाम भी उस प्रकार का है)। तो आप क्या चाहते हैं:

x2 = 1.0 * 360/4095; // or 360.0/4095 

// This is 
    double * int/int 

==> (double * double)/int 
==> (double * double)/double