Algorithme .Net intégré pour arrondir les valeurs à l'intervalle de 10 le plus proche.

Question

Comment, en C#, arrondir une valeur quelconque à l'intervalle 10 ? Par exemple, si j'ai 11, je veux qu'il renvoie 10, si j'ai 136, alors je veux qu'il renvoie 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 un code identique ou similaire dans tous mes projets, même pour quelque chose d'aussi simple que ce qui précède.

Answer 1

Il n'existe pas de fonction intégrée dans la bibliothèque de classes qui permette de faire cela. La plus proche est System.Math.Round() qui ne sert qu'à arrondir les nombres de type Decimal et Double à la valeur entière la plus proche. Toutefois, si vous travaillez avec .NET 3.5, vous pouvez envelopper votre déclaration dans une méthode d'extension, ce qui vous permettra d'utiliser la fonction de manière beaucoup plus propre.

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 cadre .NET, supprimez simplement le "this" de la fonction RoundOff, et appelez la fonction comme suit :

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

Answer 2

Utilisez Math.Ceiling pour toujours arrondir vers le haut.

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

Le module (%) récupère le reste, donc on obtient :

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

édité ci-dessus : J'aurais dû suivre mon premier instinct et utiliser Math.Ceiling.

I a fait un blog sur ce sujet en calculant les chiffres du chèque UPC .

Answer 3

C'est peut-être un peu trop tard, mais je pense que cela pourrait être utile un jour...

J'ai essayé :

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

A 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 vers le haut ou vers le bas. =)

Answer 4

L'arrondi d'un flottant à un entier est similaire à (int)(x+0,5), par opposition au simple moulage de x - si vous voulez un multiple de 10, vous pouvez facilement adapter cela.

Si vous voulez simplement faire des calculs de nombres entiers et arrondir à dix, essayez (x+10/2)/10*10.

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

Answer 5

Je préfère ne pas apporter à l' Math bibliothèque et d'aller à la virgule flottante donc, ma suggestion est juste de faire de l'arithmétique des nombres entiers comme ci-dessous où j'en rond, jusqu'à la prochaine 1K. L'envelopper dans une méthode ou lambda extrait de code ou quelque chose si vous ne voulez pas de répéter.

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

Je n'ai pas exécuter les tests de performances sur ce vs d'autres moyens, mais je parierais que c'est le moyen le plus rapide pour ce faire économiser peut-être que le déplacement et la rotation des bits version de ce.