Math.Round Método

Definição

Arredonda um valor para o inteiro mais próximo ou para o número especificado de casas decimais.

Sobrecargas

Round(Double, Int32, MidpointRounding)

Arredonda um valor de ponto flutuante de precisão dupla para um número especificado de dígitos fracionários usando a convenção de arredondamento especificada.

Round(Decimal, Int32, MidpointRounding)

Arredonda um valor decimal para um número especificado de dígitos fracionários usando a convenção de arredondamento especificada.

Round(Double, MidpointRounding)

Arredonda um valor de ponto flutuante de precisão dupla para um inteiro usando a convenção de arredondamento especificada.

Round(Double, Int32)

Arredonda um valor de ponto flutuante de precisão dupla para o número especificado de dígitos fracionários e arredonda os valores de ponto médio para o número par mais próximo.

Round(Decimal, Int32)

Arredonda um valor decimal para o número especificado de dígitos fracionários e arredonda os valores de ponto médio para o número par mais próximo.

Round(Double)

Arredonda um valor de ponto flutuante de precisão dupla para o valor inteiro mais próximo e arredonda os valores de ponto médio para o número par mais próximo.

Round(Decimal)

Arredonda um valor decimal para o valor inteiro mais próximo e arredonda os valores de ponto médio para o número par mais próximo.

Round(Decimal, MidpointRounding)

Arredonda um valor decimal de um inteiro usando a convenção de arredondamento especificada.

Exemplos

Além dos exemplos na seção Comentários , este artigo inclui exemplos que ilustram as seguintes sobrecargas do Math.Round método:

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)

Comentários

Nesta seção:

Qual método devo chamar?

Você pode usar a tabela a seguir para selecionar um método de arredondamento apropriado. Além dos Math.Round métodos, ele também inclui Math.Ceiling e Math.Floor.

Para Chamar
Arredondar um número para um inteiro usando a convenção arredondando para a mais próxima. Round(Decimal)
- ou -
Round(Double)
Arredondar um número para um inteiro usando uma convenção de arredondamento especificada. Round(Decimal, MidpointRounding)
- ou -
Round(Double, MidpointRounding)
Arredondar um número para um número especificado de dígitos fracionários usando o arredondamento para a convenção mais próxima. Round(Decimal, Int32)
- ou -
Round(Double, Int32)
Arredondar um número para um número especificado de dígitos fracionários usando uma convenção de arredondamento especificada. Round(Decimal, Int32, MidpointRounding)
- ou -
Round(Double, Int32, MidpointRounding)
Arredondar um Single valor para um número especificado de dígitos fracionários usando uma convenção de arredondamento especificada e minimizando a perda de precisão. Converter em Single um Decimal e chamar Round(Decimal, Int32, MidpointRounding).
Arredondar um número para um número especificado de dígitos fracionários, minimizando problemas de precisão em valores de ponto médio arredondados. Chame um método de arredondamento que implemente uma comparação "maior ou aproximadamente igual a". Consulte Arredondamento e precisão.
Arredondar um valor fracionário para um inteiro maior que o valor fracionário. Por exemplo, round 3.1 a 4. Ceiling
Arredondar um valor fracionário para um inteiro menor que o valor fracionário. Por exemplo, round 3.9 a 3. Floor

Valores de ponto médio e convenções arredondamento

O arredondamento envolve a conversão de um valor numérico com uma precisão especificada em um valor com menos precisão. Por exemplo, você pode usar o Round(Double) método para arredondar um valor de 3.4 a 3.0 e o Round(Double, Int32) método para arredondar um valor de 3.579 a 3.58.

Em um valor de ponto médio, o valor após o dígito menos significativo no resultado é precisamente a metade entre dois números. Por exemplo, 3,47500 é um valor de ponto médio se for arredondado para duas casas decimais, e 7,500 é um valor de ponto médio se for arredondado para um inteiro. Nesses casos, se a estratégia arredondar para mais próxima for usada, o valor mais próximo não poderá ser identificado facilmente sem uma convenção de arredondamento.

