Поделиться через


Math.Round Метод

Определение

Округляет значение до ближайшего целого или указанного количества десятичных знаков.

Перегрузки

Round(Double, Int32, MidpointRounding)

Округляет значение двойной точности с плавающей запятой до указанного числа дробных цифр, используя указанное соглашение об округлении.

Round(Decimal, Int32, MidpointRounding)

Округляет десятичное значение до указанного числа дробных цифр, используя указанное соглашение об округлении.

Round(Double, MidpointRounding)

Округляет значение двойной точности с плавающей запятой до целого числа, используя указанное соглашение об округлении.

Round(Double, Int32)

Округляет значение с плавающей запятой двойной точности до указанного числа знаков после запятой; значения посередине округляются до ближайшего четного числа.

Round(Decimal, Int32)

Округляет десятичное значение до указанного числа знаков после запятой; значения посередине округляются до ближайшего четного числа.

Round(Double)

Округляет значение с плавающей запятой двойной точности до ближайшего целого значения; значения посередине округляются до ближайшего четного числа.

Round(Decimal)

Округляет десятичное значение до ближайшего целого значения; значения посередине округляются до ближайшего четного числа.

Round(Decimal, MidpointRounding)

Округляет десятичное значение на целое число, используя указанное соглашение об округлении.

Примеры

Помимо примеров в разделе Примечания , эта статья содержит примеры, иллюстрирующие следующие перегрузки Math.Round метода:

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

Комментарии

Содержание

Какой метод вызывается?

Для выбора подходящего метода округления можно использовать следующую таблицу. Помимо Math.Round методов, он также включает Math.Ceiling и Math.Floor.

Кому Вызов
Округление числа до целого числа с помощью соглашения округления до ближайшего. Round(Decimal)
-или-
Round(Double)
Округление числа до целого числа с помощью указанного соглашения об округлении. Round(Decimal, MidpointRounding)
-или-
Round(Double, MidpointRounding)
Округление числа до указанного числа дробных цифр с помощью округления до ближайшего соглашения. Round(Decimal, Int32)
-или-
Round(Double, Int32)
Округление числа до указанного числа дробных цифр с помощью указанного соглашения об округлении. Round(Decimal, Int32, MidpointRounding)
-или-
Round(Double, Int32, MidpointRounding)
Single Округление значения до указанного числа дробных цифр с помощью заданного соглашения об округлении и минимизации потери точности. Преобразуйте в SingleDecimal и вызовите Round(Decimal, Int32, MidpointRounding).
Округление числа до указанного числа дробных цифр при минимизации проблем с точностью округления значений середины. Вызовите метод округления, реализующий сравнение "больше или приблизительно равно". См. статью Округление и точность.
Округление дробного значения до целого числа, которое больше дробного значения. Например, округление 3.1 до 4. Ceiling
Округление дробного значения до целого числа, которое меньше дробного значения. Например, округление 3,9 до 3. Floor

Средние значения и соглашения о округлениях

Округление включает преобразование числового значения с заданной точностью в значение с меньшей точностью. Например, можно использовать Round(Double) метод для округления значения от 3,4 до 3,0, а Round(Double, Int32) метод — для округления значения от 3,579 до 3,58.

В средней точке значение после наименее значимой цифры в результате находится на полпути между двумя числами. Например, 3,47500 — это среднее значение, если оно должно быть округлено до двух десятичных знаков, а 7,500 — это среднее значение, если оно должно быть округлено до целого числа. В таких случаях, если используется стратегия округления до ближайшего, ближайшее значение не может быть легко идентифицировано без соглашения об округлении.

Метод Round поддерживает два соглашения округления для обработки значений середины:

  • Округление от нуля

    Значения середины округляются до следующего числа от нуля. Например, 3,75 округляется до 3,8, 3,85 округляется до 3,9, -3,75 округляется до -3,8, а -3,85 округляется до -3,9. Эта форма округления представлена элементом MidpointRounding.AwayFromZero перечисления.

  • Округление до ближайшего четного или округление банкира

    Средние значения округляются до ближайшего четного числа. Например, значения 3,75 и 3,85 округлялись до 3,8, а значения -3,75 и -3,85 округлялись до -3,8. Эта форма округления представлена элементом MidpointRounding.ToEven перечисления.

Примечание

