Math.Round 메서드

참조

정의

네임스페이스:: System

어셈블리:: System.Runtime.Extensions.dll

어셈블리:: System.Runtime.dll

어셈블리:: mscorlib.dll

어셈블리:: netstandard.dll

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

값을 가장 가까운 정수나 지정된 소수 자릿수로 반올림합니다.

오버로드

Round(Double, Int32, MidpointRounding)	지정된 반올림 규칙을 사용하여 배정밀도 부동 소수점 값을 지정된 소수 자릿수로 반올림합니다.
Round(Decimal, Int32, MidpointRounding)	지정된 반올림 규칙을 사용하여 소수 자릿수의 소수 자릿수로 소수 값을 반올림합니다.
Round(Double, MidpointRounding)	지정된 반올림 규칙을 사용하여 배정밀도 부동 소수점 값을 정수로 반올림합니다.
Round(Double, Int32)	지정된 수의 소수 자릿수를 배정밀도 부동 소수점 값으로 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.
Round(Decimal, Int32)	소수 자릿수가 지정된 수의 10진수 값을 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.
Round(Double)	배정밀도 부동 소수점 값을 가장 가까운 정수 값으로 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.
Round(Decimal)	10진수 값을 가장 가까운 정수로 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.
Round(Decimal, MidpointRounding)	지정된 반올림 규칙을 사용하여 10진수 값을 정수로 반올림합니다.

예제

이 문서에는 설명 섹션의 예제 외에도 메서드의 다음 오버로드를 보여 주는 예제가 Math.Round 포함되어 있습니다.

Math.Round(Decimal)Math.Round(Double)Math.Round(Decimal, Int32)Math.Round(Decimal, MidpointRounding)Math.Round(Double, Int32)Math.Round(Double, MidpointRounding)Math.Round(Decimal, Int32, MidpointRounding)Math.Round(Double, Int32, MidpointRounding)

설명

이 섹션에서는 다음 작업을 수행합니다.

어떤 메서드를 호출합니까?
중간점 값 및 반올림 규칙
반올림 및 정밀도
반올림 및 단정밀도 부동 소수점 값
개별 오버로드의 예

어떤 메서드를 호출합니까?

다음 표를 사용하여 적절한 반올림 방법을 선택할 수 있습니다. 메서드 외에도 Math.Round 및 Math.Floor도 포함합니다Math.Ceiling.

대상	호출
가장 가까운 반올림 규칙을 사용하여 숫자를 정수로 반올림합니다.	Round(Decimal) 또는 Round(Double)
지정된 반올림 규칙을 사용하여 숫자를 정수로 반올림합니다.	Round(Decimal, MidpointRounding) 또는 Round(Double, MidpointRounding)
가장 가까운 규칙으로 반올림을 사용하여 숫자를 지정된 소수 자릿수로 반올림합니다.	Round(Decimal, Int32) 또는 Round(Double, Int32)
지정된 반올림 규칙을 사용하여 숫자를 지정된 소수 자릿수로 반올림합니다.	Round(Decimal, Int32, MidpointRounding) 또는 Round(Double, Int32, MidpointRounding)
Single 지정된 반올림 규칙을 사용하고 정밀도 손실을 최소화하여 값을 지정된 소수 자릿수로 반올림합니다.	을 Single 로 변환하고 를 Decimal 호출 Round(Decimal, Int32, MidpointRounding)합니다.
중간점 값을 반올림할 때 정밀도 문제를 최소화하면서 숫자를 지정된 소수 자릿수로 반올림합니다.	"보다 크거나 거의 같음" 비교를 구현하는 반올림 메서드를 호출합니다. 반올림 및 전체 자릿수를 참조하세요.
소수 값을 소수 값보다 큰 정수로 반올림합니다. 예를 들어 3.1에서 4로 반올림합니다.	Ceiling
소수 값을 소수 값보다 작은 정수로 반올림합니다. 예를 들어 3.9에서 3으로 반올림합니다.	Floor

중간점 값 및 반올림 규칙

반올림에는 지정된 정밀도의 숫자 값을 정밀도가 낮은 값으로 변환하는 작업이 포함됩니다. 예를 들어 메서드를 Round(Double) 사용하여 값을 3.4에서 3.0으로 반올림하고 Round(Double, Int32) 메서드를 사용하여 값을 3.579에서 3.58로 반올림할 수 있습니다.

중간점 값에서 결과에서 유효 자릿수가 가장 낮은 다음 값은 두 숫자 사이의 절반 정도입니다. 예를 들어 3.47500은 10진수 두 자리로 반올림되는 경우 중간점 값이고 정수로 반올림되는 경우 7.500은 중간점 값입니다. 이러한 경우 가장 가까운 반올림 전략을 사용하는 경우 반올림 규칙 없이는 가장 가까운 값을 쉽게 식별할 수 없습니다.

메서드는 Round 중간점 값을 처리하기 위한 두 가지 반올림 규칙을 지원합니다.

0에서 반올림

중간점 값은 0에서 다음 숫자로 반올림됩니다. 예를 들어 3.75는 3.8로, 3.85는 3.9로, -3.75는 -3.8로, -3.85는 -3.9로 반올림합니다. 이 형태의 반올림은 열거형 멤버로 MidpointRounding.AwayFromZero 표시됩니다.
가장 가까운 짝수로 반올림 또는 은행의 반올림

중간점 값은 가장 가까운 짝수로 반올림됩니다. 예를 들어 3.75와 3.85는 모두 3.8로 반올림되고 -3.75 및 -3.85는 모두 -3.8로 반올림합니다. 이 형태의 반올림은 열거형 멤버로 MidpointRounding.ToEven 표시됩니다.

참고

.NET Core 3.0 이상 버전에서는 열거형을 통해 MidpointRounding 세 가지 추가 반올림 전략을 사용할 수 있습니다. 이러한 전략은 중간점 값 MidpointRounding.ToEven 뿐만 아니라 모든 경우에 사용됩니다 MidpointRounding.AwayFromZero .

0에서 반올림하는 것은 가장 널리 알려진 반올림 형태이며, 가장 가까운 짝수로 반올림하는 것은 재무 및 통계 운영의 표준입니다. IEEE 표준 754, 섹션 4를 준수합니다. 여러 반올림 작업에서 사용되는 경우 가장 가까운 로 반올림하면 중간점 값을 한 방향으로 일관되게 반올림하여 발생하는 반올림 오류가 줄어듭니다. 경우에 따라 이 반올림 오류가 중요할 수 있습니다.

다음 예제에서는 중간점 값을 한 방향으로 일관되게 반올림하여 발생할 수 있는 바이어스를 보여 줍니다. 이 예제에서는 값 배열의 실제 평균을 계산한 다음, 두 규칙을 사용하여 배열의 Decimal 값이 반올림될 때 평균을 계산합니다. 이 예제에서는 가장 가까운 으로 반올림할 때의 실제 평균 및 평균이 동일합니다. 그러나 0에서 반올림할 때의 결과는 실제 평균과 .05(또는 3.6%)로 다릅니다.

decimal[] values = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
decimal sum = 0;

