C# भाग गुणन से धीमा क्यों है?

प्रोग्रामिंग भाषाओं में और विशेष रूप से C# में 4 अंकगणितीय ऑपरेशन किए जा सकते हैं: जोड़, घटाव, गुणा और भाग।

और बाहरी दृष्टिकोण से, ऐसा लग सकता है कि प्रदर्शन के मामले में वे सभी समान हैं, लेकिन यह पता चला है कि उनमें से एक अन्य तीन की तुलना में बहुत धीमा है।

आप पूछ सकते हैं कि कौन सा धीमा है? डिवीजन.

इस HP पेपर के अनुसार:

फ़्लोटिंग पॉइंट डिवीजन और वर्गमूल की गणना करने में जोड़ और गुणा की तुलना में काफी अधिक समय लगता है। बाद वाले दो की गणना सीधे की जाती है जबकि पहले की गणना आमतौर पर पुनरावृत्त एल्गोरिदम के साथ की जाती है। सबसे सामान्य दृष्टिकोण हर (विभाजन) या व्युत्क्रम वर्गमूल के व्युत्क्रम का अनुमान प्राप्त करने के लिए एक विभाजन-मुक्त न्यूटन-रेफसन पुनरावृत्ति का उपयोग करना है, और फिर अंश (विभाजन) या इनपुट तर्क (वर्गमूल) से गुणा करना है।.

उपरोक्त कथन को सत्यापित करने के लिए मैंने नीचे दिए गए कोड का उपयोग करके एक सरल परीक्षण चलाने का निर्णय लिया:

        //Generate two random numbers
        var rand = new System.Random();
        float a = rand.Next();
        float b = rand.Next();

        Debug.Log("Number a: " + a + " Number b: " + b);

        System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();

        watch.Start();
        //Addition
        for (int i = 1; i < 1000000; i++)
        {
            float tmp = a + b;
        }
        watch.Stop();
        //Output
        Debug.Log("Addition took: " + watch.Elapsed.TotalSeconds.ToString("0.0000") + " seconds");

        watch.Reset();
        watch.Start();
        //Subtraction
        for (int i = 1; i < 1000000; i++)
        {
            float tmp = a - b;
        }
        watch.Stop();
        //Output
        Debug.Log("Subtraction took: " + watch.Elapsed.TotalSeconds.ToString("0.0000") + " seconds");

        watch.Reset();
        watch.Start();
        //Multiplication
        for (int i = 1; i < 1000000; i++)
        {
            float tmp = a * b;
        }
        watch.Stop();
        //Output
        Debug.Log("Multiplication took: " + watch.Elapsed.TotalSeconds.ToString("0.0000") + " seconds");

        watch.Reset();
        watch.Start();
        //Division
        for (int i = 1; i < 1000000; i++)
        {
            float tmp = a / b;
        }
        watch.Stop();
        //Division
        Debug.Log("Division took: " + watch.Elapsed.TotalSeconds.ToString("0.0000") + " seconds");

मूल रूप से, मैंने दो यादृच्छिक संख्याओं के लिए दस लाख जोड़, घटाव, गुणा और भाग चलाए और उनमें से प्रत्येक को संसाधित करने में लगने वाले समय को मापा, परीक्षण 5 बार दोहराया गया, और यहां परिणाम है:

• जोड़ने में औसतन 0.0004 सेकंड लगे
• घटाने में औसतन 0.0003 सेकंड लगे
• गुणन में औसतन 0.0003 सेकंड लगे
• विभाजन में औसतन 0.0044 सेकंड लगे

परिणाम से पता चला कि जोड़, घटाव और गुणा प्रदर्शन के मामले में समान हैं, लेकिन विभाजन लगभग 1100% धीमा प्रतीत होता है।

यह कोई छोटा अंतर नहीं है, जिससे यह निष्कर्ष निकलता है कि जब भी संभव हो भाग के बजाय गुणन का उपयोग करना हमेशा बेहतर होता है। उदाहरण के लिए, जब आपको किसी संख्या को 2 से विभाजित करने की आवश्यकता हो, तो इसके बजाय इसे 0.5 से गुणा करना सबसे अच्छा है।