В .NET Core 3.0 и более поздних версиях с помощью перечисления MidpointRounding доступны три дополнительные стратегии округления. Эти стратегии используются во всех случаях, а не только для средних значений как MidpointRounding.ToEven и MidpointRounding.AwayFromZero есть.

Округление от нуля является наиболее широко известной формой округления, в то время как округление до ближайшего является стандартом в финансовых и статистических операциях. Он соответствует стандарту IEEE 754, раздел 4. При использовании в нескольких операциях округления округление до ближайшего уменьшает ошибку округления, вызванную последовательным округлением значений середины в одном направлении. В некоторых случаях эта ошибка округления может быть значительной.

В следующем примере показана смещение, которое может быть результатом последовательного округления значений средней точки в одном направлении. В примере вычисляется истинное среднее массива значений Decimal , а затем вычисляется среднее, когда значения в массиве округляются с помощью двух соглашений. В этом примере истинное среднее и среднее значение, которое при округляется до ближайшего, совпадают. Однако среднее значение, которое при округляется от нуля, отличается на 0,05 (или на 3,6 %) от истинного среднего.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// The example displays the following output:
//       True mean:     1.40
//       AwayFromZero:  1.45
//       ToEven:        1.40
Dim values() As Decimal = {1.15D, 1.25D, 1.35D, 1.45D, 1.55D, 1.65D}
Dim sum As Decimal

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

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

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

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

По умолчанию Round метод использует круглую к ближайшему соглашению о четных значениях. В следующей таблице перечислены перегрузки Round метода и соглашения о округлениях, которые используются каждым из них.

Перегрузка Соглашение о округлениях
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) Определяется параметром mode .
Round(Double, MidpointRounding) Определяется параметром mode
Round(Decimal, Int32, MidpointRounding) Определяется параметром mode
Round(Double, Int32, MidpointRounding) Определяется параметром mode

Округление и точность

Чтобы определить, включает ли операция округления среднее значение, Round метод умножает исходное значение для округления на 10n, где n — требуемое число дробных цифр в возвращаемом значении, а затем определяет, больше ли оставшаяся дробная часть значения или равна 0,5. Это небольшой вариант проверки на равенство, и, как описано в разделе "Тестирование на равенство" справочного Double раздела, тесты на равенство со значениями с плавающей запятой являются проблематичными из-за проблем формата с плавающей запятой с двоичным представлением и точностью. Это означает, что любая дробная часть числа, которая немного меньше 0,5 (из-за потери точности), не будет округлена вверх.

В следующем примере показана эта проблема. Он многократно добавляет .1 к 11.0 и округляет результат до ближайшего целого числа. 11.5 следует округлить до 12, используя любое из соглашений о округлениях в середине (ToEven или AwayFromZero). Однако, как показано в выходных данных из примера, это не так. В примере используется строка стандартного числового формата "R" для отображения полной точности значения с плавающей запятой и показывает, что округляемое значение потеряло точность во время повторяющихся сложений и его значение фактически равно 11,499999999998. Поскольку значение .499999999999998 меньше 0,5, соглашения о округлении в середине не вступают в игру, и значение округляется вниз. Как показано в примере, эта проблема не возникает, если присвоить переменной Double значение константы 11,5.

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

    Console.WriteLine();

    value = 11.5;
    RoundValueAndAdd(value);
}

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

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

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

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12
Public Sub Example()
    Dim value As Double = 11.1

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

    value = 11.5
    RoundValueAndAdd(value)
End Sub

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

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

Проблемы с точностью округления значений середины, скорее всего, возникают в следующих условиях:

