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 () (위에서 언급 한) 메서드를 사용하면 개발자가 반올림 유형 (반올림에서 11로 또는 0에서 멀어짐) 을 지정할 수 있습니다. Convert.ToInt32 () 메서드와 그 변형은 round-to-even을 사용 합니다. 천장 () 와 바닥 () 메소드는 관련이 있습니다.

맞춤 숫자 형식 으로 반올림 할 수도 있습니다.

참고 Decimal.Round ()가 Math.Round () 이외의 다른 방법을 사용한다;

다음은 은행가의 반올림 알고리즘에 대한 유용한 위치 입니다. 반올림에 대한 Raymond의 유머 게시물 중 하나를 참조하십시오 ...

// 소수점 이하 두 자리까지 변환

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"

나는 오래된 질문을 알고 있지만 Math round 와 String format round 의 다음 차이점에 유의하십시오 .

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"

이것은 C #에서 소수점 이하 2 자리로 반올림하기위한 것입니다.

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

VB.NET에서 :

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

숫자를 반올림하려면 Math.Round () 함수를 사용하는 방법 (반올림 또는 반올림의 경우)에 따라 다른 결과를 얻을 수 있습니다. 중간 점 반올림을 적용합니다. 특히 내부 연산이나 반올림 변수와 함께 사용할 때 연산에서 비롯됩니다. 0.75 * 0.95 = 0.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

보시다시피, 중간 지점을 반올림하려면 첫 번째 Round ()가 정확합니다. 그러나 두 번째 Round ()는 반올림하려는 경우 잘못되었습니다.

음수에 적용됩니다.

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

변수 'corrector'는 부동 또는 이중 숫자로 작동하는 부정확성을 수정하기위한 것입니다.

한 가지 확인해야 할 것은 반올림 메커니즘의 수학입니다.

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

그 외에는 * 100/100보다 Math.Round (inputNumer, numberOfPlaces) 접근 방식이 더 좋습니다.

Math.Round (YourNumber, 2)를 사용하여 반올림하려는 자릿수를 지정할 수 있어야합니다.

자세한 내용은 여기를 참조 하십시오 .

수학 플로어 (123456.646 * 100) / 100은 123456.64를 반환합니다.

문자열 a = "10.65678";

10 진수 d = Math.Round (Convert.ToDouble (a.ToString ()), 2)

10 진수 변수가있는 이상한 상황이 있었지만 55.50을 직렬화 할 때 항상 기본값을 수학적으로 55.5로 설정합니다. 그러나 클라이언트 시스템은 어떤 이유로 55.50을 심각하게 기대하고 있으며 십진법을 확실히 기대했습니다. 내가 아래 도우미를 작성했을 때 문자열을 보내지 않고 항상 2 자리로 채워진 10 진수 값을 0으로 변환합니다.

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