दिलचस्प पोस्ट
आईओएस डिवाइस मैक एड्रेस प्रोग्राम को कैसे प्राप्त करें I PHP चेतावनी: move_uploaded_file () स्थानांतरित करने में असमर्थ गिट उथले submodules आर जेवा को आर पर लोड करने में असमर्थ टुकड़ों का उपयोग करते समय एंड्रॉइड नेविगेशन ड्रॉवर छवि और अप कैरेट के बीच स्विच करना यदि सेल में '@' सम्मिलित नहीं है, तो पूरे पंक्ति को हटाने का कुशल तरीका एसआईएम द्वारा MySQL ग्रुप कैसे पृष्ठ लोड के बाद jQuery के माध्यम से गतिशील रूप से एक <स्क्रिप्ट> टैग डालें? वर्तमान फ़ोल्डर का रास्ता ढूंढें – सीएमडी सेलेनियम में जावास्क्रिप्ट कोड का रिटर्न वैल्यू प्राप्त करना MySQL की स्थापना और डॉकरफाइल के भीतर डंप को आयात करना पिछले कमिट को जांचने के बाद नवीनतम प्रतिबद्धता वापस कैसे प्राप्त करें? सरल डायलॉग के साथ पायथन में फाइल चुनना जब बंदर एक विधि को पैचिंग करते हैं, तो क्या आप नए कार्यान्वयन से ओवरराइड विधि को कॉल कर सकते हैं? सीट के साथ दशमलव अंकों की सही संख्या छपाई

+0.0 और -0.0 पर कौन से आपरेशन और फ़ंक्शन अलग-अलग अंकगणित परिणाम देते हैं?

सी में, जब ±0.0 समर्थित होता है, +0.0 या +0.0 गए +0.0 आमतौर पर कोई अंकगणित अंतर नहीं होता है। हालांकि उनके पास अलग-अलग पैटर्न हैं, वे गणितीय रूप से समान के रूप में तुलना करते हैं।

 double zp = +0.0; double zn = -0.0; printf("0 == memcmp %d\n", 0 == memcmp(&zn, &zp, sizeof zp));// --> 0 == memcmp 0 printf("== %d\n", zn == zp); // --> == 1 

@ पास्कल क्यूक टिप्पणी से प्रेरित होकर, मैं मानक सी में कुछ और कार्यों की तलाश कर रहा हूं जो अंकगणित रूप से भिन्न परिणाम प्रदान करते हैं।

नोट: कई कार्यों, जैसे sin() , f(+0.0) और f(+0.0) । लेकिन ये अलग अंकगणित परिणाम प्रदान नहीं करते हैं। इसके अलावा 2 परिणाम दोनों NaN नहीं होना चाहिए

वेब के समाधान से एकत्रित समाधान "+0.0 और -0.0 पर कौन से आपरेशन और फ़ंक्शन अलग-अलग अंकगणित परिणाम देते हैं?"

कुछ मानक संचालन और कार्य हैं जो f(+0.0) और f(-0.0) f(+0.0) बीच संख्यात्मक रूप से अलग-अलग उत्तरों करते हैं।