В случаях, когда отсутствие точности в операциях округления является проблематичным, можно сделать следующее:

  • Если операция округления вызывает перегрузку, округляющую Double значение, можно изменить DoubleDecimal на значение и вызвать перегрузку Decimal , которая округляет значение. Хотя тип Decimal данных также имеет проблемы с представлением и потерей точности, эти проблемы встречаются гораздо реже.

  • Определите пользовательский алгоритм округления, который выполняет "почти равный" тест, чтобы определить, допустимо ли округляемое значение близко к средней точке. В следующем примере определяется RoundApproximate метод, который проверяет, достаточно ли дробное значение близко к значению средней точки для округления в середине. Как показано в выходных данных из примера, она исправляет проблему округления, показанную в предыдущем примере.

    public static void Example()
    {
        Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                          "Value", "Full Precision", "ToEven",
                          "AwayFromZero");
        double value = 11.1;
        for (int ctr = 0; ctr <= 5; ctr++)
            value = RoundValueAndAdd(value);
    
        Console.WriteLine();
    
        value = 11.5;
        RoundValueAndAdd(value);
    }
    
    private static double RoundValueAndAdd(double value)
    {
        const double tolerance = 8e-14;
    
        Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                          value,
                          RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                          RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero));
        return value + .1;
    }
    
    private static double RoundApproximate(double dbl, int digits, double margin,
                                      MidpointRounding mode)
    {
        double fraction = dbl * Math.Pow(10, digits);
        double value = Math.Truncate(fraction);
        fraction = fraction - value;
        if (fraction == 0)
            return dbl;
    
        double tolerance = margin * dbl;
        // Determine whether this is a midpoint value.
        if ((fraction >= .5 - tolerance) & (fraction <= .5 + tolerance))
        {
            if (mode == MidpointRounding.AwayFromZero)
                return (value + 1) / Math.Pow(10, digits);
            else
               if (value % 2 != 0)
                return (value + 1) / Math.Pow(10, digits);
            else
                return value / Math.Pow(10, digits);
        }
        // Any remaining fractional value greater than .5 is not a midpoint value.
        if (fraction > .5)
            return (value + 1) / Math.Pow(10, digits);
        else
            return value / Math.Pow(10, digits);
    }
    
    // The example displays the following output:
    //       Value       Full Precision        ToEven    AwayFromZero
    //
    //        11.1                 11.1            11              11
    //        11.2                 11.2            11              11
    //        11.3   11.299999999999999            11              11
    //        11.4   11.399999999999999            11              11
    //        11.5   11.499999999999998            12              12
    //        11.6   11.599999999999998            12              12
    //
    //        11.5                 11.5            12              12
    
    open System
    
    let roundApproximate dbl digits margin mode =
        let fraction = dbl * Math.Pow(10, digits)
        let value = Math.Truncate fraction
        let fraction = fraction - value
        if fraction = 0 then
            dbl
        else
            let tolerance = margin * dbl
            // Determine whether this is a midpoint value.
            if (fraction >= 0.5 - tolerance) && (fraction <= 0.5 + tolerance) then
                if mode = MidpointRounding.AwayFromZero then
                    (value + 1.) / Math.Pow(10, digits)
                elif value % 2. <> 0 then
                    (value + 1.) / Math.Pow(10, digits)
                else
                    value / Math.Pow(10, digits)
            // Any remaining fractional value greater than .5 is not a midpoint value.
            elif fraction > 0.5 then
                (value + 1.) / Math.Pow(10, digits)
            else
                value / Math.Pow(10, digits)
    
    
    let roundValueAndAdd value =
        let tolerance = 8e-14
        let round = roundApproximate value 0 tolerance
    
        printfn $"{value,5:N1} {value,20:R}  {round MidpointRounding.ToEven,12} {round MidpointRounding.AwayFromZero,15}"
        value + 0.1
    
    printfn "%5s %20s  %12s %15s\n" "Value" "Full Precision" "ToEven" "AwayFromZero"
    let mutable value = 11.1
    for _ = 0 to 5 do
        value <- roundValueAndAdd value
    
    printfn ""
    
    value <- 11.5
    roundValueAndAdd value 
    |> ignore
    
    // The example displays the following output:
    //       Value       Full Precision        ToEven    AwayFromZero
    //
    //        11.1                 11.1            11              11
    //        11.2                 11.2            11              11
    //        11.3   11.299999999999999            11              11
    //        11.4   11.399999999999999            11              11
    //        11.5   11.499999999999998            12              12
    //        11.6   11.599999999999998            12              12
    //
    //        11.5                 11.5            12              12
    
    Public Sub Example()
        Dim value As Double = 11.1
    
        Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                        "Value", "Full Precision", "ToEven",
                        "AwayFromZero")
        For ctr As Integer = 0 To 5
            value = RoundValueAndAdd(value)
        Next
        Console.WriteLine()
    
        value = 11.5
        RoundValueAndAdd(value)
    End Sub
    
    Private Function RoundValueAndAdd(value As Double) As Double
        Const tolerance As Double = 0.00000000000008
        Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                        value,
                        RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                        RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero))
        Return value + 0.1
    End Function
    
    Private Function RoundApproximate(dbl As Double, digits As Integer, margin As Double,
                                     mode As MidpointRounding) As Double
        Dim fraction As Double = dbl * Math.Pow(10, digits)
        Dim value As Double = Math.Truncate(fraction)
        fraction = fraction - value
        If fraction = 0 Then Return dbl
    
        Dim tolerance As Double = margin * dbl
        ' Determine whether this is a midpoint value.
        If (fraction >= 0.5 - tolerance) And (fraction <= 0.5 + tolerance) Then
            If mode = MidpointRounding.AwayFromZero Then
                Return (value + 1) / Math.Pow(10, digits)
            Else
                If value Mod 2 <> 0 Then
                    Return (value + 1) / Math.Pow(10, digits)
                Else
                    Return value / Math.Pow(10, digits)
                End If
            End If
        End If
        ' Any remaining fractional value greater than .5 is not a midpoint value.
        If fraction > 0.5 Then
            Return (value + 1) / Math.Pow(10, digits)
        Else
            Return value / Math.Pow(10, digits)
        End If
    End Function
    
    ' The example displays the following output:
    '       Value       Full Precision        ToEven    AwayFromZero
    '       
    '        11.1                 11.1            11              11
    '        11.2                 11.2            11              11
    '        11.3   11.299999999999999            11              11
    '        11.4   11.399999999999999            11              11
    '        11.5   11.499999999999998            12              12
    '        11.6   11.599999999999998            12              12
    '       
    '        11.5                 11.5            12              12
    

