Is it safe if I use comparision like this (a is int, b and c is float/double):
a == b
b == c
It may hear ridiculous, but in my old programing language, sometimes 1 + 2 == 3 is false (because left side returns 2.99999999999...). And, what about this:
Math.sqrt(b) == Math.sqrt(c)
b / 3 == 10 / 3 //In case b = 10, does it return true?
In general, no it is not safe due to the fact that so many decimal numbers cannot be precisely represented as float or double values. The often stated solution is test if the difference between the numbers is less than some "small" value (often denoted by a greek 'epsilon' character in the maths literature).
However - you need to be a bit careful how you do the test. For instance, if you write:
if (Math.abs(a - b) < 0.000001) {
System.err.println("equal");
}
where a and b are supposed to be "the same", you are testing the absolute error. If you do this, you can get into trouble if a and b are (say_ 1,999,999.99 and 2,000,000.00 respectively. The difference between these two numbers is less than the smallest representable value at that scale for a float, and yet it is much bigger than our chosen epsilon.
Arguably, a better approach is to use the relative error; e.g. coded (defensively) as
if (a == b ||
Math.abs(a - b) / Math.max(Math.abs(a), Math.abs(b)) < 0.000001) {
System.err.println("close enough to be equal");
}
But even this is not the complete answer, because it does not take account of the way that certain calculations cause the errors to build up to unmanageable proportions. Take a look at this Wikipedia link for more details.
The bottom line is that dealing with errors in floating point calculations is a lot more difficult than it appears at first glance.
The other point to note is (as others have explained) integer arithmetic behaves very differently to floating point arithmetic in a couple of respects:
Both of these happen without any warning, either at compile time or at runtime.
You do need to exercise some care.
1.0 + 2.0 == 3.0
is true because integers are exactly representable.
Math.sqrt(b) == Math.sqrt(c)
if b == c.
b / 3.0 == 10.0 / 3.0
if b == 10.0 which is what I think you meant.
The last two examples compare two different instances of the same calculation. When you have different calculations with non representable numbers then exact equality testing fails.
If you are testing the results of a calculation that is subject to floating point approximation then equality testing should be done up to a tolerance.
Do you have any specific real world examples? I think you will find that it is rare to want to test equality with floating point.
b / 3 != 10 / 3 - if b is a floating point variable like b = 10.0f, so b / 3 is 3.3333, while 10 / 3 is integer division, so is equal to 3.
If b == c, then Math.sqrt(b) == Math.sqrt(c) - this is because the sqrt function returns double anyways.
In general, you shouldn't be comparing doubles/floats for equation, because they are floating point numbers so you might get errors. You almost always want to compare them with a given precision, i.e.:
b - c < 0.000001
The safest way to compare a float/double with something else is actually to use see if their difference is a small number.
e.g.
Math.abs(a - b) < EPS
where EPS can be something like 0.0000001.
In this way you make sure that precision errors do not affect your results.
== comparison is not particularly safe for doubles/floats in basically any language. An epsilon comparison method (where you check that the difference between two floats is reasonably small) is your best bet.
For:
Math.sqrt(b) == Math.sqrt(c)
I'm not sure why you wouldn't just compare b and c, but an epsilon comparison would work here too.
For:
b / 3 == 10 / 3
Since 10/3 = 3 because of integer division, this will not necessarily give the results you're looking for. You could use 10.0 / 3, though i'm still not sure why you wouldn't just compare b and 10 (using the epsilon comparison method in either case).
Float wrapper class's compare method can be used to compare two float values.
Float.compare(float1,float2)==0
It will compare integer bits corresponding to each float object.
In java you can compare a float with another float,and a double with another double.And you will get true when comparing a double with a float when their precision is equal
b is float and 10 is integer then if you compare both with your this critearia then it will give false because...
b = flaot (meance ans 3.33333333333333333333333)
10 is integer so that make sence.
If you want a more complete explanation, here there is a good one: http://download.oracle.com/docs/cd/E19957-01/806-3568/ncg_goldberg.html (but it is a little bit long)
Efficient way for 2 digits precision:
public static void main(String[] args) {
double number = 3.14999965359;
float number2 = 3.14909265359f;
Date date = new Date();
System.out.println(equalsDoubleWithFloat(number, number2));
System.out.println(isDoubleBigFromFloat(number, number2));
System.out.println("delay: " + (new Date().getTime() - date.getTime()) + " ms");
}
private static boolean equalsDoubleWithFloat(double db, float fl) {
return Float.compare((float) db, fl) == 0 || Math.abs(db - fl) < 0.01;
}
private static boolean isDoubleBigFromFloat(double db, float fl) {
return Math.abs(db - fl) > 0.01 && Float.compare((float) db, fl) > 0;
}
public static boolean isDoubleSmallFromFloat(double db, float fl) {
return Math.abs(db - fl) > 0.01 && Float.compare((float) db, fl) < 0;
}
Output is:
true
false
delay: 1 ms
other solution:
private static final DecimalFormat TWO_DIGITS = new DecimalFormat("0.00");
public static double formatDouble(double value) {
return Double.parseDouble(TWO_DIGITS.format(value));
}
public static float formatFloat(float value) {
return Float.parseFloat(TWO_DIGITS.format(value));
}
public static int compareDoubleWithFloat(double db, float fl) {
double roundedDouble = formatDouble(db);
float roundedFloat = formatFloat(fl);
if (Math.abs(roundedDouble - roundedFloat) < 0.01) {
return 0;
} else if (roundedDouble > roundedFloat) {
return 1;
} else {
return -1;
}
}