विभिन्न गोलाकार मोड या अन्य फ्लोटिंग प्वाइंट लागूकरण विभिन्न परिणाम दे सकते हैं।

 #include <math.h> double inverse(double x) { return 1/x; } double atan2m1(double y) { return atan2(y, -1.0); } double sprintf_d(double x) { char buf[20]; // sprintf(buf, "%+f", x); Changed to e sprintf(buf, "%+e", x); return buf[0]; // returns `+` or `-` } double copysign_1(double x) { return copysign(1.0, x); } double signbit_d(double x) { int sign = signbit(x); // my compile returns 0 or INT_MIN return sign; } double pow_m1(double x) { return pow(x, -1.0); } void zero_test(const char *name, double (*f)(double)) { double fzp = (f)(+0.0); double fzn = (f)(-0.0); int differ = fzp != fzn; if (fzp != fzp && fzn != fzn) differ = 0; // if both NAN printf("%-15s f(+0):%-+15e %sf(-0):%-+15e\n", name, fzp, differ ? "!=" : "==", fzn); } void zero_tests(void) { zero_test("1/x", inverse); zero_test("atan2(x,-1)", atan2m1); zero_test("printf(\"%+e\")", sprintf_d); zero_test("copysign(x,1)", copysign_1); zero_test("signbit()", signbit_d); zero_test("pow(x,-odd)", pow_m1);; // @Pascal Cuoq zero_test("tgamma(x)", tgamma); // @vinc17 @Pascal Cuoq } 

 Output: 1/xf(+0):+inf != f(-0):-inf atan2(x,-1) f(+0):+3.141593e+00 != f(-0):-3.141593e+00 printf("%+e") f(+0):+4.300000e+01 != f(-0):+4.500000e+01 copysign(x,1) f(+0):+1.000000e+00 != f(-0):-1.000000e+00 signbit() f(+0):+0.000000e+00 != f(-0):-2.147484e+09 pow(x,-odd) f(+0):+inf != f(-0):-inf tgamma(x) f(+0):+inf != f(-0):+inf 

टिप्पणियाँ:
tgamma(x) मेरे जीसीसी 4.8.2 मशीन पर == ऊपर आया, लेकिन सही != दूसरों पर।

rsqrt() , उर्फ 1/sqrt() एक हो सकता है भावी सी मानक फ़ंक्शन। मई / मई भी काम नहीं कर सकता

double zero = +0.0; memcpy(&zero, &x, sizeof x) double zero = +0.0; memcpy(&zero, &x, sizeof x) दिखा सकता है +0.0 तुलना में एक अलग बिट पैटर्न है लेकिन x अभी भी एक +0.0 हो सकता है। मुझे लगता है कि कुछ एफपी प्रारूपों में कई बिट पैटर्न हैं जो कि +0.0 और +0.0 हैं। TBD।

https://stackoverflow.com/help/self-answer द्वारा प्रदत्त यह एक स्वयं-उत्तर है

IEEE 754-2008 फ़ंक्शन rsqrt (जो भविष्य में आईएसओ सी मानक में होगा) ± 0 पर ±) देता है, जो काफी आश्चर्यजनक है। और tgamma भी ± 0 पर ± 0 पर देता है MPFR के साथ, mpfr_digamma ± opposite के विपरीत ± 0 पर देता है

मैं इस पद्धति के बारे में सोचता हूं, लेकिन मैं सप्ताहांत से पहले नहीं देख सकता, इसलिए कोई इस पर कुछ प्रयोग कर सकता है, अगर वह चाहें, या बस मुझे बताओ कि यह बकवास है:

  • एक -0.0 एफ उत्पन्न करें यह एक छोटे से नकारात्मक निरंतर असाइन करके स्थैतिक रूप से उत्पन्न होना संभव है, जो निहित फ़्लोट प्रस्तुतीकरण करती है।

  • इस निरंतर को एक अस्थिर डबल और वापस फ्लोट करने के लिए असाइन करें।

    बिट प्रस्तुति 2 बार बदलकर, मुझे लगता है कि -0.0f के लिए कंपाइलर विशिष्ट मानक बिट प्रतिनिधित्व चर में है। कंपाइलर मुझे वहां से बाहर नहीं कर सकता, क्योंकि उन 2 प्रतियों के बीच एक अस्थिर वैल्यू में एक अन्य अन्य मान हो सकता है

  • इनपुट को 0.0f से तुलना करें अगर हमारे पास 0.0 एफ / -0.0 एफ केस है तो पता लगाने के लिए

  • अगर यह बराबर है, इनपुट वोल्टाले डबल वैरिएबल को असाइन करें, और फिर फ्लोट पर वापस जाएं।

    मैं फिर से मानता हूं कि यह अब 0.0f के लिए मानक कंपाइलर प्रतिनिधित्व है

  • एक यूनियन द्वारा बिट पैटर्न का उपयोग करें और उनकी तुलना करें, यह तय करने के लिए कि क्या यह -0.0 एफ है