Округление и значения с плавающей запятой с одной точностью

Метод Round включает перегрузки, принимаюющие аргументы типа Decimal и Double. Нет методов, округляющих значения типа Single. Если передать Single значение одной из перегрузок Round метода, оно приводится (в C#) или преобразуется (в Visual Basic) Doubleв и вызывается соответствующая Round перегрузка с параметром Double . Хотя это расширяющее преобразование, оно часто приводит к потере точности, как показано в следующем примере. Single Если значение 16,325 передается методу Round и округляется до двух десятичных знаков с помощью округления до ближайшего соглашения, результат будет равен 16,33, а не ожидаемый результат 16,32.

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

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

// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33
// In F#, 'float', 'float64', and 'double' are aliases for System.Double...
// 'float32' and 'single' are aliases for System.Single
open System

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

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

// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33
Dim value As Single = 16.325
Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ",
                value, value.GetType().Name, CDbl(value),
                CDbl(value).GetType().Name)
Console.WriteLine(Math.Round(value, 2))
Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero))
Console.WriteLine()

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

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

Этот непредвиденный результат связан с потерей точности при преобразовании значения Doubleв Single . Поскольку итоговое Double значение 16,325000762939453 не является средним и больше 16,325, оно всегда округляется вверх.

Во многих случаях, как показано в примере, потерю точности можно свести к минимуму или устранить путем приведения или преобразования значения в SingleDecimal. Обратите внимание, что, так как это сужающее преобразование, требуется использовать оператор приведения или вызвать метод преобразования.

Round(Double, Int32, MidpointRounding)

Исходный код:
Math.cs
Исходный код:
Math.cs
Исходный код:
Math.cs

Округляет значение двойной точности с плавающей запятой до указанного числа дробных цифр, используя указанное соглашение об округлении.

public:
 static double Round(double value, int digits, MidpointRounding mode);
public static double Round (double value, int digits, MidpointRounding mode);
static member Round : double * int * MidpointRounding -> double
Public Shared Function Round (value As Double, digits As Integer, mode As MidpointRounding) As Double

Параметры

value
Double

Округляемое число двойной точности с плавающей запятой.

digits
Int32

Количество дробных разрядов в возвращаемом значении.

mode
MidpointRounding

Одно из значений перечисления, указывающее, какую стратегию округления следует использовать.

Возвращаемое значение

Число с digits дробными цифрами, value округленное до. Если value имеет меньшее количество цифр дробной части, чем digits, то value возвращается без изменений.

Исключения

Параметр digits имеет значение меньше 0 или больше 15.

mode не является допустимым значением MidpointRounding.

