Math.Round Método

Definição

Arredonda um valor para o inteiro mais próximo ou para o número especificado de casas decimais.Rounds a value to the nearest integer or to the specified number of fractional digits.

Sobrecargas

Round(Decimal, Int32, MidpointRounding)

Arredonda um valor decimal para o número especificado de dígitos fracionários e usa a convenção de arredondamento especificada para os valores de ponto médio.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, Int32, MidpointRounding)

Arredonda um valor de ponto flutuante de precisão dupla para o número especificado de dígitos fracionários e usa a convenção de arredondamento especificada para os valores de ponto médio.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, MidpointRounding)

Arredonda um valor de ponto flutuante de precisão dupla para o inteiro mais próximo e usa a convenção de arredondamento especificada para os valores de ponto médio.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

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.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

Round(Double)

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.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

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.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

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.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

Round(Decimal, MidpointRounding)

Arredonda um valor decimal para o inteiro mais próximo e usa a convenção de arredondamento especificada para os valores de ponto médio.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

Exemplos

Além dos exemplos na seção comentários , este artigo inclui exemplos que ilustram as seguintes sobrecargas do Math.Round método:In addition to the examples in the Remarks section, this article includes examples that illustrate the following overloads of the Math.Round method:

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

Observação

Os exemplos de C# neste artigo são executados no executador de código embutido Try.NET e no playground.The C# examples in this article run in the Try.NET inline code runner and playground. Clique no botão Executar para executar um exemplo em uma janela interativa.Select the Run button to run an example in an interactive window. Ao executar o código, é possível modificá-lo e executar o código modificado clicando em Executar novamente.Once you execute the code, you can modify it and run the modified code by selecting Run again. O código modificado será executado na janela interativa ou, se a compilação falhar, a janela interativa exibirá todos as mensagens de erro do compilador C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Comentários

Nesta seção:In this section:

Qual método devo chamar?Which method do I call?

Você pode usar a tabela a seguir para selecionar um método de arredondamento apropriado.You can use the following table to select an appropriate rounding method. Além dos Math.Round métodos, ele também inclui Math.Ceiling e Math.Floor.In addition to the Math.Round methods, it also includes Math.Ceiling and Math.Floor.

ParaTo CallCall
Arredonde um número para um inteiro usando o arredondamento para a Convenção mais próxima.Round a number to an integer by using the rounding to nearest convention. Round(Decimal)

- ou --or-

Round(Double)
Arredonde um número para um inteiro usando uma Convenção de arredondamento especificada.Round a number to an integer by using a specified rounding convention. Round(Decimal, MidpointRounding)

- ou --or-

Round(Double, MidpointRounding)
Arredonde um número para um número especificado de dígitos fracionários usando o arredondamento para a Convenção mais próxima.Round a number to a specified number of fractional digits by using the rounding to nearest convention. Round(Decimal, Int32)

- ou --or-

Round(Double, Int32)
Arredonde um número para um número especificado de dígitos fracionários usando uma Convenção de arredondamento especificada.Round a number to a specified number of fractional digits by using a specified rounding convention. Round(Decimal, Int32, MidpointRounding)

- ou --or-

Round(Double, Int32, MidpointRounding)
Arredonde 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.Round a Single value to a specified number of fractional digits by using a specified rounding convention and minimizing the loss of precision. Converta Single Round(Decimal, Int32, MidpointRounding)para a e chame. DecimalConvert the Single to a Decimal and call Round(Decimal, Int32, MidpointRounding).
Arredonde um número para um número especificado de dígitos fracionários e, ao mesmo tempo, minimize os problemas de precisão nos valores mabaixos de arredondamento.Round a number to a specified number of fractional digits while minimizing problems of precision in rounding midpoint values. Chame um método de arredondamento que implemente uma comparação "maior que ou aproximadamente igual a".Call a rounding method that implements a "greater than or approximately equal to" comparison. Consulte arredondamento e precisão.See Rounding and precision.
Arredonde um valor fracionário para um inteiro maior que o valor fracionário.Round a fractional value to an integer that is greater than the fractional value. Por exemplo, arredonde 3,1 para 4.For example, round 3.1 to 4. Ceiling
Arredonde um valor fracionário para um inteiro menor que o valor fracionário.Round a fractional value to an integer that is less than the fractional value. Por exemplo, arredonde 3,9 para 3.For example, round 3.9 to 3. Floor

Valores de ponto médio e convenções arredondamentoMidpoint values and rounding conventions

O arredondamento envolve a conversão de um valor numérico com uma precisão especificada para o valor mais próximo com menos precisão.Rounding involves converting a numeric value with a specified precision to the nearest value with less precision. Por exemplo, você pode usar o Round(Double) método para arredondar um valor de 3,4 para 3,0 e Round(Double, Int32) o método para arredondar um valor de 3,579 para 3,58.For example, you can use the Round(Double) method to round a value of 3.4 to 3.0, and the Round(Double, Int32) method to round a value of 3.579 to 3.58.

Em um valor de ponto médio, o valor após o dígito menos significativo no resultado é precisamente meio-caminho entre dois números.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Por exemplo, 3,47500 é um valor intermediário se for para ser arredondado duas casas decimais e 7,500 é um valor intermediário se for para ser arredondado para um inteiro.For example, 3.47500 is a midpoint value if it is to be rounded two decimal places, and 7.500 is a midpoint value if it is to be rounded to an integer. Nesses casos, o valor mais próximo não pode ser facilmente identificado sem uma Convenção de arredondamento.In these cases, the nearest value can't be easily identified without a rounding convention.

