Win a copy of Kotlin in Action this week in the Kotlin forum!
programming forums Java Java JSRs Mobile Certification Databases Caching Books Engineering Languages Frameworks Products This Site Careers Other all forums
this forum made possible by our volunteer staff, including ...
Marshals:
Sheriffs:
Saloon Keepers:
Bartenders:

# Hasanov Study list question

Pres Brawner
Ranch Hand
Posts: 92
Hasanov was kind enough to contribute study questions the other day. Many thanks to you!
Here is something that caught my attention:
double d = 1/0.0;
byte b = (byte)d; //OK, b=-1
byte b = (byte)Double.NaN; //OK, b=0

Why is this? In d above d = NaN. Why does it get translated into -1 in one instance and 0 in the other?
I have read the Math API, I've gone to the JLS http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html#9208
I have looked at the Double API.
Please no requests to "look it up".
Any assistance would be greatly appreciated.
Pres
Those who don't <want to help by providing an answer>, <should not post>.

Tim Murphy
Greenhorn
Posts: 18
Maybe -1 is a numerical way of representing false

Pres Brawner
Ranch Hand
Posts: 92
Hmmm. I don't think so. NaN is a numerical constant (from the Double API)
A Not-a-Number (NaN) value of type double. It is equal to the value returned by Double.longBitsToDouble(0x7ff8000000000000L).
Why would it return -1 in one case and 0 in the other? You are comparing NaN in both.
Any other ideas out there?
Thanks,
Pres

Donald Yee
Greenhorn
Posts: 6
Originally posted by Pres Brawner:
Hmmm. I don't think so. NaN is a numerical constant (from the Double API)
A Not-a-Number (NaN) value of type double. It is equal to the value returned by Double.longBitsToDouble(0x7ff8000000000000L).
Why would it return -1 in one case and 0 in the other? You are comparing NaN in both.
Any other ideas out there?
Thanks,
Pres

Well, when in doubt, write code?
Here's some interesting output I got
(1/0.0) = (0x7FF0000000000000)
(Double.NaN) = (0x7FF8000000000000)
(Double.NEGATIVE_INFINITY) = (0xFFF0000000000000)
(Double.POSITIVE_INFINITY) = (0x7FF0000000000000)
(Double.MAX_VALUE) = (0x7FEFFFFFFFFFFFFF)
(Double.MIN_VALUE) = (0x000000000000001)
What's interesting is that 1/0.0 gives a positive infinity response (jdk 1.4.0/windows) instead of NaN. It's a difference of one bit, but casting to byte, how do you get from 1111 1111 to 0000 0000 ?
I think I'll dig around some more unless someone figures it out before me
Edit: Mistyped the value for negative infinity
[ April 11, 2002: Message edited by: Donald Yee ]
Went back and did some other stuff. Oddly, I get strange results if I cast double to long versus the Double.doubleToLongBits.
(int)(1/0.0) = 0x7FFFFFFF
(long)(1/0.0) = 0x7FFFFFFFFFFFFFFF
(float)(1/0.0) = Infinity
According to the IEEE 754 standard, infinity should be coming out as stated in the Double API. However, I think (can't remember for sure) that when floats/doubles do arithmetic (esp. multiplication and division) with small numbers, things can get wacky like this. Perhaps someone else can confirm that possibility.
[ April 11, 2002: Message edited by: Donald Yee ]

Pres Brawner
Ranch Hand
Posts: 92
Duh!
I got it now.
d = infinity. (I thought it was NaN and hence the problem I was having with this.)
Thanks everyone.
Pres

Marilyn de Queiroz
Sheriff
Posts: 9080
12
1/0.0 = positive infinity
-1/0.0 = negative infinity
0/0.0 = NaN

Jose Botella
Ranch Hand
Posts: 2120
An this is a helpful piece of theory from JLS 5.1.3

 Don't get me started about those stupid light bulbs.