O Round método dá suporte a duas convenções de arredondamento para lidar com valores de ponto médio:

  • Arredondando para longe de zero

    Os valores de ponto médio são arredondados para o próximo número longe de zero. Por exemplo, 3,75 arredonda para 3,8, 3,85 arredonda para 3,9, -3,75 arredonda para -3,8 e -3,85 arredonda para -3,9. Essa forma de arredondamento é representada pelo membro de MidpointRounding.AwayFromZero enumeração.

  • Arredondando para o par mais próximo, ou arredondamento do banqueiro

    Os valores de ponto médio são arredondados para o número par mais próximo. Por exemplo, 3,75 e 3,85 arredondam para 3,8 e -3,75 e -3,85 arredondam para -3,8. Essa forma de arredondamento é representada pelo membro de MidpointRounding.ToEven enumeração.

Observação

No .NET Core 3.0 e versões posteriores, três estratégias de arredondamento adicionais estão disponíveis por meio da MidpointRounding enumeração. Essas estratégias são usadas em todos os casos, não apenas para valores de ponto médio como MidpointRounding.ToEven e MidpointRounding.AwayFromZero são.

Arredondar para longe de zero é a forma mais conhecida de arredondamento, enquanto arredondar para o par mais próximo é o padrão em operações financeiras e estatísticas. Ele está em conformidade com o IEEE Standard 754, seção 4. Quando usado em várias operações de arredondamento, arredondar para o mais próximo reduz até mesmo o erro de arredondamento causado pelo arredondamento consistente de valores de ponto médio em uma única direção. Em alguns casos, esse erro de arredondamento pode ser significativo.

O exemplo a seguir ilustra o viés que pode resultar do arredondamento consistente de valores de ponto médio em uma única direção. O exemplo calcula a verdadeira média de uma matriz de Decimal valores e calcula a média quando os valores na matriz são arredondados usando as duas convenções. Neste exemplo, a média verdadeira e a média que resulta ao arredondar para o mais próximo são as mesmas. No entanto, a média que resulta ao arredondar para longe de zero é diferente de 0,05 (ou 3,6%) da média verdadeira.

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

Por padrão, o Round método usa a convenção de ida e volta para a par mais próxima. A tabela a seguir lista as sobrecargas do Round método e a convenção de arredondamento que cada um usa.

Sobrecarga Convenção de arredondamento
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) Determinado por mode parâmetro.
Round(Double, MidpointRounding) Determinado pelo parâmetro mode
Round(Decimal, Int32, MidpointRounding) Determinado pelo parâmetro mode
Round(Double, Int32, MidpointRounding) Determinado pelo parâmetro mode

Arredondamento e precisão

Para determinar se uma operação de arredondamento envolve um valor de ponto médio, o Round método multiplica o valor original a ser arredondado por 10 n, onde n é o número desejado de dígitos fracionários no valor retornado e determina se a parte fracionária restante do valor é maior ou igual a 0,5. Essa é uma pequena variação em um teste de igualdade e, conforme discutido na seção "Test for Equality" do tópico de referência, os Double testes de igualdade com valores de ponto flutuante são problemáticos devido aos problemas do formato de ponto flutuante com representação binária e precisão. Isso significa que qualquer parte fracionária de um número que seja ligeiramente menor que 0,5 (devido a uma perda de precisão) não será arredondada para cima.

O exemplo a seguir ilustra o problema. Ele adiciona repetidamente .1 a 11.0 e arredonda o resultado para o inteiro mais próximo. 11,5 deve arredondar para 12 usando qualquer uma das convenções de arredondamento de ponto médio (ToEven ou AwayFromZero). No entanto, como mostra a saída do exemplo, ela não. O exemplo usa a cadeia de caracteres de formato numérico padrão "R" para exibir a precisão total do valor do ponto flutuante e mostra que o valor a ser arredondado perdeu precisão durante as adições repetidas e seu valor é, na verdade, 11,499999999998. Como .499999999999998 é menor que .5, as convenções de arredondamento de ponto médio não entram em jogo e o valor é arredondado para baixo. Como o exemplo também mostra, esse problema não ocorrerá se você atribuir o valor constante 11.5 a uma Double variável.

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

