Math.ound (2.5) 3 के बजाय 2 क्यों लौटता है?

Question

C # में, Math.Round(2.5)2 का परिणाम है।

यह 3 माना जाता है, है ना? यह C # के बजाय 2 क्यों है?

Comments

यह वास्तव में एक विशेषता है। <a href=" msdn.microsoft.com/en-us/library/… MSDN दस्तावेज़ीकरण / ग्राफ़ देखें । इस तरह की गोलाई को बैंकर की गोलाई के रूप में जाना जाता है। वर्कअराउंड के लिए <href = " msdn है। microsoft.com/en-us/library/… अधिभार </a> जो कॉल करने वाले को गोलाई को निर्दिष्ट करने की अनुमति देता है।

— जो

जाहिरा तौर पर गोल विधि, जब दो पूर्णांकों के बीच एक संख्या को गोल करने के लिए कहा जाता है, तो पूर्णांक भी देता है। तो, Math.Round (3.5) रिटर्न 4. इस लेख को

— मैथ्यू जोन्स

Math.Round(2.5, 0, MidpointRounding.AwayFromZero);

— रॉबर्ट डर्गिन

एसक्यूएल सर्वर उस तरह गोल; दिलचस्प परीक्षण के परिणाम तब होते हैं जब T-SQL में C # यूनिट टेस्ट ti वेलिडेट राउंडिंग होती है।

— इडस्टम

@ यह एक बग नहीं है। यह बाइनरी फ्लोटिंग पॉइंट का काम करता है। 1.005डबल में बिल्कुल प्रतिनिधित्व नहीं किया जा सकता है। यह शायद है 1.00499...। यदि आप उपयोग करते हैं तो Decimalयह समस्या गायब हो जाएगी। Math.Round अधिभार का अस्तित्व जो दोहरे पर कई दशमलव अंकों को लेता है, एक संदिग्ध डिजाइन विकल्प IMO है, क्योंकि यह शायद ही कभी सार्थक तरीके से काम करेगा।

— कोडइन्चोस

Answer 1

सबसे पहले, यह वैसे भी एक C # बग नहीं होगा - यह एक .NET बग होगा। C # भाषा है - यह तय नहीं करता है कि कैसेMath.Round लागू किया जाता है।

और दूसरी बात, नहीं - यदि आप डॉक्स पढ़ते हैं , तो आप देखेंगे कि डिफ़ॉल्ट राउंडिंग "राउंड टू इवन" (बैंकरप्सी) है:

वापसी मान
प्रकार: System.Double
पूर्णांक निकटतम। यदि दो पूर्णांकों के बीच a का भिन्नात्मक घटक आधा है, जिसमें से एक सम और दूसरा विषम है, तो सम संख्या वापस आ जाती है। ध्यान दें कि यह विधि Doubleएक अभिन्न प्रकार के बजाय वापस आती है ।

टिप्पणियां
इस विधि का व्यवहार IEEE मानक 754, खंड 4. गोलाई इस तरह कभी कभी निकटतम करने के लिए गोलाई कहा जाता है, या बैंकर का राउंडिंग इस प्रकार है। यह एक एकल दिशा में एक मिडपॉइंट मान को लगातार गोल करने से उत्पन्न होने वाली गोलाई त्रुटियों को कम करता है।

आप निर्दिष्ट कर सकते हैं कि एक अधिभारMath.Round का उपयोग करके मध्य-बिंदुओं को कैसे गोल करना चाहिए जो एक मूल्य लेता है । प्रत्येक अधिभार के अनुरूप एक अधिभार है जिसमें एक नहीं है:MidpointRoundingMidpointRounding

• Round(Decimal) / Round(Decimal, MidpointRounding)
• Round(Double) / Round(Double, MidpointRounding)
• Round(Decimal, Int32) / Round(Decimal, Int32, MidpointRounding)
• Round(Double, Int32) / Round(Double, Int32, MidpointRounding)