// Calculate true mean.
foreach (var value in values)
    sum += value;

Console.WriteLine("True mean:     {0:N2}", sum / values.Length);

// Calculate mean with rounding away from zero.
sum = 0;
foreach (var value in values)
    sum += Math.Round(value, 1, MidpointRounding.AwayFromZero);

Console.WriteLine("AwayFromZero:  {0:N2}", sum / values.Length);

// Calculate mean with rounding to nearest.
sum = 0;
foreach (var value in values)
    sum += Math.Round(value, 1, MidpointRounding.ToEven);

Console.WriteLine("ToEven:        {0:N2}", sum / values.Length);

// The example displays the following output:
//       True mean:     1.40
//       AwayFromZero:  1.45
//       ToEven:        1.40

open System

let values = [| 1.15m; 1.25m; 1.35m; 1.45m; 1.55m; 1.65m |]
let mutable sum = 0m

// Calculate true mean.
for value in values do
    sum <- sum + value

printfn $"True mean:     {sum / decimal values.Length:N2}"

// Calculate mean with rounding away from zero.
sum <- 0m
for value in values do
    sum <- sum + Math.Round(value, 1, MidpointRounding.AwayFromZero)

printfn $"AwayFromZero:  {sum / decimal values.Length:N2}"

// Calculate mean with rounding to nearest.
sum <- 0m
for value in values do
    sum <- sum + Math.Round(value, 1, MidpointRounding.ToEven)

printfn $"ToEven:        {sum / decimal values.Length:N2}"

// The example displays the following output:
//       True mean:     1.40
//       AwayFromZero:  1.45
//       ToEven:        1.40

Dim values() As Decimal = {1.15D, 1.25D, 1.35D, 1.45D, 1.55D, 1.65D}
Dim sum As Decimal

' Calculate true mean.
For Each value In values
    sum += value
Next
Console.WriteLine("True mean:     {0:N2}", sum / values.Length)

' Calculate mean with rounding away from zero.
sum = 0
For Each value In values
    sum += Math.Round(value, 1, MidpointRounding.AwayFromZero)
Next
Console.WriteLine("AwayFromZero:  {0:N2}", sum / values.Length)

' Calculate mean with rounding to nearest.
sum = 0
For Each value In values
    sum += Math.Round(value, 1, MidpointRounding.ToEven)
Next
Console.WriteLine("ToEven:        {0:N2}", sum / values.Length)

' The example displays the following output:
'       True mean:     1.40
'       AwayFromZero:  1.45
'       ToEven:        1.40

기본적으로 메서드는 Round 가장 가까운 짝수 규칙에 대한 라운드를 사용합니다. 다음 표에서는 메서드의 Round 오버로드와 각 메서드가 사용하는 반올림 규칙을 나열합니다.

오버로드	반올림 규칙
Round(Decimal)	ToEven
Round(Double)	ToEven
Round(Decimal, Int32)	ToEven
Round(Double, Int32)	ToEven
Round(Decimal, MidpointRounding)	매개 변수에 따라 `mode` 결정됩니다.
Round(Double, MidpointRounding)	매개 변수에 의해 `mode` 결정됨
Round(Decimal, Int32, MidpointRounding)	매개 변수에 의해 `mode` 결정됨
Round(Double, Int32, MidpointRounding)	매개 변수에 의해 `mode` 결정됨

반올림 및 정밀도

반올림 작업에 중간점 값 Round 이 포함되는지 여부를 확인하기 위해 메서드는 반올림할 원래 값을 10ⁿ으로 곱합니다. 여기서 n 은 반환 값에서 원하는 소수 자릿수 수인 다음 값의 나머지 소수 부분이 .5보다 크거나 같은지 여부를 결정합니다. 이는 같음을 위한 테스트의 약간의 변형이며 참조 항목의 Double "같음 테스트" 섹션에서 설명한 것처럼 부동 소수점 값과 같음 테스트는 부동 소수점 형식의 이진 표현 및 정밀도 문제로 인해 문제가 됩니다. 즉, 전체 자릿수 손실로 인해 .5보다 약간 작은 숫자의 소수 부분이 위쪽으로 반올림되지 않습니다.

다음 예제에서 이 문제를 보여 줍니다. .1을 11.0에 반복적으로 추가하고 결과를 가장 가까운 정수로 반올림합니다. 11.5는 중간점 반올림 규칙(ToEven 또는 AwayFromZero)을 사용하여 12로 반올림해야 합니다. 그러나 예제의 출력에서 보여 주듯이 그렇지 않습니다. 이 예제에서는 "R" 표준 숫자 형식 문자열 을 사용하여 부동 소수점 값의 전체 전체 정밀도를 표시하고, 반올림할 값이 반복적으로 추가하는 동안 전체 자릿수가 손실되었으며 해당 값은 실제로 11.4999999999999999998임을 보여 줍니다. .499999999999998 .5보다 작기 때문에 중간점 반올림 규칙이 작동하지 않고 값이 반올림됩니다. 이 예제에서도 볼 수 있듯이 상수 값 11.5 Double 를 변수에 할당하면 이 문제가 발생하지 않습니다.

public static void Example()
{
    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                      "Value", "Full Precision", "ToEven",
                      "AwayFromZero");
    double value = 11.1;
    for (int ctr = 0; ctr <= 5; ctr++)
        value = RoundValueAndAdd(value);

    Console.WriteLine();

    value = 11.5;
    RoundValueAndAdd(value);
}

private static double RoundValueAndAdd(double value)
{
    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                      value, Math.Round(value, MidpointRounding.ToEven),
                      Math.Round(value, MidpointRounding.AwayFromZero));
    return value + .1;
}

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

open System

let roundValueAndAdd (value: double) =
    printfn $"{value,5:N1} {value,20:R}  {Math.Round(value, MidpointRounding.ToEven),12} {Math.Round(value, MidpointRounding.AwayFromZero),15}"
    value + 0.1

printfn "%5s %20s  %12s %15s\n" "Value" "Full Precision" "ToEven" "AwayFromZero"
let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

Public Sub Example()
    Dim value As Double = 11.1

    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}",
                    "Value", "Full Precision", "ToEven",
                    "AwayFromZero")
    Console.WriteLine()
    For ctr As Integer = 0 To 5
        value = RoundValueAndAdd(value)
    Next
    Console.WriteLine()

    value = 11.5
    RoundValueAndAdd(value)
End Sub

Private Function RoundValueAndAdd(value As Double) As Double
    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                    value, Math.Round(value, MidpointRounding.ToEven),
                    Math.Round(value, MidpointRounding.AwayFromZero))
    Return value + 0.1
End Function

' The example displays the following output:
'       Value       Full Precision        ToEven    AwayFromZero
'       
'        11.1                 11.1            11              11
'        11.2                 11.2            11              11
'        11.3   11.299999999999999            11              11
'        11.4   11.399999999999999            11              11
'        11.5   11.499999999999998            11              11
'        11.6   11.599999999999998            12              12
'       
'        11.5                 11.5            12              12

중간점 값 반올림의 정밀도 문제는 다음 조건에서 발생할 가능성이 가장 높습니다.

