Comment arrondir en haut ou en bas en C#?

j'ai essayé les maths.Round & MidpointRounding. Cela ne semble pas faire ce dont j'ai besoin.

Exemple:

52.34567 rounded to 2 decimals UP   = 52.35  
 1.183   rounded to 2 decimals DOWN =  1.18

Dois-je écrire une fonction personnalisée?

Edit:

j'aurais dû être plus précis.

parfois j'ai besoin d'un nombre comme 23.567 pour arrondir à 23.56. Dans ce scénario...

Math.Round(dec, 2, MidpointRounding.AwayFromZero) gives 23.57
Math.Round(dec, 2, MidpointRounding.ToEven) gives 23.57

nombres décimaux jusqu'à 9 décimales pouvait venir et doivent être arrondies à 1, 2, 3 ou même 4 décimales lieu.

20
demandé sur Jerry Coffin 2012-11-21 01:07:19

8 réponses

essayez d'utiliser la décimale.Tour (la):

decimal.Round(x, 2)

Où x est votre valeur et 2 est le nombre de décimales que vous souhaitez conserver.

Vous pouvez également spécifier si .5 tours vers le haut ou vers le bas en passant troisième paramètre:

decimal.Round(x, 2, MidpointRounding.AwayFromZero);

EDIT:

À la lumière de la nouvelle exigence (c'est à dire que les chiffres sont parfois arrondies vers le bas en dépit d'être supérieure à "mi-chemin" à l'intervalle suivant), vous pouvez essayer:

var pow = Math.Pow(10, numDigits);
var truncated = Math.Truncate(x*pow) / pow;

Truncate() lops au large de la non-partie entière de la décimale. Notez que numDigits ci-dessus devrait être le nombre de chiffres que vous voulez garder, pas le nombre total de décimales, etc.

enfin, si vous voulez forcer un round vers le haut (la troncature est vraiment un round vers le bas forcé), vous n'avez qu'à ajouter 1 au résultat du Truncate() appeler avant de diviser à nouveau.

38
répondu atkretsch 2012-11-20 22:09:39

Essayez d'utiliser Math.Ceiling (haut) ou Math.Floor (vers le bas). e.g Math.Floor(1.8) == 1.

22
répondu pascalhein 2012-11-20 21:29:08

en supposant que vous utilisez le decimal tapez pour vos numéros,

static class Rounding
{
    public static decimal RoundUp(decimal number, int places)
    {
        decimal factor = RoundFactor(places);
        number *= factor;
        number = Math.Ceiling(number);
        number /= factor;
        return number;
    }

    public static decimal RoundDown(decimal number, int places)
    {
        decimal factor = RoundFactor(places);
        number *= factor;
        number = Math.Floor(number);
        number /= factor;
        return number;
    }

    internal static decimal RoundFactor(int places)
    {
        decimal factor = 1m;

        if (places < 0)
        {
            places = -places;
            for (int i = 0; i < places; i++)
                factor /= 10m;
        }

        else
        {
            for (int i = 0; i < places; i++)
                factor *= 10m;
        }

        return factor;
    }
}

Exemple:

Rounding.RoundDown(23.567, 2) prints 23.56
14
répondu Jeff E 2012-11-20 22:06:11

pour une version plus courte de la réponse acceptée, voici le RoundUp et RoundDown les fonctions qui peuvent être utilisées:

public double RoundDown(double number, int decimalPlaces)
{
    return Math.Floor(number * Math.Pow(10, decimalPlaces)) / Math.Pow(10, decimalPlaces);
}

public double RoundUp(double number, int decimalPlaces)
{
    return Math.Ceiling(number * Math.Pow(10, decimalPlaces)) / Math.Pow(10, decimalPlaces);
}
6
répondu B-Rad 2018-04-22 21:15:55

Math la classe vous donne des méthodes à utiliser pour arrondir vers le haut et vers le bas, ils sont Math.Ceiling() et Math.Floor() respectivement. Ils fonctionnent comme des Math.Round(), mais ils ont une particularité, ils ne reçoivent qu'une valeur et ne les entourent que de la partie entière.

vous devez donc utiliser Math.Pow() pour multiplier la valeur par 10 aux unités n-esimal vous devez arrondir la puissance et ensuite vous devez diviser par la même valeur multipliée.

Est important que vous notez que les paramètres d'entrée de Math.Pow() méthode double, donc vous devez les convertir en double.

Par exemple:

quand vous voulez arrondir la valeur à 3 décimales (supposons que le type de valeur est decimal):

double decimalsNumber = 3;
decimal valueToRound = 1.1835675M;
// powerOfTen must be equal to 10^3 or 1000.
double powerOfTen = Math.Pow(10, decimalsNumber);
// rounded must be equal to Math.Ceiling(1.1835675 * 1000) / 1000
decimal rounded = Math.Ceiling(valueToRound * (decimal)powerOfTen) / (decimal)powerOfTen;


Result: rounded = 1.184

quand vous voulez arrondir la valeur à 3 décimales (supposons que le type de valeur est decimal):

double decimalsNumber = 3;
decimal valueToRound = 1.1835675M;
// powerOfTen must be equal to 10^3 or 1000.
double powerOfTen = Math.Pow(10, decimalsNumber);
// rounded must be equal to Math.Floor(1.1835675 * 1000) / 1000
decimal rounded = Math.Floor(valueToRound * (decimal)powerOfTen) / (decimal)powerOfTen;


Result: rounded = 1.183

pour faire référence À la façon de les utiliser plus spécialement et pour obtenir plus d'informations et sur les deux méthodes, vous pouvez voir ces pages du site officiel de Microsoft MSDN:

Classe De Mathématiques

Math.Méthode Pow (Double, Double)

Math.Méthode Du Plancher (Décimal)

Math.Méthode Du Plancher (Double)

Math.Méthode Du Plafond (Décimal)

Math.Méthode Du Plafond (Double)

1
répondu CryogenicNeo 2018-04-27 13:05:58

essayer cette coutume, arrondi

public int Round(double value)
{
    double decimalpoints = Math.Abs(value - Math.Floor(value));
    if (decimalpoints > 0.5)
        return (int)Math.Round(value);
    else
        return (int)Math.Floor(value);
}
0
répondu anand360 2016-04-20 04:36:58

peut-être ceci?

Math.Round(dec + 0.5m, MidpointRounding.AwayFromZero);
0
répondu Albert Tolokonnikov 2016-06-24 01:09:10

code complet avec résultat.

  double a = Math.Round(128.5, 0, MidpointRounding.AwayFromZero);

le résultat est 129

0
répondu Nikhil S 2016-08-12 10:15:08