Math.Round Método

Definição

Espaço de Nomes:: System

Assemblagens:: mscorlib.dll, System.Runtime.Extensions.dll

Assemblagens:: netstandard.dll, System.Runtime.dll

Assemblagem:: System.Runtime.Extensions.dll

Assemblagem:: mscorlib.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Arredonda um valor para o número inteiro mais próximo ou para o número especificado de dígitos fracionários.

Sobrecargas

Name	Description
Round(Double, Int32, MidpointRounding)	Arredonda um valor de ponto flutuante de dupla precisão 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 dupla precisão para um inteiro usando a convenção de arredondamento especificada.
Round(Double, Int32)	Arredonda um valor de ponto flutuante de precisão dupla para um número especificado de dígitos fracionários, e arredonda valores do ponto médio para o número par mais próximo.
Round(Decimal, Int32)	Arredonda um valor decimal para um número especificado de dígitos fracionários, e arredonda valores do ponto médio para o número par mais próximo.
Round(Double)	Arredonda um valor de ponto flutuante de dupla precisão ao valor integral mais próximo, e arredonda valores do ponto médio ao número par mais próximo.
Round(Decimal)	Arredonda um valor decimal para o valor integral mais próximo e arredonda valores do ponto médio para o número par mais próximo.
Round(Decimal, MidpointRounding)	Arredonda um valor decimal um inteiro usando a convenção de arredondamento especificada.

Exemplos

Para além dos exemplos na secção de Observações , este artigo inclui exemplos que ilustram as seguintes sobrecargas do Math.Round método:

Ronda.Matemática(Decimal)Ronda.Matemática(Duplo)Ronda.Matemática(Decimal, Int32)Ronda.Matemática(Decimal, Arredondamento Médio)Ronda.Matemática(Duplo, Int32)Ronda.Matemática(Duplo, Arredondamento Médio)Ronda.Matemática(Decimal, Int32, Arredondamento Médio)Ronda.Matemática(Duplo, Int32, Arredondamento Médio)

Observações

Nesta secção:

Que método devo usar?
Valores do ponto médio e convenções de arredondamento
Arredondamento e precisão
Arredondamento e valores de ponto flutuante de precisão simples
Exemplos de sobrecargas individuais

Que método devo chamar?

Pode usar a tabela seguinte para selecionar um método de arredondamento apropriado. Para além dos Math.Round métodos, inclui Math.Ceiling também e Math.Floor.

Para	Call
Arredonda um número para um inteiro usando a convenção de arredondar para o mais próximo.	Round(Decimal) -ou- Round(Double)
Arredonda um número para um inteiro usando uma convenção de arredondamento especificada.	Round(Decimal, MidpointRounding) -ou- Round(Double, MidpointRounding)
Arredonda 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)
Arredonda 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 o Single para a 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 ao arredondar valores do ponto médio.	Chama-se um método de arredondamento que implementa uma comparação "maior que ou aproximadamente igual a". Ver Arredondamento e precisão.
Arredonda-se um valor fracionário para um inteiro que seja maior do que o valor fracionário. Por exemplo, as rondas 3.1 a 4.	Ceiling
Arredonda-se um valor fracionário para um inteiro que seja inferior ao valor fracionário. Por exemplo, rondas 3.9 a 3.	Floor

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

Arredondar envolve converter um valor numérico com uma precisão especificada para um valor com menor precisão. Por exemplo, pode usar o Round(Double) método para arredondar um valor de 3,4 para 3,0, e o Round(Double, Int32) método para arredondar um valor de 3,579 para 3,58.

Num valor de ponto médio, o valor após o dígito menos significativo do resultado está precisamente a meio caminho 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. Nestes casos, se for usada a estratégia de arredondar para o mais próximo, o valor mais próximo não pode ser facilmente identificado sem uma convenção de arredondamento.

O Round método suporta duas convenções de arredondamento para lidar com valores de ponto médio:

