HOWTO · Csharp

Arredonde um valor duplo para um valor inteiro em C#

Em C#, `Math.Ceiling()`, `Math.Floor()` e `Math.Round()` arredondam um valor `double` para um valor inteiro, cada método segundo uma regra diferente.

Nesta página

Ao converter um double em int, escolha primeiro a regra de arredondamento. Use Math.Ceiling() para avançar em direção ao infinito positivo, Math.Floor() para avançar em direção ao infinito negativo e Math.Round() para escolher o valor inteiro mais próximo. Uma conversão explícita, como (int)value, trunca em direção a zero; ela não arredonda.

Os três métodos matemáticos retornam um double com valor integral. Portanto, converta o resultado quando precisar de um int. Se as entradas puderem ser grandes, verifique se o resultado está dentro do intervalo de int antes de convertê-lo.

Escolha uma regra de arredondamento antes de converter para int

A direção importa para valores dos dois lados de zero. Por exemplo, Math.Ceiling(-8.3) avança para -8, enquanto Math.Floor(-8.3) recua para -9. Nenhum dos métodos significa simplesmente “remover a parte fracionária”. Use esta comparação para escolher a operação adequada à sua aplicação:

Operação Regra Resultado de exemplo para 8.3 Resultado de exemplo para -8.3
Math.Ceiling(value) Em direção ao infinito positivo 9 -8
Math.Floor(value) Em direção ao infinito negativo 8 -9
Math.Round(value) Inteiro mais próximo; por padrão, empates no ponto médio vão para o par 8 -8
(int)value Truncamento em direção a zero 8 -8

A tabela mostra o resultado antes da conversão; cada método matemático retorna double. Uma conversão explícita para int preserva esses valores inteiros quando a entrada está dentro do intervalo de int. A escolha certa depende do que o inteiro representa: uma contagem, um limite ou uma estimativa arredondada podem exigir regras diferentes.

Execute este exemplo independente:

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

using System;

class Program
{
    static void Main()
    {
        double value = 8.3;
        double otherValue = -8.3;

        Console.WriteLine($"Ceiling: {(int)Math.Ceiling(value)}, {(int)Math.Ceiling(otherValue)}");
        Console.WriteLine($"Floor: {(int)Math.Floor(value)}, {(int)Math.Floor(otherValue)}");
        Console.WriteLine($"Nearest: {(int)Math.Round(value)}, {(int)Math.Round(otherValue)}");
        Console.WriteLine($"Cast: {(int)value}, {(int)otherValue}");
        Console.WriteLine($"Midpoints: {(int)Math.Round(2.5)}, {(int)Math.Round(3.5)}, {(int)Math.Round(2.5, MidpointRounding.AwayFromZero)}");
    }
}

Arredonde para cima com Math.Ceiling()

Math.Ceiling() retorna o menor double com valor integral que seja maior ou igual à entrada. Esse arredondamento ocorre em direção ao infinito positivo: um valor fracionário positivo avança para o próximo inteiro, enquanto um valor fracionário negativo avança para o inteiro mais próximo de zero. Converta o resultado para int somente depois de verificar se ele pode ser representado como int.

Use essa regra quando o resultado não puder ser menor que o valor original, como ao calcular quantos recipientes inteiros são necessários para armazenar uma quantidade. Por exemplo, Math.Ceiling(7.3) resulta no double de valor integral 8; (int)Math.Ceiling(7.3) produz um inteiro se o valor estiver dentro do intervalo adequado de int. Se o requisito for “arredondar para longe de zero”, Ceiling não atende a essa regra para valores negativos.

Arredonde para baixo com Math.Floor()

Math.Floor() retorna o maior double com valor integral que seja menor ou igual à entrada. O arredondamento ocorre em direção ao infinito negativo. Assim, Math.Floor(7.8) resulta em 7, e Math.Floor(-7.8) resulta em -8. Essa diferença é importante: aplicar o piso a um valor negativo não significa apenas descartar suas casas fracionárias.

Use Math.Floor() quando o resultado não puder exceder a entrada, por exemplo, ao calcular o número de unidades completas em uma quantidade medida. Assim como com Ceiling, converta o double retornado para int somente se o resultado couber no intervalo de inteiros. Se quiser descartar a parte fracionária sempre em direção a zero, use uma conversão explícita ou Math.Truncate().

Arredonde para o inteiro mais próximo com Math.Round()

Math.Round() seleciona o valor inteiro mais próximo e o retorna como double. Por padrão, os empates no ponto médio são arredondados para o par: quando um valor está exatamente entre dois inteiros, é escolhido o inteiro par. Por exemplo, Math.Round(2.5) escolhe 2, enquanto Math.Round(3.5) escolhe 4. Isso reduz o viés direcional em cálculos repetidos que envolvem valores no ponto médio.

Para escolher a outra regra comum de desempate, passe MidpointRounding.AwayFromZero: Math.Round(2.5, MidpointRounding.AwayFromZero) escolhe 3, e Math.Round(-2.5, MidpointRounding.AwayFromZero) escolhe -3. Essa opção altera o tratamento dos pontos médios; ela não faz com que todos os valores sejam arredondados para longe de zero. Quando necessário, converta o resultado arredondado para int, desde que ele esteja dentro do intervalo.

Valores de ponto flutuante binário podem representar algumas frações decimais apenas aproximadamente. Se um valor deveria ser exatamente um ponto médio, mas foi calculado a partir de outros valores de ponto flutuante, o valor armazenado pode ficar ligeiramente de um lado ou do outro do ponto médio. Para regras que dependem de quantidades decimais exatas, considere representar os dados com decimal e usar a sobrecarga correspondente de Math.Round, escolhendo ainda o modo de desempate desejado.

Por que uma conversão explícita não é arredondamento

Uma conversão explícita de double para int trunca a parte fracionária em direção a zero. Por exemplo, (int)8.9 resulta em 8, e (int)(-8.9) resulta em -8. O segundo resultado difere de Math.Floor(-8.9), que é -9, e do arredondamento para o inteiro mais próximo, que escolhe o inteiro mais próximo de acordo com a regra de desempate selecionada.

Use uma conversão explícita quando o truncamento for a operação desejada, e não como atalho para “arredondar para um inteiro”. Se a entrada puder estar fora do intervalo de int, trate esse intervalo explicitamente antes da conversão; caso contrário, o resultado poderá não representar o valor esperado pela aplicação. Em resumo, escolha Math.Ceiling() para obter um limite em direção ao infinito positivo, Math.Floor() para um limite em direção ao infinito negativo, Math.Round() para o inteiro mais próximo e uma conversão explícita somente para truncar em direção a zero.