Як я можу перевірити, чи перемноження двох чисел у Java спричинить переповнення?

Я хочу розглянути особливий випадок, коли множення двох чисел разом викликає переповнення. Код виглядає приблизно так:

int a = 20;
long b = 30;

// if a or b are big enough, this result will silently overflow
long c = a * b;

Це спрощена версія. У реальній програмі aі bпоставляються в іншому місці під час виконання. Я хочу досягти приблизно такого:

long c;
if (a * b will overflow) {
    c = Long.MAX_VALUE;
} else {
    c = a * b;
}

Як ви пропонуєте мені найкраще це кодувати?

Оновлення: aі bзавжди є негативними для мого сценарію.

Java 8 має Math.multiplyExactі Math.addExactт.д. для ints і long. Вони кидають неперевірений ArithmeticExceptionперелив.

Якщо aі bобидва позитивні, то ви можете використовувати:

if (a != 0 && b > Long.MAX_VALUE / a) {
    // Overflow
}

Якщо вам потрібно мати справу і з позитивними, і з негативними числами, тоді це складніше:

long maximum = Long.signum(a) == Long.signum(b) ? Long.MAX_VALUE : Long.MIN_VALUE;

if (a != 0 && (b > 0 && b > maximum / a ||
               b < 0 && b < maximum / a))
{
    // Overflow
}

Ось невеличка таблиця, яку я перевірив, щоб перевірити це, роблячи вигляд, що переповнення відбувається в -10 або +10:

a =  5   b =  2     2 >  10 /  5
a =  2   b =  5     5 >  10 /  2
a = -5   b =  2     2 > -10 / -5
a = -2   b =  5     5 > -10 / -2
a =  5   b = -2    -2 < -10 /  5
a =  2   b = -5    -5 < -10 /  2
a = -5   b = -2    -2 <  10 / -5
a = -2   b = -5    -5 <  10 / -2

Є бібліотеки Java, які забезпечують безпечні арифметичні операції, які перевіряють тривалий перелив / перелив. Наприклад, LongMath. checkedMultiply (довгий a, довгий b) Guava повертає добуток aі b, за умови, що він не переливається, і кидає, ArithmeticExceptionякщо a * bпереповнює підписану longарифметику.

Ви можете замість цього використовувати java.math.BigInteger і перевірити розмір результату (не перевіряли код):

BigInteger bigC = BigInteger.valueOf(a) * multiply(BigInteger.valueOf(b));
if(bigC.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) > 0) {
  c = Long.MAX_VALUE;
} else {
  c = bigC.longValue()
}

Використовуйте логарифми, щоб перевірити розмір результату.

Чи має Java щось подібне до int.MaxValue? Якщо так, то спробуйте

if (b != 0 && Math.abs(a) > Math.abs(Long.MAX_VALUE / b))
{
 // it will overflow
}

редагувати: переглянуто Long.MAX_VALUE, про який йде мова

Ось найпростіший спосіб, який я можу придумати

int a = 20;
long b = 30;
long c = a * b;

if(c / b == a) {
   // Everything fine.....no overflow
} else {
   // Overflow case, because in case of overflow "c/b" can't equal "a"
}

Вкрадено з джурбі

    long result = a * b;
    if (a != 0 && result / a != b) {
       // overflow
    }

ОНОВЛЕННЯ: Цей код короткий і працює добре; однак він не вдається для a = -1, b = Long.MIN_VALUE.

Одне можливе вдосконалення:

long result = a * b;
if( (Math.signum(a) * Math.signum(b) != Math.signum(result)) || 
    (a != 0L && result / a != b)) {
    // overflow
}

Зауважте, що це спричинить деякі переливи без будь-якого поділу.

Як було зазначено, у Java 8 є методи Math.xxxExact, які викидають винятки на переповнення.

Якщо ви не використовуєте Java 8 для свого проекту, ви все ще можете "запозичити" їхні реалізації, які досить компактні.

Ось декілька посилань на ці реалізації в сховищі вихідного коду JDK, жодної гарантії, чи залишаться вони дійсними, але в будь-якому випадку ви повинні мати можливість завантажити джерело JDK і подивитися, як вони виконують свою магію всередині java.lang.Mathкласу.

Math.multiplyExact(long, long) http://hg.openjdk.java.net/jdk/jdk11/file/1ddf9a99e4ad/src/java.base/share/classes/java/lang/Math.java#l925

Math.addExact(long, long) http://hg.openjdk.java.net/jdk/jdk11/file/1ddf9a99e4ad/src/java.base/share/classes/java/lang/Math.java#l830

тощо.

ОНОВЛЕНО: вимкнули недійсні посилання на сторонній веб-сайт до посилань на сховища Mercurial Open JDK.

Я не впевнений, чому ніхто не дивиться на таке рішення, як:

if (Long.MAX_VALUE/a > b) {
     // overflows
} 

Виберіть a, щоб бути більшим від двох чисел.

Я хотів би спиратися на відповідь Джона Кугельмана, не замінюючи її безпосередньо редагуванням. Це працює для його тестового випадку ( MIN_VALUE = -10, MAX_VALUE = 10) через симетрію MIN_VALUE == -MAX_VALUE, що не стосується цілих чисел комплементу двох. Насправді MIN_VALUE == -MAX_VALUE - 1.

scala> (java.lang.Integer.MIN_VALUE, java.lang.Integer.MAX_VALUE)
res0: (Int, Int) = (-2147483648,2147483647)

scala> (java.lang.Long.MIN_VALUE, java.lang.Long.MAX_VALUE)
res1: (Long, Long) = (-9223372036854775808,9223372036854775807)

Застосовуючи справжнє MIN_VALUEі MAX_VALUE, відповідь Джона Кугельмана дає випадок переповнення, коли a == -1і що- b ==небудь інше (питання, вперше підняте Кайлом). Ось спосіб виправити це:

long maximum = Long.signum(a) == Long.signum(b) ? Long.MAX_VALUE : Long.MIN_VALUE;

if ((a == -1 && b == Long.MIN_VALUE) ||
    (a != -1 && a != 0 && ((b > 0 && b > maximum / a) ||
                           (b < 0 && b < maximum / a))))
{
    // Overflow
}

Це не є загальним рішенням для будь-яких MIN_VALUEі MAX_VALUE, але це загальне для Java Longі, Integerі будь-яке значення aі b.

Може бути:

if(b!= 0 && a * b / b != a) //overflow

Не впевнений у цьому "рішенні".

Редагувати: Додано b! = 0.

Перш ніж звернути увагу : a * b / b не буде оптимізовано. Це буде помилка компілятора. Я досі не бачу випадку, коли помилку переповнення можна замаскувати.

можливо, це допоможе вам:

/**
 * @throws ArithmeticException on integer overflow
 */
static long multiply(long a, long b) {
    double c = (double) a * b;
    long d = a * b;

    if ((long) c != d) {
        throw new ArithmeticException("int overflow");
    } else {
        return d;
    }
}

c / c ++ (довгий * довгий):

const int64_ w = (int64_) a * (int64_) b;    
if ((long) (w >> sizeof(long) * 8) != (long) w >> (sizeof(long) * 8 - 1))
    // overflow

java (int * int, вибачте, що не знайшов int64 в java):

const long w = (long) a * (long) b;    
int bits = 32; // int is 32bits in java    
if ( (int) (w >> bits) ！= (int) (w >> (bits - 1))) {
   // overflow
}

1.збережіть результат у великому типі (int * int покладе результат на long, long * long put to int64)

2.cmp результат >> біт і результат >> (біт - 1)