Java: increment through Float.floatToIntBits?

Question

I need to increment a float value atomically. I get its int value by calling Float.floatToIntBits on it. If I just do an i++ and convert it back to float, it does not give me the expected value. So how would I go about it?

(I'm trying to create an AtomicFloat through AtomicInteger, hence this question).

EDIT: here's what I did:

Float f = 1.25f;
int i = Float.floatToIntBits(f);
i++;
f = Float.intBitsToFloat(i);

I wanted 2.25, but got 1.2500001 instead.

what is expected? what is the actual result? give some more description? — Chandra Sekhar, Mar 29 '12 at 08:29
It would help if you would give an example of what you expected and what happened. It's entirely possible that the problem is in your expectations... — Jon Skeet, Mar 29 '12 at 08:29
What do you mean by "increment a float"? Add 1 to it, or get the next-larger float value (add one ULP)? — Christian Semrau, Mar 29 '12 at 08:44
@Chandra Sekhar, edited the question to give an example of what I want. — shrini1000, Mar 29 '12 at 12:41
@Jon Skeet, edited the question to give an example of what I want. — shrini1000, Mar 29 '12 at 12:43
@Christian Semrau, edited the question to give an example of what I want. — shrini1000, Mar 29 '12 at 12:44
Be aware that for large float values (a few million and above) the value of `f+1` equals `f` due to rounding, so adding one does not always *increment* a value. — Christian Semrau, Mar 29 '12 at 19:48

score 5 · Accepted Answer · edited May 23 '17 at 11:45

5

The reason is that the bits you get from floatToIntBits represents

sign
exponent
mantissa

laid out like this:

Repr:  Sign   Exponent          Mantissa
Bit:    31   30......23  22.....................0

Incrementing the integer storing these fields with 1 won't increment the float value it represents by 1.

I'm trying to create an AtomicFloat through AtomicInteger, hence this question

I did precisely this in an answer to this question:

Java: is there no AtomicFloat or AtomicDouble?

To add functionality to increment the float by one, you could copy the code of incrementAndGet from AtomicInteger (and change from int to float):

public final float incrementAndGet() {
    for (;;) {
        float current = get();
        float next = current + 1;
        if (compareAndSet(current, next))
            return next;
    }
}

(Note that if you want to increment the float by the smallest possible value, you take the above code and change current + 1 to current +Math.ulp(current).)

edited May 23 '17 at 11:45

Community

1
1

answered Mar 29 '12 at 08:30

aioobe

413,195
112
811
826

thanks for the answer. But the code you've shown for incrementAndGet won't use CAS operation, right (the way AtomicInteger does)? So it would have to be synchronized in the usual way? – shrini1000 Mar 29 '12 at 12:53
The `incramentAndGet` method I posted in my answer was intended to be included in the `AtomicFloat` class that I described in my [other answer](http://stackoverflow.com/questions/5505460/java-is-there-no-atomicfloat-or-atomicdouble/5505512#5505512). – aioobe Mar 29 '12 at 13:19
btw, I took a look at AtomicInteger and how it uses 'unsafe' for CAS. 'unsafe' does not have any api to compareAndSwap float/double. Is that the reason why we don't have direct support for AtomicFloat/AtomicDouble? – shrini1000 Mar 30 '12 at 06:04
Don't think so. I posted the "official" reason in tha answer I linked to. – aioobe Mar 30 '12 at 06:07

Christian Semrau · Answer 2 · 2012-03-31T21:32:10.057

2

The atomic part can be implemented atop compareAndSet for a wrapper class as shown in the link of aioobe. The increment operators of AtomicInteger are implemented like that.

The increment part is a completely different problem. Depending on what you mean by "increment a float", it either requires you to add one to the number, or increment it by one ULP. For the latter, in Java 6, the Math.nextUp method is what you are looking for. For decrement by one ULP, the Math.nextAfter method is useful.

edited Mar 31 '12 at 21:32

answered Mar 29 '12 at 08:41

Christian Semrau

8,913
2
32
39

1

Note that nextAfter requires an extra "dummy" argument such as `Float.MAX_VALUE`, whereas `Math.ulp` directly gives the distance to the next float. – aioobe Mar 29 '12 at 08:47
As I just saw, `Math.nextUp(f)` (Java 6) returns the value of `f+ulp(f)` without requiring the extra argument that `nextAfter(f, INFINITY)` needs, and probably is faster than computing `f+ulp(f)` as is. – Christian Semrau Mar 29 '12 at 19:45

Java: increment through Float.floatToIntBits?

2 Answers2