È possibile arrotondare a 0,99999999999 a 1,0 quando si moltiplica?

Question

Quando moltiplicare un numero a virgola mobile che è molto vicino a 1 int> 0, può mai essere interpretato come 1.

Cioè, se Math.random() restituisce il suo massimo risultato possibile (che è 1 gradino sotto 1.0) ,

(int)(Math.random() * 8) 

essere 8 o 7?

Per un esempio pratico, può questo costrutto spesso usato dare un indice di errore di limiti:

someArray[(int)(Math.random() * someArray.length)]; 

Sono specificamente interessati a risposte per Java e ActionScript 3, ma suppongo che tutti usano il stesse regole per l'aritmetica in virgola mobile e le risposte per qualsiasi piattaforma sarebbero utili.

Aggiornamento: Anche se ho già accettato una risposta, sarei ancora apprezzare la conferma che questo non si può sbagliare in ActionScript 3, giacché la segnalazione di un collega che lo vide andare male una volta che è ciò che in parte mi ha spinto a fai questa domanda

Answer 1

Se si moltiplica il valore massimo inferiore a 1,0 con someInt (> 0), il risultato non sarà mai someInt.

Questo può essere esaustivamente testati per gli interi in questo modo:

Double greatestLessThanOne = Double.longBitsToDouble(4607182418800017407L); 

// Assert that greatestLessThanOne is indeed the largest double less than 1. 
//assert 1.0 == greatestLessThanOne + Math.ulp(greatestLessThanOne); 

for (int i = 1; i >= 0; i++) 
    if ((int) (greatestLessThanOne * i) == i) 
     System.out.println("Exception found: " + i); 

Il frammento non produce alcun output.

(Math.ulp restituisce la distanza tra la proposta doppio e il doppio valore successivo più grande in ampiezza. L'asserzione garantisce così che greatestLessThanOne è effettivamente il massimo valore inferiore a 1,0.)

In altre parole, la linea

Object element = elementArray[(int)(Math.random() * elementArray.length)]; 

non daranno mai origine a ArrayIndexOutOfBoundsException.

---

Inoltre, secondo Mark Dickinson commento sopra here, questo vale anche quando si moltiplicano con un doppio.

With IEEE 754 floating-point arithmetic in round-to-nearest mode, you can show that x * y < y for any x < 1.0 and any non-tiny positive y . (It can fail if y is either subnormal or the smallest positive normal number.)

Answer 2

proprio dietro di esso, potrebbe essere simile a questo:

BigDecimal bd = new BigDecimal(Double.toString(d)); 
bd = bd.setScale(decimalPlace,BigDecimal.ROUND_HALF_UP);