Math.Round Метод

Определение

Пространство имен:: System

Сборки:: mscorlib.dll, System.Runtime.Extensions.dll

Сборки:: netstandard.dll, System.Runtime.dll

Сборка:: System.Runtime.Extensions.dll

Сборка:: mscorlib.dll

Сборка:: netstandard.dll

Важно!

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

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

Перегрузки

Имя	Описание
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 перегрузке метода.

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

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

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

В середине значения значение после наименьшей значительной цифры в результате составляет примерно полпути между двумя числами. Например, 3.47500 — это среднее значение, если оно округляется до двух десятичных разрядов, а 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 перечисления.

Note

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

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

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

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

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

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

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

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

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

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

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

open System

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Console.WriteLine();

    value = 11.5;
    RoundValueAndAdd(value);
}

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

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

open System

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

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

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

Public Sub Example()
    Dim value As Double = 11.1

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

    value = 11.5
    RoundValueAndAdd(value)
End Sub

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

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

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

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

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

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

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

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

    Console.WriteLine();

    value = 11.5;
    RoundValueAndAdd(value);
}

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

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

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

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

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

open System

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


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

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

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

printfn ""

value <- 11.5
roundValueAndAdd value 
|> ignore

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

Public Sub Example()
    Dim value As Double = 11.1

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

    value = 11.5
    RoundValueAndAdd(value)
End Sub

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Round(Double, Int32, MidpointRounding)

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

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

Исходный код:: 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

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

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

Double

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

Исключения

ArgumentOutOfRangeException

digits меньше 0 или больше 15.

ArgumentException

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

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

Если аргумент имеет значение valueDouble.NaN, метод возвращает 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

Исходный код:: 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

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

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

Decimal

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

Исключения

ArgumentOutOfRangeException

decimals меньше 0 или больше 28.

ArgumentException

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

OverflowException

Результат находится за пределами Decimalдиапазона.

Пример

В следующем примере показано, как использовать 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

Исходный код:: 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

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

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

Double

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

Исключения

ArgumentException

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

Пример

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

Исходный код:: 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

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

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

Double

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

Исключения

ArgumentOutOfRangeException

digits меньше 0 или больше 15.

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

Это важно

Пример

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

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

Исходный код:: 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

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

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

Decimal

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

Исключения

ArgumentOutOfRangeException

decimals меньше 0 или больше 28.

OverflowException

Результат находится за пределами Decimalдиапазона.

Этот метод использует соглашение 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

Исходный код:: 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

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

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

Double

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

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

Начиная с Visual Basic 15.8 производительность преобразования double-to-integer оптимизирована при передаче значения, возвращаемого методом Round любому из функций преобразования integral преобразования, или значение Double, возвращаемое Round, автоматически преобразуется в целое число с Option 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

Пример

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

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

Исходный код:: 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

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

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

Decimal

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

Исключения

OverflowException

Результат находится за пределами 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

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

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

Round(Decimal, MidpointRounding)

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

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

Исходный код:: 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

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

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

Decimal

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

Исключения

ArgumentException

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

OverflowException

Результат находится за пределами 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

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

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

Кері байланыс

Бет пайдалы болды ма?

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)

Параметры

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

Исключения

Комментарии

Пример

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

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

Кері байланыс