Come arrotondare al numero intero più vicino in C #

Come posso arrotondare i valori all'intero più vicino?

Per esempio:

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

"Math.Ceiling ()" non mi sta aiutando. Qualche idea?

Vedere la documentazione ufficiale per ulteriori informazioni. Per esempio:

Fondamentalmente dai al Math.Roundmetodo tre parametri.

1. Il valore che vuoi arrotondare.
2. Il numero di decimali che vuoi mantenere dopo il valore.
3. Un parametro opzionale che puoi invocare per usare l'arrotondamento AwayFromZero. ( ignorato a meno che l'arrotondamento non sia ambiguo, ad esempio 1.5 )

Codice di esempio:

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

Dimostrazione dal vivo

È necessario MidpointRounding.AwayFromZerose si desidera che un valore .5 venga arrotondato per eccesso. Sfortunatamente questo non è il comportamento predefinito per Math.Round(). Se si utilizza MidpointRounding.ToEven(impostazione predefinita) il valore viene arrotondato al numero pari più vicino ( 1.5viene arrotondato a 2, ma 2.5anche arrotondato a 2).

Math.Ceiling

arrotonda sempre per eccesso (verso il soffitto)

Math.Floor

arrotonda sempre per difetto (verso il pavimento)

quello che cerchi è semplicemente

Math.Round

che arrotonda come da questo post

È necessario Math.Round, non è Math.Ceiling. Ceiling"arrotonda" sempre per eccesso, mentre Roundarrotonda per eccesso o per difetto a seconda del valore dopo il punto decimale.

c'è questo manuale, e anche un po 'carino:

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

aggiungi semplicemente 0,5 a qualsiasi numero e lancialo su int (o floor it) e sarà matematicamente arrotondato correttamente: D

Puoi usare Math.Round come altri hanno suggerito (consigliato), oppure puoi aggiungere 0.5 e cast a un int (che lascerà cadere la parte decimale).

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

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

Solo un promemoria. Attenzione al doppio.

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

Hai la funzione Math.Round che fa esattamente quello che vuoi.

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

questo verrà arrotondato al 5 più vicino o non cambierà se è già divisibile per 5

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

Lo stavo cercando, ma il mio esempio è stato quello di prendere un numero, come 4.2769 e rilasciarlo in un arco di tempo come solo 4.3. Non esattamente lo stesso, ma se questo aiuta:

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

Poi:

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

eccetera...

Usa Math.Round:

double roundedValue = Math.Round(value, 0)

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

Darà risultato:

var roundedVal = 3

Se lavori con numeri interi anziché numeri in virgola mobile, ecco il modo.

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

Qui sia "numr" che "denr" sono interi senza segno.

Utilizzo di Math.Round(number)arrotondamenti al numero intero più vicino.

Scrivi il tuo metodo circolare. Qualcosa di simile a,

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();