Комментарии

Значение аргумента digits может варьироваться от 0 до 15. Максимальное число целых и дробных цифр, поддерживаемых типом Double , равно 15.

Сведения о округлениях чисел со значениями посередине см. в статье Midpoint values and rounding conventions (Соглашения о округлениях по середине).

Важно!

При округлении средних значений алгоритм округления выполняет проверку равенства. Из-за проблем с двоичным представлением и точностью формата с плавающей запятой значение, возвращаемое этим методом, может быть непредвиденным. Дополнительные сведения см. в разделе Округление и точность.

Если аргумент имеет Double.NaNзначение value , метод возвращает Double.NaN. Если value имеет значение Double.PositiveInfinity или Double.NegativeInfinity, метод возвращает Double.PositiveInfinity или Double.NegativeInfinityсоответственно.

Пример

В следующем примере показано, как использовать Round(Double, Int32, MidpointRounding) метод с перечислением MidpointRounding .


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

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

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

// The example displays the following output:

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

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

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

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

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

// The example displays the following output:

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

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

//         -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
//         -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
//         -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)
Dim posValue As Double = 3.45
Dim negValue As Double = -3.45

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

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

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

'This code example produces the following results:

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

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

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

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

Из-за потери точности, которая может быть результатом представления десятичных значений в виде чисел с плавающей запятой или выполнения арифметических операций со значениями с плавающей запятой, в некоторых случаях Round(Double, Int32, MidpointRounding) метод может не округлить значения середины, как указано в параметре mode . Это показано в следующем примере, где 2,135 округляется до 2,13 вместо 2,14. Это происходит потому, что внутри метод умножает value на 10цифр, а операция умножения в этом случае страдает от потери точности.

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

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

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

См. также раздел

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

Round(Decimal, Int32, MidpointRounding)

Исходный код:
Math.cs
Исходный код:
Math.cs
Исходный код:
Math.cs

Округляет десятичное значение до указанного числа дробных цифр, используя указанное соглашение об округлении.

public:
 static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode);
public static decimal Round (decimal d, int decimals, MidpointRounding mode);
static member Round : decimal * int * MidpointRounding -> decimal
Public Shared Function Round (d As Decimal, decimals As Integer, mode As MidpointRounding) As Decimal

Параметры

d
Decimal

Округляемое десятичное число.

decimals
Int32

Количество десятичных разрядов в возвращаемом значении.

mode
MidpointRounding

Одно из значений перечисления, указывающее, какую стратегию округления следует использовать.

Возвращаемое значение

Число с decimals дробными цифрами, округленное d до . Если d имеет меньшее количество цифр дробной части, чем decimals, то d возвращается без изменений.

Исключения

Параметр decimals имеет значение меньше 0 или больше 28.

mode не является допустимым значением MidpointRounding.

Полученное значение находится вне допустимого диапазона типа Decimal.

Комментарии

Сведения о округлениях чисел со значениями посередине см. в статье Midpoint values and rounding conventions (Соглашения о округлениях по середине).

Важно!

При округлении средних значений алгоритм округления выполняет проверку равенства. Из-за проблем с двоичным представлением и точностью формата с плавающей запятой значение, возвращаемое этим методом, может быть непредвиденным. Дополнительные сведения см. в разделе Округление и точность.

Значение аргумента decimals может варьироваться от 0 до 28.

Пример

В следующем примере показано, как использовать Round метод с перечислением MidpointRounding .

decimal result;

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

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

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

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

/*
This code example produces the following results:

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

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
-3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)
*/
// Round a positive value using different strategies.
// The precision of the result is 1 decimal place.

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

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

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

// This code example produces the following results:

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

// -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
// -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
// -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)
Dim result As Decimal = 0D
Dim posValue As Decimal = 3.45D
Dim negValue As Decimal = -3.45D

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

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

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

См. также раздел

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

Round(Double, MidpointRounding)

Исходный код:
Math.cs
Исходный код:
Math.cs
Исходный код:
Math.cs

Округляет значение двойной точности с плавающей запятой до целого числа, используя указанное соглашение об округлении.

public:
 static double Round(double value, MidpointRounding mode);
public static double Round (double value, MidpointRounding mode);
static member Round : double * MidpointRounding -> double
Public Shared Function Round (value As Double, mode As MidpointRounding) As Double

