क्या दो असमान फ़्लोटिंग पॉइंट संख्याओं को घटाकर 0 प्राप्त करना संभव है?

Question

क्या निम्नलिखित उदाहरण में 0 (या अनंत) द्वारा विभाजन प्राप्त करना संभव है?

public double calculation(double a, double b)
{
     if (a == b)
     {
         return 0;
     }
     else
     {
         return 2 / (a - b);
     }
}

सामान्य मामलों में, यह निश्चित रूप से नहीं होगा। लेकिन क्या अगर aऔर bबहुत करीब हैं, तो गणना की सटीकता के कारण (a-b)परिणाम हो सकते हैं 0?

ध्यान दें कि यह प्रश्न जावा के लिए है, लेकिन मुझे लगता है कि यह अधिकांश प्रोग्रामिंग भाषाओं पर लागू होगा।

Comments

मुझे डबल्स के सभी संयोजनों का प्रयास करना होगा, जिसमें थोड़ी देर

— लगेगी

@ थिरर मुझे ज्यूनिट परीक्षण का उपयोग करने के लिए एक समय लगता है!

— मैट क्लार्क

@bluebrain, मेरा अनुमान है कि आपके शाब्दिक संख्या 2.000 आदि में एक फ्लोट द्वारा दर्शाए जाने वाले कई दशमलव शामिल हैं। तो पिछले लोगों की तुलना में वास्तविक उपयोग की गई संख्या द्वारा प्रतिनिधित्व नहीं किया जाएगा।

— थ्रिलर

@ थिलर शायद। 'आप वास्तव में इस बात की गारंटी नहीं दे सकते हैं कि आपके द्वारा फ़्लोट या डबल को निर्दिष्ट की गई संख्या सटीक है'

— बारूद

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

— m0skit0

Answer 1

जावा में, a - bके बराबर नहीं होती 0है, तो a != b। ऐसा इसलिए है क्योंकि जावा IEEE 754 फ़्लोटिंग पॉइंट ऑपरेशंस को अनिवार्य करता है जो कि असमान संख्याओं का समर्थन करते हैं। से कल्पना :

विशेष रूप से, जावा प्रोग्रामिंग लैंग्वेज को IEEE 754 डिनोमिनेटेड फ्लोटिंग-पॉइंट नंबरों और धीरे-धीरे अंडरफ्लो की सहायता की आवश्यकता होती है, जो विशेष संख्यात्मक एल्गोरिदम के वांछनीय गुणों को साबित करना आसान बनाता है। फ्लोटिंग-पॉइंट ऑपरेशन "शून्य से फ्लश" नहीं करते हैं यदि गणना परिणाम एक असमान संख्या है।

एक तो एफपीयू के साथ काम करता denormalized संख्या , असमान संख्या घटाकर उत्पादन नहीं कर सकते हैं शून्य (गुणा के विपरीत), यह भी देखना यह सवाल ।

अन्य भाषाओं के लिए, यह निर्भर करता है। C या C ++ में, उदाहरण के लिए, IEEE 754 समर्थन वैकल्पिक है।

उस ने कहा, अभिव्यक्ति के लिए यह संभव है2 / (a - b) , उदाहरण के लिए a = 5e-308और b = 4e-308।

Comments

हालाँकि ओपी 2 / (ab) के बारे में जानना चाहता है। क्या यह परिमित होने की गारंटी हो सकती है?

— तैमूर

उत्तर के लिए धन्यवाद, मैंने असामान्य संख्याओं के स्पष्टीकरण के लिए विकिपीडिया पर एक लिंक जोड़ा।

— थ्रिलर

@Taemyr मेरा संपादन देखें विभाजन वास्तव में अतिप्रवाह कर सकता है।

— nwellnhof

@Taemyr (a,b) = (3,1)=> 2/(a-b) = 2/(3-1) = 2/2 = 1क्या यह IEEE फ़्लोटिंग पॉइंट के साथ सच है, मुझे नहीं पता

— कोल जॉनसन

@DrewDormann IEEE 754 C99 के लिए भी वैकल्पिक है। मानक का अनुलग्नक F देखें।

— nwellnhof

