Math.Round 메서드

정의

네임스페이스:: System

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

어셈블리:: netstandard.dll, System.Runtime.dll

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

어셈블리:: mscorlib.dll

어셈블리:: netstandard.dll

중요

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

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

오버로드

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

예제

설명 섹션의 예제 외에도 메서드의 각 오버로드에 예제가 Math.Round 있습니다.

설명

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

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

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

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

에게	Call
가장 가까운 반올림 규칙을 사용하여 숫자를 정수로 반올림합니다.	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 a 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 오버로드와 각 메서드가 사용하는 반올림 규칙을 나열합니다.

Overload	반올림 규칙
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.49999999999999999988임을 보여 줍니다. .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

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

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

반올림 작업의 전체 자릿수 부족이 문제가 되는 경우 다음을 수행할 수 있습니다.

반올림 작업에서 값을 반올림 Double 하는 오버로드를 호출하는 경우 값을 변경 Double Decimal 하고 대신 값을 반올림하는 오버로드를 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 형식 Decimal 및 Double.의 인수를 허용하는 오버로드가 포함됩니다. 형식 Single의 값을 반올림하는 메서드가 없습니다. Single 값을 Round 메서드의 오버로드 중 하나에 전달하면 C#으로 캐스팅되거나(Visual Basic) Double 변환되고 Double 매개 변수를 사용하여 해당 Round 오버로드가 호출됩니다. 이는 확대 변환이지만 다음 예제와 같이 정밀도가 손실되는 경우가 많습니다. 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

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

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

Round(Double, Int32, MidpointRounding)

Source:: Math.cs

Source:: Math.cs

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 숫자입니다. 소수 자릿수보다 digitsvalue 적은 소수 자릿수가 있는 경우 value 변경되지 않은 상태로 반환됩니다.

예외

ArgumentOutOfRangeException

digits 가 0보다 작거나 15보다 큰 경우

ArgumentException

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

설명

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

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

중요합니다

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

인수 값이 value 면 메서드가 반환됩니다Double.NaN.Double.NaN is valueDouble.PositiveInfinity 또는 Double.NegativeInfinity, 메서드가 각각 반환 Double.PositiveInfinity 하거나 Double.NegativeInfinity반환합니다.

예시

다음 예제에서는 열거형을 사용 하 여 메서드를 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

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 입니다. 소수 자릿수보다 decimalsd 적은 소수 자릿수가 있는 경우 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

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에 유한한 이진 표현이 없으므로 Round(Double) 값이 11.5인 메서드에 대한 첫 번째 호출은 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

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 값을 소수 자릿수가 한 자릿수인 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

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

Source:: Math.cs

Source:: Math.cs

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

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

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 is aDouble.PositiveInfinity 또는 Double.NegativeInfinity, 메서드가 각각 반환 Double.PositiveInfinity 하거나 Double.NegativeInfinity반환합니다.

Visual Basic 15.8부터 Round 메서드에서 반환된 값을 인터네럴 변환 함수에 전달하면 정수 변환 성능이 최적화됩니다. 또는 Round 반환된 Double 값이 off로 설정된 Option Strict의 정수로 자동 변환되는 경우 이 최적화를 사용하면 정수 형식으로 많은 수의 변환을 수행하는 코드의 경우 최대 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

예시

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

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에 유한한 이진 표현이 없으므로 Round(Double) 값이 11.5인 메서드에 대한 첫 번째 호출은 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

Source:: Math.cs

Source:: Math.cs

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

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

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

추가 정보

적용 대상

피드백

이 페이지가 도움이 되었나요?