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)

Округляет десятичное значение до указанного числа знаков после запятой; использует указанное соглашение для округления значений посередине.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)

Округляет десятичное значение до указанного числа знаков после запятой; значения посередине округляются до ближайшего четного числа.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)

Округляет десятичное значение до ближайшего целого значения; значения посередине округляются до ближайшего четного числа.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)

Округляет десятичное значение до ближайшего целого числа; использует указанное соглашение для округления значений посередине.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 (десятичное число)Math.Round(Decimal)
Math. Round (двойное)Math.Round(Double)
Math. Round (десятичное число, Int32)Math.Round(Decimal, Int32)
Math. Round (десятичное число, MidpointRounding)Math.Round(Decimal, MidpointRounding)
Math. Round (Double, Int32)Math.Round(Double, Int32)
Math. Round (двойное, MidpointRounding)Math.Round(Double, MidpointRounding)
Math. Round (десятичное число, 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.Ceiling и Math.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)
Округляет Single значение до указанного числа цифр дробной части, используя указанное соглашение о округлении и уменьшая потери точности.Round a Single value to a specified number of fractional digits by using a specified rounding convention and minimizing the loss of precision. Преобразуйте в Round(Decimal, Int32, MidpointRounding)и вызов. Decimal SingleConvert 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:

  • Округление от нуляRounding away from zero

    Средние значения округляются до следующего числа от нуля.Midpoint values are rounded to the next number away from zero. Например, 3,75 округляется до 3,8, 3,85 округляет до 3,9,-3,75 округляются до-3,8, а-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.

    Округление от нуля является наиболее широко известной формой округления.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. Он соответствует стандарту IEEE 754, разделу 4.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. В примере вычисляется истинное среднее для массива 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. В этом примере истинное значение и среднее значение, получаемое при округлении до ближайшего значения.In this example, the true mean and the mean that results when rounding to nearest are the same. Однако это означает, что результат округления от нуля отличается от 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 метод умножает исходное значение на округление до 10n, где 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. Это означает, что любая часть числа, которая немного меньше 0,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. Он многократно добавляет от 0,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 меньше 0,5, оно не округляется до ближайшего наибольшего целого числа.Because .499999999999998 is less than .5, the value is not rounded to the next highest integer. Как показано в примере, эта проблема не возникает, если просто присвоить Double переменной значение 11,5.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 значение, можно Double изменить на Decimal 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

Метод включает перегрузки, принимающие аргументы типа Decimal и Double. RoundThe Round method includes overloads that accept arguments of type Decimal and Double. Нет методов, которые округляют значения типа Single.There are no methods that round values of type Single. Если Single передать значение одной из перегрузок C# Double Round метода, оно будет приведено (в) или преобразовано (в Visual Basic) в, а также будет вызвана соответствующая 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. Если значение 16,325 передается Round в метод и округляется до двух десятичных разрядов с использованием округления до ближайшего значения, результат равен 16,33, а не ожидаемому результату 16,32. SingleWhen 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)

Округляет десятичное значение до указанного числа знаков после запятой; использует указанное соглашение для округления значений посередине.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

Округляемое десятичное число.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.
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
End Class
'
'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.

Возвраты

Число, ближайшее к параметру value, содержащем количество дробных разрядов, которое равно digits.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. Если value параметр Double.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)

Примечания для тех, кто вызывает этот метод

Из-за потери точности, которая может быть результатом представления десятичных значений в виде чисел с плавающей запятой или выполнения арифметических операций с значениями с плавающей запятой 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,135 округляется до 2,13 вместо 2,14.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.

[!code-csharpSystem.Math.Round#3] [!code-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. Если value параметр Double.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) , ToEvenметод с mode mode аргументом, а также Round(Double, MidpointRounding) метод с аргументом 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

Примечания для тех, кто вызывает этот метод

Из-за потери точности, которая может быть результатом представления десятичных значений в виде чисел с плавающей запятой или выполнения арифметических операций с значениями с плавающей запятой 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. В следующем примере, поскольку значение с плавающей запятой 0,1 не имеет конечного двоичного представления, первый вызов Round(Double) метода со значением 11,5 возвращает 11 вместо 12.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. Если value параметр Double.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

Примечания для тех, кто вызывает этот метод

Из-за потери точности, которая может быть результатом представления десятичных значений в виде чисел с плавающей запятой или выполнения арифметических операций с значениями с плавающей запятой 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,135 округляется до 2,13 вместо 2,14.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.

[!code-csharpSystem.Math.Round#2] [!code-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. Если a параметр Double.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, производительность преобразования типа "двойное в целое число" оптимизирована, если передать значение, возвращаемое Round методом, в любую из целочисленных функций преобразованияили значение Round Double, возвращаемое автоматически преобразуется в целое число с параметром Option , равным 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. Эта оптимизация позволяет коду выполняться быстрее — до двух раз быстрее для кода, который выполняет большое количество преобразований в целочисленные типы.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
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) , в некоторых случаях метод может не отображаться для округления средних значений в ближайшее четное целое число.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. В следующем примере, поскольку значение с плавающей запятой 0,1 не имеет конечного двоичного представления, первый вызов Round(Double) метода со значением 11,5 возвращает 11 вместо 12.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.

[!code-csharpSystem.Math.Round#1] [!code-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)

Округляет десятичное значение до указанного числа знаков после запятой; значения посередине округляются до ближайшего четного числа.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

Округляемое десятичное число.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

В следующем примере выполняется округление десятичных значений с двумя цифрами дробной части в значения с одной дробной цифрой.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)

Округляет десятичное значение до ближайшего целого значения; значения посередине округляются до ближайшего четного числа.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

Округляемое десятичное число.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 округляется до 4, а не 5, поскольку эта перегрузка использует 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)

Округляет десятичное значение до ближайшего целого числа; использует указанное соглашение для округления значений посередине.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

Округляемое десятичное число.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) , ToEvenметод с mode mode аргументом, а также Round(Decimal, MidpointRounding) метод с аргументом 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
Дополнительно

Применяется к