소수점 값을 부동 소수점 형식의 이진 형식으로 정확하게 표현할 수 없는 경우
반올림할 값이 하나 이상의 부동 소수점 연산에서 계산되는 경우
반올림할 값이 Single 또는 Decimal가 아닌 인 Double 경우 자세한 내용은 다음 섹션인 반올림 및 단정밀도 부동 소수점 값을 참조하세요.

반올림 작업의 정밀도가 부족한 경우 다음을 수행할 수 있습니다.

반올림 작업에서 값을 반올림하는 오버로드를 Double 호출하는 경우 을 값으로 Decimal 변경 Double 하고 대신 값을 반올림하는 오버로드를 Decimal 호출할 수 있습니다. 데이터 형식에도 Decimal 표현 및 정밀도 손실 문제가 있지만 이러한 문제는 훨씬 덜 일반적입니다.

"거의 같음" 테스트를 수행하는 사용자 지정 반올림 알고리즘을 정의하여 반올림할 값이 중간점 값에 가깝게 허용되는지 여부를 결정합니다. 다음 예제에서는 소수 값이 중간점 반올림의 적용을 받을 수 있는 중간점 값에 충분히 가까운지 여부를 검사하는 메서드를 정의 RoundApproximate 합니다. 예제의 출력에서 보여 주듯이 이전 예제에 표시된 반올림 문제를 수정합니다.

public static void Example()
{
    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                      "Value", "Full Precision", "ToEven",
                      "AwayFromZero");
    double value = 11.1;
    for (int ctr = 0; ctr <= 5; ctr++)
        value = RoundValueAndAdd(value);

    Console.WriteLine();

    value = 11.5;
    RoundValueAndAdd(value);
}

private static double RoundValueAndAdd(double value)
{
    const double tolerance = 8e-14;

    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                      value,
                      RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                      RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero));
    return value + .1;
}

private static double RoundApproximate(double dbl, int digits, double margin,
                                  MidpointRounding mode)
{
    double fraction = dbl * Math.Pow(10, digits);
    double value = Math.Truncate(fraction);
    fraction = fraction - value;
    if (fraction == 0)
        return dbl;

    double tolerance = margin * dbl;
    // Determine whether this is a midpoint value.
    if ((fraction >= .5 - tolerance) & (fraction <= .5 + tolerance))
    {
        if (mode == MidpointRounding.AwayFromZero)
            return (value + 1) / Math.Pow(10, digits);
        else
           if (value % 2 != 0)
            return (value + 1) / Math.Pow(10, digits);
        else
            return value / Math.Pow(10, digits);
    }
    // Any remaining fractional value greater than .5 is not a midpoint value.
    if (fraction > .5)
        return (value + 1) / Math.Pow(10, digits);
    else
        return value / Math.Pow(10, digits);
}

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            12              12
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

open System

let roundApproximate dbl digits margin mode =
    let fraction = dbl * Math.Pow(10, digits)
    let value = Math.Truncate fraction
    let fraction = fraction - value
    if fraction = 0 then
        dbl
    else
        let tolerance = margin * dbl
        // Determine whether this is a midpoint value.
        if (fraction >= 0.5 - tolerance) && (fraction <= 0.5 + tolerance) then
            if mode = MidpointRounding.AwayFromZero then
                (value + 1.) / Math.Pow(10, digits)
            elif value % 2. <> 0 then
                (value + 1.) / Math.Pow(10, digits)
            else
                value / Math.Pow(10, digits)
        // Any remaining fractional value greater than .5 is not a midpoint value.
        elif fraction > 0.5 then
            (value + 1.) / Math.Pow(10, digits)
        else
            value / Math.Pow(10, digits)


let roundValueAndAdd value =
    let tolerance = 8e-14
    let round = roundApproximate value 0 tolerance

    printfn $"{value,5:N1} {value,20:R}  {round MidpointRounding.ToEven,12} {round MidpointRounding.AwayFromZero,15}"
    value + 0.1

printfn "%5s %20s  %12s %15s\n" "Value" "Full Precision" "ToEven" "AwayFromZero"
let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value 
|> ignore

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            12              12
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

Public Sub Example()
    Dim value As Double = 11.1

    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                    "Value", "Full Precision", "ToEven",
                    "AwayFromZero")
    For ctr As Integer = 0 To 5
        value = RoundValueAndAdd(value)
    Next
    Console.WriteLine()

    value = 11.5
    RoundValueAndAdd(value)
End Sub

Private Function RoundValueAndAdd(value As Double) As Double
    Const tolerance As Double = 0.00000000000008
    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                    value,
                    RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                    RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero))
    Return value + 0.1
End Function

Private Function RoundApproximate(dbl As Double, digits As Integer, margin As Double,
                                 mode As MidpointRounding) As Double
    Dim fraction As Double = dbl * Math.Pow(10, digits)
    Dim value As Double = Math.Truncate(fraction)
    fraction = fraction - value
    If fraction = 0 Then Return dbl

    Dim tolerance As Double = margin * dbl
    ' Determine whether this is a midpoint value.
    If (fraction >= 0.5 - tolerance) And (fraction <= 0.5 + tolerance) Then
        If mode = MidpointRounding.AwayFromZero Then
            Return (value + 1) / Math.Pow(10, digits)
        Else
            If value Mod 2 <> 0 Then
                Return (value + 1) / Math.Pow(10, digits)
            Else
                Return value / Math.Pow(10, digits)
            End If
        End If
    End If
    ' Any remaining fractional value greater than .5 is not a midpoint value.
    If fraction > 0.5 Then
        Return (value + 1) / Math.Pow(10, digits)
    Else
        Return value / Math.Pow(10, digits)
    End If
End Function

' The example displays the following output:
'       Value       Full Precision        ToEven    AwayFromZero
'       
'        11.1                 11.1            11              11
'        11.2                 11.2            11              11
'        11.3   11.299999999999999            11              11
'        11.4   11.399999999999999            11              11
'        11.5   11.499999999999998            12              12
'        11.6   11.599999999999998            12              12
'       
'        11.5                 11.5            12              12

반올림 및 단정밀도 부동 소수점 값

메서드에는 Round 및 Double형식 Decimal 의 인수를 허용하는 오버로드가 포함됩니다. 형식 Single의 값을 반올림하는 메서드는 없습니다. 메서드의 Round 오버로드 중 하나에 값을 전달 Single 하면 C#으로 캐스팅되거나(Visual Basic의 경우) Double로 변환되고 매개 변수가 있는 해당 Round 오버로드 Double 가 호출됩니다. 이는 확대 변환이지만 다음 예제와 같이 정밀도 손실이 수반되는 경우가 많습니다. Single 값 16.325를 메서드에 Round 전달하고 가장 가까운 규칙으로 반올림을 사용하여 소수점 두 자리로 반올림하면 결과는 16.33이고 예상 결과는 16.32가 아닙니다.

Single value = 16.325f;
Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ",
                  value, value.GetType().Name, (double)value,
                  ((double)(value)).GetType().Name);
Console.WriteLine(Math.Round(value, 2));
Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero));
Console.WriteLine();