Параметры

value
Double

Округляемое число двойной точности с плавающей запятой.

mode
MidpointRounding

Одно из значений перечисления, указывающее, какую стратегию округления следует использовать.

Возвращаемое значение

Целое число, value округляемое до . Этот метод возвращает Double вместо целочисленного типа.

Исключения

mode не является допустимым значением MidpointRounding.

Комментарии

Сведения о округлениях чисел со значениями посередине см. в статье Midpoint values and rounding conventions (Соглашения о округлениях по середине).

Важно!

При округлении средних значений алгоритм округления выполняет проверку равенства. Из-за проблем с двоичным представлением и точностью формата с плавающей запятой значение, возвращаемое этим методом, может быть непредвиденным. Дополнительные сведения см. в разделе Округление и точность.

Если аргумент имеет Double.NaNзначение value , метод возвращает Double.NaN. Если value имеет значение Double.PositiveInfinity или Double.NegativeInfinity, метод возвращает Double.PositiveInfinity или Double.NegativeInfinityсоответственно.

Пример

В следующем примере отображаются значения, возвращаемые методом Round(Double, MidpointRounding) , с разными mode значениями.

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

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

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

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

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

for value in values do
    $"{value,-10:R} {Math.Round(value),-10} " +
    $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
    $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
    $"{Math.Round(value, MidpointRounding.ToZero),-15}"
    |> printfn "%s"
    
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12         12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13         13         13         13              13
Dim values() As Double = {12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6,
                         12.7, 12.8, 12.9, 13.0}
Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For Each value In values
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

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

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

Из-за потери точности, которая может быть результатом представления десятичных значений в виде чисел с плавающей запятой или выполнения арифметических операций со значениями с плавающей запятой, в некоторых случаях Round(Double, MidpointRounding) метод может не округлить значения середины до ближайшего четного целого числа. В следующем примере, так как значение с плавающей запятой .1 не имеет конечного двоичного представления, первый вызов Round(Double) метода со значением 11,5 возвращает 11 вместо 12.

using System;

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

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

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

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

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12
Module Example
   Public Sub Main()
      Dim value As Double = 11.1
      For ctr As Integer = 0 To 5    
         value = RoundValueAndAdd(value)
      Next
      Console.WriteLine()

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

См. также раздел

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

Round(Double, Int32)

Исходный код:
Math.cs
Исходный код:
Math.cs
Исходный код:
Math.cs

Округляет значение с плавающей запятой двойной точности до указанного числа знаков после запятой; значения посередине округляются до ближайшего четного числа.

public:
 static double Round(double value, int digits);
public static double Round (double value, int digits);
static member Round : double * int -> double
Public Shared Function Round (value As Double, digits As Integer) As Double

Параметры

value
Double

Округляемое число двойной точности с плавающей запятой.

digits
Int32

Количество дробных разрядов в возвращаемом значении.

Возвращаемое значение

Число, ближайшее к параметру value, содержащем количество дробных разрядов, которое равно digits.

Исключения

Параметр digits имеет значение меньше 0 или больше 15.

Комментарии

Значение аргумента digits может варьироваться от 0 до 15. Максимальное число целых и дробных цифр, поддерживаемых типом Double , равно 15.

Этот метод использует соглашение округления по умолчанию для MidpointRounding.ToEven. Сведения о округлениях чисел со значениями посередине см. в статье Midpoint values and rounding conventions (Соглашения о округлениях по середине).

Важно!

При округлении средних значений алгоритм округления выполняет проверку равенства. Из-за проблем с двоичным представлением и точностью формата с плавающей запятой значение, возвращаемое этим методом, может быть непредвиденным. Дополнительные сведения см. в разделе Округление и точность.

Если аргумент имеет Double.NaNзначение value , метод возвращает Double.NaN. Если value имеет значение Double.PositiveInfinity или Double.NegativeInfinity, метод возвращает Double.PositiveInfinity или Double.NegativeInfinityсоответственно.

Пример

В следующем примере двойные значения округляется с двумя дробными цифрами до двойных значений, имеющих одну дробную цифру.

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

Math::Round(4.34, 1); // Returns 4.3
Math::Round(4.35, 1); // Returns 4.4
Math::Round(4.36, 1); // Returns 4.4
Math.Round(3.44, 1); //Returns 3.4.
Math.Round(3.45, 1); //Returns 3.4.
Math.Round(3.46, 1); //Returns 3.5.

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

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