O Round método dá suporte a duas convenções de arredondamento para manipular valores intermediários:The Round method supports two rounding conventions for handling midpoint values:

  • Arredondamento para longe de zeroRounding away from zero

    Os valores de ponto médio são arredondados para o próximo número distante do zero.Midpoint values are rounded to the next number away from 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.For example, 3.75 rounds to 3.8, 3.85 rounds to 3.9, -3.75 rounds to -3.8, and -3.85 rounds to -3.9. Essa forma de arredondamento é representada pelo MidpointRounding.AwayFromZero membro de enumeração.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

    Arredondar de zero é a forma mais amplamente conhecida de arredondamento.Rounding away from zero is the most widely known form of rounding.

  • Arredondamento para o arredondamento mais próximo ou do bancoRounding to nearest, or banker's rounding

    Os valores de ponto médio são arredondados para o número par mais próximo.Midpoint values are rounded to the nearest even number. Por exemplo, 3,75 e 3,85 arredondados para 3,8 e-3,75 e-3,85 Round to-3,8.For example, both 3.75 and 3.85 round to 3.8, and both -3.75 and -3.85 round to -3.8. Essa forma de arredondamento é representada pelo MidpointRounding.ToEven membro de enumeração.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

    O arredondamento para mais próximo é a forma padrão de arredondamento usado em operações financeiras e estatísticas.Rounding to nearest is the standard form of rounding used in financial and statistical operations. Ele está de acordo com o IEEE Standard 754, seção 4.It conforms to IEEE Standard 754, section 4. Quando usado em várias operações de arredondamento, ele reduz o erro de arredondamento causado pelo arredondamento consistente de valores de ponto médio em uma única direção.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. Em alguns casos, esse erro de arredondamento pode ser significativo.In some cases, this rounding error can be significant.

    O exemplo a seguir ilustra a diferença que pode resultar de valores de ponto médio de arredondamento consistente em uma única direção.The following example illustrates the bias that can result from consistently rounding midpoint values in a single direction. O exemplo computa a média real de uma matriz de Decimal valores e, em seguida, calcula a média de quando os valores na matriz são arredondados usando as duas convenções.The example computes the true mean of an array of Decimal values, and then computes the mean when the values in the array are rounded by using the two conventions. Neste exemplo, a média real e a média de resultados quando o arredondamento para mais próximo são iguais.In this example, the true mean and the mean that results when rounding to nearest are the same. No entanto, a média de resultados ao arredondar de zero difere em 0,05 (ou por 3,6%) da média real.However, the mean that results when rounding away from zero differs by .05 (or by 3.6%) from the true mean.

    decimal[] values = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
    decimal sum = 0;
    
    // Calculate true mean.
    foreach (var value in values)
       sum += value;
    
    Console.WriteLine("True mean:     {0:N2}", sum/values.Length);
    
    // Calculate mean with rounding away from zero.
    sum = 0;
    foreach (var value in values)
       sum += Math.Round(value, 1, MidpointRounding.AwayFromZero);
    
    Console.WriteLine("AwayFromZero:  {0:N2}", sum/values.Length);
    
    // Calculate mean with rounding to nearest.
    sum = 0;
    foreach (var value in values)
       sum += Math.Round(value, 1, MidpointRounding.ToEven);
    
    Console.WriteLine("ToEven:        {0:N2}", sum/values.Length);
    // The example displays the following output:
    //       True mean:     1.40
    //       AwayFromZero:  1.45
    //       ToEven:        1.40
    
    Module Example
       Public Sub Main()
          Dim values() As Decimal = { 1.15d, 1.25d, 1.35d, 1.45d, 1.55d, 1.65d }
          Dim sum As Decimal
          
          ' Calculate true mean.
          For Each value In values
             sum += value
          Next
          Console.WriteLine("True mean:     {0:N2}", sum/values.Length)
          
          ' Calculate mean with rounding away from zero.
          sum = 0
          For Each value In values
             sum += Math.Round(value, 1, MidpointRounding.AwayFromZero)
          Next
          Console.WriteLine("AwayFromZero:  {0:N2}", sum/values.Length)
          
          ' Calculate mean with rounding to nearest.
          sum = 0
          For Each value In values
             sum += Math.Round(value, 1, MidpointRounding.ToEven)
          Next
          Console.WriteLine("ToEven:        {0:N2}", sum/values.Length)
       End Sub
    End Module
    ' The example displays the following output:
    '       True mean:     1.40
    '       AwayFromZero:  1.45
    '       ToEven:        1.40
    

Por padrão, o Round método usa o arredondamento para a Convenção mais próxima.By default, the Round method uses the rounding to nearest convention. A tabela a seguir lista as sobrecargas do Round método e a Convenção de arredondamento que cada um usa.The following table lists the overloads of the Round method and the rounding convention that each uses.

SobrecargaOverload Convenção de arredondamentoRounding convention
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) Determinado pelo mode parâmetro.Determined by mode parameter.
Round(Double, MidpointRounding) Determinado pelo parâmetro modeDetermined by mode parameter
Round(Decimal, Int32, MidpointRounding) Determinado pelo parâmetro modeDetermined by mode parameter
Round(Double, Int32, MidpointRounding) Determinado pelo parâmetro modeDetermined by mode parameter