यह डिफ़ॉल्ट अच्छी तरह से चुना गया था या नहीं, यह अलग बात है। ( MidpointRoundingकेवल .NET 2.0 में पेश किया गया था। इससे पहले मुझे यकीन नहीं है कि इसे करने के बिना वांछित व्यवहार को लागू करने का कोई आसान तरीका था।) विशेष रूप से, इतिहास ने दिखाया है कि यह अपेक्षित व्यवहार नहीं है - और ज्यादातर मामलों में यही है। एपीआई डिजाइन में एक कार्डिनल पाप। मैं देख सकता हूं क्यों बैंकर की राउंडिंग उपयोगी है ... लेकिन यह अभी भी कई लोगों के लिए आश्चर्य की बात है।

आप निकटतम जावा समकक्ष एनुम ( RoundingMode) पर एक नज़र रखना चाह सकते हैं जो और भी अधिक विकल्प प्रदान करता है। (यह सिर्फ मिडपॉइंट्स के साथ सौदा नहीं करता है।)

Comments

मुझे नहीं पता कि यह एक बग है, मुझे लगता है कि यह डिजाइन के बाद से था ।5 निकटतम सबसे कम पूर्णांक के करीब है क्योंकि यह निकटतम उच्चतम पूर्णांक है।

— स्टेन आर।

.NET लागू होने से पहले मुझे VB में यह व्यवहार याद है।

— जॉन फियाल

वास्तव में, IEEE मानक 754, खंड 4 प्रलेखन राज्यों के रूप में।

— जॉन स्कीट

मैं इससे कुछ समय पहले जल गया था और उसने सोचा कि यह बहुत बड़ा है। सौभाग्य से उन्होंने गोलाई को निर्दिष्ट करने का एक तरीका जोड़ा जो हम सभी ने ग्रेड-स्कूल में सीखा; MidPointRounding।

— शी

+1 के लिए "यह अपेक्षित व्यवहार नहीं है [...] कि एपीआई डिजाइन में एक कार्डिनल पाप है"

— ब्लूराजा - डैनी Pflughoeft

Answer 2

इसे राउंडिंग टू सम (या बैंकर की गोलाई) कहा जाता है, जो रकमों में अर्जित त्रुटियों को कम करने के लिए एक मान्य राउंडिंग रणनीति है (MidpointRounding.ToEven)। सिद्धांत यह है कि, यदि आप हमेशा एक ही दिशा में एक 0.5 नंबर को गोल करते हैं, तो त्रुटियां तेजी से बढ़ेंगी (राउंड-टू-इवन को कम से कम माना जाता है) ^(ए) ।

MSDN विवरण के लिए इन लिंक का अनुसरण करें:

• Math.Floor, जो नकारात्मक अनंत की ओर चक्कर लगाता है।
• Math.Ceiling, जो सकारात्मक अनंत की ओर चक्कर लगाता है।
• Math.Truncate, जो शून्य की ओर ऊपर या नीचे गोल होता है।
• Math.Round, जो निकटतम पूर्णांक या दशमलव स्थानों की निर्दिष्ट संख्या के लिए गोल है। आप व्यवहार को निर्दिष्ट कर सकते हैं यदि यह दो संभावनाओं के बीच समान रूप से समान है, जैसे कि गोलाई ताकि अंतिम अंक भी (" Round(2.5,MidpointRounding.ToEven)" 2 बन रहा है) या इसलिए कि यह शून्य से दूर है (" Round(2.5,MidpointRounding.AwayFromZero)" 3)।

निम्नलिखित आरेख और तालिका मदद कर सकती है:

-3        -2        -1         0         1         2         3
 +--|------+---------+----|----+--|------+----|----+-------|-+
    a                     b       c           d            e

                       a=-2.7  b=-0.5  c=0.3  d=1.5  e=2.8
                       ======  ======  =====  =====  =====
Floor                    -3      -1      0      1      2
Ceiling                  -2       0      1      2      3
Truncate                 -2       0      0      1      2
Round(ToEven)            -3       0      0      2      3
Round(AwayFromZero)      -3      -1      0      2      3

