converting a double value

[Mohit Sinha]

Hi All,

In a method after doing some number crunching we get an int or a double based on specific conditions. We then set this value in an output object's String parameter.
The way this output's object value is used in another routine is it has separate criteria based on whether the value is an string or double.
Normally from the condition rendering a double we get values like 0.43 or say 2.33 but in some cases this condition renders values like 0.0, 1.0 or 2.0
In cases where the values are with .0 we actually want to set the values (0.0,1.0,2.0) as 0,1,2 and ignore .0 but when it is proper double type like 0.43 or 2.33 we want to retain the precision

Let me know your thoughts on how to go about this.

Regards,

[Steve Luke]

This is a bit more complicated than it may seem, since every decimal can't be held accurately. You basically have to find a count of decimal points you find significant, round to that significance, then FLOOR. Compare the floored value with the original and if they are the same, then the original was an integer.

There are a handful of ways of doing it, here are two methods - one where I keep things primitive and do the rounding, and one that uses BigDecimal. Not sure which is better ...

package compares;

import java.math.BigDecimal;

public class Doubles {
	private static final int significantDigits = 2;
	// Used in the manual rounding done in isIntegerValue(double input)
	private static final double decimalAccuracy;
	static {
		int firstInsignificantDigit = significantDigits + 1;
		decimalAccuracy = Math.pow(10, -firstInsignificantDigit);
	}

	public static boolean isIntegerValue(double input) {
		// Add the decimal accuracy to the input, then FLOOR it to an int
		double intVal = Math.floor(input + decimalAccuracy);
		// if the FLOORed value isn't < the input, then the input shouldn't be
		// considered an int
		return !(intVal < input);
	}

	public static boolean isIntegerValue2(double input) {
		// Create a big decimal with the correct number of digits after the
		// decimal
		BigDecimal inputBD = BigDecimal.valueOf(input).setScale(
				significantDigits, BigDecimal.ROUND_HALF_UP);
		// generate a double and int (FLOORed) value that can be compared
		double comparableDouble = inputBD.doubleValue();
		double comparableInt = Math.floor(comparableDouble);
		// if the FLOORed int is the same as the double, they are equal.
		return comparableInt == comparableDouble;
	}

	public static void main(String[] args) {
		for (double val = 10000000.0; val < 10000006.0; val += 0.1) {
			// Example, if significantDigits = 2,
			// "(%s) %.2f is an integer? %b%n"
			String outputString = "(%s) %." + significantDigits
					+ "f is an integer? %b%n";
			System.out.printf(outputString, "Rnd", val, isIntegerValue(val));
			System.out.printf(outputString, "BigD", val, isIntegerValue2(val));
		}
	}
}

Note the main method is using a loop of a bunch of large numbers with a small increment to test how well it works. The incremental changes help exacerbate the problem of storing decimals (as soon as one number is reached that can't accurately be help is reached the error is propagated through the rest of the increments). Large numbers mean I can use smaller display precisions to show off how the values get stored (if I wanted to, which I think I removed from this version of code).

---- EDIT ----
I take that back. I do know which is better - use the BigDecimal version. My rounding still gets flawed when there are some combinations of significantDigits and values getting passed into the methods. BigD seems to not have those problems. So go with isIntegerValue2(double input) and the asInt2(double input) method shown below.

package compares;

import java.math.BigDecimal;

public class Doubles {
	private static final int significantDigits = 2;

	public static boolean isIntegerValue2(double input) {
		// Create a big decimal with the correct number of digits after the
		// decimal
		BigDecimal inputBD = BigDecimal.valueOf(input).setScale(
				significantDigits, BigDecimal.ROUND_HALF_UP);
		// generate a double and int (FLOORed) value that can be compared
		double comparableDouble = inputBD.doubleValue();
		double comparableInt = Math.floor(comparableDouble);
		// if the FLOORed int is the same as the double, they are equal.
		return comparableInt == comparableDouble;
	}

	public static int asInt2(double input) {
		return BigDecimal.valueOf(input).setScale(significantDigits,
				BigDecimal.ROUND_HALF_UP).intValue();
	}

	public static void main(String[] args) {
		for (double val = 10000000.0; val < 10000006.0; val += 0.1) {
			if (isIntegerValue2(val))
				doWork(asInt2(val));
			else
				doWork(val);
		}
	}

	private static void doWork(int input) {
		System.out.printf("I got the integer %d%n", input);
	}

	private final static String outputString = "I got the double %."
			+ significantDigits + "f%n";

	private static void doWork(double input) {
		System.out.printf(outputString, input);
	}
}

[Mohit Sinha]

Thanks Steve. That was indeed very helpful.