คุณจะปัดเศษทศนิยมเป็นสองใน C # ได้อย่างไร

ฉันต้องการทำสิ่งนี้โดยใช้Math.Roundฟังก์ชั่น

นี่คือตัวอย่างบางส่วน:

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);

มีข้อมูลเพิ่มเติมเกี่ยวกับมันนี่

ลองสิ่งนี้:

twoDec = Math.Round(val, 2)

โดยส่วนตัวฉันไม่เคยปัดเศษอะไรเลย เก็บไว้เป็นเด็ดเดี่ยวที่สุดเนื่องจากการปัดเศษเป็นปลาเฮอริ่งแดงใน CS แต่คุณต้องการจัดรูปแบบข้อมูลสำหรับผู้ใช้ของคุณและท้ายที่สุดฉันพบว่านั่นstring.Format("{0:0.00}", number)เป็นวิธีการที่ดี

หากคุณต้องการสตริง

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

หรือทศนิยม

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

แต่จำไว้! การปัดเศษไม่ได้เป็นการแจกแจงเช่น round(x*y) != round(x) * round(y). ดังนั้นอย่าทำการปัดเศษจนสิ้นสุดการคำนวณมิฉะนั้นคุณจะเสียความแม่นยำ

Wikipedia มีหน้าดีในการปัดเศษโดยทั่วไป

ภาษา. NET (ที่มีการจัดการ) ทั้งหมดสามารถใช้กลไกการปัดเศษ (CLR) ของการเรียกใช้ภาษาทั่วไป ตัวอย่างเช่นวิธีการMath.Round () (ดังกล่าวข้างต้น) ช่วยให้นักพัฒนาสามารถระบุประเภทของการปัดเศษ (Round-to- Evenหรือ Away-from-zero) Convert.ToInt32 () วิธีการและรูปแบบของการใช้งานตลอดไปแม้กระทั่ง The Ceiling ()และFloor ()วิธีการที่เกี่ยวข้อง

คุณสามารถปัดเศษด้วยการจัดรูปแบบตัวเลขแบบกำหนดเองได้เช่นกัน

โปรดทราบว่าDecimal.Round ()ใช้วิธีที่แตกต่างจาก Math.Round ();

นี่เป็นวิธีที่มีประโยชน์ในอัลกอริทึมการปัดเศษของนายธนาคาร ดูหนึ่งในบทความตลกของเรย์มอนด์ที่นี่เกี่ยวกับการปัดเศษ ...

// แปลงได้มากถึงสองตำแหน่งทศนิยม

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"

ฉันรู้ว่าเป็นคำถามที่เก่าแก่ แต่โปรดทราบความแตกต่างดังต่อไปนี้ระหว่างรอบคณิตศาสตร์และString รอบรูปแบบ :

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"

ใช้สำหรับปัดเศษทศนิยม 2 ตำแหน่งใน C #:

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

ใน VB.NET:

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

หากคุณต้องการปัดเศษตัวเลขคุณสามารถได้ผลลัพธ์ที่แตกต่างกันโดยขึ้นอยู่กับ: วิธีที่คุณใช้ฟังก์ชัน Math.Round () (สำหรับปัดเศษขึ้นหรือปัดเศษลง) คุณกำลังทำงานกับตัวเลขทวีคูณและ / หรือลอย และคุณใช้การปัดเศษจุดกึ่งกลาง โดยเฉพาะอย่างยิ่งเมื่อใช้กับการดำเนินการภายในของมันหรือตัวแปรรอบที่มาจากการดำเนินการ สมมุติว่าคุณต้องการคูณจำนวนสองตัวเหล่านี้: 0.75 * 0.95 = 0.71250.7125 ขวา? ไม่ได้อยู่ใน C #

มาดูกันว่าจะเกิดอะไรขึ้นถ้าคุณต้องการปัดเศษทศนิยม 3:

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);
    }
}

ตัวแปร 'ตัวแก้ไข' สำหรับแก้ไขความไม่ถูกต้องของการทำงานด้วยตัวเลขลอยหรือสอง

สิ่งหนึ่งที่คุณอาจต้องการตรวจสอบคือกลไกการปัดเศษของคณิตศาสตร์รอบ:

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

นอกจากนั้นฉันขอแนะนำวิธีการ Math.Round (inputNumer, numberOfPlaces) เหนือ * 100/100 เพราะมันสะอาดกว่า

คุณควรระบุจำนวนหลักที่คุณต้องการปัดเศษเพื่อใช้ Math.Round (YourNumber, 2)

คุณสามารถอ่านเพิ่มเติมที่นี่

Math.Floor (123456.646 * 100) / 100 จะกลับมา 123456.64

สตริง a = "10.65678";

ทศนิยม d = Math.Round (Convert.ToDouble (a.ToString ()), 2)

มีสถานการณ์แปลก ๆ ที่ฉันมีตัวแปรทศนิยมเมื่อทำการจัดลำดับ 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

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