आप C # में दो दशमलव स्थानों पर एक संख्या को कैसे गोल करेंगे?

Question

मैं Math.Roundफ़ंक्शन का उपयोग करके ऐसा करना चाहता हूं

Answer 1

यहाँ कुछ उदाहरण हैं:

decimal a = 1.994444M;

Math.Round(a, 2); //returns 1.99

decimal b = 1.995555M;

Math.Round(b, 2); //returns 2.00

आप निम्न ओवरलोड के साथ बैंकरों को भी गोल-गोल / गोल-गोल दिखना चाहेंगे:

Math.Round(a, 2, MidpointRounding.ToEven);

यहाँ पर इसके बारे में अधिक जानकारी है ।

Comments

आपको स्पष्ट करना चाहिए कि MidPointRounding.ToEven डिफ़ॉल्ट है। यदि आप AwayFromZero चाहते थे, तो आपको ओवरलोड का उपयोग करना होगा

— ब्रायन वेंडर प्लैट्स

यदि आप 2 दशमलव स्थानों तक राउंड करना चाहते हैं, तो 0.005राउंडिंग से पहले संख्या में जोड़ें । इसी तरह , कार्य करने के लिए गुजरने से पहले , नीचे चक्कर लगाना । 0.005Math.Round

— 22

इसका कारण है कि .NET MidPointRounding.ToEven(उर्फ "बैंकर्स राउंडिंग" के लिए चूकता है) क्योंकि हम सभी ने स्कूल में राउंड करना सीख लिया है। 5 राउंड अप बहुत अधिक राउंडिंग का कारण बनता है। यह एक समस्या है जब पैसे, कर गणना, आदि के साथ काम करते हैं

— asporter

Answer 2

इसे इस्तेमाल करे:

twoDec = Math.Round(val, 2)

Answer 3

व्यक्तिगत रूप से मैं कभी भी कुछ भी नहीं करता। इसे जितना संभव हो उतना दृढ़ रखें, क्योंकि सीएस में वैसे भी लाल रंग की हेरिंग थोड़ी होती है। लेकिन आप अपने उपयोगकर्ताओं के लिए डेटा प्रारूपित करना चाहते हैं, और उस अंत तक, मुझे लगता है कि string.Format("{0:0.00}", number)यह एक अच्छा तरीका है।

Comments

यह प्रदर्शन के उद्देश्यों के लिए बेहतर काम करता है, विशेष रूप से पैसे के लिए, 5.4 के रूप में (Math.round के साथ) £ 5.40 (इस तरह) नहीं दिखता है।

— पीटर गॉर्डन

मैंने स्ट्रिंग से पहले कोशिश की है। फ़र्मैट ("0: 0.00", संख्या), लेकिन यह काम नहीं किया। वे वर्ग कोष्ठक बहुत महत्वपूर्ण हैं, इसलिए: string.Format ("{0: 0.00}", संख्या) कार्य करता है।

— FrenkyB

@FrenkyB जब आप 'वर्ग कोष्ठक' कहते हैं, तो मुझे उम्मीद है कि आपका मतलब ब्रेसिज़ होगा।

— गणित

यह दौर भी। 1.009 => 1.01

— डॉनी वी।

Answer 4

यदि आप एक तार चाहते हैं

> (1.7289).ToString("#.##")
"1.73"

या एक दशमलव

> Math.Round((Decimal)x, 2)
1.73m

---

लेकिन याद रखें! गोलाई वितरण योग्य नहीं है, अर्थात। round(x*y) != round(x) * round(y)। तो गणना के बहुत अंत तक कोई भी गोल न करें, अन्यथा आप सटीकता खो देंगे।

Answer 5

विकिपीडिया का एक अच्छा पृष्ठ है में सामान्य रूप से गोलाई पर ।

सभी .NET (प्रबंधित) भाषाएँ किसी भी सामान्य भाषा के रन टाइम (CLR) राउंडिंग तंत्र का उपयोग कर सकती हैं। उदाहरण के लिए, Math.Round () (जैसा कि ऊपर बताया गया है) विधि डेवलपर को गोलाई के प्रकार (राउंड-टू-इवन या अवे-फ्रॉम-जीरो) को निर्दिष्ट करने की अनुमति देती है। Convert.ToInt32 () विधि और इसकी विविधताएँ राउंड-टू-सम का उपयोग करती हैं । छत () और मंजिल () तरीकों से संबंधित हैं।

