Есть ли какая-либо функция Java или утилита class
, которая округляет этот путь: func(3/2) = 2
Math.ceil()
не помогает, что по имени должно было сделать это. Я знаю BigDecimal
, но не нуждаюсь в нем.
Есть ли какая-либо функция Java или утилита class
, которая округляет этот путь: func(3/2) = 2
Math.ceil()
не помогает, что по имени должно было сделать это. Я знаю BigDecimal
, но не нуждаюсь в нем.
Math.ceil()
всегда округляется, однако вы выполняете целочисленное деление с 3/2
. Таким образом, поскольку в целых делениях 3/2 = 1
(не 1.5
) потолок 1
равен 1
.
Что вам нужно сделать для достижения желаемых результатов, Math.ceil(3/2.0);
Выполняя деление на двойную сумму (2.0
), вы заканчиваете деление с плавающей запятой, а не целое деление. Таким образом, 3/2.0 = 1.5
, а ceil()
of 1.5
всегда 2
.
Немного черной магии, и вы можете сделать все это с помощью целых чисел:
// Divide x by n rounding up
int res = (x+n-1)/n
Вы всегда можете сделать первый:
Math.ceil((double)3/2)
Чтобы преобразовать разделение полов в потолок:
(numerator + denominator-1) / denominator
Чтобы преобразовать деление пола в округление:
(numerator + (denominator)/2) / denominator
В Java 3/2 = 1, поскольку он использует целочисленное деление. Нет функции, которая впоследствии может "исправить". То, что вам нужно сделать, это принудительное разделение и округление результата:
int result = (int)Math.ceil( ((float)3) / ((float)2) );
В этом случае обычный случай целочисленного деления? Попробуйте Math.Ceil после листинга любого числа с типом с плавающей точкой.
Многие языки "думают" так. Если вы делите int на int, тогда вы должны получить int (поэтому они усекаются, и вы получаете 1 в результате).
Мы все знаем, что это не так, но как они работают. Вы можете "обмануть" их и сделать что-то вроде приведения одного из них в double или использовать двойное представление: Math.ceil (3.0 / 2)
или Math.ceil((double)3/2)
, как указано.
Math.ceil поможет, если вы используете числа с плавающей запятой. Проблема состоит в том, что 3/2, в целых делениях, равно 1. К тому времени, когда значение получает какую-либо функцию, будь то Math.ceil или что-то еще, значение равно 1. Любая конечная десятичная часть исчезла.
if (a % b == 0)
{
return (a / b);
}
else
{
return (a / b) + 1;
}
Использует целочисленное деление, чтобы делать то, что вы хотите. Я не знаю о математической функции, которая делает это, но почему бы не сворачивать свои собственные?
ниже фрагмент работает с отрицательными целыми числами:
public static int divRoundUp(int x, int n) {
if (n<=0) throw new RuntimeException("conceived wt. pos. dividers (was:"+n+")");
int ret = (x+(n-1)*(x>0?1:0))/n;
return ret;
}
Мне нравится Рэнди Проктор ответить наилучшим образом. Здесь более подробно:
Если вы хотите выполнить реальное округление (т.е. 3/2 → 2, но 17/7 → 2) с целыми числами > 0:
используйте (dividend + (divisor / 2)) / divisor
вместо dividend / divisor
.
Если дивиденд может быть любым целым числом (т.е. отрицательным):
(dividend >= 0) ? ((dividend + divisor / 2) / divisor) : ((dividend - divisor / 2) / divisor)
.
Если дивиденд - любое целое число и делитель - любое целое число, но 0:
(dividend >= 0) ? ((dividend + Math.abs(divisor) / 2) / divisor) : ((dividend - Math.abs(divisor) / 2) / divisor)
.
(Обратите внимание, что добавление и вычитание могут привести к тому, что в противном случае это не произойдет, что сделает результат неверным.)
Вот метод, который я создал для обработки int-деления без использования Math Round и casting для float. Это работает для положительных и отрицательных чисел. Он работает, добавляя половину знаменателя, чтобы компенсировать округление
public static int div_Int(int num, int den){
if(num > 0 && den > 0 || num < 0 && den < 0 ){
return ((2*num)+ den)/(2*den);
}else{
return ((2*num)- den)/(2*den);
}
}
Если вы хотите просто разделить на 2, вы можете сделать:
n - n / 2
И вообще:
(n - 1) / d + 1 == (n + d - 1) / d
Это выполняется для целых неотрицательных чисел. Как расширить его до отрицательных целых чисел, зависит от того, что вы имеете в виду, "делает округление таким образом". Целочисленное деление округляется до нуля, а Math.ceil()
округляется, а Math.floor()
округляется. Например n / 2 != (int) Math.floor(n / 2.0)
для n == -5
.
Если вы хотите всегда округлить, вы можете использовать Math.ceil()
, как в этом ответе.
Вы пробовали Math.floor()
?