Answer 2

वर्कअराउंड के रूप में, निम्नलिखित के बारे में क्या?

public double calculation(double a, double b) {
     double c = a - b;
     if (c == 0)
     {
         return 0;
     }
     else
     {
         return 2 / c;
     }
}

इस तरह आप किसी भी भाषा में IEEE समर्थन पर निर्भर नहीं हैं।

Comments

समस्या से बचें और परीक्षण को एक ही बार में सरल करें। मुझे पसंद है।

— जोशुआ

-1 यदि a=b, आपको वापस नहीं लौटना चाहिए 0। 0IEEE 754 में विभाजित करने से आपको अनंतता मिलती है, अपवाद नहीं। आप समस्या से बच रहे हैं, इसलिए वापसी 0एक बग होने की प्रतीक्षा कर रही है। विचार करें 1/x + 1। यदि x=0, इसके परिणामस्वरूप 1, सही मान नहीं है: अनंत।

— कोल जॉनसन 19

@ColeJohnson सही उत्तर भी अनंत नहीं है (जब तक आप यह निर्दिष्ट नहीं करते हैं कि सीमा किस तरफ से आती है, दाईं ओर = + inf, बाईं ओर = -f, अनिर्दिष्ट = अपरिभाषित या NaN)।

— निक टी

: @ChrisHayes: यह सवाल पहचानने सवाल एक XY समस्या हो सकती है कि के लिए एक वैध जवाब है meta.stackexchange.com/questions/66377/what-is-the-xy-problem

— slebetman

@ColeJohnson रिटर्निंग 0वास्तव में मुद्दा नहीं है। यह ओपी सवाल में क्या करता है। आप ब्लॉक के उस हिस्से में स्थिति के लिए एक अपवाद या जो कुछ भी उपयुक्त हो सकता है। अगर आपको वापस लौटना पसंद नहीं है, तो 0इस सवाल की आलोचना करनी चाहिए। निश्चित रूप से, ओपी के रूप में करने से उत्तर का अपमान नहीं होता है। दिए गए फ़ंक्शन के पूरा होने के बाद इस प्रश्न का आगे की संगणना से कोई लेना-देना नहीं है। आप सभी जानते हैं, कार्यक्रम की आवश्यकताओं को लौटने की आवश्यकता होती है 0।

— jpmc26

Answer 3

आप के मूल्य की परवाह किए बिना शून्य से एक विभाजन नहीं मिलेगा a - b , क्योंकि 0 से फ्लोटिंग पॉइंट डिवीजन एक अपवाद नहीं है। यह अनंत लौटता है।

अब, एक ही रास्ता a == bसच होगा अगर है aऔर bइसमें ठीक उसी बिट्स हैं। यदि वे केवल कम से कम महत्वपूर्ण बिट से भिन्न होते हैं, तो उनके बीच का अंतर 0 नहीं होगा।

संपादित करें:

बतशेबा ने सही टिप्पणी की, कुछ अपवाद हैं:

1. "नहीं एक संख्या की तुलना" खुद के साथ गलत है लेकिन समान बिट पैटर्न होगा।

2. -0.0 को +0.0 के साथ सच की तुलना करने के लिए परिभाषित किया गया है, और उनके बिट पैटर्न अलग हैं।

तो दोनों अगर aऔर bकर रहे हैं Double.NaN, तो आप किसी खंड तक पहुंच जाएगा, लेकिन जब से NaN - NaNयह भी रिटर्न NaN, आप शून्य से भाग देने नहीं किया जाएगा।

Comments

Eran; सख्ती से सच नहीं है। "नहीं एक संख्या की तुलना" खुद के साथ गलत है लेकिन समान बिट पैटर्न होगा। इसके अलावा -0.0 को +0.0 के साथ सच की तुलना करने के लिए परिभाषित किया गया है, और उनके बिट पैटर्न अलग हैं।

— बाथशी

@ बाथशेबा मैंने इन विशेष मामलों पर विचार नहीं किया। टिप्पणी के लिए धन्यवाद।

— एरन

@Eran, बहुत अच्छा बिंदु है कि 0 से विभाजन एक अस्थायी बिंदु में अनंतता लौटाएगा। इसे प्रश्न में जोड़ा गया।