आप कस्टम संख्यात्मक स्वरूपण के साथ गोल कर सकते हैं ।

ध्यान दें कि Decimal.Round () Math.Round () की तुलना में एक अलग विधि का उपयोग करता है;

यहाँ बैंकर की गोलाई एल्गोरिथ्म पर एक उपयोगी स्थिति है। राउंडिंग के बारे में रेमंड के हास्य पदों में से एक देखें ...

Answer 6

// दो दशमलव स्थानों तक परिवर्तित करें

String.Format("{0:0.00}", 140.6767554);        // "140.67"
String.Format("{0:0.00}", 140.1);             // "140.10"
String.Format("{0:0.00}", 140);              // "140.00"

Double d = 140.6767554;
Double dc = Math.Round((Double)d, 2);       //  140.67

decimal d = 140.6767554M;
decimal dc = Math.Round(d, 2);             //  140.67

=========

// just two decimal places
String.Format("{0:0.##}", 123.4567);      // "123.46"
String.Format("{0:0.##}", 123.4);         // "123.4"
String.Format("{0:0.##}", 123.0);         // "123"

"#" के साथ "0" भी जोड़ सकते हैं।

String.Format("{0:0.0#}", 123.4567)       // "123.46"
String.Format("{0:0.0#}", 123.4)          // "123.4"
String.Format("{0:0.0#}", 123.0)          // "123.0"

Comments

स्ट्रिंग.फॉर्म ("{0: 0.00}", 140.6767554); ! = "140.67" यह वास्तव में "140.68" के रूप में प्रस्तुत करता है - गोल

— एंडीटी

Answer 7

मैं इसका एक पुराना प्रश्न जानता हूं, लेकिन कृपया गणित राउंड और स्ट्रिंग प्रारूप राउंड के बीच निम्नलिखित अंतरों पर ध्यान दें :

decimal d1 = (decimal)1.125;
Math.Round(d1, 2).Dump();   // returns 1.12
d1.ToString("#.##").Dump(); // returns "1.13"

decimal d2 = (decimal)1.1251;
Math.Round(d2, 2).Dump();   // returns 1.13
d2.ToString("#.##").Dump(); // returns "1.13"

Answer 8

यह C # में 2 दशमलव स्थानों पर घूमने के लिए है:

label8.Text = valor_cuota .ToString("N2") ;

VB.NET में:

 Imports System.Math
 round(label8.text,2)

Answer 9

यदि आप एक संख्या को गोल करना चाहते हैं, तो आप इसके आधार पर अलग-अलग परिणाम प्राप्त कर सकते हैं: आप Math.Round () फ़ंक्शन का उपयोग कैसे करते हैं (यदि राउंड-अप या राउंड-डाउन के लिए), तो आप युगल और / या फ़्लोट नंबर के साथ काम कर रहे हैं। , और आप मिडपॉइंट गोलाई लागू करते हैं। विशेष रूप से, जब इसके अंदर के संचालन के साथ उपयोग किया जाता है या गोल से चर एक ऑपरेशन से आता है। मान लीजिए, आप इन दो संख्याओं को गुणा करना चाहते हैं: 0.75 * 0.95 = 0.7125 । सही? C # में नहीं

आइए देखें कि क्या होता है यदि आप तीसरे दशमलव में चक्कर लगाना चाहते हैं:

double result = 0.75d * 0.95d; // result = 0.71249999999999991
double result = 0.75f * 0.95f; // result = 0.71249997615814209

result = Math.Round(result, 3, MidpointRounding.ToEven); // result = 0.712. Ok
result = Math.Round(result, 3, MidpointRounding.AwayFromZero); // result = 0.712. Should be 0.713

जैसा कि आप देख रहे हैं, पहला राउंड () सही है अगर आप मिडपॉइंट को राउंड डाउन करना चाहते हैं। लेकिन अगर आप राउंड अप करना चाहते हैं तो दूसरा राउंड () गलत है।