ध्यान दें कि Roundयह बहुत अधिक शक्तिशाली है जितना लगता है, बस इसलिए कि यह एक विशिष्ट संख्या में दशमलव स्थानों के लिए गोल हो सकता है। अन्य सभी हमेशा शून्य दशमलव तक गोल करते हैं। उदाहरण के लिए:

n = 3.145;
a = System.Math.Round (n, 2, MidpointRounding.ToEven);       // 3.14
b = System.Math.Round (n, 2, MidpointRounding.AwayFromZero); // 3.15

अन्य कार्यों के साथ, आपको समान प्रभाव प्राप्त करने के लिए गुणा / भाग की चाल का उपयोग करना होगा:

c = System.Math.Truncate (n * 100) / 100;                    // 3.14
d = System.Math.Ceiling (n * 100) / 100;                     // 3.15

---

^(ए) निश्चित रूप से, यह सिद्धांत इस तथ्य पर निर्भर करता है कि आपके डेटा में समरूपता (0.5, 2.5, 4.5, ...) और विषम हिस्सों (1.5, 3.5, ...) के मूल्यों का काफी फैला हुआ है।

यदि सभी "आधे-मान" उदाहरण हैं (उदाहरण के लिए), तो त्रुटियाँ उतनी ही तेजी से बढ़ेंगी जितनी कि आप हमेशा गोल करते हैं।

Comments

बैंकर की गोलाई के रूप में भी जाना जाता है

— पंडिडम

अच्छे खर्च! मैं अपने लिए देखना चाहता था कि त्रुटि कैसे होती है और मैंने एक पटकथा लिखी, जो दिखाती है कि बैंकर के दौर का उपयोग करके गोल किए गए मान, लंबे समय में, उनके मूल और इन मूल मूल्यों के बहुत करीब हैं। github.com/AmadeusW/RoundingDemo (उपलब्ध भूखंडों के चित्र)

— Amadeusz Wieczorek

बस थोड़े समय के बाद: eटिक (= 2.8) 2टिक से आगे सही नहीं होना चाहिए ?

— सुपरजोस

दसवें स्थान को याद रखने और मानने का एक सरल तरीका 5 है: - वे स्थान और दसवें स्थान सभी विषम = गोल ऊपर हैं - वे स्थान और दसवें स्थान मिश्रित हैं = नीचे गोल हैं * शून्य विषम नहीं है * नकारात्मक संख्याओं के लिए उल्टा

— आर्केल एंजेल

@ArkhamAngel, कि वास्तव में याद करने के लिए कठिन लगता है की तुलना में "अंतिम अंक भी बनाते हैं" :-)

— paxdiablo

Answer 3

से MSDN, गणित.गोल (डबल क) देता है:

पूर्णांक निकटतम a। यदि दो पूर्णांकों के बीच एक का भिन्नात्मक घटक आधा है, जिसमें से एक सम और दूसरा विषम है, तो सम संख्या वापस आ जाती है।

... और इसलिए २.५, २ और ३ के बीच आधा रहकर, सम संख्या (२) तक सिमट जाता है। इसे बैंकर राउंडिंग (या राउंड-टू-इवन) कहा जाता है, और आमतौर पर इस्तेमाल किया जाने वाला राउंडिंग मानक है।

वही MSDN लेख:

इस पद्धति का व्यवहार IEEE मानक 754, खंड 4 का अनुसरण करता है। इस प्रकार की गोलाई को कभी-कभी निकटतम, या बैंकर के गोलाई कहा जाता है। यह एक एकल दिशा में एक मिडपॉइंट मान को लगातार गोल करने से उत्पन्न होने वाली गोलाई त्रुटियों को कम करता है।

आप Math.Round के अधिभार को कॉल करके एक अलग गोलाई व्यवहार निर्दिष्ट कर सकते हैं जो एक MidpointRoundingमोड लेता है।

Answer 4

आपको Math.Roundनिम्न के लिए MSDN की जाँच करनी चाहिए :

