How to check if float is being truncated by Float.parseFloat() from String

Question

I want to validate a string input for a float value.

Is there a way to check if a float value is being truncated (precision is being lost) when parsing a String with a call to Float.parseFloat()?

For example, a user enters too many numbers in an EditText. I want to check when this happens so I can prevent it. I am not trying to get an exact result, I'm just trying to limit the value that a user can enter so it does not exceed the precision limit of a float.

float f = Float.parseFloat("9999999.999"); //this returns 1.0E7 but doesn't throw any error.

I understand that for accuracy I would be using BigDecimal rather a floating-point type. But floating-point accuracy is not my concern here. My concern is validation of the user’s textual input representing a float value.

Answer 1

This is what I could come up with using BigDecimal, it seems to do the job just fine.

String input = "9999999.999";
boolean precisionLost = false;
try {
    BigDecimal bd = new BigDecimal(input);
    BigDecimal bd2 = new BigDecimal(String.valueOf(bd.floatValue()));
    if (bd.compareTo(bd2) != 0) {
        precisionLost = true;
    }
} catch (NumberFormatException e) { // when values are absurdly too large even for BigDecimal
    precisionLost = true;
}


input = "9999999.999"; // precisionLost is true
input = "9.999999"; // precisionLost is true
input = "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999.999"; // exception is thrown, precisionLost is true
input = "999"; // precisionLost is false
input = "999.999"; // precisionLost is false
input = ".999"; // precisionLost is false
input = "999."; // precisionLost is false

I wonder if even something as simple as this would be enough? Any thoughts?

String input = "9999999.999";
boolean precisionLost = false;
try {
    float f = Float.parseFloat(input);
    if (String.valueOf(f).contains("E")) {
        precisionLost = true;
    }
} catch (NumberFormatException e) {
    precisionLost = true;
}

Answer 2

If you insist on doing this check, you can try this function:

private static boolean isPrecise(String input) {
    float f = Float.parseFloat(input);
    
    String back = String.format(Locale.ENGLISH, "%f", f);
    System.out.println(back);

    if (back.length() > input.length())
        back = back.substring(0, input.length());

    return back.equals(input);
}

Note the use of String.format: this is to make sure that translation back is done with decimal notation, instead of scientific notation (i.e. 10000000.000000 instead of 1.0E7 you would get from String.valueOf)

However, this check is not really useful, other than satisfying curiosity.
That is why I added printing of back variable - if you run this on examples provided by Arvind Kumar Avinash, you will see that in some cases precision is lost, but digits are actually added instead of being truncated.

Specifically:

999.999 => 999.999023

That's why I added the substring part.

The real question is, what do you do with the answer of the function in your code?

Because of the way float point numbers work, you can't create a simple limitation on an EditText that will make sure user only enters valid floats.

And there is no way a reasonable person will be able to use an app that gives them error popups every time their input suffers precision loss.