Arredondamento e precisãoRounding and precision

Para determinar se uma operação de arredondamento envolve um valor de ponto médio Round , o método multiplica o valor original a ser arredondado por 10n, em que n é o número desejado de dígitos fracionários no valor de retorno e, em seguida, Determina se a parte fracionária restante do valor é maior ou igual a. 5.In order to determine whether a rounding operation involves a midpoint value, the Round method multiplies the original value to be rounded by 10n, where n is the desired number of fractional digits in the return value, and then determines whether the remaining fractional portion of the value is greater than or equal to .5. Essa é uma pequena variação em um teste de igualdade e, conforme discutido na seção "testando a igualdade" do tópico Double de referência, os testes de igualdade com valores de ponto flutuante são problemáticos devido aos problemas de formato de ponto flutuante com binário representação e precisão.This is a slight variation on a test for equality, and as discussed in the "Testing for Equality" section of the Double reference topic, tests for equality with floating-point values are problematic because of the floating-point format's issues with binary representation and precision. Isso significa que qualquer parte fracionária de um número que seja ligeiramente menor que 0,5 (devido à perda de precisão) não será arredondada para cima.This means that any fractional portion of a number that is slightly less than .5 (because of a loss of precision) will not be rounded upward.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade.When rounding midpoint values, the rounding algorithm performs an equality test. 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.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para saber mais, confira "Arredondamento e precisão".For more information, see "Rounding and precision".

O exemplo a seguir ilustra o problema.The following example illustrates the problem. Ele adiciona repetidamente 1 a 11,0 e arredonda o resultado para o número inteiro mais próximo.It repeatedly adds .1 to 11.0 and rounds the result to the nearest integer. Independentemente da Convenção de arredondamento, 11,5 deve arredondar para 12.Regardless of the rounding convention, 11.5 should round to 12. No entanto, como a saída do exemplo mostra, ela não faz isso.However, as the output from the example shows, it does not. O exemplo usa a cadeia de caracteres de formato numérico padrão "R" para exibir a precisão total do valor de ponto flutuante e mostra que o valor a ser arredondado perdeu a precisão durante as adições repetidas e seu valor é realmente 11.499999999999998.The example uses the "R" standard numeric format string to display the floating point value's full precision, and shows that the value to be rounded has lost precision during repeated additions, and its value is actually 11.499999999999998. Como. 499999999999998 é menor que 0,5, o valor não é arredondado para o próximo número inteiro mais alto.Because .499999999999998 is less than .5, the value is not rounded to the next highest integer. Como o exemplo também mostra, esse problema não ocorre se simplesmente atribuímos o valor de constante 11,5 a uma Double variável.As the example also shows, this problem does not occur if we simply assign the constant value 11.5 to a Double variable.

using System;

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

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }
   
   private static double RoundValueAndAdd(double value)
   {
      Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                        value, Math.Round(value, MidpointRounding.ToEven),
                        Math.Round(value, MidpointRounding.AwayFromZero));
      return value + .1;
   }
}
// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//       
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//       
//        11.5                 11.5            12              12
Module Example
   Public Sub Main()
      Dim value As Double = 11.1

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

      value = 11.5
      RoundValueAndAdd(value)
   End Sub
   
   Private Function RoundValueAndAdd(value As Double) As Double
      Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                        value, Math.Round(value, MidpointRounding.ToEven),
                        Math.Round(value, MidpointRounding.AwayFromZero))
      Return value + .1
   End Function   
End Module
' The example displays the following output:
'       Value       Full Precision        ToEven    AwayFromZero
'       
'        11.1                 11.1            11              11
'        11.2                 11.2            11              11
'        11.3   11.299999999999999            11              11
'        11.4   11.399999999999999            11              11
'        11.5   11.499999999999998            11              11
'        11.6   11.599999999999998            12              12
'       
'        11.5                 11.5            12              12

Problemas de precisão em valores de ponto médio de arredondamento têm maior probabilidade de surgir nas seguintes condições:Problems of precision in rounding midpoint values are most likely to arise in the following conditions:

  • Quando um valor fracionário não pode ser expresso precisamente no formato binário do tipo de ponto flutuante.When a fractional value cannot be expressed precisely in the floating-point type's binary format.

  • Quando o valor a ser arredondado é calculado a partir de uma ou mais operações de ponto flutuante.When the value to be rounded is calculated from one or more floating-point operations.

  • Quando o valor a ser arredondado é Single um em vez Double de Decimalum ou.When the value to be rounded is a Single rather than a Double or Decimal. Para obter mais informações, consulte a próxima seção, arredondamento e valores de ponto flutuante de precisão simples.For more information, see the next section, Rounding and single-precision floating-point values.

