Как я могу удостовериться, что подразделение целых чисел всегда окружается?

ОБНОВЛЕНИЕ: Этот вопрос был темой моего блога в январе 2013 года . Спасибо за отличный вопрос!

Получить правильную целочисленную арифметику сложно. Как уже было достаточно продемонстрировано, в тот момент, когда вы пытаетесь выполнить «умный» трюк, высока вероятность того, что вы допустили ошибку. А когда обнаруживается недостаток, изменение кода для исправления недостатка без учета того, ломает ли исправление что-то еще , не является хорошим методом решения проблем. На данный момент, я думаю, у нас есть пять различных неверных целочисленных арифметических решений для этой совершенно не особо сложной проблемы.

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

Начните с прочтения спецификации того, что вы пытаетесь заменить. В спецификации для целочисленного деления четко указано:

1. При делении результат округляется до нуля

2. Результат равен нулю или положительному, если два операнда имеют одинаковый знак, и нулю или отрицательному, если два операнда имеют противоположные знаки

3. Если левый операнд - наименьшее представимое целое число, а правый операнд - –1, происходит переполнение. [...] это определяется реализацией относительно того, выбрасывается ли [ArithmeticException] или переполнение не сообщается с результирующим значением, равным значению левого операнда.

4. Если значение правого операнда равно нулю, система .DivideByZeroException выбрасывается.

Нам нужна функция целочисленного деления, которая вычисляет частное, но округляет результат всегда в сторону увеличения , а не всегда в сторону нуля .

Итак, напишите спецификацию для этой функции. Наша функция int DivRoundUp (int divisor, int divisor) должна иметь поведение, определенное для каждого возможного ввода. Такое неопределенное поведение вызывает глубокое беспокойство, поэтому давайте его устраним. Мы скажем, что наша операция имеет следующую спецификацию:

1. операция генерирует, если делитель равен нулю

2. операция генерирует, если делимое равно int.minval, а делитель -1

3. , если нет остатка - деление 'четное '- тогда возвращаемое значение является интегральным частным

4. . В противном случае возвращается наименьшее целое число, которое на больше частного, то есть, он всегда округляется в большую сторону.

Теперь у нас есть спецификация, поэтому мы знаем, что можем предложить тестируемый дизайн . Предположим, мы добавляем дополнительный критерий проектирования, согласно которому проблема решается исключительно с помощью целочисленной арифметики, а не вычислением частного как двойного, поскольку «двойное» решение было явно отклонено в формулировке задачи.

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

Теперь, когда у нас есть спецификация и дизайн, мы можем начать писать код.

public static int DivRoundUp(int dividend, int divisor)
{
  if (divisor == 0 ) throw ...
  if (divisor == -1 && dividend == Int32.MinValue) throw ...
  int roundedTowardsZeroQuotient = dividend / divisor;
  bool dividedEvenly = (dividend % divisor) == 0;
  if (dividedEvenly) 
    return roundedTowardsZeroQuotient;

  // At this point we know that divisor was not zero 
  // (because we would have thrown) and we know that 
  // dividend was not zero (because there would have been no remainder)
  // Therefore both are non-zero.  Either they are of the same sign, 
  // or opposite signs. If they're of opposite sign then we rounded 
  // UP towards zero so we're done. If they're of the same sign then 
  // we rounded DOWN towards zero, so we need to add one.

  bool wasRoundedDown = ((divisor > 0) == (dividend > 0));
  if (wasRoundedDown) 
    return roundedTowardsZeroQuotient + 1;
  else
    return roundedTowardsZeroQuotient;
}

Это умно? Нет. Красиво? Нет. Короткий? Нет. Правильно по спецификации? Думаю, да, но я не тестировал его полностью. Хотя выглядит неплохо.

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