— थ्रिलर

@Prashant लेकिन विभाजन इस मामले में नहीं होगा, क्योंकि a == ख सही होगा।

— एरन

वास्तव में आप शून्य से विभाजन के लिए एक एफपी अपवाद प्राप्त कर सकते हैं, यह IEEE-754 मानक द्वारा परिभाषित एक विकल्प है, हालांकि यह शायद नहीं है कि ज्यादातर लोग "अपवाद" के साथ क्या करेंगे;)

— वू

Answer 4

ऐसा कोई मामला नहीं है जहां शून्य से एक विभाजन यहां हो सकता है।

श्रीमती सॉल्वर जेड 3 चल बिन्दु गणित सटीक आईईईई का समर्थन करता है। आइए Z3 को संख्या aऔर bऐसे खोजने के लिए कहें a != b && (a - b) == 0:

(set-info :status unknown)
(set-logic QF_FP)
(declare-fun b () (FloatingPoint 8 24))
(declare-fun a () (FloatingPoint 8 24))
(declare-fun rm () RoundingMode)
(assert
(and (not (fp.eq a b)) (fp.eq (fp.sub rm a b) +zero) true))
(check-sat)

परिणाम है UNSAT । ऐसी कोई संख्या नहीं है।

उपरोक्त SMTLIB स्ट्रिंग भी Z3 को एक मनमाना गोलाई मोड ( rm) चुनने की अनुमति देता है । इसका मतलब यह है कि परिणाम सभी संभव राउंडिंग मोड के लिए है (जिनमें से पांच हैं)। परिणाम में यह संभावना भी शामिल है कि खेलने में कोई भी चर NaNया अनंत हो सकता है ।

a == bfp.eqगुणवत्ता के रूप में कार्यान्वित किया जाता है ताकि तुलना +0fऔर -0fसमान हो। शून्य के साथ तुलना का उपयोग करके भी लागू किया fp.eqजाता है। चूंकि सवाल शून्य से एक विभाजन से बचने के उद्देश्य से है, इसलिए यह उचित तुलना है।

यदि बिटवाइस समानता का उपयोग करके समानता परीक्षण लागू किया गया था, +0fऔर -0fबनाने का एक तरीका होगाa - b शून्य । इस उत्तर के एक गलत पिछले संस्करण में जिज्ञासु के लिए उस मामले के बारे में मोड विवरण शामिल हैं।

Z3 ऑनलाइन अभी तक FPA सिद्धांत का समर्थन नहीं करता है। यह परिणाम नवीनतम अस्थिर शाखा का उपयोग करके प्राप्त किया गया था। इसे निम्नानुसार .NET बाइंडिंग का उपयोग करके पुन: प्रस्तुत किया जा सकता है:

var fpSort = context.MkFPSort32();
var aExpr = (FPExpr)context.MkConst("a", fpSort);
var bExpr = (FPExpr)context.MkConst("b", fpSort);
var rmExpr = (FPRMExpr)context.MkConst("rm", context.MkFPRoundingModeSort());
var fpZero = context.MkFP(0f, fpSort);
var subExpr = context.MkFPSub(rmExpr, aExpr, bExpr);
var constraintExpr = context.MkAnd(
        context.MkNot(context.MkFPEq(aExpr, bExpr)),
        context.MkFPEq(subExpr, fpZero),
        context.MkTrue()
    );

var smtlibString = context.BenchmarkToSMTString(null, "QF_FP", null, null, new BoolExpr[0], constraintExpr);

var solver = context.MkSimpleSolver();
solver.Assert(constraintExpr);

var status = solver.Check();
Console.WriteLine(status);

आईईईई नाव सवालों के जवाब देने जेड 3 का उपयोग करना अच्छा है क्योंकि यह मामलों को नजरअंदाज करने के लिए (जैसे कठिन है है NaN, -0f, +-inf) और आप मनमाने ढंग से सवाल पूछ सकते हैं। विनिर्देशों की व्याख्या और हवाला देने की आवश्यकता नहीं है। आप मिश्रित फ्लोट और पूर्णांक प्रश्न भी पूछ सकते हैं जैसे कि "क्या यह विशेष int log2(float)एल्गोरिथ्म सही है?"।