Nos casos em que a falta de precisão nas operações de arredondamento é problemática, você pode fazer o seguinte:In cases where the lack of precision in rounding operations is problematic, you can do the following:

  • Se a operação de arredondamento chamar uma sobrecarga que Double Arredonda um valor, você poderá Double alterar o Decimal para um valor e chamar uma sobrecarga que Decimal Arredonda um valor em vez disso.If the rounding operation calls an overload that rounds a Double value, you can change the Double to a Decimal value and call an overload that rounds a Decimal value instead. 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.Although the Decimal data type also has problems of representation and loss of precision, these issues are far less common.

  • Defina um algoritmo de arredondamento personalizado que executa um teste "quase igual" para determinar se o valor a ser arredondado é aceitável próximo a um valor de ponto médio.Define a custom rounding algorithm that performs a "nearly equal" test to determine whether the value to be rounded is acceptably close to a midpoint value. O exemplo a seguir define RoundApproximate um método que examina se um valor fracionário é suficientemente próximo a um valor de ponto médio para estar sujeito ao arredondamento de ponto médio.The following example defines a RoundApproximate method that examines whether a fractional value is sufficiently near to a midpoint value to be subject to midpoint rounding. Como a saída do exemplo mostra, ela corrige o problema de arredondamento mostrado no exemplo anterior.As the output from the example shows, it corrects the rounding problem shown in the previous example.

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

Arredondamento e valores de ponto flutuante de precisão simplesRounding and single-precision floating-point values

O Round método inclui sobrecargas que aceitam argumentos do Decimal tipo Doublee.The Round method includes overloads that accept arguments of type Decimal and Double. Não há métodos que arredondam valores do Singletipo.There are no methods that round values of type Single. Se você passar um Single valor para uma das sobrecargas Round do método, ele será conversão (in C#) ou convertido (em Visual Basic) em um Double, e a sobrecarga correspondente Round com um Double parâmetro será chamada.If you pass a Single value to one of the overloads of the Round method, it is cast (in C#) or converted (in Visual Basic) to a Double, and the corresponding Round overload with a Double parameter is called. Embora essa seja uma conversão de alargamento, ela geralmente envolve uma perda de precisão, como ilustra o exemplo a seguir.Although this is a widening conversion, it often involves a loss of precision, as the following example illustrates. 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.When a Single value of 16.325 is passed to the Round method and rounded to two decimal places using the rounding to nearest convention, the result is 16.33 and not the expected result of 16.32.

using System;

public class Example
{
   public static void Main()
   {
      Single value = 16.325f;
      Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ", 
                        value, value.GetType().Name, (double) value, 
                        ((double) (value)).GetType().Name);
      Console.WriteLine(Math.Round(value, 2));
      Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero));
      Console.WriteLine();
      
      Decimal decValue = (decimal) value;
      Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ", 
                        value, value.GetType().Name, decValue, 
                        decValue.GetType().Name);
      Console.WriteLine(Math.Round(decValue, 2));
      Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero));
   }
}
// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//    
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33
Module Example
   Public Sub Main()
      Dim value As Single = 16.325
      Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ", 
                        value, value.GetType().Name, CDbl(value), 
                        CDbl(value).GetType().Name)
      Console.WriteLine(Math.Round(value, 2))
      Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero))
      Console.WriteLine()
      
      Dim decValue As Decimal = CDec(value)
      Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ", 
                        value, value.GetType().Name, decValue, 
                        decValue.GetType().Name)
      Console.WriteLine(Math.Round(decValue, 2))
      Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero))
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
'    16.33
'    16.33
'    
'    Cast of 16.325 (type Single) to 16.325 (type Decimal):
'    16.32
'    16.33

Esse resultado inesperado ocorre devido a uma perda de precisão na conversão do Single valor em um Double.This unexpected result is due to a loss of precision in the conversion of the Single value to a Double. Como o valor Double resultante de 16.325000762939453 não é um valor de ponto médio e é maior que 16,325, ele é sempre arredondado para cima.Because the resulting Double value of 16.325000762939453 is not a midpoint value and is greater than 16.325, it is always rounded upward.

Em muitos casos, como ilustra o exemplo, a perda de precisão pode ser minimizada ou eliminada por meio da conversão Single ou da conversão Decimaldo valor em um.In many cases, as the example illustrates, the loss of precision can be minimized or eliminated by casting or converting the Single value to a Decimal. Observe que, como essa é uma conversão de restrição, ela requer o uso de um operador cast ou a chamada de um método de conversão.Note that, because this is a narrowing conversion, it requires using a cast operator or calling a conversion method.

Round(Decimal, Int32, MidpointRounding)

Arredonda um valor decimal para o número especificado de dígitos fracionários e usa a convenção de arredondamento especificada para os valores de ponto médio.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.A decimal number to be rounded.

decimals
Int32

O número de casas decimais no valor retornado.The number of decimal places in the return value.

mode
MidpointRounding

Especificação de como arredondar d se o valor estiver entre dois outros números.Specification for how to round d if it is midway between two other numbers.

Retornos

O número mais próximo de d que contém um número de dígitos fracionários igual a decimals.The number nearest to d that contains a number of fractional digits equal to decimals. Se d tiver menos dígitos fracionários que decimals, d será retornado inalterado.If d has fewer fractional digits than decimals, d is returned unchanged.

Exceções

decimals é menor que 0 ou maior que 28.decimals is less than 0 or greater than 28.

mode não é um valor válido de MidpointRounding.mode is not a valid value of MidpointRounding.

O resultado é fora do intervalo de um Decimal.The result is outside the range of a Decimal.

Comentários

Consulte valores de ponto médio e convenções de arredondamento para obter informações sobre arredondamento de números com valores de ponto médio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade.When rounding midpoint values, the rounding algorithm performs an equality test. 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.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para saber mais, confira "Arredondamento e precisão".For more information, see "Rounding and precision".

O valor do decimals argumento pode variar de 0 a 28.The value of the decimals argument can range from 0 to 28.

