Ubuntu insights, Programming in groovy, java, et als!

Monday, December 22, 2014

Command Pattern in java/groovy

Command pattern encapsulates a request. A command pattern maybe used whenever there is a Sender, Receiver who communicate via a request (let's call it command). Assume, we simulate the game of cricket via a Simulator class which sends commands  to the Batsman objects to play certain shots. Each shot is a command given by the simulator to a batsman.

interface Shot{
public void execute();
}

class CoverDrive implements Shot{

private Batsman batter;

public void execute(){
batter.playCoverDrive()
}
}

class straightDrive implements Shot{

private Batsman batter;

public void execute(){
batter.playStraightDrive();
}
}

class Batsman{

def playCoverDrive(){
println("Cover drive")
}

def playStraightDrive(){
println("Cover drive")
}
}

class BatSimulator{

Shot shot

def play(){
shot.execute()
}
}

// main - groovy script start

def sachin = new Batsman()
def command = new CoverDrive(batter : sachin)
def simulator = new BatSimulator(shot : command)
simulator.play()

Monday, December 15, 2014

Write a custom event handler in groovy/java

One may write a couple of classes and an interface to achieve event handling without having to implement the Observable/Observer interface. Assume, we have a computer that runs several processes. If it receives a shutdown command, we fire an event to let the running process handle its own clean up method to release resources and halt execution.

interface ShutdownListener{
    public void handle();
}

public class Computer{

    private def listeners = []

    def addShutdownListener(ShutdownListener l){
listeners.add(l)
    }

    def shutdown(){
for(ShutdownListener l : listeners)
l.handle()
    }

    def compute(){ // whatever  }

}

public class Process implements ShutdownListener{

    public void handle(){
// release resources of "this" Process 
// halt execution of self
println("Process ended.");
    }
}

//groovy script start 
def computer = new Computer()
def process = new Process()
computer.addShutdownListener(process)
computer.compute()
computer.shutdown()

Monday, October 20, 2014

Simple way to implement find(select) and collect block closures in java

Languages like ruby, groovy, smalltalk have language constructs for blocks and closures. Java 8 now has feature to evaluate lambda expressions. But here is one simple and straight way to implement the same:

In groovy :

[1, 2, 3, 10, 20, 30].findAll { num -> num > 5 }
=> yields a new list [10, 20, 30]

[ 1, 2, 3, 4 ].collect{ num -> num * num}
=> yields a new list [1, 4, 9, 16]

The above code for those more familiar with the smalltalk syntax will be:

#(1 2 3 10 20 30) select: [ :num | num > 5 ]
==> displays [10, 20, 30]

#( 1 2 3 4 ) collect: [:i | i * i ].
==> displays [1, 4, 9, 16]

In java, the same could be implemented with a set of abstract classes as a collection utility that mandate implementation of method which returns the boolean condition to add or transform the element under iteration :

Find.java
abstract class Find extends ArrayList{ 
    /** let the default constructor worry about iteration **/
    public Find(List list){    
        Iterator it = list.iterator();
        while(it.hasNext()){
            Object element = it.next();        
            if(all(element))           
                this.add(element);         
        }
    }
     
    /** This defines the boolean condition for find/select **/
    public abstract Boolean all(Object obj);
     
}

FindDemo.java
// find all elements in the list that are greater than 5
List list = Arrays.asList(1, 2, 3, 10, 20, 30);
selected = new Find(list) {
    public Boolean all(Object num) {               
        return (int) num > 5;
    }
};
// => yields a new list [10, 20, 30]

Collect.java
abstract class Collect extends ArrayList{  
    /** let the default constructor worry about iteration **/
    public Collect(List list){
        Iterator it = list.iterator();
        while(it.hasNext()){
            Object element = it.next();
            Object transformed = transform(element);
            this.add(transformed);
        }
    }
    /** This defines the transformation logic for collect **/
    public abstract Object transform(Object obj);
}

CollectDemo.java
// collect the squares of all elements in the list
List list = Arrays.asList(1, 2, 3, 4);
collected = new Collect(list) {    
    public Object transform(Object num) {
            return (int) num * (int) num;
    }
};
// => yields a new list [1, 4, 9, 16]

Saturday, October 11, 2014

Gauss Circle Problem

Can do better without two loops :-|


latticePoints = 0
radius = 3.2
mod = int(radius) + 1

def isInCircle(x, y):
    return x*x + y*y <= radius*radius

def calc(x, y):
    global latticePoints
    if x == 0 and y == 0:
        latticePoints = latticePoints + 1
        print((x, y))
    elif x == 0 and y != 0:
        latticePoints = latticePoints + 2
        print((x, y),(x, -y))      
    elif x != 0 and y == 0:
        latticePoints = latticePoints + 2
        print((x, y),(-x, y))      
    else :
        latticePoints = latticePoints + 4
        print((x, y), (-x, -y), (x, -y), (-x, y))          

for i in range(mod) :
    for j in range(mod) :
        if(isInCircle(i,j)):
            calc(i,j)
 
print(latticePoints)