Decimal decValue = (decimal)value;
Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ",
                  value, value.GetType().Name, decValue,
                  decValue.GetType().Name);
Console.WriteLine(Math.Round(decValue, 2));
Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero));

// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33

// In F#, 'float', 'float64', and 'double' are aliases for System.Double...
// 'float32' and 'single' are aliases for System.Single
open System

let value = 16.325f
printfn $"Widening Conversion of {value:R} (type {value.GetType().Name}) to {double value:R} (type {(double value).GetType().Name}): "
printfn $"{Math.Round(decimal value, 2)}"
printfn $"{Math.Round(decimal value, 2, MidpointRounding.AwayFromZero)}"
printfn ""

let decValue = decimal value
printfn $"Cast of {value:R} (type {value.GetType().Name}) to {decValue} (type {decValue.GetType().Name}): "
printfn $"{Math.Round(decValue, 2)}"
printfn $"{Math.Round(decValue, 2, MidpointRounding.AwayFromZero)}"

// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33

Dim value As Single = 16.325
Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ",
                value, value.GetType().Name, CDbl(value),
                CDbl(value).GetType().Name)
Console.WriteLine(Math.Round(value, 2))
Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero))
Console.WriteLine()

Dim decValue As Decimal = CDec(value)
Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ",
                value, value.GetType().Name, decValue,
                decValue.GetType().Name)
Console.WriteLine(Math.Round(decValue, 2))
Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero))
Console.WriteLine()

' The example displays the following output:
'    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
'    16.33
'    16.33
'    
'    Cast of 16.325 (type Single) to 16.325 (type Decimal):
'    16.32
'    16.33

이 예기치 않은 결과는 값이 로 변환되는 동안 전체 자릿수가 Single 손실되기 때문입니다 Double. 결과 Double 값 16.325000762939453은 중간점 값이 아니고 16.325보다 크므로 항상 위쪽으로 반올림됩니다.

예제에서 알 수 있듯이 대부분의 경우 값을 Decimal캐스팅하거나 로 변환 Single 하여 정밀도 손실을 최소화하거나 제거할 수 있습니다. 축소 변환이므로 캐스트 연산자를 사용하거나 변환 메서드를 호출해야 합니다.

Round(Double, Int32, MidpointRounding)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

지정된 반올림 규칙을 사용하여 배정밀도 부동 소수점 값을 지정된 소수 자릿수로 반올림합니다.

public:
 static double Round(double value, int digits, MidpointRounding mode);

public static double Round (double value, int digits, MidpointRounding mode);

static member Round : double * int * MidpointRounding -> double

Public Shared Function Round (value As Double, digits As Integer, mode As MidpointRounding) As Double

매개 변수

value: Double

반올림할 배정밀도 부동 소수점 수입니다.

digits: Int32

반환 값의 소수 자릿수입니다.

mode: MidpointRounding

사용할 반올림 전략을 지정하는 열거형 값 중 하나입니다.

반환

Double

반올림되는 digits 소수 자릿수가 있는 value 숫자입니다. value의 소수 자릿수가 digits보다 작은 경우, value가 변경되지 않은 상태로 반환됩니다.

예외

ArgumentOutOfRangeException

digits가 0보다 작거나 15보다 큽니다.

ArgumentException

mode는 유효한 MidpointRounding 값이 아닙니다.

설명

인수의 digits 값은 0에서 15까지입니다. 형식에서 지원하는 정수 및 소수 자릿수의 Double 최대 수는 15개입니다.

중간점 값으로 숫자를 반올림하는 방법에 대한 자세한 내용은 중간점 값 및 반올림 규칙을 참조하세요.

중요

중간점 값을 반올림 하는 경우 반올림 알고리즘이 같음 테스트를 수행합니다. 이진 표현 및 정밀도 부동 소수점 형식에서의 문제 때문에 메서드를 통해 반환된 값이 예상 밖일 수 있습니다. 자세한 내용은 반올림 및 전체 자릿수를 참조하세요.

인수의 값이 value 이 Double.NaN면 메서드는 를 반환합니다 Double.NaN. 가 또는 이면 value 메서드는 각각 또는 Double.NegativeInfinity를 반환 Double.PositiveInfinity 합니다.Double.NegativeInfinity Double.PositiveInfinity

예

다음 예제에서는 사용 하는 방법을 보여 줍니다는 열거형을 사용 하 MidpointRounding 여 Round(Double, Int32, MidpointRounding) 메서드입니다.


// Round a positive and a negative value using the default.
double result = Math.Round(3.45, 1);
Console.WriteLine($"{result,4} = Math.Round({3.45,5}, 1)");
result = Math.Round(-3.45, 1);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1)\n");

// Round a positive value using a MidpointRounding value.
result = Math.Round(3.45, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.ToEven)");
result = Math.Round(3.45, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(3.47, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result,4} = Math.Round({3.47,5}, 1, MidpointRounding.ToZero)\n");

// Round a negative value using a MidpointRounding value.
result = Math.Round(-3.45, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.ToEven)");
result = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(-3.47, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result,4} = Math.Round({-3.47,5}, 1, MidpointRounding.ToZero)\n");

// The example displays the following output:

//         3.4 = Math.Round( 3.45, 1)
//         -3.4 = Math.Round(-3.45, 1)

//         3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
//         3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
//         3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

//         -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
//         -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
//         -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)

// Round a positive and a negative value using the default.
let result = Math.Round(3.45, 1)
printfn $"{result,4} = Math.Round({3.45,5}, 1)"
let result = Math.Round(-3.45, 1)
printfn $"{result,4} = Math.Round({-3.45,5}, 1)\n"

// Round a positive value using a MidpointRounding value.
let result = Math.Round(3.45, 1, MidpointRounding.ToEven)
printfn $"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.ToEven)"
let result = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
printfn $"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(3.47, 1, MidpointRounding.ToZero)
printfn $"{result,4} = Math.Round({3.47,5}, 1, MidpointRounding.ToZero)\n"

// Round a negative value using a MidpointRounding value.
let result = Math.Round(-3.45, 1, MidpointRounding.ToEven)
printfn $"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.ToEven)"
let result = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
printfn $"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(-3.47, 1, MidpointRounding.ToZero)
printfn $"{result,4} = Math.Round({-3.47,5}, 1, MidpointRounding.ToZero)\n"

// The example displays the following output:

//         3.4 = Math.Round( 3.45, 1)
//         -3.4 = Math.Round(-3.45, 1)

//         3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
//         3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
//         3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

//         -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
//         -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
//         -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)

Dim posValue As Double = 3.45
Dim negValue As Double = -3.45

' Round a positive and a negative value using the default.  
Dim result As Double = Math.Round(posValue, 1)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
result = Math.Round(negValue, 1)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
Console.WriteLine()

' Round a positive value using a MidpointRounding value. 
result = Math.Round(posValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                   result, posValue)
result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, posValue)
Console.WriteLine()

' Round a positive value using a MidpointRounding value. 
result = Math.Round(negValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                    result, negValue)
result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, negValue)
Console.WriteLine()

'This code example produces the following results:

