import java.math.*;

public class BigDecimalTest {

//BigDecimal uses unscaled value(BigInteger) and scale(int) to

//represent any decimal number. value = unscaled_value * 10^(-scale)

private static void checkBigDecimal(BigDecimal bd) {

System.out.println("BigDecimal = " + bd);

System.out.println("Unscaled = " + bd.unscaledValue());

System.out.println("Scale = " + bd.scale());

System.out.println("Scale = 3(round half even): " +

bd.setScale(3, BigDecimal.ROUND_HALF_EVEN));

System.out.println("Scale = -1(round half even): " +

bd.setScale(-1, BigDecimal.ROUND_HALF_EVEN));

System.out.println("");

}

private static void checkDouble(Double d) {

//The following will call d.toString(), which is the same as

//Double.toString(d) and String.valueOf(d).

//The actual value in d is not strictly equal to 5.123

//due to precision lost. The value of converted string x is selected

//such that the actual value in d(say d_a) is the closest to x,

//and x has as least number of fractional digits as possible.

//This way makes sure that there is a reversable mapping between

//x and d_a. So that if the string is converted back to double,

//it will be the same as the original one. And the results are

//the same no mattter how many times you do the conversion.

//However multiple double string values could be mapped to the same

//underlying doubel value, like in :

//http://www.onjava.com/pub/a/onjava/2000/12/15/formatting_doubles.html

//5.39E-322D and 5.41E-322D are stored as same double value. In this

//case, the converted string value is 5.4E-322.

System.out.println("d.toString() = " + d);

//bd stores the exact underlying representation of d, instead of calling

//d.toString() first.

BigDecimal bd = new BigDecimal(d);

checkBigDecimal(bd);

}

private static void checkDouble(String s) {

System.out.println("String double = " + s);

//There is a one-to-one mapping between the distinguishable

//BigDecimal values and the string representation of it.

//See Javadoc BigDecimal.toString()

BigDecimal bd = new BigDecimal(s);

checkBigDecimal(bd);

}

private static void testBigDecimalMethods() {

BigDecimal bd1 = new BigDecimal("4.52");

BigDecimal bd2 = new BigDecimal("-443.44893");

BigDecimal bd3 = new BigDecimal("-3.52");

//4.52 + -3.52 = 1.00

//bd1 is immutable and the method returns a new object

System.out.println(bd1 + " + " + bd3 + " = " + bd1.add(bd3));

//4.52 + -443.44893 = -438.92893

System.out.println(bd1 + " + " + bd2 + " = " + bd1.add(bd2));

BigDecimal bd4 = new BigDecimal("1");

BigDecimal bd5 = new BigDecimal("3");

//The following throws an exception since the result is Non-terminating

//and no rounding method is specified

//System.out.println(bd4 + " / " + bd5 + " = " + bd4.divide(bd5));

//1 / 3 = 0, since bd4.scale() == 0

System.out.println(bd4 + " / " + bd5 + " = "

+ bd4.divide(bd5, BigDecimal.ROUND_HALF_DOWN));

//1 / 3 = 0.333

System.out.println(bd4 + " / " + bd5 + " = "

+ bd4.divide(bd5, 3, BigDecimal.ROUND_HALF_DOWN) + ", scale = 3");

System.out.println(bd4 + " / " + bd5 + " = "

+ bd4.divide(bd5, 10, BigDecimal.ROUND_HALF_DOWN) + ", scale = 10");

//4.52 x -443.44893 = -2004.3891636

//Same as multiply(bd2, MathContext.UNLIMITED)

System.out.println(bd1 + " x " + bd2 + " = "

+ bd1.multiply(bd2));

//4.52 x -443.44893 = -2004.39

System.out.println(bd1 + " x " + bd2 + " = "

+ bd1.multiply(bd2, new MathContext(6)));

BigDecimal bd6 = new BigDecimal("4.5200");

//False ! equals compares the contents of objects -- [unscaled_value, scale],

//which are different since string representation and [unscaled_value, scale]

//are one-to-one mapping.

System.out.println("4.52 equals 4.5200 ? " + bd1.equals(bd6));

//0, so they are equal in value.

System.out.println("4.52 compareTo 4.5200 ?? " + bd1.compareTo(bd6));

// a.signum() returns (-1 if a < 0), (0 if a == 0), (1 if a > 0)

// In this case, returns 1

System.out.println(bd6 + " sign = " + bd6.signum());

}

public static void main(String[] args) {

//When the compiler compiles this, I guess it will treat '5.123' as

//a string and call Double.valueOf on it.

checkDouble(5.123);

checkDouble(-21.3455555);

checkDouble(173.0);

checkDouble(Double.valueOf(0));

checkDouble(1.0/3.0);

checkDouble("123.456");

checkDouble("123.456000");

checkDouble("-344444444433.555555");

//valueOf first calls Double.toString to convert the double to a string,

//then call the constructor that takes a string as the parameter

checkBigDecimal(BigDecimal.valueOf(123.456));

checkBigDecimal(BigDecimal.valueOf(-3333.74444));

testBigDecimalMethods();

}

}