कोड कुछ ऐसा हो सकता है:

 typedef union { float fvalue; /* assuming int has at least the same number of bits as float */ unsigned int bitpat; } tBitAccess; float my_signf(float x) { /* assuming double has smaller min and other bit representation than float */ volatile double refitbits; tBitAccess tmp; unsigned int pat0, patX; if (x < 0.0f) return -1.0f; if (x > 0.0f) return 1.0f; refitbits = (double) (float) -DBL_MIN; tmp.fvalue = (float) refitbits; pat0 = tmp.bitpat; refitbits = (double) x; tmp.fvalue = (float) refitbits; patX = tmp.bitpat; return (patX == pat0)? -1.0f : 1.0f; } 
  • यह मानक फ़ंक्शन या ऑपरेटर नहीं है, लेकिन एक फ़ंक्शन जो -0.0 और 0.0 के बीच अंतर होना चाहिए।
  • यह धारणा पर आधारित है (मुख्यतः) कि संकलक विक्रेता -0.0f के प्रारूपों में परिवर्तन के परिणामस्वरूप भिन्न बिट पैटर्न का उपयोग नहीं करता है, भले ही फ़ॉक्टिंग प्वाइंट प्रारूप इसे अनुमति देगा, और यदि यह हो, तो यह चयनित से स्वतंत्र है थोड़ा अभ्यास।
  • फ्लोटिंग प्वाइंट प्रारूपों के लिए जिनके लिए -0.0 एफ का सटीक एक पैटर्न है, इस फ़ंक्शन को उस पैटर्न में बिट ऑर्डर करने के ज्ञान के बिना चाल को सुरक्षित रूप से सुरक्षित करना चाहिए।
  • अन्य मान्यताओं (प्रकारों के आकार के बारे में और इतने पर) को फ्लोट एच स्थिरांक पर प्रीकंपलर स्विचेस के साथ नियंत्रित किया जा सकता है।

संपादित करें: एक दूसरे विचार पर: यदि हम मूल्य की तुलना में सबसे छोटा प्रतिनिधित्व योग्य डायनरमल (असामान्य) फ़्लोटिंग बिंदु संख्या या इसके नकारात्मक समकक्ष से नीचे (0.0 || -0.0) बल कर सकते हैं, और -0.0f के लिए कोई दूसरा पैटर्न नहीं है (सटीक ), एफपी प्रारूप में, हम दोहरे अस्थिर करने के लिए कास्टिंग को छोड़ सकते हैं (लेकिन हो सकता है कि फ्लोट अस्थिर हो, यह सुनिश्चित करने के लिए कि निष्क्रिय डेनिमर्ल के साथ कंपाइलर परिचालन को अनदेखा करने के लिए कोई फैंसी चाल नहीं कर सकता है, जो कि 0.0 के बराबर की तुलना में चीजों के निरपेक्ष मूल्य को कम करता है।)

कोड तब दिख सकता है:

 typedef union { float fvalue; /* assuming int has at least the same number of bits as float */ unsigned int bitpat; } tBitAccess; float my_signf(float x) { volatile tBitAccess tmp; unsigned int pat0, patX; if (x < 0.0f) return -1.0f; if (x > 0.0f) return 1.0f; tmp.fvalue = -DBL_MIN; /* forcing something compares equal to 0.0f below smallest subnormal - not sure if one abs()-factor is enough */ tmp.fvalue = tmp.fvalue * fabsf(tmp.fvalue); pat0 = tmp.bitpat; tmp.fvalue = x; tmp.fvalue = tmp.fvalue * fabsf(tmp.fvalue); patX = tmp.bitpat; return (patX == pat0)? -1.0f : 1.0f; } 

यह फैंसी गोलाई विधियों के साथ काम नहीं करेगा, जो नकारात्मक मानकों से -0.0 की ओर घूमती रहती है।