इस पद्धति का व्यवहार IEEE मानक 754, खंड 4 का अनुसरण करता है। इस प्रकार की गोलाई को कभी-कभी निकटतम, या बैंकर के गोलाई कहा जाता है।

आप Math.Roundएक अधिभार का उपयोग करने के व्यवहार को निर्दिष्ट कर सकते हैं :

Math.Round(2.5, 0, MidpointRounding.AwayFromZero); // gives 3

Math.Round(2.5, 0, MidpointRounding.ToEven); // gives 2

Answer 5

गोलाई का स्वभाव

एक ऐसी संख्या को गोल करने के कार्य पर विचार करें, जिसमें पूर्णांक, कहने के लिए एक अंश हो। इस परिस्थिति में गोलाई की प्रक्रिया यह निर्धारित करने के लिए है कि कौन सी पूरी संख्या आपके द्वारा गोलाई जाने वाली संख्या का सर्वोत्तम प्रतिनिधित्व करती है।

आम तौर पर, या 'अंकगणित' गोलाई में, यह स्पष्ट है कि 2.1, 2.2, 2.3 और 2.4 से 2.0 का दौर; और 2.6, 2.7, 2.8 और 2.9 से 3.0।

यह 2.5 छोड़ देता है, जो 3.0 के मुकाबले 2.0 के करीब नहीं है। यह 2.0 और 3.0 के बीच चयन करना है, या तो समान रूप से मान्य होगा।

माइनस नंबर के लिए, -2.1, -2.2, -2.3 और -2.4, -2.0 हो जाएगा; और -2.6, 2.7, 2.8 और 2.9 अंकगणितीय गोलाई के तहत -3.0 हो जाएगा।

-2.5 के लिए -2.0 और -3.0 के बीच एक विकल्प की आवश्यकता होती है।

गोलाई के अन्य रूप

'राउंडिंग अप' दशमलव स्थानों के साथ किसी भी संख्या को लेता है और इसे अगला 'संपूर्ण' नंबर बनाता है। इस प्रकार न केवल २.५ और २.६ राउंड ३.०, लेकिन इतना ही २.१ और २.२ करते हैं।

राउंडिंग पॉजिटिव और नेगेटिव दोनों को शून्य से दूर ले जाता है। उदाहरण के लिए। 2.5 से 3.0 और -2.5 से -3.0।

अवांछित अंकों को काटकर 'राउंडिंग डाउन' संख्याओं को काटता है। इससे संख्याओं के शून्य की ओर बढ़ने का प्रभाव पड़ता है। उदाहरण के लिए। 2.5 से 2.0 और -2.5 से -2.0

"बैंकर राउंडिंग" में - अपने सबसे सामान्य रूप में - .5 को राउंड किया जाता है या तो ऊपर या नीचे गोल किया जाता है ताकि राउंडिंग का परिणाम हमेशा एक सम संख्या हो। इस प्रकार 2.5 राउंड 2.0, 3.5 से 4.0, 4.5 से 4.0, 5.5 से 6.0, और इसी तरह।

Altern अल्टरनेट राउंडिंग ’किसी भी प्रक्रिया के लिए .5 को राउंडिंग डाउन और राउंडिंग के बीच वैकल्पिक करता है।

'रैंडम राउंडिंग' पूरी तरह से रैंडम आधार पर .5 अप या डाउन राउंड करता है।

समरूपता और विषमता

एक राउंडिंग फ़ंक्शन को 'सममित' कहा जाता है यदि यह या तो सभी संख्याओं को शून्य से दूर करता है या सभी संख्याओं को शून्य की ओर गोल करता है।

एक फ़ंक्शन 'एसिमेट्रिक' है यदि शून्य की ओर धनात्मक संख्याएँ और शून्य से दूर ऋणात्मक संख्याएँ हैं .. जैसे। 2.5 से 2.0; और -2.5 से -3.0।

