Overflow doppio o BigDecimal?

Question

Java 8 ci ha fornito Math.addExact() per numeri interi ma non decimali.

E 'possibile che double e BigDecimal superino? Giudicando da Double.MAX_VALUE e da How to get biggest BigDecimal value Direi che la risposta è sì.

Come tale, perché non abbiamo anche Math.addExact() per questi tipi? Qual è il modo più gestibile per controllarlo?

Answer 1

double overflow a Infinity e -Infinity, non si avvolge. BigDecimal non ha overflow, periodo, è limitato solo dalla quantità di memoria nel tuo computer. Vedere: How to get biggest BigDecimal value

L'unica differenza tra + e .addExact è che tenta di rilevare se si è verificato un overflow e genera un'eccezione invece di un wrapping. Ecco il codice sorgente:

public static int addExact(int x, int y) { 
    int r = x + y; 
    // HD 2-12 Overflow iff both arguments have the opposite sign of the result 
    if (((x^r) & (y^r)) < 0) { 
     throw new ArithmeticException("integer overflow"); 
    } 
    return r; 
} 

Se si desidera verificare che si è verificato un overflow, in un certo senso è più semplice farlo con double comunque, perché si può semplicemente verificare la presenza di Double.POSITIVE_INFINITY o Double.NEGATIVE_INFINITY; nel caso di int e long, è una questione un po 'più complicata perché non è sempre un valore fisso, ma in un altro, questi potrebbero essere input (ad esempio Infinity + 10 = Infinity e probabilmente non si vuole lanciare un'eccezione in questo caso) .

Per tutti questi motivi (e non abbiamo ancora menzionato lo NaN), questo è probabilmente il motivo per cui un tale metodo addExact non esiste nel JDK. Naturalmente, è sempre possibile aggiungere la propria implementazione a una classe di utilità nella propria applicazione.

Answer 2

La ragione per cui non è necessaria la funzione addExact per le cifre in virgola mobile è perché, invece di avvolgersi, viene portata a Double.Infinity.

Di conseguenza è possibile controllare molto facilmente al termine dell'operazione in caso di overflow o meno. Dal momento che Double.POSITIVE_INFINITY + Double.NEGATIVE_INFINITY è NaN è anche necessario verificare la presenza di NaN in caso di espressioni più complicate.

Questo non è solo più veloce ma anche più facile da leggere. Invece di dover Math.addExact(Math.addExact(x, y), z) aggiungere 3 doppie insieme, si può invece scrivere:

double result = x + y + z; 
if (Double.isInfinite(result) || Double.isNan(result)) throw ArithmeticException("overflow"); 

BigDecimal d'altra parte volontà davvero troppo pieno e gettare un corrispondente un'eccezione in questo caso, come pure - questo è molto improbabile che accada mai in pratica però.

Answer 3

Per double, consultare le altre risposte.

BigDecimal ha la protezione addExact() già costruito in molti metodi un'operazione aritmetica (ad esempio multiply) di BigDecimal contengono un controllo sulla scala del risultato:.

private int checkScale(long val) { 
    int asInt = (int)val; 
    if (asInt != val) { 
     asInt = val>Integer.MAX_VALUE ? Integer.MAX_VALUE : Integer.MIN_VALUE; 
     BigInteger b; 
     if (intCompact != 0 && 
      ((b = intVal) == null || b.signum() != 0)) 
      throw new ArithmeticException(asInt>0 ? "Underflow":"Overflow"); 
    } 
    return asInt; 
}