Arredondando a partir do zero

Os valores do ponto médio são arredondados para o número seguinte a partir de zero. Por exemplo, 3,75 rodadas para 3,8, 3,85 para 3,9, -3,75 para -3,8 e -3,85 para -3,9. Esta forma de arredondamento é representada pelo MidpointRounding.AwayFromZero membro de enumeração.
Arredondando para o par mais próximo, ou arredondamento do banqueiro

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

Note

Nas versões .NET Core 3.0 e posteriores, estão disponíveis três estratégias adicionais de arredondamento através da enumeração MidpointRounding. Estas 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 a partir de zero é a forma de arredondamento mais conhecida, enquanto arredondar para o mais próximo par é o padrão em operações financeiras e estatísticas. Está em conformidade com a Norma IEEE 754, secção 4. Quando usado em operações de arredondamento múltiplo, arredondar para o mais próximo ainda reduz o erro de arredondamento causado pelo arredondamento consistente dos valores do ponto médio numa única direção. Em alguns casos, este erro de arredondamento pode ser significativo.

O exemplo seguinte ilustra o viés que pode resultar de arredondar consistentemente os valores do ponto médio numa única direção. O exemplo calcula a média verdadeira de um array de Decimal valores e depois calcula a média quando os valores do array 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 a partir de zero difere em 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 defeito, o Round método usa a convenção de arredondar para o mais próximo par. A tabela seguinte lista as sobrecargas do Round método e a convenção de arredondamento que cada um utiliza.

Overload	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 `mode` parâmetro
Round(Decimal, Int32, MidpointRounding)	Determinado pelo `mode` parâmetro
Round(Double, Int32, MidpointRounding)	Determinado pelo `mode` parâmetro

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 arredondar por 10ⁿ, onde n é o número desejado de dígitos fracionários no valor de retorno, e depois determina se a porção fracionária restante do valor é maior ou igual a 0,5. Esta é uma ligeira variação de um teste de igualdade e, como discutido na secção "Testar a Igualdade" do Double tópico de referência, os 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. Isto significa que qualquer fração de um número que seja ligeiramente inferior a 0,5 (devido à perda de precisão) não será arredondada para cima.

O exemplo a seguir ilustra o problema. Adiciona repetidamente 0,1 a 11,0 e arredonda o resultado para o número inteiro mais próximo. 11,5 deve arredondar para 12 usando qualquer uma das convenções de arredondamento do ponto médio (ToEven ou AwayFromZero). No entanto, como mostra o resultado do exemplo, não o faz. O exemplo utiliza a cadeia numérica padrão "R" para mostrar a precisão total do valor do ponto flutuante e mostra que o valor a arredondar perdeu precisão durante adições repetidas, sendo que o seu valor é na verdade 11,499999999999999998. Como .499999999999998 é inferior a 0,5, as convenções de arredondamento do ponto médio não entram em jogo e o valor é arredondado para baixo. Como o exemplo também mostra, este problema não ocorre se 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

Problemas de precisão no arredondamento dos valores do ponto médio são mais prováveis de 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 arredondar é calculado a partir de uma ou mais operações de ponto flutuante.
Quando o valor a arredondar é a Single em vez de a Double ou Decimal. Para mais informações, consulte a secção seguinte, Arredondamento e valores de ponto flutuante de precisão simples.

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

Se a operação de arredondamento chamar uma sobrecarga que arredonda um Double valor, pode mudar o Double para um Decimal valor e chamar uma sobrecarga que arredonda um Decimal valor em vez disso. Embora o Decimal tipo de dado também tenha problemas de representação e perda de precisão, estes problemas são muito menos comuns.