इसके अलावा असममितता एक ऐसा कार्य है जो शून्य से दूर सकारात्मक संख्या और नकारात्मक संख्या को शून्य की ओर गोल करता है। उदाहरण के लिए। 2.5 से 3.0; और -2.5 से -2.0।

ज्यादातर समय लोग सममित गोलाई के बारे में सोचते हैं, जहां -2.5 को -3.0 की ओर और 3.5 को 4.0 की ओर गोल किया जाएगा। (सी # मेंRound(AwayFromZero))

Answer 6

डिफ़ॉल्ट MidpointRounding.ToEven, या बैंकर्स गोलाई ( 2.5 बन 2, 4.5 4 और इतने पर हो जाता है) ) ने मुझे लेखांकन के लिए रिपोर्ट लिखने से पहले डंक मार दिया है, इसलिए मैं जो कुछ मुझे पता चला है, उससे पहले और उससे ढूंढने के कुछ शब्द लिखूंगा। ये पद।

ये बैंकर कौन हैं जो संख्याओं पर गोल कर रहे हैं (ब्रिटिश बैंकर शायद!)।

विकिपीडिया से

बैंकरों की गोलाई शब्द की उत्पत्ति अधिक अस्पष्ट है। यदि यह राउंडिंग विधि कभी बैंकिंग में एक मानक था, तो प्रमाणों को खोजना बहुत कठिन साबित हुआ है। इसके विपरीत, यूरोपीय आयोग की धारा 2 में यूरो का परिचय और मुद्रा राशियों का दौर बताता है कि पहले बैंकिंग में गोलाई के लिए कोई मानक दृष्टिकोण नहीं था; और यह निर्दिष्ट करता है कि "आधा रास्ता" मात्राओं को गोल किया जाना चाहिए।

यह विशेष रूप से बैंकिंग के लिए राउंडिंग का एक बहुत ही अजीब तरीका लगता है, जब तक कि बैंक बहुत अधिक मात्रा में जमा प्राप्त करने के लिए उपयोग नहीं करते हैं। £ 2.4m जमा करें, लेकिन हम इसे £ 2m सर कहेंगे।

आईईईई मानक 754 1985 तक वापस आता है और राउंडिंग के दोनों तरीके देता है, लेकिन बैंकर के साथ मानक द्वारा अनुशंसित है। इस विकिपीडिया लेख की एक लंबी सूची है कि किस तरह से भाषाएं राउंडिंग को लागू करती हैं (यदि नीचे में से कोई भी गलत है तो मुझे सही करें) और अधिकांश बैंकर्स का उपयोग नहीं करते हैं, लेकिन स्कूल में आपको जो राउंडिंग सिखाई जाती है:

• C / C ++ राउंड () गणित से। शून्य से दूर राउंड (बैंकर के राउंडिंग नहीं)
• Java Math.Round जीरो से दूर होता है (यह परिणाम को बढ़ाता है, 0.5 जोड़ता है, एक पूर्णांक तक कास्ट करता है)। BigDecimal में एक विकल्प है
• पर्ल सी के समान तरीके का उपयोग करता है
• जावास्क्रिप्ट जावा के गणित के समान है।

Comments

जानकारी के लिए धन्यवाद। मुझे कभी इसका एहसास नहीं हुआ। आपका उदाहरण लाखों उपहास के बारे में है, लेकिन अगर आप सेंट पर चक्कर लगाते हैं, तो 10 मिलियन बैंक खातों पर ब्याज का भुगतान करने पर बैंक को बहुत अधिक लागत आएगी यदि सभी आधे सेंट गोल हो जाते हैं, या ग्राहकों को बहुत अधिक खर्च होंगे आधा सेंटीमीटर नीचे गोल हैं। इसलिए मैं सोच सकता हूं कि यह सहमत मानक है। यकीन नहीं अगर यह वास्तव में बैंकरों द्वारा उपयोग किया जाता है, हालांकि। अधिकांश ग्राहकों को बहुत सारे पैसे लाते हुए, राउंडिंग नोटिस नहीं होगा, लेकिन मैं कल्पना कर सकता हूं कि यह कानूनों द्वारा बाध्य है यदि आप ग्राहक-अनुकूल कानूनों वाले देश में रहते हैं