Os problemas de precisão nos valores de ponto médio de arredondamento são mais propensos a surgir nas seguintes condições:

  • Quando um valor fracionário não pode ser expresso precisamente no formato binário do tipo de ponto flutuante.

  • Quando o valor a ser arredondado é calculado de uma ou mais operações de ponto flutuante.

  • Quando o valor a ser arredondado é um Single em vez de um Double ou Decimal. Para obter mais informações, consulte a próxima seção, arredondamento e valores de ponto flutuante de precisão única.

Nos casos em que a falta de precisão nas operações de arredondamento é problemática, você pode fazer o seguinte:

  • Se a operação de arredondamento chamar uma sobrecarga que arredonda um Double valor, você poderá alterar o Double valor para um Decimal valor e chamar uma sobrecarga que arredonda um Decimal valor em vez disso. Embora o Decimal tipo de dados também tenha problemas de representação e perda de precisão, esses problemas são muito menos comuns.

  • Defina um algoritmo de arredondamento personalizado que executa um teste "quase igual" para determinar se o valor a ser arredondado é aceito perto de um valor de ponto médio. O exemplo a seguir define um RoundApproximate método que examina se um valor fracionário está suficientemente próximo a um valor de ponto médio para estar sujeito ao arredondamento de ponto médio. Como mostra a saída do exemplo, ela corrige o problema de arredondamento mostrado no exemplo anterior.

    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
    

Arredondamento e valores de ponto flutuante de precisão simples