Comments

क्या आप कृपया SMT Solver Z3 का लिंक और ऑनलाइन इंटरप्रेटर का लिंक जोड़ सकते हैं? हालांकि यह जवाब पूरी तरह से वैध लगता है, कोई सोच सकता है कि ये परिणाम गलत हैं।

— AL

Answer 5

आपूर्ति किए गए फ़ंक्शन वास्तव में अनंत लौट सकते हैं:

public class Test {
    public static double calculation(double a, double b)
    {
         if (a == b)
         {
             return 0;
         }
         else
         {
             return 2 / (a - b);
         }
    }    

    /**
     * @param args
     */
    public static void main(String[] args) {
        double d1 = Double.MIN_VALUE;
        double d2 = 2.0 * Double.MIN_VALUE;
        System.out.println("Result: " + calculation(d1, d2)); 
    }
}

आउटपुट है Result: -Infinity।

जब विभाजन का परिणाम एक डबल में संग्रहीत होने के लिए बड़ा होता है, तो अनंत को तब भी लौटाया जाता है, जब भाजक गैर-शून्य हो।

Answer 6

फ्लोटिंग-पॉइंट कार्यान्वयन जो IEEE-754 के अनुरूप है, प्रत्येक फ़्लोटिंग-पॉइंट प्रकार दो स्वरूपों में संख्याओं को पकड़ सकता है। एक ("सामान्यीकृत") का उपयोग अधिकांश फ़्लोटिंग-पॉइंट मानों के लिए किया जाता है, लेकिन दूसरी सबसे छोटी संख्या जिसका प्रतिनिधित्व कर सकते हैं वह केवल सबसे छोटे से थोड़ा बड़ा है, और इसलिए उनके बीच का अंतर उसी प्रारूप में प्रतिनिधित्व करने योग्य नहीं है। अन्य ("भाजित") प्रारूप का उपयोग केवल बहुत कम संख्याओं के लिए किया जाता है जो पहले प्रारूप में प्रतिनिधित्व करने योग्य नहीं हैं।

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

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

Answer 7

IEEE 754 से पहले के पुराने समय में, यह बहुत संभव था कि a =! B का अभिप्राय ab नहीं था! = 0 और इसके विपरीत। पहली जगह में IEEE 754 बनाने का एक कारण यह था।

IEEE 754 के साथ यह लगभग गारंटीकृत है। सी या सी ++ संकलक को आवश्यकता से अधिक परिशुद्धता के साथ एक ऑपरेशन करने की अनुमति है। इसलिए यदि a और b वैरिएबल नहीं हैं, लेकिन अभिव्यक्तियाँ हैं, तो (a + b)! = C का अर्थ यह नहीं है (a + a)) - c! = 0, क्योंकि a + b की गणना एक बार उच्च परिशुद्धता के साथ की जा सकती है, और एक बार बिना उच्च परिशुद्धता।

कई FPU को एक मोड में स्विच किया जा सकता है, जहां वे असमान संख्याएं नहीं लौटाते हैं, लेकिन उन्हें 0. के साथ प्रतिस्थापित करते हैं। उस मोड में, यदि a और b छोटे सामान्यीकृत संख्याएं हैं, जहां अंतर सबसे छोटी सामान्यीकृत संख्या से छोटा है, लेकिन 0 से अधिक है, तो ! = b भी गारंटी नहीं देता है == b।

"फ्लोटिंग-पॉइंट नंबरों की तुलना कभी न करें" कार्गो पंथ प्रोग्रामिंग है। जिन लोगों के पास मंत्र है "आपको एप्सिलॉन की आवश्यकता है", उनमें से अधिकांश को यह पता नहीं है कि कैसे उस एप्सिलॉन को ठीक से चुनना है।

Answer 8

मैं एक मामले में जहां आप सोच सकते हैं हो सकता है ऐसा करने के लिए पैदा करने में सक्षम हो। यहां आधार 10 में एक अनुरूप नमूना है - वास्तव में, यह बेस 2 में होगा, निश्चित रूप से।