— हैराल्ड कोप्पुलसे

Answer 7

MSDN से:

डिफ़ॉल्ट रूप से, Math.Round MidpointRounding.ToEven का उपयोग करता है। ज्यादातर लोग "गोल से सम तक" के विकल्प के रूप में परिचित नहीं होते हैं, "शून्य से दूर गोलाई" अधिक सामान्यतः स्कूल में पढ़ाया जाता है। .NET "राउंडिंग टू इवन" के रूप में परिभाषित करता है क्योंकि यह सांख्यिकीय रूप से बेहतर है क्योंकि यह "शून्य से दूर गोलाई" की प्रवृत्ति को साझा नहीं करता है क्योंकि यह राउंड डाउन होने की तुलना में थोड़ा अधिक बार गोल होता है (यह मानते हुए कि राउंड को राउंड पॉजिटिव माना जाता है। )

http://msdn.microsoft.com/en-us/library/system.math.round.aspx

Answer 8

चूंकि Silverlight मिडपॉइंटिंग विकल्प का समर्थन नहीं करता है, इसलिए आपको अपना स्वयं का लिखना होगा। कुछ इस तरह:

public double RoundCorrect(double d, int decimals)
{
    double multiplier = Math.Pow(10, decimals);

    if (d < 0)
        multiplier *= -1;

    return Math.Floor((d * multiplier) + 0.5) / multiplier;

}

एक्सटेंशन के रूप में इसका उपयोग कैसे करें सहित उदाहरणों के लिए पोस्ट देखें: .NET और सिल्वरलाइट राउंडिंग

Answer 9

मुझे यह समस्या थी जहाँ मेरा SQL सर्वर 0.5 से 1 तक चक्कर लगाता है जबकि मेरा C # एप्लिकेशन नहीं था। तो आपको दो अलग-अलग परिणाम दिखाई देंगे।

यहाँ int / long के साथ कार्यान्वयन है। यह जावा का दौर है।

int roundedNumber = (int)Math.Floor(d + 0.5);

यह शायद सबसे कुशल तरीका है जिसे आप भी सोच सकते हैं।

यदि आप इसे डबल रखना चाहते हैं और दशमलव परिशुद्धता का उपयोग करना चाहते हैं, तो यह वास्तव में कितने दशमलव स्थानों के आधार पर 10 के घातांक का उपयोग करने की बात है।

public double getRounding(double number, int decimalPoints)
{
    double decimalPowerOfTen = Math.Pow(10, decimalPoints);
    return Math.Floor(number * decimalPowerOfTen + 0.5)/ decimalPowerOfTen;
}

आप दशमलव बिंदुओं के लिए एक नकारात्मक दशमलव इनपुट कर सकते हैं और यह ठीक शब्द भी है।

getRounding(239, -2) = 200

Answer 10

सरल तरीका है:

Math.Ceiling(decimal.Parse(yourNumber + ""));

Answer 11

इस पोस्ट का उत्तर आपके लिए है:

http://weblogs.asp.net/sfurman/archive/2003/03/07/3537.aspx

मूल रूप से यह वही है जो यह कहता है:

प्रतिलाभ की मात्रा

अंकों के बराबर परिशुद्धता के साथ संख्या निकटतम मूल्य। यदि मान दो संख्याओं के बीच आधा है, जिनमें से एक सम और दूसरा विषम है, तो सम संख्या वापस आ जाती है। यदि मान की सटीकता अंकों से कम है, तो मान अपरिवर्तित लौटाया जाता है।

इस पद्धति का व्यवहार IEEE मानक 754, खंड 4 का अनुसरण करता है। इस प्रकार की गोलाई को कभी-कभी निकटतम, या बैंकर के गोलाई कहा जाता है। यदि अंक शून्य है, तो इस तरह की गोलाई को कभी-कभी शून्य की ओर गोलाई कहा जाता है।

Answer 12

