Comment arrondir au nombre entier le plus proche en C #

Comment arrondir les valeurs à l'entier le plus proche?

Par exemple:

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

"Math.Ceiling ()" ne m'aide pas. Des idées?

Consultez la documentation officielle pour en savoir plus. Par exemple:

En gros, vous donnez à la Math.Roundméthode trois paramètres.

1. La valeur que vous souhaitez arrondir.
2. Le nombre de décimales que vous souhaitez conserver après la valeur.
3. Un paramètre facultatif que vous pouvez appeler pour utiliser l'arrondi AwayFromZero. ( ignoré sauf si l'arrondi est ambigu, par exemple 1.5 )

Exemple de code:

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

Démo en direct

Vous en avez besoin MidpointRounding.AwayFromZerosi vous voulez qu'une valeur de .5 soit arrondie. Malheureusement, ce n'est pas le comportement par défaut pour Math.Round(). Si vous utilisez MidpointRounding.ToEven(valeur par défaut), la valeur est arrondie au nombre pair le plus proche ( 1.5est arrondie à 2, mais 2.5est également arrondie à 2).

Math.Ceiling

arrondit toujours vers le haut (vers le plafond)

Math.Floor

arrondit toujours vers le bas (vers le sol)

ce que vous recherchez est simplement

Math.Round

qui arrondit selon ce post

Vous avez besoin Math.Round, non Math.Ceiling. Ceiling"arrondit" toujours vers le haut, tandis que les Roundarrondis vers le haut ou vers le bas selon la valeur après la virgule décimale.

il y a ce manuel, et assez mignon aussi:

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

ajoutez simplement 0,5 à n'importe quel nombre, et transtypez-le en int (ou plancher) et il sera mathématiquement arrondi correctement: D

Vous pouvez utiliser Math.Round comme d'autres l'ont suggéré (recommandé), ou vous pouvez ajouter 0,5 et convertir en un entier (ce qui supprimera la partie décimale).

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

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

Juste un rappel. Méfiez-vous du double.

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

Vous avez la fonction Math.Round qui fait exactement ce que vous voulez.

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

cela arrondira au 5 le plus proche ou ne changera pas s'il est déjà divisible par 5

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

Je cherchais ceci, mais mon exemple était de prendre un nombre, tel que 4.2769 et de le déposer dans une plage de 4,3. Pas exactement la même chose, mais si cela aide:

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

Ensuite:

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

etc...

Utilisez Math.Round:

double roundedValue = Math.Round(value, 0)

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

Cela donnera le résultat:

var roundedVal = 3

Si vous travaillez avec des nombres entiers plutôt que des nombres à virgule flottante, voici le chemin.

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

Ici, "numr" et "denr" sont des entiers non signés.

En utilisant des Math.Round(number)arrondis au nombre entier le plus proche.

Écrivez votre propre méthode ronde. Quelque chose comme,

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