Встроенный алгоритм .Net для округления значения до ближайшего 10 интервалов

Как на С# округлить любое значение до 10 интервалов? Например, если у меня есть 11, я хочу, чтобы он возвращал 10, если у меня есть 136, то я хочу, чтобы он возвращал 140.

Я легко могу сделать это вручную

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

Но я ищу встроенный алгоритм для выполнения этой работы, что-то вроде Math.Round(). Причина, по которой я не хочу делать вручную, заключается в том, что я не хочу писать один и тот же или похожий фрагмент кода по всем моим проектам, даже для чего-то простого, как указано выше.

Ответ 1

В библиотеке классов нет встроенной функции, которая будет делать это. Самый близкий System.Math.Round(), который предназначен только для округления чисел типов Decimal и Double до ближайшего целочисленного значения. Тем не менее, вы можете обернуть свой оператор в метод расширения, если вы работаете с .NET 3.5, что позволит вам использовать эту функцию намного чище.

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

Если вы программируете более старую версию платформы .NET, просто удалите "this" из функции RoundOff и вызовите функцию следующим образом:

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

Ответ 2

Используйте Math.Ceiling, чтобы всегда округлять.

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

Модуль (%) получает остаток, поэтому вы получаете:

// number = 236 + 10 - 6

Поместите это в метод расширения

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

выше отредактировано: я должен был с первого инстинкта использовать Math.Ceiling

I сообщается об этом при расчете контрольных цифр UPC.

Ответ 3

Это может быть слишком поздно, но я думаю, что это может быть полезно когда-нибудь...

Я пробовал это:

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

Для использования:

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

Таким образом, у вас есть опция, будет ли половина интервала округлена или округлена. =)

Ответ 4

Округление float на целое число похоже на (int) (x + 0,5), а не просто наложение x - если вам нужно несколько из 10, вы можете легко адаптировать это.

Если вы просто хотите сделать целочисленную математику и округлите ее до десяти, попробуйте (x + 10/2)/10 * 10.

Изменить: Я заметил, что этот ответ не соответствует первоначальному запросу автора, а также является предвзятой формой округления, которую я предпочитаю не делать. Однако другой принятый ответ уже заявил Math.round(), гораздо лучшее решение.

Ответ 5

Я предпочитаю не вносить библиотеку Math и не переходить к плавающей точке, поэтому мое предложение просто выполняет целочисленную арифметику, как показано ниже, где я округляю до следующего 1K. Оберните его методом или фрагментом лямбда или чем-то, если вы не хотите повторять.

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

Я не выполнял тесты производительности на этом и других способах, но я бы поставил, что это самый быстрый способ сделать это, за исключением, возможно, смещения и вращения версии битов этого.

Ответ 6

Старый вопрос, но вот способ сделать то, что было задано, плюс я расширил его, чтобы иметь возможность округлить любое число до количества сиг-фигов, которые вы хотите.

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