फ्लोटिंग पॉइंट नंबर को वैज्ञानिक संकेतन में कम या ज्यादा स्टोर किया जाता है - अर्थात, 35.2 को देखने के बजाय, स्टोर की जाने वाली संख्या 3.52e2 की तरह अधिक होगी।

सुविधा के लिए कल्पना करें कि हमारे पास एक अस्थायी बिंदु इकाई है जो आधार 10 में संचालित होती है और सटीकता के 3 अंक हैं। जब आप 10.0 से 9.99 घटाते हैं तो क्या होता है?

1.00e2-9.99e1

प्रत्येक मान को समान घातांक देने के लिए शिफ्ट करें

1.00e2-0.999e2

3 अंकों के लिए गोल

1.00e2-1.00e2

उह ओह!

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

Comments

घटाव के लिए गठबंधन किए गए ऑपरेंड को रखने वाले रजिस्टरों को इस स्थिति से निपटने के लिए अतिरिक्त दो बिट्स को "गार्ड बिट्स" कहा जाता है। इस परिदृश्य में जहां घटाव सबसे महत्वपूर्ण बिट से एक उधार का कारण होगा, या तो छोटे ऑपरेंड की परिमाण बड़े ऑपरेंड के आधे से अधिक होनी चाहिए (इसका मतलब है कि इसमें केवल एक अतिरिक्त बिट की सटीकता हो सकती है) या परिणाम कम से कम होना चाहिए छोटे ऑपरेंड का आधा परिमाण (इसका मतलब है कि इसे केवल एक और बिट की आवश्यकता होगी, और सही गोलाई सुनिश्चित करने के लिए पर्याप्त जानकारी)।

— सुपरकैट

"क्या यह हो सकता है अंततः FPU डिजाइन पर निर्भर करता है" नहीं, ऐसा नहीं हो सकता क्योंकि जावा परिभाषा कहती है कि यह नहीं हो सकता। FPU डिजाइन का इससे कोई लेना-देना नहीं है।

— पास्कल क्यूक

@PascalCuoq: अगर मैं गलत हूं तो मुझे सही करें, लेकिन strictfpसक्षम नहीं है, यह उन मूल्यों की उपज के लिए गणना के लिए संभव है जो बहुत छोटे हैं, doubleलेकिन विस्तारित-सटीक फ़्लोटिंग-पॉइंट मान में फिट होंगे।

— सुपरकाट

@supercat strictfpकेवल "मध्यवर्ती परिणाम" के मूल्यों को प्रभावित करता है, और मैं docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.4 से उद्धृत कर रहा हूं । aऔर bकर रहे हैं doubleचर, नहीं मध्यवर्ती परिणाम है, इसलिए उनके मूल्यों डबल परिशुद्धता मान हैं इस प्रकार 2 ^ -1074 के गुणज हैं,। इन दो दोहरे-सटीक मानों का घटाव, परिणामस्वरूप 2 ^ -1074 का एक बहु है, इसलिए व्यापक घातांक सीमा गुण को बदलती है जो अंतर 0 iff a == b है।

— पास्कल क्यूक

@ सुपरफ़ैट यह समझ में आता है - ऐसा करने के लिए आपको केवल एक अतिरिक्त बिट की आवश्यकता होगी।

— Keldor314

Answer 9

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

समान रूप से समानता के लिए फ़्लोट्स की तुलना करने के लिए, आपको यह जांचने की ज़रूरत है कि क्या मान उसी मान के लिए "पर्याप्त रूप से बंद" है:

