Math.Round Método

Definição

Namespace:

System

Assembly:

System.Runtime.dll

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

Sobrecargas

Round(Double, Int32, MidpointRounding)	Arredonda um valor de ponto flutuante de precisão dupla para um número especificado de dígitos fracionários usando a convenção de arredondamento especificada.
Round(Decimal, Int32, MidpointRounding)	Arredonda um valor decimal para um número especificado de dígitos fracionários usando a convenção de arredondamento especificada.
Round(Double, MidpointRounding)	Arredonda um valor de ponto flutuante de precisão dupla para um inteiro usando a convenção de arredondamento especificada.
Round(Double, Int32)	Arredonda um valor de ponto flutuante de precisão dupla para o número especificado de dígitos fracionários e arredonda os valores de ponto médio para o número par mais próximo.
Round(Decimal, Int32)	Arredonda um valor decimal para o número especificado de dígitos fracionários e arredonda os valores de ponto médio para o número par mais próximo.
Round(Double)	Arredonda um valor de ponto flutuante de precisão dupla para o valor inteiro mais próximo e arredonda os valores de ponto médio para o número par mais próximo.
Round(Decimal)	Arredonda um valor decimal para o valor inteiro mais próximo e arredonda os valores de ponto médio para o número par mais próximo.
Round(Decimal, MidpointRounding)	Arredonda um valor decimal de um inteiro usando a convenção de arredondamento especificada.

Exemplos

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

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

Comentários

Nesta seção:

• Qual método devo chamar?
• Valores de ponto médio e convenções arredondamento
• Arredondamento e precisão
• Valores de ponto flutuante de precisão única e arredondamento
• Exemplos de sobrecargas individuais

Qual método devo chamar?

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

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

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

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

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

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

• Arredondando para longe de zero

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

• Arredondando para o mais próximo até mesmo, ou arredondamento do banqueiro

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

Observação

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

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

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

C#

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

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

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

Arredondamento e precisão

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

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

C#

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

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

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

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

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

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

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

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

  C#

  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
  

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

C#

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

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

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

Round(Double, Int32, MidpointRounding)

Origem:

Math.cs

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

C#

public static double Round (double value, int digits, MidpointRounding mode);

Parâmetros

value

Double

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

digits

Int32

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

mode

MidpointRounding

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

Retornos

Double

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

Exceções

ArgumentOutOfRangeException

digits é menor que 0 ou maior que 15.

ArgumentException

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

Comentários

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

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

Importante

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

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

Exemplo

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

C#

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

Notas aos Chamadores

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

C#

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

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

Confira também

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, Int32, MidpointRounding)

Round(Decimal, Int32, MidpointRounding)

Origem:

Math.cs

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

C#

public static decimal Round (decimal d, int decimals, MidpointRounding mode);

Parâmetros

d

Decimal

Um número decimal a ser arredondado.

decimals

Int32

O número de casas decimais no valor retornado.

mode

MidpointRounding

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

Retornos

Decimal

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

Exceções

ArgumentOutOfRangeException

decimals é menor que 0 ou maior que 28.

ArgumentException

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

OverflowException

O resultado é fora do intervalo de um Decimal.

Comentários

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

Importante

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

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

Exemplo

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

C#

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

Confira também

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, Int32, MidpointRounding)

Round(Double, MidpointRounding)

Origem:

Math.cs

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

C#

public static double Round (double value, MidpointRounding mode);

Parâmetros

value

Double

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

mode

MidpointRounding

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

Retornos

Double

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

Exceções

ArgumentException

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

Comentários

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

Importante

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

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

Exemplo

O exemplo a seguir exibe valores retornados pelo Round(Double, MidpointRounding) método com valores diferentes mode .

C#

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

Notas aos Chamadores

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

C#

using System;

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

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

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

Confira também

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, MidpointRounding)

Round(Double, Int32)

Origem:

Math.cs

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.

C#

public static double Round (double value, int digits);

Parâmetros

value

Double

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

digits

Int32

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

Retornos

Double

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

Exceções

ArgumentOutOfRangeException

digits é menor que 0 ou maior que 15.

Comentários

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

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

Importante

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

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

Exemplo

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

C#

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 digits em valores de ponto flutuante, em alguns casos o Round(Double, Int32) método pode não parecer arredondar valores de ponto médio para o valor par mais próximo na posição decimal. Isso é ilustrado no exemplo a seguir, em que 2.135 é arredondado para 2.13 em vez de 2.14. Isso ocorre porque internamente o método multiplica-se value por 10^dígitos e a operação de multiplicação nesse caso sofre uma perda de precisão.

C#

using System;

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

Confira também

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, Int32)

Round(Decimal, Int32)

Origem:

Math.cs

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.

C#

public static decimal Round (decimal d, int decimals);

Parâmetros

d

Decimal

Um número decimal a ser arredondado.

decimals

Int32

O número de casas decimais no valor retornado.

Retornos

Decimal

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

Exceções

ArgumentOutOfRangeException

decimals é menor que 0 ou maior que 28.

OverflowException

O resultado é fora do intervalo de um Decimal.

Comentários

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

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

Importante

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

Exemplo

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

C#

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

Confira também

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, Int32)

Round(Double)

Origem:

Math.cs

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.

C#

public static double Round (double a);

Parâmetros

a

Double

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

Retornos

Double

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

Comentários

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

Importante

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

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

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

VB

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

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

Exemplo

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

C#

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

Notas aos Chamadores

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

C#

using System;

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

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

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

Confira também

• Ceiling(Double)
• Floor(Double)
• Round(Decimal)

Round(Decimal)

Origem:

Math.cs

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.

C#

public static decimal Round (decimal d);

Parâmetros

d

Decimal

Um número decimal a ser arredondado.

Retornos

Decimal

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

Exceções

OverflowException

O resultado é fora do intervalo de um Decimal.

Exemplos

O exemplo a seguir demonstra o Round(Decimal) método. O Decimal valor de 4,5 arredonda para 4 em vez de 5, pois essa sobrecarga usa a convenção padrão ToEven .

C#

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

Comentários

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

Importante

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

Confira também

• Ceiling(Double)
• Floor(Double)
• Round(Decimal)

Round(Decimal, MidpointRounding)

Origem:

Math.cs

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

C#

public static decimal Round (decimal d, MidpointRounding mode);

Parâmetros

d

Decimal

Um número decimal a ser arredondado.

mode

MidpointRounding

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

Retornos

Decimal

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

Exceções

ArgumentException

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

OverflowException

O resultado é fora do intervalo de um Decimal.

Comentários

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

Importante

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

Exemplo

O exemplo a seguir exibe valores retornados pelo Round(Decimal, MidpointRounding) método com valores diferentes mode .

C#

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

Confira também

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, MidpointRounding)