Algorithme .Net intégré pour arrondir la valeur au 10ème intervalle le plus proche

Question

Comment, en C #, arrondir une valeur à 10 intervalles? Par exemple, si j'ai 11, je veux qu'il en retourne 10, si j'en ai 136, alors je veux qu'il en retourne 140.

Je peux facilement le faire à la main

return ((int)(number / 10)) * 10;

Mais je cherche un algorithme intégré pour faire ce travail, quelque chose comme Math.Round (). La raison pour laquelle je ne veux pas le faire à la main est que je ne veux pas écrire le même code ou un morceau de code similaire dans tous mes projets, même pour quelque chose d'aussi simple que ce qui est décrit ci-dessus.

Answer 1

Il n'y a pas de fonction intégrée dans la bibliothèque de classes qui le fasse. Le plus proche est System.Math.Round () , qui est uniquement destiné à arrondir les nombres de types Decimal et Double à la valeur entière la plus proche. Cependant, vous pouvez envelopper votre instruction dans une méthode d'extension, si vous travaillez avec .NET 3.5, ce qui vous permettra d'utiliser la fonction beaucoup plus proprement.

public static class ExtensionMethods
{
    public static int RoundOff (this int i)
    {
        return ((int)Math.Round(i / 10.0)) * 10;
    }
}

int roundedNumber = 236.RoundOff(); // returns 240
int roundedNumber2 = 11.RoundOff(); // returns 10

Si vous programmez avec une ancienne version du framework .NET, supprimez simplement le fichier "this". à partir de la fonction RoundOff, et appelez-la comme suit:

int roundedNumber = ExtensionMethods.RoundOff(236); // returns 240
int roundedNumber2 = ExtensionMethods.RoundOff(11); // returns 10

Answer 2

Utilisez Math.Ceiling pour toujours arrondir.

int number = 236;
number = (int)(Math.Ceiling(number / 10.0d) * 10);

Module (%) obtient le reste, vous obtenez donc:

// number = 236 + 10 - 6

Mettez cela dans une méthode d'extension

public static int roundupbyten(this int i){
    // return i + (10 - i % 10); <-- logic error. Oops!
    return (int)(Math.Ceiling(i / 10.0d)*10); // fixed
}

// call like so:
int number = 236.roundupbyten();

ci-dessus modifié: j'aurais dû utiliser mon premier instinct d'utiliser Math.Ceiling

J'ai blogué à ce sujet lors du calcul des chiffres de contrôle UPC .

Answer 3

C’est peut-être un peu trop tard, mais j’imagine que cela pourrait être utile un jour ...

J'ai essayé ceci:

public int RoundOff(int number, int interval){
    int remainder = number % interval;
    number += (remainder < interval / 2) ? -remainder : (interval - remainder);
    return number;
}

Pour utiliser:

int number = 11;
int roundednumber = RoundOff(number, 10);

De cette façon, vous avez la possibilité de choisir si la moitié de l'intervalle sera arrondie ou arrondie. =)

Answer 4

Arrondir un nombre à virgule flottante en un entier est similaire à (int) (x + 0,5), par opposition à la simple conversion de x - si vous voulez un multiple de 10, vous pouvez facilement l'adapter.

Si vous souhaitez simplement calculer des nombres entiers et les arrondir à dix, essayez (x + 10/2) / 10 * 10.

Modifier: j'ai remarqué que cette réponse ne répond pas à la demande de l'auteur de l'original et constitue également une forme d'arrondi biaisée que je préfère ne pas faire. Cependant, une autre réponse acceptée indiquait déjà Math.round (), une solution bien meilleure.

Answer 5

Vieille question, mais voici une façon de faire ce qui a été demandé et je l’ai étendue pour pouvoir arrondir n’importe quel nombre au nombre de figures que vous voulez.

    private double Rounding(double d, int digits)
    {
        int neg = 1;
        if (d < 0)
        {
            d = d * (-1);
            neg = -1;
        }

        int n = 0;
        if (d > 1)
        {
            while (d > 1)
            {
                d = d / 10;
                n++;
            }
            d = Math.Round(d * Math.Pow(10, digits));
            d = d * Math.Pow(10, n - digits);
        }
        else
        {
            while (d < 0.1)
            {
                d = d * 10;
                n++;
            }
            d = Math.Round(d * Math.Pow(10, digits));
            d = d / Math.Pow(10, n + digits);
        }

        return d*neg;
    }


   private void testing()
   {
       double a = Rounding(1230435.34553,3);
       double b = Rounding(0.004567023523,4);
       double c = Rounding(-89032.5325,2);
       double d = Rounding(-0.123409,4);
       double e = Rounding(0.503522,1);
       Console.Write(a.ToString() + "\n" + b.ToString() + "\n" + 
           c.ToString() + "\n" + d.ToString() + "\n" + e.ToString() + "\n");
   }

Answer 6

Je préfère ne pas importer la bibliothèque Math , ni aller en virgule flottante. Je vous suggère donc de faire de l'arithmétique entière, comme ci-dessous, où je arrondis au 1K suivant. Enveloppez-le dans une méthode ou un extrait de code lambda ou quelque chose si vous ne voulez pas répéter.

int MyRoundedUp1024Int = ((lSomeInteger + 1023) / 1024) * 1024;

Je n’ai pas testé les performances de ce produit par rapport à d’autres, mais je parierais que c’est le moyen le plus rapide de le faire, sauf peut-être une version décalée et rotative de bits.