Casting of long to float

Question

Hello Friends,
While preparing for A JAVA test, i came across a strange behavior in java language. will be greatful if somebody can clarify it.
The problem is:
if we try to assign long data type to int without casting explicitly, complier will throw an error, e.g. consider the following piece of code-
int iData2=10000000000000L;
The compiler will say that there is a possible loss of precision.
but if i replace int by float e.g. change the above code to
float fData2=10000000000000L;
the compiler is accepting code without giving any warning that there is a possible loss of precision, although there is such a loss in the output.
is this behaviour justified?

Answer 1

you have to draw the line somewhere... so Java just
looks at the range of numbers that can be presented;
for every long there is a float that is fairly close to it.Okay, but the difference between some long values that have been converted to a float are not close at all. For example:
     long l = (long)Math.pow(2,63) - 1000000000000L;
     float f = l;
     long l2 = (long)f;
     System.out.println("l is:" + l);
     System.out.println("l2 is:" + l2);
     System.out.println("l-l2 is:" + (l-l2));
The output is:
l is:9223371036854775807
l2 is:9223370937343148032
l-l2 is:99511627775
I don't call a difference of 99511627775 close. I think you should have to cast a long to a float.
-- MWR
you can't have the compiler complain about
everything, otherwise you woldn't be able to do
anything useful...
for example:
double d = 0.1; // 1
float f = 1;
f = f/10; // 2
double d = d - f; // 3
on line 1: possible loss of precision becausethere
is no double that represents one tenth exactlyCould not really get it. where is the chance ofloss
of precision? In Java, floating point literals areby
default double type. So if u assign double to a
double , there is no chance of loss of precision.By
the way, i executed this code. Compiler didnot
complain and output was "d=0.1"
on line 2: possible loss of precision because
the
result of dividing by a non-power of two cannotbe
represented exactly as a floating point numberhere also, there is no chance of loss ofprecision.
because u r assigning an int literal(32 bit) to a
float variable (also 32 bit).
on line 3: possible loss of precision because
you
subtract near-equal values from each other,producing
a massive relative errorthis is ok.. it will give loss of precision with
compiler complaints. :-)
you have to draw the line somewhere... so Javajust
looks at the range of numbers that can bepresented;
for every long there is a float that is fairlyclose
to it.
srry one rectification..
*this is ok.. it will give loss of precision
without
compiler complaints. :-)