Defina um algoritmo de arredondamento personalizado que realize um teste "quase igual" para determinar se o valor a arredondar está aceitivelmente próximo de um valor do ponto médio. O exemplo seguinte define um RoundApproximate método que examina se um valor fracionário está suficientemente próximo de um valor do ponto médio para estar sujeito a arredondamento do ponto médio. Como mostra o resultado do exemplo, 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 do tipo Decimal e Double. Não existem métodos que arredondam valores do tipo Single. Se passar um valor Single a uma das sobrecargas do método Round, ele é cast (em C#) ou convertido (em Visual Basic) num Double, e a correspondente sobrecarga Round com um parâmetro Double é chamada. Embora esta seja uma conversão de alargamento, muitas vezes implica uma perda de precisão, como ilustra o exemplo seguinte. Quando um Single valor de 16,325 é passado ao 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

Este resultado inesperado deve-se a uma perda de precisão na conversão do Single valor para um Double. Como o valor resultante Double de 16,325000762939453 não é um valor de ponto médio e é superior a 16,325, é sempre arredondado para cima.

Em muitos casos, como o exemplo ilustra, a perda de precisão pode ser minimizada ou eliminada fundindo ou convertendo o Single valor para um Decimal. Note-se que, por se tratar de uma conversão de estreito, requer o uso de um operador cast ou chamar um método de conversão.

Round(Double, Int32, MidpointRounding)

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Arredonda um valor de ponto flutuante de dupla precisão 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 dupla precisão a arredondar.

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.

Devoluções

Double

O número que tem digits dígitos fracionários que value é arredondado para. Se value tiver menos dígitos fracionários do que digits, value é devolvido inalterado.

Exceções

ArgumentOutOfRangeException

digits é inferior a 0 ou superior a 15.

ArgumentException

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

Observações

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

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

Importante

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

Se o valor do value argumento for Double.NaN, o método devolve Double.NaN. Se value for Double.PositiveInfinity ou Double.NegativeInfinity, o método devolve Double.PositiveInfinity ou Double.NegativeInfinity, respetivamente.

Example

O exemplo seguinte 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 para Chamadores

Devido à perda de precisão que pode resultar de representar valores decimais como números de vírgula flutuante ou de realizar operações aritméticas em valores de vírgula 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. Isto é ilustrado no exemplo seguinte, onde 2,135 é arredondado para 2,13 em vez de 2,14. Isto ocorre porque, internamente, o método multiplica value por 10^dígitos, e a operação de multiplicação neste caso sofre de 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

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

Ver também

Aplica-se a

Round(Decimal, Int32, MidpointRounding)

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

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

decimals: Int32

O número de casas decimais no valor de retorno.

mode: MidpointRounding

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

Devoluções

Decimal

O número com decimals dígitos fracionários que d é arredondado para. Se d tiver menos dígitos fracionários do que decimals, d é devolvido inalterado.

Exceções

ArgumentOutOfRangeException

decimals é inferior a 0 ou superior a 28.

ArgumentException

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

OverflowException

O resultado está fora do intervalo de um Decimal.

Observações

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

Importante

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

Example

O exemplo seguinte 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)
'

Ver também

Aplica-se a

Round(Double, MidpointRounding)

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Arredonda um valor de ponto flutuante de dupla precisão 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 dupla precisão a arredondar.

mode: MidpointRounding

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

Devoluções

Double

O inteiro arredondado value para. Este método devolve um Double tipo em vez de inteiro.

Exceções

ArgumentException

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

Observações

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

Importante

Example

O exemplo seguinte mostra os valores devolvidos 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 para Chamadores

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

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

Ver também

Aplica-se a

Round(Double, Int32)

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Arredonda um valor de ponto flutuante de precisão dupla para um número especificado de dígitos fracionários, e arredonda valores do 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 dupla precisão a arredondar.

digits: Int32

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

Devoluções

Double

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

Exceções

ArgumentOutOfRangeException

digits é inferior a 0 ou superior a 15.

Observações

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

Este método utiliza a convenção de arredondamento padrão de MidpointRounding.ToEven. Consulte Valores do ponto médio e convenções de arredondamento para informações sobre arredondar números com valores do ponto médio.