'  3.4 = Math.Round( 3.45, 1)
' -3.4 = Math.Round(-3.45, 1)

' 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
' 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)

' -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
' -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

호출자 참고

소수점 값을 부동 소수점 숫자로 나타내거나 부동 소수점 값에 대한 산술 연산을 수행하여 발생할 수 있는 Round(Double, Int32, MidpointRounding) 정밀도의 손실로 인해 메서드가 매개 변수에 지정된 mode 대로 둥근 중간점 값에 나타나지 않을 수 있습니다. 다음 예제에서는 2.135가 2.14 대신 2.13으로 반올림됩니다. 이는 내부적으로 메서드가 10^자리를 곱 value 하고 이 경우 곱하기 작업이 정밀도 손실로 인해 발생하기 때문입니다.

double[] values = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 };
foreach (double value in values)
   Console.WriteLine("{0} --> {1}", value,
                     Math.Round(value, 2, MidpointRounding.AwayFromZero));

// The example displays the following output:
//       2.125 --> 2.13
//       2.135 --> 2.13
//       2.145 --> 2.15
//       3.125 --> 3.13
//       3.135 --> 3.14
//       3.145 --> 3.15

open System

let values = [| 2.125; 2.135; 2.145; 3.125; 3.135; 3.145 |]
for value in values do
    printfn $"{value} --> {Math.Round(value, 2, MidpointRounding.AwayFromZero)}"
// The example displays the following output:
//       2.125 --> 2.13
//       2.135 --> 2.13
//       2.145 --> 2.15
//       3.125 --> 3.13
//       3.135 --> 3.14
//       3.145 --> 3.15

