Есть ли какая-либо функция Java или класс util, который округляет этот путь: func (3/2) = 2?

Question

Есть ли функция Java или Util class который не округление таким образом: func(3/2) = 2

Math.ceil() не помогает, что по имени должно быть сделано. Я знаю BigDecimal, но это не нужно.

Answer 1

Math.ceil() всегда будет окружать, однако вы делаете целочисленное деление с 3/2. Таким образом, поскольку в целых деление 3/2 = 1 (не 1.5) потолок 1 составляет 1.

Что вам нужно будет сделать, чтобы достичь желаемых результатов является Math.ceil(3/2.0);

Поступая разделение двойной суммы (2.0), вы в конечном итоге делает точку деления с плавающей вместо деления на целое число. Таким образом, 3/2.0 = 1.5 и ceil() от 1.5 всегда 2.

Answer 2

На самом деле это обычный случай целочисленного деления? Попробуйте Math.Ceil после литья любого числа в тип с плавающей точкой.

Answer 3

Вы всегда можете бросить первым:

Math.ceil((double)3/2) 

Answer 4

Math.ceil help help при условии использования чисел с плавающей запятой. Проблема в том, что 3/2, в целых делениях, равно 1. К тому времени, когда значение получает какую-либо функцию, будь то Math.ceil или что-то еще, значение равно 1. Любая конечная десятичная часть исчезла.

Answer 5

Немного черной магии, и вы можете делать все это с целыми числами:

// Divide x by n rounding up 
int res = (x+n-1)/n 

Answer 6

Вы пробовали Math.floor()?

Answer 7

В Java, 3/2 = 1, поскольку он использует целочисленное деление. Нет функции, которая впоследствии может «исправить». Что вам нужно сделать, так это заставить делить поплавок и округлить результат:

int result = (int)Math.ceil(((float)3)/((float)2)); 

Answer 8

Многие языки «думают» вот так. Если вы делите int на int, тогда вы должны получить int (поэтому они усекаются, и вы получаете 1 в результате).

Мы все знаем, что это неправда, но вот как они работают. Вы можете «обмануть» их и сделать что-то вроде литья одного из них в двойное или использовать двойное представление: Math.ceil (3.0/2) или Math.ceil((double)3/2), как уже упоминалось.

Answer 9

if (a % b == 0) 
{ 
    return (a/b); 
} 
else 
{ 
    return (a/b) + 1; 
} 

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

Answer 10

Для преобразования пола деления до потолка деления:

(numerator + denominator-1)/denominator 

Для преобразования пола подразделения округляющего деления:

(numerator + (denominator)/2)/denominator 

Answer 11

ниже фрагмента работает с отрицательными числами, а также:

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

Answer 12

Мне больше нравится ответ Рэнди Проктора. Здесь более подробно:

Если вы хотите сделать реальное округление (т.е. 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).

(Обратите внимание, что добавление и вычитание могут привести к обволакивающему, что в противном случае не будет происходить, рендеринг результата неверен.)

Answer 13

Вот метод, который я создал для обработки Int деления без использования Math раунда и литья плавать , Это работает для положительных и отрицательных чисел. Он работает путем добавления половины знаменателя, чтобы компенсировать округление вниз

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

} 

Answer 14

Если вы хотите просто разделить на 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(), как в this answer.