O Round método inclui sobrecargas que aceitam argumentos de tipo Decimal e Double. Não há métodos que arredondam valores do tipo Single. Se você passar um Single valor para uma das sobrecargas do Round método, ele será convertido (em C#) ou convertido (no Visual Basic) em um Double, e a sobrecarga correspondente Round com um Double parâmetro será chamada. Embora essa seja uma conversão de ampliação, geralmente envolve uma perda de precisão, como ilustra o exemplo a seguir. Quando um Single valor de 16.325 é passado para o Round método e arredondado para duas casas decimais usando o arredondamento para a convenção mais próxima, o resultado é 16,33 e não o resultado esperado de 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

Esse resultado inesperado ocorre devido a uma perda de precisão na conversão do Single valor em um Double. Como o valor resultante Double de 16,325000762939453 não é um valor de ponto médio e é maior que 16,325, ele é sempre arredondado para cima.

Em muitos casos, como ilustra o exemplo, a perda de precisão pode ser minimizada ou eliminada pela conversão ou conversão do Single valor em um Decimal. Observe que, como essa é uma conversão de estreitamento, ela requer o uso de um operador de conversão ou a chamada de um método de conversão.

Round(Double, Int32, MidpointRounding)

Arredonda um valor de ponto flutuante de precisão dupla para um número especificado de dígitos fracionários usando a convenção de arredondamento especificada.

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

Parâmetros

value
Double

Um número de ponto flutuante de precisão dupla a ser arredondado.

digits
Int32

O número de dígitos fracionários no valor de retorno.

mode
MidpointRounding

Um dos valores de enumeração que especifica qual estratégia de arredondamento usar.

Retornos

Double

O número que tem digits dígitos fracionários arredondados value para. Se value tiver menos dígitos fracionários que digits, value será retornado inalterado.

Exceções

digits é menor que 0 ou maior que 15.

mode não é um valor válido de MidpointRounding.

Comentários

O valor do digits argumento pode variar de 0 a 15. O número máximo de dígitos integrais e fracionários com suporte pelo Double tipo é 15.

Consulte valores de ponto médio e convenções de arredondamento para obter informações sobre como arredondar números com valores de ponto médio.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade. Devido a problemas de representação binária e precisão no formato do ponto flutuante, o valor retornado pelo método pode ser inesperado. Para obter mais informações, consulte Arredondamento e precisão.

Se o valor do value argumento for Double.NaN, o método retornará Double.NaN. Se value for Double.PositiveInfinity ou Double.NegativeInfinity, o método retornará Double.PositiveInfinity ou Double.NegativeInfinity, respectivamente.

Exemplo

O exemplo a seguir demonstra como usar o Round(Double, Int32, MidpointRounding) método com a MidpointRounding enumeração.


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

Notas aos Chamadores

Devido à perda de precisão que pode resultar da representação de valores decimais como números de ponto flutuante ou da execução de operações aritméticas em valores de ponto flutuante, em alguns casos o Round(Double, Int32, MidpointRounding) método pode não parecer arredondar valores de ponto médio conforme especificado pelo mode parâmetro. Isso é ilustrado no exemplo a seguir, em que 2.135 é arredondado para 2.13 em vez de 2.14. Isso ocorre porque internamente o método multiplica-se value por 10dígitos e a operação de multiplicação nesse caso sofre de uma perda de precisão.

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

Confira também

Aplica-se a

Round(Decimal, Int32, MidpointRounding)

Arredonda um valor decimal para um número especificado de dígitos fracionários usando a convenção de arredondamento especificada.

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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.

decimals
Int32

O número de casas decimais no valor retornado.

mode
MidpointRounding

Um dos valores de enumeração que especifica qual estratégia de arredondamento usar.

Retornos

Decimal

O número com decimals dígitos fracionários arredondados d para. Se d tiver menos dígitos fracionários que decimals, d será retornado inalterado.

Exceções

decimals é menor que 0 ou maior que 28.

mode não é um valor válido de MidpointRounding.

O resultado é fora do intervalo de um Decimal.

Comentários

Consulte valores de ponto médio e convenções de arredondamento para obter informações sobre como arredondar números com valores de ponto médio.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade. Devido a problemas de representação binária e precisão no formato do ponto flutuante, o valor retornado pelo método pode ser inesperado. Para obter mais informações, consulte Arredondamento e precisão.

O valor do decimals argumento pode variar de 0 a 28.

Exemplo

O exemplo a seguir demonstra como usar o Round método com a MidpointRounding enumeração.

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

Confira também

Aplica-se a

Round(Double, MidpointRounding)

Arredonda um valor de ponto flutuante de precisão dupla para um inteiro usando a convenção de arredondamento especificada.

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

Parâmetros

value
Double

Um número de ponto flutuante de precisão dupla a ser arredondado.

mode
MidpointRounding

Um dos valores de enumeração que especifica qual estratégia de arredondamento usar.

Retornos

Double

O inteiro que value é arredondado para. Esse método retorna um Double tipo integral em vez de um tipo integral.

Exceções

mode não é um valor válido de MidpointRounding.

Comentários

Consulte valores de ponto médio e convenções de arredondamento para obter informações sobre como arredondar números com valores de ponto médio.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade. Devido a problemas de representação binária e precisão no formato do ponto flutuante, o valor retornado pelo método pode ser inesperado. Para obter mais informações, consulte Arredondamento e precisão.

Se o valor do value argumento for Double.NaN, o método retornará Double.NaN. Se value for Double.PositiveInfinity ou Double.NegativeInfinity, o método retornará Double.PositiveInfinity ou Double.NegativeInfinity, respectivamente.

Exemplo

O exemplo a seguir exibe valores retornados pelo Round(Double, MidpointRounding) método com valores diferentes 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

Notas aos Chamadores

Devido à perda de precisão que pode resultar da representação de valores decimais como números de ponto flutuante ou da execução de operações aritméticas em valores de ponto flutuante, em alguns casos o Round(Double, MidpointRounding) método pode não parecer arredondar valores de ponto médio para o inteiro par mais próximo. No exemplo a seguir, como o valor de ponto flutuante .1 não tem representação binária finita, a primeira chamada para o Round(Double) método com um valor de 11,5 retorna 11 em vez de 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

Confira também

Aplica-se a

Round(Double, Int32)

Arredonda um valor de ponto flutuante de precisão dupla para o número especificado de dígitos fracionários e arredonda os valores de ponto médio para o número par mais próximo.

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

Parâmetros

value
Double

Um número de ponto flutuante de precisão dupla a ser arredondado.

digits
Int32

O número de dígitos fracionários no valor de retorno.

Retornos

Double

O número mais próximo de value que contém um número de dígitos fracionários igual a digits.

Exceções

digits é menor que 0 ou maior que 15.

Comentários

O valor do digits argumento pode variar de 0 a 15. O número máximo de dígitos integrais e fracionários suportados pelo Double tipo é 15.

Esse método usa a convenção de arredondamento padrão de MidpointRounding.ToEven. Consulte valores de ponto médio e convenções de arredondamento para obter informações sobre como arredondar números com valores de ponto médio.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade. Devido a problemas de representação binária e precisão no formato do ponto flutuante, o valor retornado pelo método pode ser inesperado. Para obter mais informações, consulte Arredondamento e precisão.

Se o valor do value argumento for Double.NaN, o método retornará Double.NaN. Se value for Double.PositiveInfinity ou Double.NegativeInfinity, o método retornará Double.PositiveInfinity ou Double.NegativeInfinity, respectivamente.

Exemplo

O exemplo a seguir arredonda valores duplos com dois dígitos fracionários para duplos que têm um único dígito fracionário.

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

Notas aos Chamadores

Devido à perda de precisão que pode resultar da representação de valores decimais como números de ponto flutuante ou execução de operações aritméticas em valores de ponto flutuante, em alguns casos o Round(Double, Int32) método pode não parecer arredondar valores de ponto médio para o valor par mais próximo na digits posição decimal. Isso é ilustrado no exemplo a seguir, em que 2.135 é arredondado para 2.13 em vez de 2.14. Isso ocorre porque internamente o método multiplica value por 10dígitos e a operação de multiplicação nesse caso sofre com perda de precisão.

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

Confira também

Aplica-se a

Round(Decimal, Int32)

Arredonda um valor decimal para o número especificado de dígitos fracionários e arredonda os valores de ponto médio para o número par mais próximo.

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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.

decimals
Int32

O número de casas decimais no valor retornado.

Retornos

Decimal

O número mais próximo de d que contém um número de dígitos fracionários igual a decimals.

Exceções

decimals é menor que 0 ou maior que 28.

O resultado é fora do intervalo de um Decimal.

Comentários

O valor do decimals argumento pode variar de 0 a 28.

Esse método usa a convenção de arredondamento padrão de MidpointRounding.ToEven. Para obter informações sobre como arredondar números com valores de ponto médio, consulte valores de ponto médio e convenções de arredondamento.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade. Devido a problemas de representação binária e precisão no formato do ponto flutuante, o valor retornado pelo método pode ser inesperado. Para obter mais informações, consulte Arredondamento e precisão.

Exemplo

O exemplo a seguir arredonda valores decimais com dois dígitos fracionários para valores que têm um único dígito fracionário.

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

Confira também

Aplica-se a

Round(Double)

Arredonda um valor de ponto flutuante de precisão dupla para o valor inteiro mais próximo e arredonda os valores de ponto médio para o número par mais próximo.

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

Parâmetros

a
Double

Um número de ponto flutuante de precisão dupla a ser arredondado.

Retornos

Double

O inteiro mais próximo de a. Se o componente fracionário de a estiver entre dois inteiros, sendo um deles par e o outro ímpar, o número par será retornado. Observe que esse método retorna um Double em vez de um tipo integral.

Comentários

Esse método usa a convenção de arredondamento padrão de MidpointRounding.ToEven. Para obter informações sobre como arredondar números com valores de ponto médio, consulte valores de ponto médio e convenções de arredondamento.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade. Devido a problemas de representação binária e precisão no formato do ponto flutuante, o valor retornado pelo método pode ser inesperado. Para obter mais informações, consulte Arredondamento e precisão.

Se o valor do a argumento for Double.NaN, o método retornará Double.NaN. Se a for Double.PositiveInfinity ou Double.NegativeInfinity, o método retornará Double.PositiveInfinity ou Double.NegativeInfinity, respectivamente.

A partir do Visual Basic 15.8, o desempenho da conversão de duplo para inteiro será otimizado se você passar o valor retornado pelo Round método para qualquer uma das funções de conversão integral ou se o valor Duplo retornado for Round convertido automaticamente em um inteiro com Option Strict definido como Desativado. Essa otimização permite que o código seja executado mais rapidamente – até duas vezes mais rápido para o código que faz um grande número de conversões para tipos de inteiro. O exemplo a seguir ilustra essas conversões otimizadas:

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

Exemplo

O exemplo a seguir demonstra arredondamento para o valor inteiro mais próximo.

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

Notas aos Chamadores

Devido à perda de precisão que pode resultar da representação de valores decimais como números de ponto flutuante ou da execução de operações aritméticas em valores de ponto flutuante, em alguns casos o Round(Double) método pode não parecer arredondar valores de ponto médio para o inteiro par mais próximo. No exemplo a seguir, como o valor de ponto flutuante .1 não tem representação binária finita, a primeira chamada para o Round(Double) método com um valor de 11,5 retorna 11 em vez de 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

Confira também

Aplica-se a

Round(Decimal)

Arredonda um valor decimal para o valor inteiro mais próximo e arredonda os valores de ponto médio para o número par mais próximo.

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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.

Retornos

Decimal

O inteiro mais próximo do parâmetro d. Se o componente fracionário de d estiver entre dois inteiros, sendo um deles par e o outro ímpar, o número par será retornado. Observe que esse método retorna um Decimal em vez de um tipo integral.

Exceções

O resultado é fora do intervalo de um Decimal.

Exemplos

O exemplo a seguir demonstra o Round(Decimal) método. O Decimal valor de 4,5 arredonda para 4 em vez de 5, pois essa sobrecarga usa a convenção padrão 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

Comentários

Esse método usa a convenção de arredondamento padrão de MidpointRounding.ToEven. Para obter informações sobre como arredondar números com valores de ponto médio, consulte valores de ponto médio e convenções de arredondamento.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade. Devido a problemas de representação binária e precisão no formato do ponto flutuante, o valor retornado pelo método pode ser inesperado. Para obter mais informações, consulte Arredondamento e precisão.

Confira também

Aplica-se a

Round(Decimal, MidpointRounding)

Arredonda um valor decimal de um inteiro usando a convenção de arredondamento especificada.

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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.

mode
MidpointRounding

Um dos valores de enumeração que especifica qual estratégia de arredondamento usar.

Retornos

Decimal

O inteiro que d é arredondado para. Esse método retorna um Decimal tipo integral em vez de um tipo integral.

Exceções

mode não é um valor válido de MidpointRounding.

O resultado é fora do intervalo de um Decimal.

Comentários

Para obter informações sobre como arredondar números com valores de ponto médio, consulte valores de ponto médio e convenções de arredondamento.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade. Devido a problemas de representação binária e precisão no formato do ponto flutuante, o valor retornado pelo método pode ser inesperado. Para obter mais informações, consulte Arredondamento e precisão.

Exemplo

O exemplo a seguir exibe valores retornados pelo Round(Decimal, MidpointRounding) método com valores diferentes 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

Confira também

Aplica-se a