यह नकारात्मक संख्याओं पर लागू होता है:

double result = -0.75 * 0.95;  //result = -0.71249999999999991
result = Math.Round(result, 3, MidpointRounding.ToEven); // result = -0.712. Ok
result = Math.Round(result, 3, MidpointRounding.AwayFromZero); // result = -0.712. Should be -0.713

तो, IMHO, आपको Math.Round () के लिए अपना स्वयं का रैप फ़ंक्शन बनाना चाहिए जो आपकी आवश्यकताओं के अनुरूप हो। मैंने एक फ़ंक्शन बनाया, जिसमें पैरामीटर 'roundUp = true' का अर्थ है कि अगली बड़ी संख्या पर चक्कर लगाना। वह है: 0.7125 राउंड से 0.713 और -0.7125 राउंड से -0.712 (क्योंकि -0.712> -0.713)। यह वह फ़ंक्शन है जिसे मैंने बनाया है और किसी भी संख्या में दशमलव के लिए काम करता है:

double Redondea(double value, int precision, bool roundUp = true)
{
    if ((decimal)value == 0.0m)
        return 0.0;

    double corrector = 1 / Math.Pow(10, precision + 2);

    if ((decimal)value < 0.0m)
    {
        if (roundUp)
            return Math.Round(value, precision, MidpointRounding.ToEven);
        else
            return Math.Round(value - corrector, precision, MidpointRounding.AwayFromZero);
    }
    else
    {
        if (roundUp)
            return Math.Round(value + corrector, precision, MidpointRounding.AwayFromZero);
        else
            return Math.Round(value, precision, MidpointRounding.ToEven);
    }
}

चर The करेक्टर ’फ्लोटिंग या डबल नंबरों के साथ संचालन की अशुद्धि को ठीक करने के लिए है।

Answer 10

एक चीज जिसे आप जांचना चाहते हैं, वह Math.Round का गोलाई तंत्र है:

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

इसके अलावा, मैं Math.Round (inputNumer, numberOfPlaces) को * 100/100 एक से अधिक होने की सलाह देता हूं क्योंकि यह क्लीनर है।

Answer 11

आपको Math.Round (YourNumber, 2) का उपयोग करने के लिए आपके द्वारा निर्धारित अंकों की संख्या निर्दिष्ट करने में सक्षम होना चाहिए (YourNumber, 2)

आप यहाँ और पढ़ सकते हैं ।

Answer 12

Math.Floor (123456.646 * 100) / 100 123456.64 लौटाएगा

Answer 13

स्ट्रिंग a = "10.65678";

दशमलव d = Math.Round (Convert.ToDouble (a.ToString ()), 2)

Answer 14

एक अजीब स्थिति थी जहां मेरे पास एक दशमलव चर था, जब 55.50 को क्रमिक रूप से यह हमेशा डिफ़ॉल्ट मान को 55.5 के रूप में सेट करता है। लेकिन जबकि, हमारा क्लाइंट सिस्टम किसी कारण से 55.50 की उम्मीद कर रहा है और वे निश्चित रूप से दशमलव की उम्मीद कर रहे हैं। जब मैंने नीचे सहायक लिखा था, जो हमेशा एक स्ट्रिंग भेजने के बजाय शून्य के साथ किसी भी दशमलव मान को 2 अंकों में परिवर्तित करता है।

public static class DecimalExtensions
{
    public static decimal WithTwoDecimalPoints(this decimal val)
    {
        return decimal.Parse(val.ToString("0.00"));
    }
}

उपयोग होना चाहिए

var sampleDecimalValueV1 = 2.5m;
Console.WriteLine(sampleDecimalValueV1.WithTwoDecimalPoints());

decimal sampleDecimalValueV1 = 2;
Console.WriteLine(sampleDecimalValueV1.WithTwoDecimalPoints());

आउटपुट:

2.50
2.00

Answer 15

  public double RoundDown(double number, int decimalPlaces)
        {
            return Math.Floor(number * Math.Pow(10, decimalPlaces)) / Math.Pow(10, decimalPlaces);
        }