ExemploExample

O exemplo a seguir demonstra como usar o Round método com a MidpointRounding enumeração.The following example demonstrates how to use the Round method with the MidpointRounding enumeration.

// This example demonstrates the Math.Round() method in conjunction 
// with the MidpointRounding enumeration.
using namespace System;

void main()
{
    Decimal result = (Decimal) 0.0;
    Decimal posValue = (Decimal) 3.45;
    Decimal negValue = (Decimal) -3.45;

    // By default, round a positive and a negative value to the nearest
    // even number. The precision of the result is 1 decimal place.
    result = Math::Round(posValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
    result = Math::Round(negValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
    Console::WriteLine();

    // Round a positive value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(posValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, posValue);
    result = Math::Round(posValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, posValue);
    Console::WriteLine();

    // Round a negative value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(negValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, negValue);
    result = Math::Round(negValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, negValue);
    Console::WriteLine();
}

/*
This code example produces the following results:

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

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

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

*/
decimal result = 0.0m;
decimal posValue =  3.45m;
decimal negValue = -3.45m;

// By default, round a positive and a negative value to the nearest even number. 
// The precision of the result is 1 decimal place.

result = Math.Round(posValue, 1);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
result = Math.Round(negValue, 1);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
Console.WriteLine();

// Round a positive value to the nearest even number, then to the nearest number away from zero. 
// The precision of the result is 1 decimal place.

result = Math.Round(posValue, 1, MidpointRounding.ToEven);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", result, posValue);
result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", result, posValue);
Console.WriteLine();

// Round a negative value to the nearest even number, then to the nearest number away from zero. 
// The precision of the result is 1 decimal place.

result = Math.Round(negValue, 1, MidpointRounding.ToEven);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", result, negValue);
result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", result, negValue);
Console.WriteLine();
/*
This code example produces the following results:

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

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

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

*/
' This example demonstrates the Math.Round() method in conjunction 
' with the MidpointRounding enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim result As Decimal = 0D
        Dim posValue As Decimal = 3.45D
        Dim negValue As Decimal = -3.45D
        
        ' By default, round a positive and a negative value to the nearest even number. 
        ' The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
        result = Math.Round(negValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
        Console.WriteLine()
        
        ' Round a positive value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                           result, posValue)
        result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, posValue)
        Console.WriteLine()
        
        ' Round a negative value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(negValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                            result, negValue)
        result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, negValue)
        Console.WriteLine()
    
    End Sub
End Class
'
'This code example produces the following results:
'
' 3.4 = Math.Round( 3.45, 1)
'-3.4 = Math.Round(-3.45, 1)
'
' 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
' 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
'
'-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
'

Veja também

Round(Double, Int32, MidpointRounding)

Arredonda um valor de ponto flutuante de precisão dupla para o número especificado de dígitos fracionários e usa a convenção de arredondamento especificada para os valores de ponto médio.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

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

Parâmetros

value
Double

Um número de ponto flutuante de precisão dupla a ser arredondado.A double-precision floating-point number to be rounded.

digits
Int32

O número de dígitos fracionários no valor de retorno.The number of fractional digits in the return value.

mode
MidpointRounding

Especificação de como arredondar value se o valor estiver entre dois outros números.Specification for how to round value if it is midway between two other numbers.

Retornos

O número mais próximo de value que tem um número de dígitos fracionários igual a digits.The number nearest to value that has a number of fractional digits equal to digits. Se value tiver menos dígitos fracionários que digits, value será retornado inalterado.If value has fewer fractional digits than digits, value is returned unchanged.

Exceções

digits é menor que 0 ou maior que 15.digits is less than 0 or greater than 15.

mode não é um valor válido de MidpointRounding.mode is not a valid value of MidpointRounding.

Comentários

O valor do digits argumento pode variar de 0 a 15.The value of the digits argument can range from 0 to 15. Observe que 15 é o número máximo de dígitos inteiros e fracionários com suporte do Double tipo.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Consulte valores de ponto médio e convenções de arredondamento para obter informações sobre arredondamento de números com valores de ponto médio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade.When rounding midpoint values, the rounding algorithm performs an equality test. 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.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para saber mais, confira "Arredondamento e precisão".For more information, see "Rounding and precision".

Se o valor do value argumento for Double.NaN, o método retornará Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. Se value for Double.PositiveInfinity ou Double.PositiveInfinity , o método retornará ouDouble.NegativeInfinity, respectivamente. Double.NegativeInfinityIf value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

ExemploExample

O exemplo a seguir demonstra como usar o Round(Double, Int32, MidpointRounding) método com a MidpointRounding enumeração.The following example demonstrates how to use the Round(Double, Int32, MidpointRounding) method with the MidpointRounding enumeration.

 double posValue =  3.45;
 double negValue = -3.45;

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

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

 // Round a negative value using a MidpointRounding value. 
 result = Math.Round(negValue, 1, MidpointRounding.ToEven);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", 
                   result, negValue);
 result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)\n", 
                   result, negValue);
// The example displays the following output:
//        3.4 = Math.Round( 3.45, 1)
//       -3.4 = Math.Round(-3.45, 1)
//       
//        3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
//        3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
//       
//       -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
//       -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
Module Example
    Public Sub Main() 
        Dim posValue As Double = 3.45
        Dim negValue As Double = -3.45
        
        ' Round a positive and a negative value using the default.  
        Dim result As Double = Math.Round(posValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
        result = Math.Round(negValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
        Console.WriteLine()
        
        ' Round a positive value using a MidpointRounding value. 
        result = Math.Round(posValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", 
                           result, posValue)
        result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", 
                           result, posValue)
        Console.WriteLine()
        
        ' Round a positive value using a MidpointRounding value. 
        result = Math.Round(negValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", 
                            result, negValue)
        result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", 
                           result, negValue)
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'       3.4 = Math.Round( 3.45, 1)
'       -3.4 = Math.Round(-3.45, 1)
'       
'       3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
'       3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
'       
'       -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'       -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

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 Round(Double, Int32, MidpointRounding) alguns casos o método pode não aparecer para arredondar valores de ponto médio conforme especificado mode pelo parâmetro.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32, MidpointRounding) method may not appear to round midpoint values as specified by the mode parameter. Isso é ilustrado no exemplo a seguir, em que 2,135 é arredondado para 2,13 em vez de 2,14.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. Isso ocorre porque, internamente, o método value multiplica por 10dígitose a operação de multiplicação, nesse caso, sofre uma perda de precisão.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

[!code-csharpSystem.Math.Round#3] [!code-vbSystem.Math.Round#3][!code-csharpSystem.Math.Round#3] [!code-vbSystem.Math.Round#3]

Veja também

Round(Double, MidpointRounding)

Arredonda um valor de ponto flutuante de precisão dupla para o inteiro mais próximo e usa a convenção de arredondamento especificada para os valores de ponto médio.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

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

Parâmetros

value
Double

Um número de ponto flutuante de precisão dupla a ser arredondado.A double-precision floating-point number to be rounded.

mode
MidpointRounding

Especificação de como arredondar value se o valor estiver entre dois outros números.Specification for how to round value if it is midway between two other numbers.

Retornos

O inteiro mais próximo de value.The integer nearest value. Se value estiver entre dois inteiros, sendo um deles par e o outro ímpar, mode determinará qual dos dois será retornado.If value is halfway between two integers, one of which is even and the other odd, then mode determines which of the two is returned. Observe que esse método retorna um Double em vez de um tipo integral.Note that this method returns a Double instead of an integral type.

Exceções

mode não é um valor válido de MidpointRounding.mode is not a valid value of MidpointRounding.

Comentários

Consulte valores de ponto médio e convenções de arredondamento para obter informações sobre arredondamento de números com valores de ponto médio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade.When rounding midpoint values, the rounding algorithm performs an equality test. 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.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para saber mais, confira "Arredondamento e precisão".For more information, see "Rounding and precision".

Se o valor do value argumento for Double.NaN, o método retornará Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. Se value for Double.PositiveInfinity ou Double.PositiveInfinity , o método retornará ouDouble.NegativeInfinity, respectivamente. Double.NegativeInfinityIf value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

ExemploExample

O exemplo a seguir exibe valores retornados pelo Round(Double) método, o Round(Double, MidpointRounding) método com um mode argumento de ToEvene o Round(Double, MidpointRounding) método com um mode argumento de AwayFromZero.The following example displays values returned by the Round(Double) method, the Round(Double, MidpointRounding) method with a mode argument of ToEven, and the Round(Double, MidpointRounding) method with a mode argument of AwayFromZero.

using System;

public class Example
{
   public static void Main()
   {
      Double[] values = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 
                          12.7, 12.8, 12.9, 13.0 };
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero");
      foreach (var value in values)
         Console.WriteLine("{0,-10:R} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero));
   }
}
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero
//       12         12         12         12
//       12.1       12         12         12
//       12.2       12         12         12
//       12.3       12         12         12
//       12.4       12         12         12
//       12.5       12         12         13
//       12.6       13         13         13
//       12.7       13         13         13
//       12.8       13         13         13
//       12.9       13         13         13
//       13.0       13         13         13
Module Example
   Public Sub Main()
      Dim values() As Double = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 
                                 12.7, 12.8, 12.9, 13.0 }
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero")
      For Each value In values
         Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero
'       12         12         12         12
'       12.1       12         12         12
'       12.2       12         12         12
'       12.3       12         12         12
'       12.4       12         12         12
'       12.5       12         12         13
'       12.6       13         13         13
'       12.7       13         13         13
'       12.8       13         13         13
'       12.9       13         13         13
'       13.0       13         13         13

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 Round(Double, MidpointRounding) alguns casos o método pode não aparecer para arredondar valores de ponto médio para o inteiro par mais próximo.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, MidpointRounding) method may not appear to round midpoint values to the nearest even integer. No exemplo a seguir, como o valor de ponto flutuante 1 não tem uma representação binária finita, a primeira chamada para Round(Double) o método com um valor de 11,5 retorna 11 em vez de 12.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