printfn $"{Math.Round(4.34, 1)}" // Returns 4.3
printfn $"{Math.Round(4.35, 1)}" // Returns 4.4
printfn $"{Math.Round(4.36, 1)}" // Returns 4.4
Math.Round(3.44, 1) 'Returns 3.4.
Math.Round(3.45, 1) 'Returns 3.4.
Math.Round(3.46, 1) 'Returns 3.5.

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

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

Из-за потери точности, которая может быть вызвана представлением десятичных значений в виде чисел с плавающей запятой или выполнением арифметических операций со значениями с плавающей запятой, в некоторых случаях Round(Double, Int32) метод не может округлить значения середины до ближайшего четного значения в digits десятичной позиции. Это показано в следующем примере, где 2,135 округляется до 2,13 вместо 2,14. Это происходит потому, что внутри метод умножает value на 10цифр, а операция умножения в этом случае страдает от потери точности.

using System;

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

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

См. также раздел

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

Round(Decimal, Int32)

Исходный код:
Math.cs
Исходный код:
Math.cs
Исходный код:
Math.cs

Округляет десятичное значение до указанного числа знаков после запятой; значения посередине округляются до ближайшего четного числа.

public:
 static System::Decimal Round(System::Decimal d, int decimals);
public static decimal Round (decimal d, int decimals);
static member Round : decimal * int -> decimal
Public Shared Function Round (d As Decimal, decimals As Integer) As Decimal

Параметры

d
Decimal

Округляемое десятичное число.

decimals
Int32

Количество десятичных разрядов в возвращаемом значении.

Возвращаемое значение

Число, ближайшее к параметру d, содержащем количество дробных разрядов, которое равно decimals.

Исключения

Параметр decimals имеет значение меньше 0 или больше 28.

Полученное значение находится вне допустимого диапазона типа Decimal.

Комментарии

Значение аргумента decimals может варьироваться от 0 до 28.

Этот метод использует соглашение округления по умолчанию для MidpointRounding.ToEven. Сведения о округление чисел со значениями середины см. в разделе Значения посередине и соглашения об округлениях.

Важно!

При округлении средних значений алгоритм округления выполняет проверку равенства. Из-за проблем с двоичным представлением и точностью формата с плавающей запятой значение, возвращаемое этим методом, может быть непредвиденным. Дополнительные сведения см. в разделе Округление и точность.

Пример

В следующем примере десятичные значения с двумя дробными цифрами округляется до значений, имеющих одну дробную цифру.

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

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

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

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

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

// The example displays the following output:
//       3.4
//       3.4
//       3.5
//
//       4.3
//       4.4
//       4.4
Console.WriteLine(Math.Round(3.44, 1))
Console.WriteLine(Math.Round(3.45, 1))
Console.WriteLine(Math.Round(3.46, 1))
Console.WriteLine()

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

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

См. также раздел

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

Round(Double)

Исходный код:
Math.cs
Исходный код:
Math.cs
Исходный код:
Math.cs

Округляет значение с плавающей запятой двойной точности до ближайшего целого значения; значения посередине округляются до ближайшего четного числа.

public:
 static double Round(double a);
public static double Round (double a);
static member Round : double -> double
Public Shared Function Round (a As Double) As Double

Параметры

a
Double

Округляемое число двойной точности с плавающей запятой.

Возвращаемое значение

Целое число, ближайшее к значению параметра a. Если дробная часть a находится на равном расстоянии от двух целых чисел (четного и нечетного), возвращается четное число. Обратите внимание, что данный метод возвращает не целочисленное значение, а значение типа Double.

Комментарии

Этот метод использует соглашение округления по умолчанию для MidpointRounding.ToEven. Сведения о округление чисел со значениями середины см. в разделе Значения посередине и соглашения об округлениях.

Важно!

При округлении средних значений алгоритм округления выполняет проверку равенства. Из-за проблем с двоичным представлением и точностью формата с плавающей запятой значение, возвращаемое этим методом, может быть непредвиденным. Дополнительные сведения см. в разделе Округление и точность.

