Como arredondar para o número inteiro mais próximo em C #

Como posso arredondar os valores para o número inteiro mais próximo?

Por exemplo:

1.1 => 1
1.5 => 2
1.9 => 2

"Math.Ceiling ()" não está me ajudando. Alguma ideia?

Veja a documentação oficial para mais. Por exemplo:

Basicamente, você dá ao Math.Roundmétodo três parâmetros.

1. O valor que você deseja arredondar.
2. O número de decimais que você deseja manter após o valor.
3. Um parâmetro opcional que você pode invocar para usar o arredondamento AwayFromZero. ( ignorado a menos que o arredondamento seja ambíguo, por exemplo, 1,5 )

Código de amostra:

var roundedA = Math.Round(1.1, 0); // Output: 1
var roundedB = Math.Round(1.5, 0, MidpointRounding.AwayFromZero); // Output: 2
var roundedC = Math.Round(1.9, 0); // Output: 2
var roundedD = Math.Round(2.5, 0); // Output: 2
var roundedE = Math.Round(2.5, 0, MidpointRounding.AwayFromZero); // Output: 3
var roundedF = Math.Round(3.49, 0, MidpointRounding.AwayFromZero); // Output: 3

Demonstração ao vivo

Você precisa MidpointRounding.AwayFromZerose quiser que um valor 0,5 seja arredondado para cima. Infelizmente, este não é o comportamento padrão para Math.Round(). Se estiver usando MidpointRounding.ToEven(o padrão), o valor é arredondado para o número par mais próximo ( 1.5é arredondado para 2, mas 2.5também é arredondado para 2).

Math.Ceiling

sempre arredonda para cima (em direção ao teto)

Math.Floor

sempre arredonda para baixo (em direção ao chão)

o que você busca é simplesmente

Math.Round

que ronda de acordo com esta postagem

Você precisa Math.Round, não Math.Ceiling. Ceilingsempre "arredonda" para cima, enquanto Roundarredonda para cima ou para baixo, dependendo do valor após o ponto decimal.

tem este manual, e um jeito meio fofo também:

double d1 = 1.1;
double d2 = 1.5;
double d3 = 1.9;

int i1 = (int)(d1 + 0.5);
int i2 = (int)(d2 + 0.5);
int i3 = (int)(d3 + 0.5);

simplesmente adicione 0,5 a qualquer número e lance-o para int (ou base) e ele será arredondado matematicamente de maneira correta: D

Você pode usar Math.Round como outros sugeriram (recomendado), ou você pode adicionar 0,5 e converter para um int (o que eliminará a parte decimal).

double value = 1.1;
int roundedValue = (int)(value + 0.5); // equals 1

double value2 = 1.5;
int roundedValue2 = (int)(value2 + 0.5); // equals 2

Apenas um lembrete. Cuidado com o dobro.

Math.Round(0.3 / 0.2 ) result in 1, because in double 0.3 / 0.2 = 1.49999999
Math.Round( 1.5 ) = 2

Você tem a função Math.Round que faz exatamente o que você deseja.

Math.Round(1.1) results with 1
Math.Round(1.8) will result with 2.... and so one.

isso será arredondado para o próximo 5 ou não mudará se já for divisível por 5

public static double R(double x)
{
    // markup to nearest 5
    return (((int)(x / 5)) * 5) + ((x % 5) > 0 ? 5 : 0);
}

Eu estava procurando por isso, mas meu exemplo foi pegar um número, como 4,2769 e soltá-lo em um intervalo de apenas 4,3. Não é exatamente o mesmo, mas se isso ajudar:

Model.Statistics.AverageReview   <= it's just a double from the model

Então:

@Model.Statistics.AverageReview.ToString("n1")   <=gives me 4.3
@Model.Statistics.AverageReview.ToString("n2")   <=gives me 4.28

etc ...

Use Math.Round:

double roundedValue = Math.Round(value, 0)

var roundedVal = Math.Round(2.5, 0);

Isso dará resultado:

var roundedVal = 3

Se você está trabalhando com inteiros em vez de números de ponto flutuante, aqui está o caminho.

#define ROUNDED_FRACTION(numr,denr) ((numr/denr)+(((numr%denr)<(denr/2))?0:1))

Aqui ambos "numr" quanto "denr" são inteiros sem sinal.

Usando Math.Round(number)rodadas para o número inteiro mais próximo.

Escreva seu próprio método de rodada. Algo como,

function round(x) rx = Math.ceil(x) if (rx - x <= .000001) return int(rx) else return int(x) end

decimal RoundTotal = Total - (int)Total;
if ((double)RoundTotal <= .50)
   Total = (int)Total;
else
   Total = (int)Total + 1;
lblTotal.Text = Total.ToString();