Saturday, March 14, 2009

Groovy numbers

I was very pleasantly surprised when I learned how to work with numbers in Groovy. The first difference between Groovy and Java (while dealing with numbers) is that in Groovy numbers are always objects. There are no primitive numbers like in Java. This may have the disadvantage of increased memory usage, but it also has the advantage that working with large numbers is much easier.

If you have tried doing high precision calculations or working with really large numbers in Java, then you know how difficult it is to work with BigDecimal and BigInteger to perform calculations. We have to call methods instead of using operators. Let's see this with a small example. If I want to print the value of Long.MAX_VALUE * 2, I have to use BigInteger and then invoke it's multiply method as shown in the example below:

System.out.println(Long.MAX_VALUE * 2); //Incorrect: prints -2
//The right way to work with large numbers in Java
BigInteger bi1 = new BigInteger("9223372036854775807");
BigInteger bi2 = new BigInteger("2");
BigInteger bi3 = bi1.multiply(bi2);

Output of this program is:


See how cumbersome it is to do even simple operations with integers larger than 263-1. However in Groovy, multiplying Long.MAX_VALUE with 2 would have automatically resulted in a BigInteger. Floating point numbers in Groovy are always BigDecimals, and as a rule, when we do arithmetic operations in Groovy, the result is always what we expect it to be.

This small snippet of Groovy code is self explanatory.

//It is very natural to do high precision calculations in Groovy because
//in Groovy numbers can be directly represented with BigDecimal and BigInteger
//and we can use regular arithmatic operators with them

//Numbers in Groovy are first class objects
def i = 5
println '5 is of type ' + i.getClass().getName()

def d = 5.4
println '5.4 is of type ' + d.getClass().getName()

//It is possible to explicitly create Long, Float, Double, and G???
def l = 8999000000000L
println '8999000000000L is of type ' + l.getClass().getName()

def f = 1.2F
println '1.2F is of type ' + f.getClass().getName()

def doubleObj = 1.2D
println '1.2D is of type ' + doubleObj.class.getName()

def g = 3G
def g1 = 3.5G
println '3G is of type ' + g.getClass().getName()
println '3.5G is of type ' + g1.getClass().getName()

//type conversions in arithmatic operations
//Mostly the result is what you would expect
println 'Adding Integers results in a : ' + (3 + 3).class.getName()
println 'Multiplying Integers results in a : ' + (3*3).class.getName()
println 'subtraction between Integers results in a : ' + (3-8).class.getName()
println 'Division of an Integer with an Integer results in a : ' + (3/3).class.getName()

//Integer division can be forced with the intdiv() method
def fi = 1.intdiv(2)
println 'fi is of type: ' + fi.class.getName() + ' and it\'s value is ' + fi

//Some numbers also have methods which can be used instead of for loops
//by accepting a closure
def n = 5
n.times { print """${it} """} //notice the use of GStrings

//other methods on numbers include upto, downto, and step
//we also need a more advanced example on numbers to explore all the other
//methods present in various number classes

Output of this program is:

5 is of type java.lang.Integer
5.4 is of type java.math.BigDecimal
8999000000000L is of type java.lang.Long
1.2F is of type java.lang.Float
1.2D is of type java.lang.Double
3G is of type java.math.BigInteger
3.5G is of type java.math.BigDecimal
Adding Integers results in a : java.lang.Integer
Multiplying Integers results in a : java.lang.Integer
subtraction between Integers results in a : java.lang.Integer
Division of an Integer with an Integer results in a : java.math.BigDecimal
fi is of type: java.lang.Integer and it's value is 0
0 1 2 3 4

No comments: