Math.Round Math.Round Math.Round Math.Round Method

정의

값을 가장 가까운 정수나 지정된 소수 자릿수로 반올림합니다.Rounds a value to the nearest integer or to the specified number of fractional digits.

오버로드

Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding)

소수 자릿수가 지정된 수의 10진수 값을 반올림하고 지정된 반올림 규칙을 사용합니다.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding)

지정된 수의 소수 자릿수를 배정밀도 부동 소수점 값으로 반올림하고 중간점 값에 대한 지정된 반올림 규칙을 사용합니다.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding)

가장 가까운 정수로 배정밀도 부동 소수점 값을 반올림하고 중간점 값에 대한 지정된 반올림 규칙을 사용합니다.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

Round(Double, Int32) Round(Double, Int32) Round(Double, Int32) Round(Double, Int32)

지정된 수의 소수 자릿수를 배정밀도 부동 소수점 값으로 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

Round(Double) Round(Double) Round(Double) Round(Double)

배정밀도 부동 소수점 값을 가장 가까운 정수 값으로 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32)

소수 자릿수가 지정된 수의 10진수 값을 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

Round(Decimal) Round(Decimal) Round(Decimal) Round(Decimal)

10진수 값을 가장 가까운 정수로 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding)

10진수 값을 가장 가까운 정수로 반올림하고 중간점 값에 대한 지정된 반올림 규칙을 사용합니다.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

예제

에 대 한 예제 외에 비고 섹션에서이 문서에서는 다음과 같은 오버 로드를 보여 주는 예제는 Math.Round 메서드:In addition to the examples in the Remarks section, this article includes examples that illustrate the following overloads of the Math.Round method:

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

참고

이 문서의 C# 예제는 Try.NET 인라인 코드 러너 및 놀이터에서 실행됩니다.The C# examples in this article run in the Try.NET inline code runner and playground. 대화형 창에서 예제를 실행하려면 실행 버튼을 선택합니다.Select the Run button to run an example in an interactive window. 코드를 실행하면 실행을 다시 선택하여 코드를 수정하고 수정된 코드를 실행할 수 있습니다.Once you execute the code, you can modify it and run the modified code by selecting Run again. 수정된 코드는 대화형 창에서 실행되거나, 컴파일이 실패하면 대화형 창에 모든 C# 컴파일러 오류 메시지가 표시됩니다.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

설명

섹션 내용In this section:

메서드 호출 합니까?Which method do I call?

다음 표에서 반올림 적절 한 방법을 선택 하 여 사용할 수 있습니다.You can use the following table to select an appropriate rounding method. 이외에 Math.Round 메서드에 포함 Math.CeilingMath.Floor.In addition to the Math.Round methods, it also includes Math.Ceiling and Math.Floor.

대상To CallCall
가장 가까운 규칙에 따라 반올림을 사용 하 여 정수로 반올림 합니다.Round a number to an integer by using the rounding to nearest convention. Round(Decimal)

또는-or-

Round(Double)
숫자로 지정을 사용 하 여 정수로 반올림 규칙을 반올림 합니다.Round a number to an integer by using a specified rounding convention. Round(Decimal, MidpointRounding)

또는-or-

Round(Double, MidpointRounding)
가장 가까운 규칙에 따라 반올림을 사용 하 여 지정 된 수의 소수 자릿수 숫자를 반올림 합니다.Round a number to a specified number of fractional digits by using the rounding to nearest convention. Round(Decimal, Int32)

또는-or-

Round(Double, Int32)
숫자로 지정을 사용 하 여 소수 자릿수가 지정 된 숫자로 반올림 규칙을 반올림 합니다.Round a number to a specified number of fractional digits by using a specified rounding convention. Round(Decimal, Int32, MidpointRounding)

또는-or-

Round(Double, Int32, MidpointRounding)
Round는 Single 소수 자릿수를 지정 된 반올림 규칙 및 전체 자릿수 손실을 최소화를 사용 하 여 지정 된 수의 값입니다.Round a Single value to a specified number of fractional digits by using a specified rounding convention and minimizing the loss of precision. 변환 합니다 SingleDecimal 호출 Round(Decimal, Int32, MidpointRounding)합니다.Convert the Single to a Decimal and call Round(Decimal, Int32, MidpointRounding).
반올림 중간점 값의 전체 자릿수는 문제를 최소화 하는 동안 지정 된 수의 소수 자릿수 숫자를 반올림 합니다.Round a number to a specified number of fractional digits while minimizing problems of precision in rounding midpoint values. "보다 크거나 약 같음" 비교를 구현 하는 반올림 메서드를 호출 합니다.Call a rounding method that implements a "greater than or approximately equal to" comparison. 참조 반올림 및 전체 자릿수합니다.See Rounding and precision.
소수 자릿수 값을 정수로 반올림 하는 보다 큰 경우 소수 자릿수 값Round a fractional value to an integer that is greater than the fractional value. 예를 들어 3.1을 4로 반올림 합니다.For example, round 3.1 to 4. Ceiling
소수 자릿수 값을 정수로 반올림 하는 보다 작으면 소수 자릿수 값입니다.Round a fractional value to an integer that is less than the fractional value. 예를 들어 3.9 ~ 3 개를 반올림 합니다.For example, round 3.9 to 3. Floor

중간점 값 및 반올림 규칙Midpoint values and rounding conventions

반올림 정밀도 사용 하 여 가장 가까운 값으로 지정한 전체 자릿수를 사용 하 여 숫자 값을 변환 해야 합니다.Rounding involves converting a numeric value with a specified precision to the nearest value with less precision. 예를 들어 사용할 수 있습니다 합니다 Round(Double) 3.4-3.0의 값을 반올림 하는 방법 및 Round(Double, Int32) 3.579를 3.58 값을 반올림 하는 방법입니다.For example, you can use the Round(Double) method to round a value of 3.4 to 3.0, and the Round(Double, Int32) method to round a value of 3.579 to 3.58.

중간점 값을 결과에 가장 중요 하지 않은 숫자 후 값이 정확 하 게 절반만 두 숫자.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. 예를 들어 3.47500 이며 중간값은 경우 두 자리로 반올림 7.500 중간점 값을 정수로 반올림 되는 경우.For example, 3.47500 is a midpoint value if it is to be rounded two decimal places, and 7.500 is a midpoint value if it is to be rounded to an integer. 이러한 경우에 가장 가까운 값을 반올림 규칙 없이 쉽게 식별할 수 없습니다.In these cases, the nearest value can't be easily identified without a rounding convention.

Round 메서드 중간점 값을 처리 하기 위해 두 반올림 규칙을 지원 합니다.The Round method supports two rounding conventions for handling midpoint values:

  • 0에서 멀어지는 쪽으로 반올림Rounding away from zero

    중간점 값은 다음 번호 0에서 멀어지는 쪽으로 반올림 됩니다.Midpoint values are rounded to the next number away from zero. 예를 들어, 3.8, 3.75 반올림-3.8, 3.9, 3.85 반올림-3.75 반올림-3.85-3.9 반올림 하 고 합니다.For example, 3.75 rounds to 3.8, 3.85 rounds to 3.9, -3.75 rounds to -3.8, and -3.85 rounds to -3.9. 반올림이 폼은 표현 된 MidpointRounding.AwayFromZero 열거형 멤버입니다.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

    0에서 멀어지는 쪽으로 반올림 하는 것은 가장 널리 알려진된 형태의 반올림 합니다.Rounding away from zero is the most widely known form of rounding.

  • 가장 가까운 수로 반올림 또는 은행원의 반올림Rounding to nearest, or banker's rounding

    중간점 값을 가장 가까운 짝수로 반올림 됩니다.Midpoint values are rounded to the nearest even number. 예를 들어 3.75와 3.85 3.8을 반올림할 및-3.75와-3.85-3.8 반내림 합니다.For example, both 3.75 and 3.85 round to 3.8, and both -3.75 and -3.85 round to -3.8. 반올림이 폼은 표현 된 MidpointRounding.ToEven 열거형 멤버입니다.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

    재무 및 통계 작업에 사용 되는 반올림 하 여 표준 형식의 가장 가까운 수로 반올림 합니다.Rounding to nearest is the standard form of rounding used in financial and statistical operations. 섹션 4 IEEE 표준 754를 준수 합니다.It conforms to IEEE Standard 754, section 4. 반올림 작업을 여러 개를 사용 하면 일관 되 게 한 방향 중간점 값을 반올림 하 여 발생 하는 반올림 오류를 줄입니다.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. 경우에 따라이 반올림 오류 중요할 수 있습니다.In some cases, this rounding error can be significant.

    다음 예제에서는 일관 되 게 한 방향 중간점 값을 반올림에서 발생할 수 있는 편차를 보여 줍니다.The following example illustrates the bias that can result from consistently rounding midpoint values in a single direction. 배열의 true 평균을 계산 하는 예제 Decimal 값 및 다음 두 개의 규칙을 사용 하 여 배열의 값은 반올림 하는 경우 평균을 계산 합니다.The example computes the true mean of an array of Decimal values, and then computes the mean when the values in the array are rounded by using the two conventions. 이 예제에서는 true 평균 및 가장 가까운 수로 반올림 때 발생 하는 평균 동일 합니다.In this example, the true mean and the mean that results when rounding to nearest are the same. 그러나 0에서 멀어지는 쪽으로 반올림 하는 경우 발생 하는 평균 true 평균과에서.05 (또는 3.6%) 다릅니다.However, the mean that results when rounding away from zero differs by .05 (or by 3.6%) from the true mean.

    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
    
    Module Example
       Public Sub Main()
          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)
       End Sub
    End Module
    ' The example displays the following output:
    '       True mean:     1.40
    '       AwayFromZero:  1.45
    '       ToEven:        1.40
    

기본적으로 Round 메서드가 가장 가까운 규칙에 따라 반올림을 사용 합니다.By default, the Round method uses the rounding to nearest convention. 다음 표에서 오버 로드는 Round 메서드 및 반올림 규칙 각 사용 합니다.The following table lists the overloads of the Round method and the rounding convention that each uses.

오버로드Overload 반올림 규칙Rounding convention
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) 에 의해 결정 mode 매개 변수입니다.Determined by mode parameter.
Round(Double, MidpointRounding) 에 의해 결정 mode 매개 변수Determined by mode parameter
Round(Decimal, Int32, MidpointRounding) 에 의해 결정 mode 매개 변수Determined by mode parameter
Round(Double, Int32, MidpointRounding) 에 의해 결정 mode 매개 변수Determined by mode parameter

반올림 하 고 전체 자릿수Rounding and precision

반올림 작업을 중간점 값을 수행 하는지 여부를 확인 하기 위해 합니다 Round 메서드 10으로 반올림 되는 원래 값을 곱합니다n여기서 n 원하는 수의 소수 자릿수는 반환 값의 숫자 값의 소수 자릿수에 남은.5 보다 크거나 같은 경우 인지를 확인 합니다.In order to determine whether a rounding operation involves a midpoint value, the Round method multiplies the original value to be rounded by 10n, where n is the desired number of fractional digits in the return value, and then determines whether the remaining fractional portion of the value is greater than or equal to .5. 이 "같음 테스트" 섹션에서 같은지 및 설명 된 것 처럼 테스트에서 약간의 변형이 Double 참조 항목을 이진 부동 소수점 형식으로 문제로 인해 부동 소수점 값을 사용 하 여 같은지 여부를 테스트 문제가 많이 표현 및 전체 자릿수입니다.This is a slight variation on a test for equality, and as discussed in the "Testing for Equality" section of the Double reference topic, tests for equality with floating-point values are problematic because of the floating-point format's issues with binary representation and precision. 이 소수 부분 (때문에 전체 자릿수 손실) 보다 약간 작습니다. 5는 숫자는 반올림 되지 않습니다 상향 것을 의미 합니다.This means that any fractional portion of a number that is slightly less than .5 (because of a loss of precision) will not be rounded upward.

중요

중간점 값을 반올림 하는 경우 반올림 알고리즘이 같음 테스트를 수행합니다.When rounding midpoint values, the rounding algorithm performs an equality test. 이진 표현 및 정밀도 부동 소수점 형식에서의 문제 때문에 메서드를 통해 반환된 값이 예상 밖일 수 있습니다.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. 자세한 내용은 “반올림 및 전체 자릿수”를 참조하세요.For more information, see "Rounding and precision".

다음 예제에서 이 문제를 보여줍니다.The following example illustrates the problem. 반복적으로.1을 11.0을 추가 하 고 결과를 가장 가까운 정수로 반올림 합니다.It repeatedly adds .1 to 11.0 and rounds the result to the nearest integer. 반올림 규칙에 관계 없이 대 한 11.5 12로 반올림 해야 합니다.Regardless of the rounding convention, 11.5 should round to 12. 그러나 예제의 출력으로 포함 되지 않습니다.However, as the output from the example shows, it does not. 예제에서는 "R" 표준 숫자 서식 문자열 표시할 부동 소수점 값의 전체 자릿수 및 값을 반올림할 전체 자릿수 반복된 추가 하는 동안 손실에 표시 및 해당 값이 실제로 11.499999999999998 합니다.The example uses the "R" standard numeric format string to display the floating point value's full precision, and shows that the value to be rounded has lost precision during repeated additions, and its value is actually 11.499999999999998. .499999999999998.5 미만인 이기 때문에 값은 다음 가장 큰 정수를 반올림 되지 않습니다.Because .499999999999998 is less than .5, the value is not rounded to the next highest integer. 또한 예와 같이 단순히에 대 한 11.5 상수 값을 할당 하는 경우이 문제가 발생 하지 않습니다는 Double 변수입니다.As the example also shows, this problem does not occur if we simply assign the constant value 11.5 to a Double variable.

using System;

public class Example
{
   public static void Main()
   {
      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
Module Example
   Public Sub Main()
      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 + .1
   End Function   
End Module
' 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

다음 조건에서 발생할 가능성이 가장 높은 문제 중간점 값을 반올림에서 정밀도 같습니다.Problems of precision in rounding midpoint values are most likely to arise in the following conditions:

  • 경우 소수 자릿수 값은 부동 소수점 형식의 이진 형식으로 정확 하 게 표현할 수 없습니다.When a fractional value cannot be expressed precisely in the floating-point type's binary format.

  • 때 하나 이상의 부동 소수점 작업에서 값으로 계산 됩니다.When the value to be rounded is calculated from one or more floating-point operations.

  • 반올림할 값이를 Single 아닌 Double 또는 Decimal합니다.When the value to be rounded is a Single rather than a Double or Decimal. 자세한 내용은 다음 섹션을 참조 하세요 반올림 하 고 단 정밀도 부동 소수점 값합니다.For more information, see the next section, Rounding and single-precision floating-point values.

작업을 반올림에서 정밀도 부족 문제가 있는 경우에서 다음을 수행할 수 있습니다.In cases where the lack of precision in rounding operations is problematic, you can do the following:

  • 반올림 연산 반올림 하는 오버 로드를 호출 하는 경우를 Double 변경할 수 값을는 DoubleDecimal 값을 반올림 하는 오버 로드를 호출를 Decimal 값을 대신 합니다.If the rounding operation calls an overload that rounds a Double value, you can change the Double to a Decimal value and call an overload that rounds a Decimal value instead. 하지만 Decimal 표현의 문제와 정밀도의 손실에도 데이터 형식에, 이러한 문제는 훨씬 덜 일반적인 합니다.Although the Decimal data type also has problems of representation and loss of precision, these issues are far less common.

  • 만족 스럽게 값을 반올림할 중간점 값에 가까운 적용 되는지 확인 하려면 "거의 같은" 테스트를 수행 하는 사용자 지정 반올림 알고리즘을 정의 합니다.Define a custom rounding algorithm that performs a "nearly equal" test to determine whether the value to be rounded is acceptably close to a midpoint value. 다음 예제에서는 정의 RoundApproximate 중간점 반올림이 적용 되도록 중간점 값에 가까이 있는 소수 자릿수 값을 충분히 인지 검사 하는 메서드.The following example defines a RoundApproximate method that examines whether a fractional value is sufficiently near to a midpoint value to be subject to midpoint rounding. 예제의 출력에서 볼 수 있듯이 이전 예에서 같이 반올림 문제를 해결 합니다.As the output from the example shows, it corrects the rounding problem shown in the previous example.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          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
    
    Module Example
       Public Sub Main()
          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 = 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
       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 >= .5 - tolerance) And (fraction <= .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 > .5 Then
             Return (value + 1)/Math.Pow(10, digits)
          Else
             return value/Math.Pow(10, digits)
          End If      
       End Function
    End Module
    ' 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
    

반올림 하 고 단 정밀도 부동 소수점 값Rounding and single-precision floating-point values

합니다 Round 형식의 인수를 받아들이는 오버 로드를 포함 하는 메서드 DecimalDouble합니다.The Round method includes overloads that accept arguments of type Decimal and Double. 형식의 값을 반올림 하는 메서드가 없으면 Single합니다.There are no methods that round values of type Single. 전달 하는 경우는 Single 오버 로드 중 하나에 값을 Round 메서드는 캐스팅 (C#) 또는 변환 (Visual Basic)를 Double, 및 해당 Round 오버 로드를 Double 매개 변수 라고 합니다.If you pass a Single value to one of the overloads of the Round method, it is cast (in C#) or converted (in Visual Basic) to a Double, and the corresponding Round overload with a Double parameter is called. 확대 변환이 있지만 문제가 다음 예제와 같이 정밀도 손실 종종 것입니다.Although this is a widening conversion, it often involves a loss of precision, as the following example illustrates. 경우는 Single 16.325의 값이 전달는 Round 메서드 결과 16.32 16.33 및 없습니다 예상 결과 가장 가까운 규칙에 따라 반올림을 사용 하 여 두 자리로 반올림 합니다.When a Single value of 16.325 is passed to the Round method and rounded to two decimal places using the rounding to nearest convention, the result is 16.33 and not the expected result of 16.32.

using System;

public class Example
{
   public static void Main()
   {
      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
Module Example
   Public Sub Main()
      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()
   End Sub
End Module
' 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입니다.This unexpected result is due to a loss of precision in the conversion of the Single value to a Double. 때문에 결과 Double 16.325000762939453 값 중간점 값이 아닙니다 16.325 보다 크면를 항상 반올림 상향 합니다.Because the resulting Double value of 16.325000762939453 is not a midpoint value and is greater than 16.325, it is always rounded upward.

대부분의 경우에서 예제와 같이 전체 자릿수 손실을 최소화 하거나 수 캐스팅 하거나 변환 하 여 제거 합니다 Single 값을 Decimal합니다.In many cases, as the example illustrates, the loss of precision can be minimized or eliminated by casting or converting the Single value to a Decimal. 참고, 축소 변환 이기 때문에 필요 하다는 캐스트 연산자를 사용 하 여 또는 변환 메서드를 호출 합니다.Note that, because this is a narrowing conversion, it requires using a cast operator or calling a conversion method.

Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding)

소수 자릿수가 지정된 수의 10진수 값을 반올림하고 지정된 반올림 규칙을 사용합니다.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

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 Decimal Decimal Decimal

반올림할 10진수입니다.A decimal number to be rounded.

decimals
Int32 Int32 Int32 Int32

반환 값의 소수 자릿수입니다.The number of decimal places in the return value.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

서로 다른 두 숫자 중간에 있는 d의 반올림 방법에 대한 사양입니다.Specification for how to round d if it is midway between two other numbers.

반환

d와(과) 일치하는 소수 자릿수가 포함된 decimals에 가장 가까운 수입니다.The number nearest to d that contains a number of fractional digits equal to decimals. d의 소수 자릿수가 decimals보다 작은 경우, d가 변경되지 않은 상태로 반환됩니다.If d has fewer fractional digits than decimals, d is returned unchanged.

예외

decimals가 0보다 작거나 28보다 큽니다.decimals is less than 0 or greater than 28.

mode는 유효한 MidpointRounding 값이 아닙니다.mode is not a valid value of MidpointRounding.

결과가 Decimal 범위를 벗어나는 경우The result is outside the range of a Decimal.

설명

참조 중간점 값 및 반올림 규칙 중간점 값을 사용 하 여 숫자를 반올림 하는 방법에 대 한 정보에 대 한 합니다.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

중요

중간점 값을 반올림 하는 경우 반올림 알고리즘이 같음 테스트를 수행합니다.When rounding midpoint values, the rounding algorithm performs an equality test. 이진 표현 및 정밀도 부동 소수점 형식에서의 문제 때문에 메서드를 통해 반환된 값이 예상 밖일 수 있습니다.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. 자세한 내용은 “반올림 및 전체 자릿수”를 참조하세요.For more information, see "Rounding and precision".

값은 decimals 인수는 0부터 28까지 있습니다.The value of the decimals argument can range from 0 to 28.

예제Example

다음 예제에서는 사용 하는 방법에 설명 합니다 Round 메서드는 MidpointRounding 열거형입니다.The following example demonstrates how to use the Round method with the MidpointRounding enumeration.

// This example demonstrates the Math.Round() method in conjunction 
// with the MidpointRounding enumeration.
using namespace System;

void main()
{
    Decimal result = (Decimal) 0.0;
    Decimal posValue = (Decimal) 3.45;
    Decimal negValue = (Decimal) -3.45;

    // By default, round a positive and a negative value to the nearest
    // even number. The precision of the result is 1 decimal place.
    result = 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 to the nearest even number, then to the
    // nearest number away from zero. 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);
    Console::WriteLine();

    // Round a negative value to the nearest even number, then to the
    // nearest number away from zero. 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);
    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)

*/
decimal result = 0.0m;
decimal posValue =  3.45m;
decimal negValue = -3.45m;

// By default, round a positive and a negative value to the nearest even number. 
// The precision of the result is 1 decimal place.

result = 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 to the nearest even number, then to the nearest number away from zero. 
// 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);
Console.WriteLine();

// Round a negative value to the nearest even number, then to the nearest number away from zero. 
// 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);
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)

*/
' This example demonstrates the Math.Round() method in conjunction 
' with the MidpointRounding enumeration.
Imports System

Class Sample
    Public Shared Sub Main() 
        Dim result As Decimal = 0D
        Dim posValue As Decimal = 3.45D
        Dim negValue As Decimal = -3.45D
        
        ' By default, round a positive and a negative value to the nearest even number. 
        ' The precision of the result is 1 decimal place.
        result = 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 to the nearest even number, then to the nearest number 
        ' away from zero. 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)
        Console.WriteLine()
        
        ' Round a negative value to the nearest even number, then to the nearest number 
        ' away from zero. 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)
        Console.WriteLine()
    
    End Sub 'Main
End Class 'Sample
'
'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) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding)

지정된 수의 소수 자릿수를 배정밀도 부동 소수점 값으로 반올림하고 중간점 값에 대한 지정된 반올림 규칙을 사용합니다.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

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 Double Double Double

반올림할 배정밀도 부동 소수점 수입니다.A double-precision floating-point number to be rounded.

digits
Int32 Int32 Int32 Int32

반환 값의 소수 자릿수입니다.The number of fractional digits in the return value.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

서로 다른 두 숫자 중간에 있는 value의 반올림 방법에 대한 사양입니다.Specification for how to round value if it is midway between two other numbers.

반환

digits와(과) 일치하는 소수 자릿수가 포함된 value에 가장 가까운 수입니다.The number nearest to value that has a number of fractional digits equal to digits. value의 소수 자릿수가 digits보다 작은 경우, value가 변경되지 않은 상태로 반환됩니다.If value has fewer fractional digits than digits, value is returned unchanged.

예외

digits가 0보다 작거나 15보다 큽니다.digits is less than 0 or greater than 15.

mode는 유효한 MidpointRounding 값이 아닙니다.mode is not a valid value of MidpointRounding.

설명

값은 digits 인수는 0에서 15까지 수 있습니다.The value of the digits argument can range from 0 to 15. 15에서 지원 되는 정수 부분과 소수 부분 자릿수의 최대 수는는 Double 형식입니다.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

참조 중간점 값 및 반올림 규칙 중간점 값을 사용 하 여 숫자를 반올림 하는 방법에 대 한 정보에 대 한 합니다.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

중요

중간점 값을 반올림 하는 경우 반올림 알고리즘이 같음 테스트를 수행합니다.When rounding midpoint values, the rounding algorithm performs an equality test. 이진 표현 및 정밀도 부동 소수점 형식에서의 문제 때문에 메서드를 통해 반환된 값이 예상 밖일 수 있습니다.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. 자세한 내용은 “반올림 및 전체 자릿수”를 참조하세요.For more information, see "Rounding and precision".

경우의 값은 value 인수는 Double.NaN, 메서드가 Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. 경우 valueDouble.PositiveInfinity 또는 Double.NegativeInfinity, 메서드가 Double.PositiveInfinity 또는 Double.NegativeInfinity, 각각.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

예제Example

다음 예제에서는 사용 하는 방법에 설명 합니다 Round(Double, Int32, MidpointRounding) 메서드는 MidpointRounding 열거형입니다.The following example demonstrates how to use the Round(Double, Int32, MidpointRounding) method with the MidpointRounding enumeration.

 double posValue =  3.45;
 double negValue = -3.45;

 // Round a positive and a negative value using the default. 
 double result = 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)\n", result, negValue);

 // 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)\n", 
                   result, posValue);

 // Round a negative 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)\n", 
                   result, negValue);
// 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.45, 1, MidpointRounding.ToEven)
//       -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
Module Example
    Public Sub Main() 
        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()
    End Sub
End Module
' 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.45, 1, MidpointRounding.ToEven)
'       -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

호출자 참고

경우에 따라 부동 소수점 값에 산술 연산을 수행 또는 10 진수 값을 부동 소수점 표현에서 발생할 수 있는 전체 자릿수 손실을 인해는 Round(Double, Int32, MidpointRounding) 메서드는 지정 된 대로 중간점 값을 반올림할 나타나지 않을 수 있습니다 여는 mode 매개 변수입니다.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32, MidpointRounding) method may not appear to round midpoint values as specified by the mode parameter. 이 2.14 대신 2.13 2.135 반올림는 다음 예제에 나와 있습니다.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. 이 메서드를 내부적으로 곱합니다 때문에 발생 value 10 씩자릿수, 곱하기 연산의 정밀도의 손실 로부터 경우 저하.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

[! 코드 csharpSystem.Math.Round#3] [! 코드 vbSystem.Math.Round#3][!code-csharpSystem.Math.Round#3] [!code-vbSystem.Math.Round#3]

추가 정보

Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding)

가장 가까운 정수로 배정밀도 부동 소수점 값을 반올림하고 중간점 값에 대한 지정된 반올림 규칙을 사용합니다.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

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 Double Double Double

반올림할 배정밀도 부동 소수점 수입니다.A double-precision floating-point number to be rounded.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

서로 다른 두 숫자 중간에 있는 value의 반올림 방법에 대한 사양입니다.Specification for how to round value if it is midway between two other numbers.

반환

value에 가장 가까운 정수입니다.The integer nearest value. value가 두 정수의 중간이고, 이 숫자 중 하나는 짝수이고 다른 하나는 홀수이면, mode에 의해 두 숫자 중 하나가 반환됩니다.If value is halfway between two integers, one of which is even and the other odd, then mode determines which of the two is returned. 이 메서드는 정수 계열 형식이 아니라 Double을 반환합니다.Note that this method returns a Double instead of an integral type.

예외

mode는 유효한 MidpointRounding 값이 아닙니다.mode is not a valid value of MidpointRounding.

설명

참조 중간점 값 및 반올림 규칙 중간점 값을 사용 하 여 숫자를 반올림 하는 방법에 대 한 정보에 대 한 합니다.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

중요

중간점 값을 반올림 하는 경우 반올림 알고리즘이 같음 테스트를 수행합니다.When rounding midpoint values, the rounding algorithm performs an equality test. 이진 표현 및 정밀도 부동 소수점 형식에서의 문제 때문에 메서드를 통해 반환된 값이 예상 밖일 수 있습니다.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. 자세한 내용은 “반올림 및 전체 자릿수”를 참조하세요.For more information, see "Rounding and precision".

경우의 값은 value 인수는 Double.NaN, 메서드가 Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. 경우 valueDouble.PositiveInfinity 또는 Double.NegativeInfinity, 메서드가 Double.PositiveInfinity 또는 Double.NegativeInfinity, 각각.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

예제Example

반환 된 값을 표시 하는 다음 예제는 Round(Double) 메서드를를 Round(Double, MidpointRounding) 메서드를 mode 인수의 ToEven, 및 Round(Double, MidpointRounding) 메서드를 mode 인수의 AwayFromZero.The following example displays values returned by the Round(Double) method, the Round(Double, MidpointRounding) method with a mode argument of ToEven, and the Round(Double, MidpointRounding) method with a mode argument of AwayFromZero.

using System;

public class Example
{
   public static void Main()
   {
      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("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero");
      foreach (var value in values)
         Console.WriteLine("{0,-10:R} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero));
   }
}
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero
//       12         12         12         12
//       12.1       12         12         12
//       12.2       12         12         12
//       12.3       12         12         12
//       12.4       12         12         12
//       12.5       12         12         13
//       12.6       13         13         13
//       12.7       13         13         13
//       12.8       13         13         13
//       12.9       13         13         13
//       13.0       13         13         13
Module Example
   Public Sub Main()
      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}", "Value", "Default", 
                        "ToEven", "AwayFromZero")
      For Each value In values
         Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero
'       12         12         12         12
'       12.1       12         12         12
'       12.2       12         12         12
'       12.3       12         12         12
'       12.4       12         12         12
'       12.5       12         12         13
'       12.6       13         13         13
'       12.7       13         13         13
'       12.8       13         13         13
'       12.9       13         13         13
'       13.0       13         13         13

호출자 참고

경우에 따라 부동 소수점 값에 산술 연산을 수행 또는 10 진수 값을 부동 소수점 표현에서 발생할 수 있는 전체 자릿수 손실을 인해는 Round(Double, MidpointRounding) 메서드 중간점 값을 반올림할 나타나지 않을 수 있습니다는 가장 근사한 짝수 정수로 합니다.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, MidpointRounding) method may not appear to round midpoint values to the nearest even integer. 다음 예제에서는 부동 소수점 값.1이 유한 이진 표현이 없기 때문에 첫 번째 호출 하는 Round(Double) 11.5 값을 사용 하 여 메서드 12 대신 11을 반환 합니다.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

[! 코드 csharpSystem.Math.Round#4] [! 코드 vbSystem.Math.Round#4][!code-csharpSystem.Math.Round#4] [!code-vbSystem.Math.Round#4]

추가 정보

Round(Double, Int32) Round(Double, Int32) Round(Double, Int32) Round(Double, Int32)

지정된 수의 소수 자릿수를 배정밀도 부동 소수점 값으로 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

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 Double Double Double

반올림할 배정밀도 부동 소수점 수입니다.A double-precision floating-point number to be rounded.

digits
Int32 Int32 Int32 Int32

반환 값의 소수 자릿수입니다.The number of fractional digits in the return value.

반환

value와(과) 일치하는 소수 자릿수가 포함된 digits에 가장 가까운 수입니다.The number nearest to value that contains a number of fractional digits equal to digits.

예외

digits가 0보다 작거나 15보다 큽니다.digits is less than 0 or greater than 15.

설명

값은 digits 인수는 0에서 15까지 수 있습니다.The value of the digits argument can range from 0 to 15. 15에서 지원 되는 정수 부분과 소수 부분 자릿수의 최대 수는는 Double 형식입니다.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

이 메서드를 사용 하 여 반올림 규칙을 기본 MidpointRounding.ToEven.This method uses the default rounding convention of MidpointRounding.ToEven. 참조 중간점 값 및 반올림 규칙 중간점 값을 사용 하 여 숫자를 반올림 하는 방법에 대 한 정보에 대 한 합니다.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

중요

중간점 값을 반올림 하는 경우 반올림 알고리즘이 같음 테스트를 수행합니다.When rounding midpoint values, the rounding algorithm performs an equality test. 이진 표현 및 정밀도 부동 소수점 형식에서의 문제 때문에 메서드를 통해 반환된 값이 예상 밖일 수 있습니다.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. 자세한 내용은 “반올림 및 전체 자릿수”를 참조하세요.For more information, see "Rounding and precision".

경우의 값은 value 인수는 Double.NaN, 메서드가 Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. 경우 valueDouble.PositiveInfinity 또는 Double.NegativeInfinity, 메서드가 Double.PositiveInfinity 또는 Double.NegativeInfinity, 각각.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

예제Example

다음 예제에서는 두 소수 자릿수를 소수 자리 있는 double 사용 하 여 double 값을 반올림 합니다.The following example rounds double values with two fractional digits to doubles that have a single fractional digit.

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

호출자 참고

경우에 따라 부동 소수점 값에 산술 연산을 수행 또는 10 진수 값을 부동 소수점 표현에서 발생할 수 있는 전체 자릿수 손실을 인해는 Round(Double, Int32) 메서드 중간점 값을 반올림할 나타나지 않을 수 있습니다는 에 값에 가장 가까운는 digits 소수 자릿수입니다.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32) method may not appear to round midpoint values to the nearest even value in the digits decimal position. 이 2.14 대신 2.13 2.135 반올림는 다음 예제에 나와 있습니다.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. 이 메서드를 내부적으로 곱합니다 때문에 발생 value 10 씩자릿수, 곱하기 연산의 정밀도의 손실 로부터 경우 저하.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

[! 코드 csharpSystem.Math.Round#2] [! 코드 vbSystem.Math.Round#2][!code-csharpSystem.Math.Round#2] [!code-vbSystem.Math.Round#2]

추가 정보

Round(Double) Round(Double) Round(Double) Round(Double)

배정밀도 부동 소수점 값을 가장 가까운 정수 값으로 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

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 Double Double

반올림할 배정밀도 부동 소수점 수입니다.A double-precision floating-point number to be rounded.

반환

a에 가장 가까운 정수입니다.The integer nearest a. a의 소수 부분이 하나는 짝수이고 다른 하나는 홀수인 두 정수의 중간인 경우에는 짝수가 반환됩니다.If the fractional component of a is halfway between two integers, one of which is even and the other odd, then the even number is returned. 이 메서드는 정수 계열 형식이 아니라 Double을 반환합니다.Note that this method returns a Double instead of an integral type.

설명

이 메서드를 사용 하 여 반올림 규칙을 기본 MidpointRounding.ToEven.This method uses the default rounding convention of MidpointRounding.ToEven. 참조 중간점 값 및 반올림 규칙 중간점 값을 사용 하 여 숫자를 반올림 하는 방법에 대 한 정보에 대 한 합니다.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

중요

중간점 값을 반올림 하는 경우 반올림 알고리즘이 같음 테스트를 수행합니다.When rounding midpoint values, the rounding algorithm performs an equality test. 이진 표현 및 정밀도 부동 소수점 형식에서의 문제 때문에 메서드를 통해 반환된 값이 예상 밖일 수 있습니다.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. 자세한 내용은 “반올림 및 전체 자릿수”를 참조하세요.For more information, see "Rounding and precision".

경우의 값은 a 인수는 Double.NaN, 메서드가 Double.NaN.If the value of the a argument is Double.NaN, the method returns Double.NaN. 경우 aDouble.PositiveInfinity 또는 Double.NegativeInfinity, 메서드가 Double.PositiveInfinity 또는 Double.NegativeInfinity, 각각.If a is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

Visual Basic 15.8부터 Double을 정수로 변환의 성능을 최적화 된 반환 값을 전달 하는 경우는 Round 메서드 중 하나를 합니다 정수 계열 변환 함수, 이거나 Double 값 반환한 Round 자동으로 포함 된 정수 변환할 Option Strict Off로 설정 합니다.Starting with Visual Basic 15.8, the performance of Double-to-integer conversion is optimized if you pass the value returned by the Round method to the any of the integral conversion functions, or if the Double value returned by Round is automatically converted to an integer with Option Strict set to Off. 이렇게 최적화하면 다량의 정수 형식 변환을 수행하는 코드의 경우 코드 실행 속도가 최대 2배까지 더 빨라집니다.This optimization allows code to run faster -- up to twice as fast for code that does a large number of conversions to integer types. 다음 예제에서는 이러한 최적화 된 변환을 보여 줍니다.The following example illustrates such optimized conversions:

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

예제Example

다음 예제에서는 가장 근사한 정수값으로 반올림 하는 방법을 보여 줍니다.The following example demonstrates rounding to the nearest integer value.

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
Imports System

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

호출자 참고

경우에 따라 부동 소수점 값에 산술 연산을 수행 또는 10 진수 값을 부동 소수점 표현에서 발생할 수 있는 전체 자릿수 손실을 인해는 Round(Double) 메서드 중간점 값을 반올림할 나타나지 않을 수 있습니다는 가장 근사한 짝수 정수로 합니다.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double) method may not appear to round midpoint values to the nearest even integer. 다음 예제에서는 부동 소수점 값.1이 유한 이진 표현이 없기 때문에 첫 번째 호출 하는 Round(Double) 11.5 값을 사용 하 여 메서드 12 대신 11을 반환 합니다.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

[! 코드 csharpSystem.Math.Round#1] [! 코드 vbSystem.Math.Round#1][!code-csharpSystem.Math.Round#1] [!code-vbSystem.Math.Round#1]

추가 정보

Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32)

소수 자릿수가 지정된 수의 10진수 값을 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

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 Decimal Decimal Decimal

반올림할 10진수입니다.A decimal number to be rounded.

decimals
Int32 Int32 Int32 Int32

반환 값의 소수 자릿수입니다.The number of decimal places in the return value.

반환

d와(과) 일치하는 소수 자릿수가 포함된 decimals에 가장 가까운 수입니다.The number nearest to d that contains a number of fractional digits equal to decimals.

예외

decimals가 0보다 작거나 28보다 큽니다.decimals is less than 0 or greater than 28.

결과가 Decimal 범위를 벗어나는 경우The result is outside the range of a Decimal.

설명

값은 decimals 인수는 0부터 28까지 있습니다.The value of the decimals argument can range from 0 to 28.

이 메서드를 사용 하 여 반올림 규칙을 기본 MidpointRounding.ToEven.This method uses the default rounding convention of MidpointRounding.ToEven. 참조 중간점 값 및 반올림 규칙 중간점 값을 사용 하 여 숫자를 반올림 하는 방법에 대 한 정보에 대 한 합니다.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

중요

중간점 값을 반올림 하는 경우 반올림 알고리즘이 같음 테스트를 수행합니다.When rounding midpoint values, the rounding algorithm performs an equality test. 이진 표현 및 정밀도 부동 소수점 형식에서의 문제 때문에 메서드를 통해 반환된 값이 예상 밖일 수 있습니다.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. 자세한 내용은 “반올림 및 전체 자릿수”를 참조하세요.For more information, see "Rounding and precision".

예제Example

다음 예제에서는 단일 소수 자릿수를 포함 하는 값을 두 소수 자릿수를 사용 하 여 10 진수 값을 반올림 합니다.The following example rounds decimal values with two fractional digits to values that have a single fractional digit.

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
Public Module Example
   Sub Main()
      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)) 
   End Sub  
End Module
' The example displays the following output:
'       3.4
'       3.4
'       3.5
'       
'       4.3
'       4.4
'       4.4
추가 정보

Round(Decimal) Round(Decimal) Round(Decimal) Round(Decimal)

10진수 값을 가장 가까운 정수로 반올림하고 중간점 값을 가장 가까운 짝수로 반올림합니다.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

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 Decimal Decimal Decimal

반올림할 10진수입니다.A decimal number to be rounded.

반환

d 매개 변수에 가장 가까운 정수입니다.The integer nearest the d parameter. d의 소수 부분이 하나는 짝수이고 다른 하나는 홀수인 두 정수의 중간인 경우에는 짝수가 반환됩니다.If the fractional component of d is halfway between two integers, one of which is even and the other odd, the even number is returned. 이 메서드는 정수 계열 형식이 아니라 Decimal을 반환합니다.Note that this method returns a Decimal instead of an integral type.

예외

결과가 Decimal 범위를 벗어나는 경우The result is outside the range of a Decimal.

설명

이 메서드를 사용 하 여 반올림 규칙을 기본 MidpointRounding.ToEven.This method uses the default rounding convention of MidpointRounding.ToEven. 참조 중간점 값 및 반올림 규칙 중간점 값을 사용 하 여 숫자를 반올림 하는 방법에 대 한 정보에 대 한 합니다.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

중요

중간점 값을 반올림 하는 경우 반올림 알고리즘이 같음 테스트를 수행합니다.When rounding midpoint values, the rounding algorithm performs an equality test. 이진 표현 및 정밀도 부동 소수점 형식에서의 문제 때문에 메서드를 통해 반환된 값이 예상 밖일 수 있습니다.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. 자세한 내용은 “반올림 및 전체 자릿수”를 참조하세요.For more information, see "Rounding and precision".

예제Example

다음 예제는 Round(Decimal) 메서드.The following example demonstrates the Round(Decimal) method. 이때 합니다 Decimal 4.5의 값이 5 보다는 4 반올림이 오버 로드는 기본값을 사용 하므로 ToEven 규칙입니다.Note that the Decimal value of 4.5 rounds to 4 rather than 5, because this overload uses the default ToEven convention.

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
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) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding)

10진수 값을 가장 가까운 정수로 반올림하고 중간점 값에 대한 지정된 반올림 규칙을 사용합니다.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

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 Decimal Decimal Decimal

반올림할 10진수입니다.A decimal number to be rounded.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

서로 다른 두 숫자 중간에 있는 d의 반올림 방법에 대한 사양입니다.Specification for how to round d if it is midway between two other numbers.

반환

d에 가장 가까운 정수입니다.The integer nearest d. d가 두 숫자의 중간이고, 이 숫자 중 하나는 짝수이고 다른 하나는 홀수이면, mode에 의해 두 숫자 중 하나가 반환됩니다.If d is halfway between two numbers, one of which is even and the other odd, then mode determines which of the two is returned. 이 메서드는 정수 계열 형식이 아니라 Decimal을 반환합니다.Note that this method returns a Decimal instead of an integral type.

예외

mode는 유효한 MidpointRounding 값이 아닙니다.mode is not a valid value of MidpointRounding.

결과가 Decimal 범위를 벗어나는 경우The result is outside the range of a Decimal.

설명

참조 중간점 값 및 반올림 규칙 중간점 값을 사용 하 여 숫자를 반올림 하는 방법에 대 한 정보에 대 한 합니다.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

중요

중간점 값을 반올림 하는 경우 반올림 알고리즘이 같음 테스트를 수행합니다.When rounding midpoint values, the rounding algorithm performs an equality test. 이진 표현 및 정밀도 부동 소수점 형식에서의 문제 때문에 메서드를 통해 반환된 값이 예상 밖일 수 있습니다.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. 자세한 내용은 “반올림 및 전체 자릿수”를 참조하세요.For more information, see "Rounding and precision".

예제Example

반환 된 값을 표시 하는 다음 예제는 Round(Decimal) 메서드를를 Round(Decimal, MidpointRounding) 메서드를 mode 인수의 ToEven, 및 Round(Decimal, MidpointRounding) 메서드를 mode 인수의 AwayFromZero.The following example displays values returned by the Round(Decimal) method, the Round(Decimal, MidpointRounding) method with a mode argument of ToEven, and the Round(Decimal, MidpointRounding) method with a mode argument of AwayFromZero.

Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                  "ToEven", "AwayFromZero");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
   Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                     value, Math.Round(value), 
                     Math.Round(value, MidpointRounding.ToEven),
                     Math.Round(value, MidpointRounding.AwayFromZero));
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero
//       12         12         12         12
//       12.1       12         12         12
//       12.2       12         12         12
//       12.3       12         12         12
//       12.4       12         12         12
//       12.5       12         12         13
//       12.6       13         13         13
//       12.7       13         13         13
//       12.8       13         13         13
//       12.9       13         13         13
//       13.0       13         13         13
Module Example
   Public Sub Main()
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero")
      For value As Decimal = 12.0d To 13.0d Step .1d
         Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero
'       12         12         12         12
'       12.1       12         12         12
'       12.2       12         12         12
'       12.3       12         12         12
'       12.4       12         12         12
'       12.5       12         12         13
'       12.6       13         13         13
'       12.7       13         13         13
'       12.8       13         13         13
'       12.9       13         13         13
'       13.0       13         13         13
추가 정보

적용 대상