Module Example
   Public Sub Main()
      Dim values() As Double = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 }
      For Each value As Double In values
         Console.WriteLine("{0} --> {1}", value, 
                           Math.Round(value, 2, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       2.125 --> 2.13
'       2.135 --> 2.13
'       2.145 --> 2.15
'       3.125 --> 3.13
'       3.135 --> 3.14
'       3.145 --> 3.15

추가 정보

적용 대상

Round(Decimal, Int32, MidpointRounding)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

지정된 반올림 규칙을 사용하여 소수 자릿수의 소수 자릿수로 소수 값을 반올림합니다.

public:
 static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode);

public static decimal Round (decimal d, int decimals, MidpointRounding mode);

static member Round : decimal * int * MidpointRounding -> decimal

Public Shared Function Round (d As Decimal, decimals As Integer, mode As MidpointRounding) As Decimal

매개 변수

d: Decimal

반올림할 10진수입니다.

decimals: Int32

반환 값의 소수 자릿수입니다.

mode: MidpointRounding

사용할 반올림 전략을 지정하는 열거형 값 중 하나입니다.

반환

Decimal

반올림되는 소수 자릿수가 있는 d 숫자 decimals 입니다. d의 소수 자릿수가 decimals보다 작은 경우, d가 변경되지 않은 상태로 반환됩니다.

예외

ArgumentOutOfRangeException

decimals가 0보다 작거나 28보다 큽니다.

ArgumentException

mode는 유효한 MidpointRounding 값이 아닙니다.

OverflowException

결과가 Decimal 범위를 벗어나는 경우

설명

중간점 값으로 숫자를 반올림하는 방법에 대한 자세한 내용은 중간점 값 및 반올림 규칙을 참조하세요.

중요

인수의 decimals 값은 0에서 28까지입니다.

예

다음 예제에서는 사용 하는 방법을 보여 줍니다는 열거형을 사용 하 MidpointRounding 여 Round 메서드입니다.

decimal result;

// Round a positive value using different strategies.
// The precision of the result is 1 decimal place.

result = Math.Round(3.45m, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({3.45m}, 1, MidpointRounding.ToEven)");
result = Math.Round(3.45m, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({3.45m}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(3.47m, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result} = Math.Round({3.47m}, 1, MidpointRounding.ToZero)\n");

// Round a negative value using different strategies.
// The precision of the result is 1 decimal place.

result = Math.Round(-3.45m, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({-3.45m}, 1, MidpointRounding.ToEven)");
result = Math.Round(-3.45m, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({-3.45m}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(-3.47m, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result} = Math.Round({-3.47m}, 1, MidpointRounding.ToZero)\n");

/*
This code example produces the following results:

3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
-3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)
*/

// Round a positive value using different strategies.
// The precision of the result is 1 decimal place.

let result = Math.Round(3.45m, 1, MidpointRounding.ToEven)
printfn $"{result} = Math.Round({3.45m}, 1, MidpointRounding.ToEven)"
let result = Math.Round(3.45m, 1, MidpointRounding.AwayFromZero)
printfn $"{result} = Math.Round({3.45m}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(3.47m, 1, MidpointRounding.ToZero)
printfn $"{result} = Math.Round({3.47m}, 1, MidpointRounding.ToZero)\n"

// Round a negative value using different strategies.
// The precision of the result is 1 decimal place.

let result = Math.Round(-3.45m, 1, MidpointRounding.ToEven)
printfn $"{result} = Math.Round({-3.45m}, 1, MidpointRounding.ToEven)"
let result = Math.Round(-3.45m, 1, MidpointRounding.AwayFromZero)
printfn $"{result} = Math.Round({-3.45m}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(-3.47m, 1, MidpointRounding.ToZero)
printfn $"{result} = Math.Round({-3.47m}, 1, MidpointRounding.ToZero)\n"

// This code example produces the following results:

// 3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
// 3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
// 3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

// -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
// -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
// -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)

Dim result As Decimal = 0D
Dim posValue As Decimal = 3.45D
Dim negValue As Decimal = -3.45D

' Round a positive value using different strategies.
' The precision of the result is 1 decimal place.
result = Math.Round(posValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                   result, posValue)
result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, posValue)
result = Math.Round(posValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, posValue)
Console.WriteLine()

' Round a negative value using different strategies.
' The precision of the result is 1 decimal place.
result = Math.Round(negValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                    result, negValue)
result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, negValue)
result = Math.Round(negValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, negValue)
Console.WriteLine()

'This code example produces the following results:
'
'        3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
'        3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
'        3.4 = Math.Round(3.45, 1, MidpointRounding.ToZero)
'
'        -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'        -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
'        -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToZero)
'

추가 정보

적용 대상

Round(Double, MidpointRounding)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

지정된 반올림 규칙을 사용하여 배정밀도 부동 소수점 값을 정수로 반올림합니다.

public:
 static double Round(double value, MidpointRounding mode);

public static double Round (double value, MidpointRounding mode);

static member Round : double * MidpointRounding -> double

Public Shared Function Round (value As Double, mode As MidpointRounding) As Double

매개 변수

value: Double

반올림할 배정밀도 부동 소수점 수입니다.

mode: MidpointRounding

사용할 반올림 전략을 지정하는 열거형 값 중 하나입니다.

반환

Double

반올림되는 value 정수입니다. 이 메서드는 Double 정수 형식 대신 을 반환합니다.

예외

ArgumentException

mode는 유효한 MidpointRounding 값이 아닙니다.

설명

중간점 값으로 숫자를 반올림하는 방법에 대한 자세한 내용은 중간점 값 및 반올림 규칙을 참조하세요.

중요

예

다음 예제에서는 다른 값을 사용 mode 하는 메서드에서 반환 하는 Round(Double, MidpointRounding) 값을 표시 합니다.

Double[] values = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6,
                  12.7, 12.8, 12.9, 13.0 };
Console.WriteLine($"{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}");

foreach (var value in values)
    Console.WriteLine($"{value,-10:R} {Math.Round(value),-10} " +
        $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
        $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
        $"{Math.Round(value, MidpointRounding.ToZero),-15}");

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12         12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13         13         13         13              13

open System

let values = 
    [| 12.; 12.1; 12.2; 12.3; 12.4; 12.5
       12.6; 12.7; 12.8; 12.9; 13. |]

printfn "%-10s %-10s %-10s %-15s %-15s" "Value" "Default" "ToEven" "AwayFromZero" "ToZero"

for value in values do
    $"{value,-10:R} {Math.Round(value),-10} " +
    $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
    $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
    $"{Math.Round(value, MidpointRounding.ToZero),-15}"
    |> printfn "%s"
    
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12         12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13         13         13         13              13

Dim values() As Double = {12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6,
                         12.7, 12.8, 12.9, 13.0}
Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For Each value In values
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero     ToZero
'       12         12         12         12               12
'       12.1       12         12         12               12
'       12.2       12         12         12               12
'       12.3       12         12         12               12
'       12.4       12         12         12               12
'       12.5       12         12         13               12
'       12.6       13         13         13               12
'       12.7       13         13         13               12
'       12.8       13         13         13               12
'       12.9       13         13         13               12
'       13         13         13         13               13

호출자 참고

소수점 값을 부동 소수점 숫자로 나타내거나 부동 소수점 값에 대한 산술 연산을 수행하여 발생할 수 있는 정밀도의 손실로 인해 메서드 Round(Double, MidpointRounding) 가 중간점 값을 가장 가까운 정수로 반올림하지 않을 수 있습니다. 다음 예제에서는 부동 소수점 값 .1에 유한한 이진 표현이 없으므로 값이 11.5인 메서드에 대한 첫 번째 호출 Round(Double) 은 12가 아닌 11을 반환합니다.

using System;

public class Example
{
   public static void Main()
   {
      double value = 11.1;
      for (int ctr = 0; ctr <= 5; ctr++)
         value = RoundValueAndAdd(value);

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

   private static double RoundValueAndAdd(double value)
   {
      Console.WriteLine("{0} --> {1}", value, Math.Round(value,
                        MidpointRounding.AwayFromZero));
      return value + .1;
   }
}
// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

open System

let roundValueAndAdd (value: float) =
      printfn $"{value} --> {Math.Round(value, MidpointRounding.AwayFromZero)}"
      value + 0.1

let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

Module Example
   Public Sub Main()
      Dim value As Double = 11.1
      For ctr As Integer = 0 To 5    
         value = RoundValueAndAdd(value)
      Next
      Console.WriteLine()

      value = 11.5
      RoundValueAndAdd(value)
   End Sub
   
   Private Function RoundValueAndAdd(value As Double) As Double
      Console.WriteLine("{0} --> {1}", value, Math.Round(value, 
                        MidpointRounding.AwayFromZero))
      Return value + .1
   End Function   
End Module
' The example displays the following output:
'       11.1 --> 11
'       11.2 --> 11
'       11.3 --> 11
'       11.4 --> 11
'       11.5 --> 11
'       11.6 --> 12
'       
'       11.5 --> 12

추가 정보

적용 대상

Round(Double, Int32)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

지정된 수의 소수 자릿수를 배정밀도 부동 소수점 값으로 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.

public:
 static double Round(double value, int digits);

public static double Round (double value, int digits);

static member Round : double * int -> double

Public Shared Function Round (value As Double, digits As Integer) As Double

매개 변수

value: Double

반올림할 배정밀도 부동 소수점 수입니다.

digits: Int32

반환 값의 소수 자릿수입니다.

반환

Double

value와(과) 일치하는 소수 자릿수가 포함된 digits에 가장 가까운 수입니다.

예외

ArgumentOutOfRangeException

digits가 0보다 작거나 15보다 큽니다.

설명

인수의 digits 값은 0에서 15까지입니다. 형식에서 지원하는 정수 및 소수 자릿수의 Double 최대 수는 15개입니다.

이 메서드는 의 기본 반올림 규칙을 MidpointRounding.ToEven사용합니다. 중간점 값으로 숫자를 반올림하는 방법에 대한 자세한 내용은 중간점 값 및 반올림 규칙을 참조하세요.

중요

예

다음 예제에서는 소수 자릿수가 두 자리인 double 값을 소수 자릿수가 한 자리인 두 자리로 반올림합니다.

Math::Round(3.44, 1); //Returns 3.4.
Math::Round(3.45, 1); //Returns 3.4.
Math::Round(3.46, 1); //Returns 3.5.

Math::Round(4.34, 1); // Returns 4.3
Math::Round(4.35, 1); // Returns 4.4
Math::Round(4.36, 1); // Returns 4.4

Math.Round(3.44, 1); //Returns 3.4.
Math.Round(3.45, 1); //Returns 3.4.
Math.Round(3.46, 1); //Returns 3.5.

Math.Round(4.34, 1); // Returns 4.3
Math.Round(4.35, 1); // Returns 4.4
Math.Round(4.36, 1); // Returns 4.4

open System

printfn $"{Math.Round(3.44, 1)}" //Returns 3.4.
printfn $"{Math.Round(3.45, 1)}" //Returns 3.4.
printfn $"{Math.Round(3.46, 1)}" //Returns 3.5.

printfn $"{Math.Round(4.34, 1)}" // Returns 4.3
printfn $"{Math.Round(4.35, 1)}" // Returns 4.4
printfn $"{Math.Round(4.36, 1)}" // Returns 4.4

Math.Round(3.44, 1) 'Returns 3.4.
Math.Round(3.45, 1) 'Returns 3.4.
Math.Round(3.46, 1) 'Returns 3.5.

Math.Round(4.34, 1) ' Returns 4.3
Math.Round(4.35, 1) ' Returns 4.4
Math.Round(4.36, 1) ' Returns 4.4

호출자 참고

소수점 값을 부동 소수점 숫자로 나타내거나 부동 소수점 값에 대한 산술 연산을 수행하여 발생할 수 있는 정밀도의 손실로 인해 메서드 Round(Double, Int32) 는 소수점 위치에서 가장 가까운 짝수 값 digits 으로 중간점 값을 반올림하지 않을 수 있습니다. 다음 예제에서는 2.135가 2.14 대신 2.13으로 반올림됩니다. 이는 내부적으로 메서드가 10^자리를 곱 value 하고 이 경우 곱하기 작업이 정밀도 손실로 인해 발생하기 때문입니다.

using System;

public class Example
{
   public static void Main()
   {
      double[] values = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 };
      foreach (double value in values)
         Console.WriteLine("{0} --> {1}", value, Math.Round(value, 2));
   }
}
// The example displays the following output:
//       2.125 --> 2.12
//       2.135 --> 2.13
//       2.145 --> 2.14
//       3.125 --> 3.12
//       3.135 --> 3.14
//       3.145 --> 3.14

open System

let values = [| 2.125; 2.135; 2.145; 3.125; 3.135; 3.145 |]
for value in values do
    printfn $"{value} --> {Math.Round(value, 2)}"
// The example displays the following output:
//       2.125 --> 2.12
//       2.135 --> 2.13
//       2.145 --> 2.14
//       3.125 --> 3.12
//       3.135 --> 3.14
//       3.145 --> 3.14

Module Example
   Public Sub Main()
      Dim values() As Double = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 }
      For Each value As Double In values
         Console.WriteLine("{0} --> {1}", value, Math.Round(value, 2))
      Next
   End Sub
End Module
' The example displays the following output:
'       2.125 --> 2.12
'       2.135 --> 2.13
'       2.145 --> 2.14
'       3.125 --> 3.12
'       3.135 --> 3.14
'       3.145 --> 3.14

추가 정보

적용 대상

Round(Decimal, Int32)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

소수 자릿수가 지정된 수의 10진수 값을 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.

public:
 static System::Decimal Round(System::Decimal d, int decimals);

public static decimal Round (decimal d, int decimals);

static member Round : decimal * int -> decimal

Public Shared Function Round (d As Decimal, decimals As Integer) As Decimal

매개 변수

d: Decimal

반올림할 10진수입니다.

decimals: Int32

반환 값의 소수 자릿수입니다.

반환

Decimal

d와(과) 일치하는 소수 자릿수가 포함된 decimals에 가장 가까운 수입니다.

예외

ArgumentOutOfRangeException

decimals가 0보다 작거나 28보다 큽니다.

OverflowException

결과가 Decimal 범위를 벗어나는 경우

설명

인수의 값은 decimals 0에서 28까지입니다.

이 메서드는 의 기본 반올림 규칙을 MidpointRounding.ToEven사용합니다. 중간점 값을 사용하여 숫자를 반올림하는 방법에 대한 자세한 내용은 중간점 값 및 반올림 규칙을 참조하세요.

중요

예

다음 예제에서는 소수 자릿수가 두 자리인 10진수 값을 소수 자릿수가 한 자리인 값으로 반올림합니다.

Console.WriteLine(Math.Round(3.44m, 1));
Console.WriteLine(Math.Round(3.45m, 1));
Console.WriteLine(Math.Round(3.46m, 1));
Console.WriteLine();

Console.WriteLine(Math.Round(4.34m, 1));
Console.WriteLine(Math.Round(4.35m, 1));
Console.WriteLine(Math.Round(4.36m, 1));

// The example displays the following output:
//       3.4
//       3.4
//       3.5
//
//       4.3
//       4.4
//       4.4

open System

printfn 
    $"""{Math.Round(3.44m, 1)}
{Math.Round(3.45m, 1)}
{Math.Round(3.46m, 1)}

{Math.Round(4.34m, 1)}
{Math.Round(4.35m, 1)}
{Math.Round(4.36m, 1)}"""

// The example displays the following output:
//       3.4
//       3.4
//       3.5
//
//       4.3
//       4.4
//       4.4

Console.WriteLine(Math.Round(3.44, 1))
Console.WriteLine(Math.Round(3.45, 1))
Console.WriteLine(Math.Round(3.46, 1))
Console.WriteLine()

Console.WriteLine(Math.Round(4.34, 1))
Console.WriteLine(Math.Round(4.35, 1))
Console.WriteLine(Math.Round(4.36, 1))

' The example displays the following output:
'       3.4
'       3.4
'       3.5
'       
'       4.3
'       4.4
'       4.4

추가 정보

적용 대상

Round(Double)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

배정밀도 부동 소수점 값을 가장 가까운 정수 값으로 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.

public:
 static double Round(double a);

public static double Round (double a);

static member Round : double -> double

Public Shared Function Round (a As Double) As Double

매개 변수

a: Double

반올림할 배정밀도 부동 소수점 수입니다.

반환

Double

a에 가장 가까운 정수입니다. a의 소수 부분이 하나는 짝수이고 다른 하나는 홀수인 두 정수의 중간인 경우에는 짝수가 반환됩니다. 이 메서드는 정수 계열 형식이 아니라 Double을 반환합니다.

설명

중요

인수의 값이 a 이 Double.NaN면 메서드는 를 반환합니다 Double.NaN. 가 또는 이면 a 메서드는 각각 또는 Double.NegativeInfinity를 반환 Double.PositiveInfinity 합니다.Double.NegativeInfinity Double.PositiveInfinity

Visual Basic 15.8부터 메서드에서 반환한 값을 정수 변환 함수에 전달하거나 에서 반환 Round 된 Round Double 값이 Option Strict가 Off로 설정된 정수로 자동으로 변환되는 경우 이중-정수 변환의 성능이 최적화됩니다. 이렇게 최적화하면 다량의 정수 형식 변환을 수행하는 코드의 경우 코드 실행 속도가 최대 2배까지 더 빨라집니다. 다음 예제에서는 이러한 최적화된 변환을 보여 줍니다.

Dim d1 As Double = 1043.75133
Dim i1 As Integer = CInt(Math.Ceiling(d1))        ' Result: 1044

Dim d2 As Double = 7968.4136
Dim i2 As Integer = CInt(Math.Ceiling(d2))        ' Result: 7968

예

다음 예제에서는 가장 가까운 정수 값으로 반올림하는 방법을 보여 줍니다.

using namespace System;

void main()
{
    Console::WriteLine("Classic Math.Round in CPP");
    Console::WriteLine(Math::Round(4.4));     // 4
    Console::WriteLine(Math::Round(4.5));     // 4
    Console::WriteLine(Math::Round(4.6));     // 5
    Console::WriteLine(Math::Round(5.5));     // 6
}

Console.WriteLine("Classic Math.Round in CSharp");
Console.WriteLine(Math.Round(4.4)); // 4
Console.WriteLine(Math.Round(4.5)); // 4
Console.WriteLine(Math.Round(4.6)); // 5
Console.WriteLine(Math.Round(5.5)); // 6

open System

printfn "Classic Math.Round in F#"
printfn $"{Math.Round(4.4)}" // 4
printfn $"{Math.Round(4.5)}" // 4
printfn $"{Math.Round(4.6)}" // 5
printfn $"{Math.Round(5.5)}" // 6

Module Module1

    Sub Main()
    Console.WriteLine("Classic Math.Round in Visual Basic")
    Console.WriteLine(Math.Round(4.4)) ' 4
    Console.WriteLine(Math.Round(4.5)) ' 4
    Console.WriteLine(Math.Round(4.6)) ' 5
    Console.WriteLine(Math.Round(5.5)) ' 6
    End Sub

End Module

호출자 참고

소수점 값을 부동 소수점 숫자로 나타내거나 부동 소수점 값에 대한 산술 연산을 수행하여 발생할 수 있는 정밀도의 손실로 인해 메서드 Round(Double) 가 중간점 값을 가장 가까운 정수로 반올림하는 것처럼 보이지 않을 수 있습니다. 다음 예제에서는 부동 소수점 값 .1에 유한한 이진 표현이 없으므로 값이 11.5인 메서드에 대한 첫 번째 호출 Round(Double) 은 12가 아닌 11을 반환합니다.

using System;

public class Example
{
   public static void Main()
   {
      double value = 11.1;
      for (int ctr = 0; ctr <= 5; ctr++)
         value = RoundValueAndAdd(value);

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

   private static double RoundValueAndAdd(double value)
   {
      Console.WriteLine("{0} --> {1}", value, Math.Round(value));
      return value + .1;
   }
}
// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

open System

let roundValueAndAdd (value: float) =
    printfn $"{value} --> {Math.Round value}"
    value + 0.1

let mutable value = 11.1

for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

Module Example
   Public Sub Main()
      Dim value As Double = 11.1
      For ctr As Integer = 0 To 5    
         value = RoundValueAndAdd(value)
      Next
      Console.WriteLine()

      value = 11.5
      RoundValueAndAdd(value)
   End Sub
   
   Private Function RoundValueAndAdd(value As Double) As Double
      Console.WriteLine("{0} --> {1}", value, Math.Round(value))
      Return value + .1
   End Function   
End Module
' The example displays the following output:
'       11.1 --> 11
'       11.2 --> 11
'       11.3 --> 11
'       11.4 --> 11
'       11.5 --> 11
'       11.6 --> 12
'       
'       11.5 --> 12

추가 정보

적용 대상

Round(Decimal)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

10진수 값을 가장 가까운 정수로 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.

public:
 static System::Decimal Round(System::Decimal d);

public static decimal Round (decimal d);

static member Round : decimal -> decimal

Public Shared Function Round (d As Decimal) As Decimal

매개 변수

d: Decimal

반올림할 10진수입니다.

반환

Decimal

d 매개 변수에 가장 가까운 정수입니다. d의 소수 부분이 하나는 짝수이고 다른 하나는 홀수인 두 정수의 중간인 경우에는 짝수가 반환됩니다. 이 메서드는 정수 계열 형식이 아니라 Decimal을 반환합니다.

예외

OverflowException

결과가 Decimal 범위를 벗어나는 경우

예제

다음 예제는 Round(Decimal) 메서드. 이 오버로드는 기본 ToEven 규칙을 사용하므로 4.5 값은 Decimal 5가 아닌 4로 반올림됩니다.

for (decimal value = 4.2m; value <= 4.8m; value+=.1m )
   Console.WriteLine("{0} --> {1}", value, Math.Round(value));
// The example displays the following output:
//       4.2 --> 4
//       4.3 --> 4
//       4.4 --> 4
//       4.5 --> 4
//       4.6 --> 5
//       4.7 --> 5
//       4.8 --> 5

open System

for value in 4.2m .. 0.1m .. 4.8m do
    printfn $"{value} --> {Math.Round value}"
// The example displays the following output:
//       4.2 --> 4
//       4.3 --> 4
//       4.4 --> 4
//       4.5 --> 4
//       4.6 --> 5
//       4.7 --> 5
//       4.8 --> 5

Module Example
   Public Sub Main()
      For value As Decimal = 4.2d To 4.8d Step .1d
         Console.WriteLine("{0} --> {1}", value, Math.Round(value))
      Next   
   End Sub                                                                 
End Module
' The example displays the following output:
'       4.2 --> 4
'       4.3 --> 4
'       4.4 --> 4
'       4.5 --> 4
'       4.6 --> 5
'       4.7 --> 5
'       4.8 --> 5

설명

중요

추가 정보

적용 대상

Round(Decimal, MidpointRounding)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

지정된 반올림 규칙을 사용하여 10진수 값을 정수로 반올림합니다.

public:
 static System::Decimal Round(System::Decimal d, MidpointRounding mode);

public static decimal Round (decimal d, MidpointRounding mode);

static member Round : decimal * MidpointRounding -> decimal

Public Shared Function Round (d As Decimal, mode As MidpointRounding) As Decimal

매개 변수

d: Decimal

반올림할 10진수입니다.

mode: MidpointRounding

사용할 반올림 전략을 지정하는 열거형 값 중 하나입니다.

반환

Decimal

반올림되는 d 정수입니다. 이 메서드는 Decimal 정수 형식 대신 를 반환합니다.

예외

ArgumentException

mode는 유효한 MidpointRounding 값이 아닙니다.

OverflowException

결과가 Decimal 범위를 벗어나는 경우

설명

중간점 값을 사용하여 숫자를 반올림하는 방법에 대한 자세한 내용은 중간점 값 및 반올림 규칙을 참조하세요.

중요

예제

다음 예제에서는 다른 값을 사용 하는 mode 메서드에서 반환 된 Round(Decimal, MidpointRounding) 값을 표시 합니다.

Console.WriteLine($"{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
    Console.WriteLine($"{value,-10} {Math.Round(value),-10} " +
        $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
        $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
        $"{Math.Round(value, MidpointRounding.ToZero),-15}");

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13

printfn $"""{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}"""
for value in 12m .. 0.1m .. 13m do
    printfn "%-10O %-10O %-10O %-15O %-15O" 
        value
        (Math.Round value)
        (Math.Round(value, MidpointRounding.ToEven))
        (Math.Round(value, MidpointRounding.AwayFromZero))
        (Math.Round(value, MidpointRounding.ToZero))

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13

Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For value As Decimal = 12D To 13D Step 0.1D
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero     ToZero
'       12         12         12         12               12
'       12.1       12         12         12               12
'       12.2       12         12         12               12
'       12.3       12         12         12               12
'       12.4       12         12         12               12
'       12.5       12         12         13               12
'       12.6       13         13         13               12
'       12.7       13         13         13               12
'       12.8       13         13         13               12
'       12.9       13         13         13               12
'       13.0       13         13         13               13

추가 정보

적용 대상

다음을 통해 공유

Math.Round 메서드

정의

오버로드

예제

설명

어떤 메서드를 호출합니까?

중간점 값 및 반올림 규칙

반올림 및 정밀도

반올림 및 단정밀도 부동 소수점 값

Round(Double, Int32, MidpointRounding)

매개 변수

반환

예외

설명

예

호출자 참고

추가 정보

적용 대상

Round(Decimal, Int32, MidpointRounding)

매개 변수

반환

예외

설명

예

추가 정보

적용 대상

Round(Double, MidpointRounding)

매개 변수

반환

예외

설명

예

호출자 참고

추가 정보

적용 대상

Round(Double, Int32)

매개 변수

반환

예외

설명

예

호출자 참고

추가 정보

적용 대상

Round(Decimal, Int32)

매개 변수

반환

예외

설명

예

추가 정보

적용 대상

Round(Double)

매개 변수

반환

설명

예

호출자 참고

추가 정보

적용 대상

Round(Decimal)

매개 변수

반환

예외

예제

설명

추가 정보

적용 대상

Round(Decimal, MidpointRounding)

매개 변수

반환

예외

설명

예제

추가 정보

적용 대상

추가 리소스