Silverlight मिडपॉइंटिंग विकल्प का समर्थन नहीं करता है। यहां सिल्वरलाइट के लिए एक विस्तार विधि है जो मिडपॉइंट राउंडिंग एनम को जोड़ता है:

public enum MidpointRounding
{
    ToEven,
    AwayFromZero
}

public static class DecimalExtensions
{
    public static decimal Round(this decimal d, MidpointRounding mode)
    {
        return d.Round(0, mode);
    }

    /// <summary>
    /// Rounds using arithmetic (5 rounds up) symmetrical (up is away from zero) rounding
    /// </summary>
    /// <param name="d">A Decimal number to be rounded.</param>
    /// <param name="decimals">The number of significant fractional digits (precision) in the return value.</param>
    /// <returns>The number nearest d with precision equal to decimals. If d is halfway between two numbers, then the nearest whole number away from zero is returned.</returns>
    public static decimal Round(this decimal d, int decimals, MidpointRounding mode)
    {
        if ( mode == MidpointRounding.ToEven )
        {
            return decimal.Round(d, decimals);
        }
        else
        {
            decimal factor = Convert.ToDecimal(Math.Pow(10, decimals));
            int sign = Math.Sign(d);
            return Decimal.Truncate(d * factor + 0.5m * sign) / factor;
        }
    }
}

स्रोत: http://anderly.com/2009/08/08/silverlight-midpoint-rounding-solution/

Answer 13

एक कस्टम गोलाई का उपयोग करना

public int Round(double value)
{
    double decimalpoints = Math.Abs(value - Math.Floor(value));
    if (decimalpoints > 0.5)
        return (int)Math.Round(value);
    else
        return (int)Math.Floor(value);
}

Comments

>.5जैसा व्यवहार करता है वैसा ही व्यवहार करता है Math.Round। सवाल यह है कि क्या होता है जब दशमलव भाग बिल्कुल होता है 0.5। Math.Round आपको इच्छित एल्गोरिथ्म की तरह को निर्दिष्ट करने की अनुमति देता है

— Panagiotis Kanavos

Answer 14

यह सभी नरक के रूप में बदसूरत है, लेकिन हमेशा सही अंकगणित का उत्पादन करता है।

public double ArithRound(double number,int places){

  string numberFormat = "###.";

  numberFormat = numberFormat.PadRight(numberFormat.Length + places, '#');

  return double.Parse(number.ToString(numberFormat));

}

Comments

तो कॉलिंग Math.Roundऔर निर्दिष्ट करता है कि आप इसे कैसे गोल करना चाहते हैं।

— विन्यासकर्ता

Answer 15

यहाँ मुझे इसके आसपास काम करने का तरीका बताया गया है:

Public Function Round(number As Double, dec As Integer) As Double
    Dim decimalPowerOfTen = Math.Pow(10, dec)
    If CInt(number * decimalPowerOfTen) = Math.Round(number * decimalPowerOfTen, 2) Then
        Return Math.Round(number, 2, MidpointRounding.AwayFromZero)
    Else
        Return CInt(number * decimalPowerOfTen + 0.5) / 100
    End If
End Function

2 दशमलव के साथ 1.905 के साथ प्रयास करने से उम्मीद के अनुसार 1.91 मिलेगा लेकिन Math.Round(1.905,2,MidpointRounding.AwayFromZero)1.90 देता है! मैथ.उंड विधि बिल्कुल मूल रूप से असंगत और अनुपयोगी है जिसके लिए मूल बातें समस्याओं के अधिकांश प्रोग्रामर मुठभेड़ कर सकते हैं। मुझे यह जांचना होगा कि क्या (int) 1.905 * decimalPowerOfTen = Math.Round(number * decimalPowerOfTen, 2)कारण है कि मैं गोल नहीं करना चाहता हूं जो नीचे गोल होना चाहिए।

Comments

Math.Round(1.905,2,MidpointRounding.AwayFromZero)रिटर्न1.91

— पैनागोटिस कान्वोस