Can 0.999... be rounded to 1 when multiplying?

Question

When multiplying a floating point number that is very close to 1 with an int > 0, can it ever be interpreted as 1.

That is, if Math.random() returns its highest possible result (which is 1 step below 1.0), will

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

be 8 or 7?

For a practical example, can this often-used construct give an index out of bounds error:

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

I'm specifically interested in answers for Java and ActionScript 3, but I suppose they all use the same rules for floating point arithmetic, and answers for any platform would be useful.

Update: Though I already accepted an answer, I'd still appreciate confirmation that this can't go wrong in ActionScript 3 either, since a colleague reporting that he saw it go wrong once is what partly prompted me to ask this question.

@JenniferCanas You say you've already accepted an answer, but there isn't even an answer yet. Okay as I was typing this one showed up, but you haven't accepted it. — Paul, Apr 27 '12 at 21:02
I don't know where the actual steps are, but I guess it's possible, for some values. This is trivially dealt with though - use `Math.max()`, or the `Random` class (with `nextInt(someArray.length)`. — Clockwork-Muse, Apr 27 '12 at 21:04

score 1 · Accepted Answer · answered Apr 27 '12 at 21:03

Because 8 is a power of 2, multiplying a float by it will never add or remove precision from the value unless you overflow. Multiplying by other numbers, and in particular floating point numbers (other than a negative power of 2, e.g. 0.25, 0.0625, etc.), will reduce precision.

score 0 · Answer 2 · answered Apr 27 '12 at 21:14

Using Math.random in java (http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Math.html) the value can be greater than or equal to 0.0 and less than 1.0.

Using one test with value 0.999999 the value of (int)(Math.random() * 8) is 8. You can test the experiment using the next code

public static void main(String args[]) {
        for (int i = 0; i <= 100; i++) {
            double frac1=0.999999999999999999 ;
            double frac=Math.random() ;
            int integer=(int) (frac*8);
            int integer1=(int) (frac1*8);
            System.out.println( integer+"-"+frac);
            System.out.println( integer1+"-"+frac);
        }
    }

But Math.random()*8 can return other values like 1,2,3,4,5,7 or 6 depends of the value returned for Math.random. You can test this running the sample code

Did you check the actual value of `frac1`? – Ignacio Vazquez-Abrams Apr 27 '12 at 21:51 — Ignacio Vazquez-Abrams, Apr 27 '12 at 21:51

score 0 · Answer 3 · answered Apr 27 '12 at 22:15

Actually a quick exhaustive search can show that this cannot happen for any 32bit integer with floats:

public static void main(String[] args) {
    int repr = Float.floatToIntBits(1f) - 1;
    float val = Float.intBitsToFloat(repr);
    for (long i = 1; i <= -(long)Integer.MIN_VALUE; i++) {
        if ((int) (val * i) == i) {
            System.out.println("FOUND VALUE: " + i);
        }
        if ((int) (val * -i) == -i) {
            System.out.println("FOUND VALUE: " + -i);
        }
        if (i % 100000000 == 0) {
            System.out.println("Done: " + (double)i/Integer.MAX_VALUE);
        }
    }
    // nothing printed
}

Can 0.999... be rounded to 1 when multiplying?

3 Answers3