[!code-csharpSystem.Math.Round#4] [!code-vbSystem.Math.Round#4][!code-csharpSystem.Math.Round#4] [!code-vbSystem.Math.Round#4]

Veja também

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.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

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

Parâmetros

value
Double

Um número de ponto flutuante de precisão dupla a ser arredondado.A double-precision floating-point number to be rounded.

digits
Int32

O número de dígitos fracionários no valor de retorno.The number of fractional digits in the return value.

Retornos

O número mais próximo de value que contém um número de dígitos fracionários igual a digits.The number nearest to value that contains a number of fractional digits equal to digits.

Exceções

digits é menor que 0 ou maior que 15.digits is less than 0 or greater than 15.

Comentários

O valor do digits argumento pode variar de 0 a 15.The value of the digits argument can range from 0 to 15. Observe que 15 é o número máximo de dígitos inteiros e fracionários com suporte do Double tipo.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Esse método usa a Convenção de arredondamento MidpointRounding.ToEvenpadrão de.This method uses the default rounding convention of MidpointRounding.ToEven. Consulte valores de ponto médio e convenções de arredondamento para obter informações sobre arredondamento de números com valores de ponto médio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade.When rounding midpoint values, the rounding algorithm performs an equality test. 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.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para saber mais, confira "Arredondamento e precisão".For more information, see "Rounding and precision".

Se o valor do value argumento for Double.NaN, o método retornará Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. Se value for Double.PositiveInfinity ou Double.PositiveInfinity , o método retornará ouDouble.NegativeInfinity, respectivamente. Double.NegativeInfinityIf value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

ExemploExample

O exemplo a seguir Arredonda os valores duplos com dois dígitos fracionários para duplos que têm um único dígito fracionário.The following example rounds double values with two fractional digits to doubles that have a single fractional digit.

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

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

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

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

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 Round(Double, Int32) alguns casos o método pode não aparecer para arredondar valores de ponto médio para o valor par mais próximo na digits posição decimal.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32) method may not appear to round midpoint values to the nearest even value in the digits decimal position. Isso é ilustrado no exemplo a seguir, em que 2,135 é arredondado para 2,13 em vez de 2,14.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. Isso ocorre porque, internamente, o método value multiplica por 10dígitose a operação de multiplicação, nesse caso, sofre uma perda de precisão.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

[!code-csharpSystem.Math.Round#2] [!code-vbSystem.Math.Round#2][!code-csharpSystem.Math.Round#2] [!code-vbSystem.Math.Round#2]

Veja também

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.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

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

Parâmetros

a
Double

Um número de ponto flutuante de precisão dupla a ser arredondado.A double-precision floating-point number to be rounded.

Retornos

O inteiro mais próximo de a.The integer nearest 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.If the fractional component of a is halfway between two integers, one of which is even and the other odd, then the even number is returned. Observe que esse método retorna um Double em vez de um tipo integral.Note that this method returns a Double instead of an integral type.

Comentários

Esse método usa a Convenção de arredondamento MidpointRounding.ToEvenpadrão de.This method uses the default rounding convention of MidpointRounding.ToEven. Consulte valores de ponto médio e convenções de arredondamento para obter informações sobre arredondamento de números com valores de ponto médio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade.When rounding midpoint values, the rounding algorithm performs an equality test. 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.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para saber mais, confira "Arredondamento e precisão".For more information, see "Rounding and precision".

Se o valor do a argumento for Double.NaN, o método retornará Double.NaN.If the value of the a argument is Double.NaN, the method returns Double.NaN. Se a for Double.PositiveInfinity ou Double.PositiveInfinity , o método retornará ouDouble.NegativeInfinity, respectivamente. Double.NegativeInfinityIf a is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

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 integralou se o valor Double retornado por Round é automaticamente convertido em um inteiro com Option Strict definida como off.Starting with Visual Basic 15.8, the performance of Double-to-integer conversion is optimized if you pass the value returned by the Round method to the any of the integral conversion functions, or if the Double value returned by Round is automatically converted to an integer with Option Strict set to Off. 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.This optimization allows code to run faster -- up to twice as fast for code that does a large number of conversions to integer types. O exemplo a seguir ilustra essas conversões otimizadas:The following example illustrates such optimized conversions:

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

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

ExemploExample

O exemplo a seguir demonstra o arredondamento para o valor inteiro mais próximo.The following example demonstrates rounding to the nearest integer value.

using namespace System;

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

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

End Module

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 Round(Double) alguns casos o método pode não aparecer para arredondar valores de ponto médio para o inteiro par mais próximo.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double) method may not appear to round midpoint values to the nearest even integer. No exemplo a seguir, como o valor de ponto flutuante 1 não tem uma representação binária finita, a primeira chamada para Round(Double) o método com um valor de 11,5 retorna 11 em vez de 12.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

