web-dev-qa-db-fra.com

Comment arrondir en C #?

J'ai essayé d'utiliser Math.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?

Modifier:

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

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

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

Des décimales jusqu'à 9 décimales peuvent apparaître et doivent être arrondies à 1, 2, 3 ou même 4 décimales.

c#math
20
B-Rad

Essayez d'utiliser decimal.Round ():

decimal.Round(x, 2)

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

Vous pouvez également spécifier si .5 arrondit au chiffre supérieur ou inférieur en passant le troisième paramètre:

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

MODIFIER:

À la lumière de la nouvelle exigence (c’est-à-dire que les chiffres sont parfois arrondis alors qu’ils sont supérieurs à la moitié de l’intervalle suivant), vous pouvez essayer:

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

Truncate () coupe la partie non entière de la décimale. Notez que numDigits ci-dessus devrait correspondre au nombre de chiffres que vous souhaitez GARDER, et non au nombre total de décimales, etc.

Enfin, si vous souhaitez forcer un arrondi (la troncature est vraiment un arrondi forcé), il vous suffit d'ajouter 1 au résultat de l'appel Truncate() avant de diviser à nouveau.

39
atkretsch

Essayez d’utiliser Math.Ceiling (haut) ou Math.Floor (bas). par exemple Math.Floor(1.8) == 1.

23
pascalhein

En supposant que vous utilisez le type decimal pour vos nombres,

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
Jeff E

Pour une version plus courte de la réponse acceptée, voici les fonctions RoundUp et RoundDown pouvant ê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);
}
7
B-Rad

Code complet avec résultat.

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

Le résultat est 129

1
Nikhil S

La classe Math vous donne les méthodes à utiliser pour arrondir de haut en bas, elles sont respectivement Math.Ceiling() et Math.Floor(). Ils fonctionnent comme Math.Round(), mais ils ont une particularité, ils ne reçoivent qu'une valeur et les arrondissent à la totalité de la pièce. 

Vous devez donc utiliser Math.Pow() pour multiplier la valeur par 10 en unités n-esimales dont vous avez besoin pour arrondir le pouvoir, puis diviser par la même valeur multipliée.

Il est important de noter que les paramètres d'entrée de la méthode Math.Pow() sont double, vous devez donc les convertir en double.

Par exemple:

Lorsque vous souhaitez arrondir la valeur à 3 décimales (en supposant 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

Lorsque vous voulez arrondir la valeur à 3 décimales (en supposant 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 savoir comment les utiliser plus spécifiquement et pour obtenir plus d'informations et sur les deux méthodes, vous pouvez consulter ces pages à partir du site officiel MSDN de Microsoft:

Cours de maths

Méthode Math.Pow (Double, Double)

Méthode Math.Floor (décimale)

Méthode Math.Floor (Double)

Méthode Math.Ceiling (décimale)

Méthode Math.Ceiling (Double)

1
CryogenicNeo

Peut être ça?

Math.Round(dec + 0.5m, MidpointRounding.AwayFromZero);
0
Albert Tolokonnikov

essayez cet arrondi personnalisé

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
anand360