Importante

Example

O exemplo seguinte 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

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

Devido à perda de precisão que pode resultar de representar valores decimais como números de vírgula flutuante ou de realizar operações aritméticas em valores de vírgula flutuante, em alguns casos o Round(Double, Int32) método pode não parecer arredondar valores do ponto médio para o valor par mais próximo na digits posição decimal. Isto é ilustrado no exemplo seguinte, onde 2,135 é arredondado para 2,13 em vez de 2,14. Isto ocorre porque, internamente, o método multiplica value por 10^dígitos, e a operação de multiplicação neste caso sofre de 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

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

Ver também

Aplica-se a

Round(Decimal, Int32)

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Arredonda um valor decimal para um número especificado de dígitos fracionários, e arredonda valores do 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 arredondar.

decimals: Int32

O número de casas decimais no valor de retorno.

Devoluções

Decimal

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

Exceções

ArgumentOutOfRangeException

decimals é inferior a 0 ou superior a 28.

OverflowException

O resultado está fora do intervalo de um Decimal.

Observações

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

Este método utiliza a convenção de arredondamento padrão de MidpointRounding.ToEven. Para informações sobre arredondamento de números com valores do ponto médio, veja Valores do ponto médio e convenções de arredondamento.

Importante

Example

O exemplo seguinte 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

Ver também

Aplica-se a

Round(Double)

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Arredonda um valor de ponto flutuante de dupla precisão ao valor integral mais próximo, e arredonda valores do ponto médio ao 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 dupla precisão a arredondar.

Devoluções

Double

O inteiro mais próximo ade . Se o componente fracionário de a estiver a meio caminho entre dois inteiros, um dos quais é par e o outro ímpar, então o número par é devolvido. Note-se que este método devolve um Double em vez de um tipo inteiro.

Observações

Importante

Se o valor do a argumento for Double.NaN, o método devolve Double.NaN. Se a for Double.PositiveInfinity ou Double.NegativeInfinity, o método devolve Double.PositiveInfinity ou Double.NegativeInfinity, respetivamente.

A partir de Visual Basic 15.8, o desempenho da conversão de Duplo para inteiro é otimizado se passar o valor devolvido pelo método Round para qualquer uma das funções de conversão integral, ou se o valor Duplo devolvido por Round for automaticamente convertido num inteiro com Opção Estrito definido para Desligado. 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 inteiros. O exemplo seguinte 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

Example

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

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

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

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

Ver também

Aplica-se a

Round(Decimal)

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Arredonda um valor decimal para o valor integral mais próximo e arredonda valores do 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 arredondar.

Devoluções

Decimal

O inteiro mais próximo do d parâmetro. Se a componente fracionária de d estiver a meio caminho entre dois inteiros, um dos quais é par e o outro ímpar, o número par é devolvido. Note-se que este método devolve um Decimal em vez de um tipo inteiro.

Exceções

OverflowException

O resultado está fora do intervalo de um Decimal.

Exemplos

O exemplo seguinte demonstra o Round(Decimal) método. O Decimal valor de 4,5 tiros para 4 em vez de 5, porque esta 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

Observações

Importante

Ver também

Aplica-se a

Round(Decimal, MidpointRounding)

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Origem:: Math.cs

Arredonda um valor decimal 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 arredondar.

mode: MidpointRounding

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

Devoluções

Decimal

O inteiro arredondado d para. Este método devolve um Decimal tipo em vez de inteiro.

Exceções

ArgumentException

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

OverflowException

O resultado está fora do intervalo de um Decimal.

Observações

Para informações sobre arredondamento de números com valores do ponto médio, veja Valores do ponto médio e convenções de arredondamento.

Importante

Example

O exemplo seguinte mostra os valores devolvidos 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

Ver também

Aplica-se a

Comentários

Esta página foi útil?