[!code-csharpSystem.Math.Round#1] [!code-vbSystem.Math.Round#1][!code-csharpSystem.Math.Round#1] [!code-vbSystem.Math.Round#1]

Veja também

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.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.A decimal number to be rounded.

decimals
Int32

O número de casas decimais no valor retornado.The number of decimal places in the return value.

Retornos

O número mais próximo de d que contém um número de dígitos fracionários igual a decimals.The number nearest to d that contains a number of fractional digits equal to decimals.

Exceções

decimals é menor que 0 ou maior que 28.decimals is less than 0 or greater than 28.

O resultado é fora do intervalo de um Decimal.The result is outside the range of a Decimal.

Comentários

O valor do decimals argumento pode variar de 0 a 28.The value of the decimals argument can range from 0 to 28.

Esse método usa a Convenção de arredondamento MidpointRounding.ToEvenpadrão de.This method uses the default rounding convention of MidpointRounding.ToEven. Consulte valores de ponto médio e convenções de arredondamento para obter informações sobre arredondamento de números com valores de ponto médio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade.When rounding midpoint values, the rounding algorithm performs an equality test. 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.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para saber mais, confira "Arredondamento e precisão".For more information, see "Rounding and precision".

ExemploExample

O exemplo a seguir arredonda valores decimais com dois dígitos fracionários para valores que têm um único dígito fracionário.The following example rounds decimal values with two fractional digits to values that have a single fractional digit.

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

Console.WriteLine(Math.Round(4.34m, 1)); 
Console.WriteLine(Math.Round(4.35m, 1)); 
Console.WriteLine(Math.Round(4.36m, 1)); 
// The example displays the following output:
//       3.4
//       3.4
//       3.5
//       
//       4.3
//       4.4
//       4.4
Public Module Example
   Sub Main()
      Console.WriteLine(Math.Round(3.44, 1)) 
      Console.WriteLine(Math.Round(3.45, 1)) 
      Console.WriteLine(Math.Round(3.46, 1)) 
      Console.WriteLine()
      
      Console.WriteLine(Math.Round(4.34, 1)) 
      Console.WriteLine(Math.Round(4.35, 1)) 
      Console.WriteLine(Math.Round(4.36, 1)) 
   End Sub  
End Module
' The example displays the following output:
'       3.4
'       3.4
'       3.5
'       
'       4.3
'       4.4
'       4.4

Veja também

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.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.A decimal number to be rounded.

Retornos

O inteiro mais próximo do parâmetro d.The integer nearest the d parameter. 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.If the fractional component of d is halfway between two integers, one of which is even and the other odd, the even number is returned. Observe que esse método retorna um Decimal em vez de um tipo integral.Note that this method returns a Decimal instead of an integral type.

Exceções

O resultado é fora do intervalo de um Decimal.The result is outside the range of a Decimal.

Comentários

Esse método usa a Convenção de arredondamento MidpointRounding.ToEvenpadrão de.This method uses the default rounding convention of MidpointRounding.ToEven. Consulte valores de ponto médio e convenções de arredondamento para obter informações sobre arredondamento de números com valores de ponto médio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade.When rounding midpoint values, the rounding algorithm performs an equality test. 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.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para saber mais, confira "Arredondamento e precisão".For more information, see "Rounding and precision".

ExemploExample

O exemplo a seguir demonstra Round(Decimal) o método.The following example demonstrates the Round(Decimal) method. Observe que o Decimal valor de 4,5 arredonda para 4 em vez de 5, pois essa sobrecarga usa a ToEven convenção padrão.Note that the Decimal value of 4.5 rounds to 4 rather than 5, because this overload uses the default ToEven convention.

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

Veja também

Round(Decimal, MidpointRounding)

Arredonda um valor decimal para o inteiro mais próximo e usa a convenção de arredondamento especificada para os valores de ponto médio.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.A decimal number to be rounded.

mode
MidpointRounding

Especificação de como arredondar d se o valor estiver entre dois outros números.Specification for how to round d if it is midway between two other numbers.

Retornos

O inteiro mais próximo de d.The integer nearest d. Se d estiver entre dois números, sendo um deles par e o outro ímpar, mode determinará qual dos dois será retornado.If d is halfway between two numbers, one of which is even and the other odd, then mode determines which of the two is returned. Observe que esse método retorna um Decimal em vez de um tipo integral.Note that this method returns a Decimal instead of an integral type.

Exceções

mode não é um valor válido de MidpointRounding.mode is not a valid value of MidpointRounding.

O resultado é fora do intervalo de um Decimal.The result is outside the range of a Decimal.

Comentários

Consulte valores de ponto médio e convenções de arredondamento para obter informações sobre arredondamento de números com valores de ponto médio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Ao arredondar valores de ponto médio, o algoritmo de arredondamento executa um teste de igualdade.When rounding midpoint values, the rounding algorithm performs an equality test. 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.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para saber mais, confira "Arredondamento e precisão".For more information, see "Rounding and precision".

ExemploExample

O exemplo a seguir exibe valores retornados pelo Round(Decimal) método, o Round(Decimal, MidpointRounding) método com um mode argumento de ToEvene o Round(Decimal, MidpointRounding) método com um mode argumento de AwayFromZero.The following example displays values returned by the Round(Decimal) method, the Round(Decimal, MidpointRounding) method with a mode argument of ToEven, and the Round(Decimal, MidpointRounding) method with a mode argument of AwayFromZero.

Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                  "ToEven", "AwayFromZero");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
   Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                     value, Math.Round(value), 
                     Math.Round(value, MidpointRounding.ToEven),
                     Math.Round(value, MidpointRounding.AwayFromZero));
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero
//       12         12         12         12
//       12.1       12         12         12
//       12.2       12         12         12
//       12.3       12         12         12
//       12.4       12         12         12
//       12.5       12         12         13
//       12.6       13         13         13
//       12.7       13         13         13
//       12.8       13         13         13
//       12.9       13         13         13
//       13.0       13         13         13
Module Example
   Public Sub Main()
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero")
      For value As Decimal = 12.0d To 13.0d Step .1d
         Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero
'       12         12         12         12
'       12.1       12         12         12
'       12.2       12         12         12
'       12.3       12         12         12
'       12.4       12         12         12
'       12.5       12         12         13
'       12.6       13         13         13
'       12.7       13         13         13
'       12.8       13         13         13
'       12.9       13         13         13
'       13.0       13         13         13

Veja também

Aplica-se a