Если аргумент имеет Double.NaNзначение a , метод возвращает Double.NaN. Если a имеет значение Double.PositiveInfinity или Double.NegativeInfinity, метод возвращает Double.PositiveInfinity или Double.NegativeInfinityсоответственно.

Начиная с Visual Basic 15.8, производительность преобразования типа Double в целочисленное значение оптимизирована, если вы передаете значение, возвращаемое методом, в любую из функций целочисленного преобразования или если значение Double, возвращаемое параметром, автоматически преобразуется в целое число с параметром RoundRoundOption Strict, равным Off. Эта оптимизация позволяет коду выполняться быстрее — до двух раз быстрее для кода, который выполняет большое количество преобразований в целочисленные типы. В следующем примере показаны такие оптимизированные преобразования:

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

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

Пример

В следующем примере показано округление до ближайшего целочисленного значения.

using namespace System;

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

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

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

End Module

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

Из-за потери точности, которая может быть результатом представления десятичных значений в виде чисел с плавающей запятой или выполнения арифметических операций со значениями с плавающей запятой, в некоторых случаях Round(Double) метод может не округлить значения середины до ближайшего четного целого числа. В следующем примере, так как значение с плавающей запятой .1 не имеет конечного двоичного представления, первый вызов Round(Double) метода со значением 11,5 возвращает 11 вместо 12.

using System;

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

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

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

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

let mutable value = 11.1

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12
Module Example
   Public Sub Main()
      Dim value As Double = 11.1
      For ctr As Integer = 0 To 5    
         value = RoundValueAndAdd(value)
      Next
      Console.WriteLine()

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

См. также раздел

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

Round(Decimal)

Исходный код:
Math.cs
Исходный код:
Math.cs
Исходный код:
Math.cs

Округляет десятичное значение до ближайшего целого значения; значения посередине округляются до ближайшего четного числа.

public:
 static System::Decimal Round(System::Decimal d);
public static decimal Round (decimal d);
static member Round : decimal -> decimal
Public Shared Function Round (d As Decimal) As Decimal

Параметры

d
Decimal

Округляемое десятичное число.

Возвращаемое значение

Целое число, ближайшее к значению параметра d. Если дробная часть d находится на равном расстоянии от двух целых чисел (четного и нечетного), возвращается четное число. Обратите внимание, что данный метод возвращает не целочисленное значение, а значение типа Decimal.

Исключения

Полученное значение находится вне допустимого диапазона типа Decimal.

Примеры

В следующем примере демонстрируется Round(Decimal) метод. Значение Decimal 4,5 округляется до 4, а не 5, так как эта перегрузка использует соглашение по умолчанию ToEven .

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

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

Комментарии

Этот метод использует соглашение округления по умолчанию для MidpointRounding.ToEven. Сведения о округление чисел со значениями середины см. в разделе Значения посередине и соглашения об округлениях.

Важно!

При округлении средних значений алгоритм округления выполняет проверку равенства. Из-за проблем с двоичным представлением и точностью формата с плавающей запятой значение, возвращаемое этим методом, может быть непредвиденным. Дополнительные сведения см. в разделе Округление и точность.

См. также раздел

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

Round(Decimal, MidpointRounding)

Исходный код:
Math.cs
Исходный код:
Math.cs
Исходный код:
Math.cs

Округляет десятичное значение на целое число, используя указанное соглашение об округлении.

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

Округляемое десятичное число.

mode
MidpointRounding

Одно из значений перечисления, указывающее, какую стратегию округления следует использовать.

Возвращаемое значение

Целое число, d округляемое до . Этот метод возвращает Decimal вместо целочисленного типа.

Исключения

mode не является допустимым значением MidpointRounding.

Полученное значение находится вне допустимого диапазона типа Decimal.

Комментарии

Сведения о округление чисел со значениями середины см. в разделе Значения посередине и соглашения об округлениях.

Важно!

При округлении средних значений алгоритм округления выполняет проверку равенства. Из-за проблем с двоичным представлением и точностью формата с плавающей запятой значение, возвращаемое этим методом, может быть непредвиденным. Дополнительные сведения см. в разделе Округление и точность.

Пример

В следующем примере отображаются значения, возвращаемые методом Round(Decimal, MidpointRounding) , с разными mode значениями.

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

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

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13
Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For value As Decimal = 12D To 13D Step 0.1D
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

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

См. также раздел

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