if ((first >= second - error) || (first <= second + error)

Comments

"कभी नहीं होना चाहिए" थोड़ा मजबूत है, लेकिन आम तौर पर यह अच्छी सलाह है।

— मार्क पैटिसन

जब आप सच्चे होते हैं, abs(first - second) < error(या <= error) आसान और अधिक संक्षिप्त होता है।

— ग्लोगल

जबकि ज्यादातर मामलों में सच है ( सभी नहीं ), वास्तव में सवाल का जवाब नहीं देता है।

— सहस्राब्दी

समानता के लिए फ्लोटिंग-पॉइंट संख्याओं का परीक्षण करना अक्सर उपयोगी होता है। एक एप्सिलॉन के साथ तुलना करने के बारे में कुछ भी समझदार नहीं है जिसे सावधानी से नहीं चुना गया है, और समानता के लिए परीक्षण करते समय एक एप्सिलॉन के साथ तुलना करने के बारे में भी कम समझदार नहीं है।

— tmyklebu

यदि आप फ़्लोटिंग-पॉइंट कुंजी पर एक सरणी को सॉर्ट करते हैं, तो मैं गारंटी दे सकता हूं कि यदि आप एक एप्सिलॉन के साथ फ़्लोटिंग-पॉइंट संख्याओं की तुलना करने वाले ट्रिक का उपयोग करने का प्रयास करते हैं तो आपका कोड काम नहीं करेगा। क्योंकि गारंटी है कि a == b और b == c का तात्पर्य a == c नहीं है। हैश टेबल के लिए, एक ही समस्या। जब समानता सकर्मक नहीं होती है, तो आपके एल्गोरिदम बस टूट जाते हैं।

— gnasher729

Answer 10

शून्य से विभाजन अपरिभाषित है, क्योंकि सकारात्मक संख्या से सीमा अनंत तक होती है, नकारात्मक संख्या से सीमित नकारात्मक अनंत तक होती है।

निश्चित नहीं है कि यह C ++ या जावा है क्योंकि कोई भाषा टैग नहीं है।

double calculation(double a, double b)
{
     if (a == b)
     {
         return nan(""); // C++

         return Double.NaN; // Java
     }
     else
     {
         return 2 / (a - b);
     }
}

Answer 11

मुख्य समस्या यह है कि जब आपके पास "बहुत अधिक" दशमलव होता है, तो दोहरे (उर्फ फ्लोट, या गणितीय भाषा में वास्तविक संख्या) का कंप्यूटर प्रतिनिधित्व उदाहरण के लिए होता है जब आप दोहरे के साथ सौदा करते हैं जिसे संख्यात्मक मान के रूप में नहीं लिखा जा सकता है ( पीआई या 1/3 का परिणाम)।

इसलिए a = b किसी भी दोहरे मान के साथ नहीं किया जा सकता है a और b, आप एक == b के साथ कैसे व्यवहार करते हैं जब a = 0.333 और b = 1/3? 0 के बाद आपके ओएस बनाम एफपीयू बनाम नंबर बनाम भाषा बनाम 3 की गिनती के आधार पर, आपके पास सही या गलत होगा।

वैसे भी अगर आप कंप्यूटर पर "डबल वैल्यू कैलकुलेशन" करते हैं, तो आपको सटीकता के साथ व्यवहार करना होगा, इसलिए करने के बजाय a==b, आपको करना होगा absolute_value(a-b)<epsilon, और एप्सिलन आपके एल्गोरिथ्म में उस समय जो आप कर रहे हैं, उसके सापेक्ष है। आप अपनी दोहरी तुलना के सभी के लिए एक एप्सिलॉन मान नहीं कर सकते।

संक्षेप में, जब आप एक == बी टाइप करते हैं, तो आपके पास एक गणितीय अभिव्यक्ति होती है जिसे कंप्यूटर पर (किसी भी अस्थायी बिंदु संख्या के लिए) अनुवादित नहीं किया जा सकता है।

पुनश्च: हाँ, मैं यहाँ जो कुछ भी उत्तर देता हूं वह कमोबेश अन्य प्रतिक्रियाओं और टिप्पणियों में है।

Answer 12

@Malarres प्रतिक्रिया और @ टिप्पणी के आधार पर, यहाँ मेरा थोड़ा योगदान है:

public double calculation(double a, double b)
{
     double c = 2 / (a - b);

     // Should not have a big cost.
     if (isnan(c) || isinf(c))
     {
         return 0; // A 'whatever' value.
     }
     else
     {
         return c;
     }
}

मेरा कहना यह है कि: यह जानने का सबसे आसान तरीका है कि विभाजन का परिणाम नैनो है या विभाजन करने के लिए वास्तविक है।