My most recent venture in technical world has been learning MS technologies and eventually O/RM using LINQ. Language Integrated Query or LINQ is a Microsoft feature that allows you to map your relational database tables to objects. I will talk about mapping a single table to a class hierarchy – Single Table Inheritance – using LINQ.

LINQ features are located in System.Linq, System.Data.Linq, and System.Data.Linq.Mapping namespaces. It’s mapping attribute [InheritanceMapping] does all the job for you.

Let us write a base class called Node and map it to a table in database using the TableAttribute.

  [Table(Name = "MST_EQUIP")]
[InheritanceMapping(Code = "SOURCE", Type = typeof(Source)]
public class Node
   {
       [Column(Name = "EQUIP_TYPE", IsDiscriminator = true,IsPrimaryKey=true)]
       public string NodeType;
  }

The Attribute, Column maps the field, NodeType to a column, EQUIP_TYPE, in database. The parameter IsDiscriminator identifies whether this column is the basis of inheritance.

In the Attribute, InheritanceMapping the parameter Code identifies the value in the Discriminating column which results in child class for the node. The Type parameter identifies the class.

In simple English, if the column EQUIP_TYPE of the table MST_EQUIP has the string “SOURCE” in it,  LINQ will create an Object of type Source for you. The class Source, of course, inherits the class Node.

That’s cool, isn’t it ?

This is what I saw When I downloaded Microsoft Research’s World Wide Telescope. 

Can’t wait to connect it a Stellarscope Star Finder.

Any buyers?

Most of us had a hard time learning asymptotic notation. I fairly skipped it, like my other classmates until recently I found that it was quite interesting to understand.

Asymptote is a curve on a graph that is approached but not reached. Performance of algorithms is an important algorithmic study, only after it’s correctness. It is measured in terms of size of the input. As the input size increases boundlessly how does the running time of the algorithm vary ? We plot the graph of the input size versus the running time of the algorithm. The curve of the graph essentially tells us the performance of the algorithm.

The first sorting procedure we learnt in school is insertion sort. The worst-case time of this algorithm is Θ(n²). So, what is this?

The mathematical definition of Θ is as follows: Given a function g(n) , Θ(g(n) ) is defined as a set of functions:

Θ(g(n) ) = {f(n): there exist positive constants c₁ and c_2, and n₀ such that 0 ≤ c₁g(n) ≤ f(n) ≤ c₂g(n) for all n ≥ n₀ }.

So, we are trying to club f(n) between c₁g(n) and c₂g(n) for a large value of n. So, since Θ(g(n) ) is a set of function and f(n) belongs to it, it means f(n) ε Θ(g(n) ). Instead we write f(n) = Θ(g(n) ), to mean the same (and we shall stick to that). The graph for f(n) = Θ(g(n) ) is:

The figure says that the value of function f(n) lies between an upper bound , c₂g(n) , and a lower bound c₁g(n). f(n) is hence a tightly bound by g(n).

The asymptotic running time ignores machine constants and looks for the growth of running time. So, as n approaches infinity, a Θ(n²) algorithm beats a Θ(n³). There will a point after which no matter how much step up you give to a Θ(n³) algorithm in terms of processing power – Θ(n²) will beat it. This point is n₀ .

The O-notation gives an upper bound to the function. When it is used for bounding the worst running time of the algorithm, it gives a bound on every input to the algorithm. Ω-notation gives a lower bound to the function. When it is used to describe the best running time for an algorithm, it gives a bound to any random input.

For example, consider insertion sort on an array A.

1. for i = 2 to length(A)
do k = A[ i ]
j = i – 1;
while j > 0 and A[ j ] > k
do A[ j+1 ] = A[ j ]
j = j – 1;
A[ j+1 ] = k;

The running time of insertion sort is Θ(n²), when the input is reverse sorted. However, if the input is already sorted, it gives a running time of Θ(n).

Saying that running time is O(n²), means that there is a function f(n)=O(n²) so that no matter how large the input is or what the input is, running time will never go beyond f(n).

Saying that running time is Ω(n), means that there is a function
f(n)=Ω(n) so that no matter how large the input is or what the input is , running time will never fall below f(n).

To say running time (of insertion sort) is Ω(n²) means that there is a function f(n) = Ω(n²), such that no matter what size input is chosen it will never go below f(n). This is, of course, incorrect in case of insertion sort.

Thus, insertion sort will take a minimum of Ω(n) and a maximum of O(n²).

Worst case running time is a guarantee of performance, while best-case can cheat since some algorithms work faster on some input.

Recently I wrote on Sequential Expression Evaluation in its stack-based recursive form. As a part of my course work, I wrote a parallel version for it referencing this. My implementation was in OpenMP using shared memory on SHARCNET.

Parallel implementation is done using Tree Contraction technique. The important operation of this technique is raking, that involves removing of many leaves of the binary expression tree in parallel. Tree Contraction and Raking is explained as under:

For a vertex u in tree having v and w as its left and right children. The vertex v ( and every other node) is associated with label .The initial value of this label id (1,0). At every iteration new value for this labels are evaluated until the the tree is reduced to 3 vertices. The value of the parent node v is given by:

The value of the parent of u, denoted by p(u) is given by:

When we rake v, labels of w are updated. Thus, on applying rake operation repeatedly we get a three-vertex tree T with root r, having the operator, and its children as and .

The value at the root, and hence the expression is given by:

Parallel Expression Evaluation is about applying raking operation in parallel. Here is a glimpse of raking operation.

The raking operation has to be done with a small strategy. Consider this tree.

We clearly cannot rake node 1 and 8, whose parents are consecutive, at the same time. So we apply raking to non-consecutive leaves as they appear from left to right. The algorithm for the raking operation is as:

1. Label the leaves consecutively in order from left to right, excluding the left-most and right-most nodes (since we need then for final evaluation), and store this in an array A of size n. Create a subarray A_odd and A_even that consist of odd- and even-indexed elements of A.

2.for(lg(n+1)) iteration do

1. Apply rake operation that modifies the siblings labels concurrently to all the elements of A_odd that are left children,

2. Apply rake operation that modifies the siblings labels concurrently to all the rest of the elements of A_odd .

3. Make A = A_even.

3.Compute the value of arithmetic expression from the three-vertex binary tree.

A glimpse of this operation in action is here:

The OpenMP implementation of this algorithm gave significant results when applied on a Full Binary Tree with height = 30.

The complexity of sequential arithmetic evaluation, for an n node tree is O(n), while for parallel version it is reduced to O(lg(n)).

All figures, excluding chart, are from here.

I have to always connect to the database for some reason. My usual problem is “Access denied”. I thought I would document it once. The steps to start connecting to MySQL from a program are as:

1) Install MySQL server and download mysql-connector-java-3.0.17-ga.

2) Set the class path. ( could be C:\mysql-connector-java-3.0.17-ga )

3) Grant permission on the SQL server as:
GRANT ALL PRIVILEGES ON some_database.* TO ’someuser’@'localhost’ IDENTIFIED BY ’some_password’ WITH GRANT OPTION;

4) Load driver in JDBC as com.mysql.jdbc.Driver

5) Get the connection as jdbc:mysql://localhost:3306/<db_name>?user=some_user&password=some_password’6

6) Do you queries.

7) Close your connection.

You are all set.

Here is a quick example of this.

import java.io.*;
import java.sql.*;

public class SQLExample{
	public static void main(String args[])
	{
		Connection conn = null;
		Statement stmt = null;
		try{
	        //LOAD THE DRIVER
	       Class.forName("com.mysql.jdbc.Driver");
	       //GET THE CONNECTION STRING
	       conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/db_name?
user=someuser&password=somepassword");
	       //GET A STATEMENT TO EXECUTE
	       stmt=conn.createStatement ();
	       String query="insert into newtable values('someName',10)";
	       ResultSet result = stmt.executeQuery(query);
               System.out.println("query executed");
               int row = result.getRow();
               if(row>0)
               System.out.println("Row " +row+" Added");
	        }catch(Exception e){
	        	e.printStackTrace();
	        }
	        finally
	        {
	        	try {
	        			conn.close();
				}catch (SQLException e) {
					e.printStackTrace();
				}
	        }
	}
}

Good Luck connecting the database !

The way to probe agent properties that are user-defined objects in repast is through converters. For example, we have an agent with a parameter Volume, an object.

package properties;
/* @author Shefali Kulkarni */
public class Volume {
    private double vol;
    private double minVol;
    private double maxVol;
     public Volume()
    {
        this.vol = 100;
        this.minVol = 0;
        this.maxVol = 500;
    }
   // to define Accessor methods
   @Override
   public String toString() {
        return vol+" "+minVol+" "+maxVol;
    }
}

There is a need to write a Converter class for Volume, that converts Volume object to and from String. This is required since, the probe display is essentially String representation of Object. The definition for this Volume converter would be something as:

package properties.converter;
import repast.simphony.parameter.StringConverter;
/**
 * @author Shefali Kulkarni
  */
public class VolumeConverter implements
StringConverter<Volume>
{

    public Volume fromString(String str) {
        if(str.equals(null)) new Volume();
        int index = str.indexOf(" ");
        System.out.println(index);
        Double vol = Double.parseDouble
(str.substring(0,index));
        int next_index = str.indexOf(" ",index+1);
        System.out.println(next_index);
        Double min = Double.parseDouble
(str.substring(index+1,next_index));
        double max = Double.parseDouble
(str.substring(next_index+1, str.length()));
        return new Volume(vol,min,max);
     }

    public String toString(Volume obj) {
        if(obj.equals(null))
 return "Volume of the Tank is Undefined.";
       return obj.getVol()+" "+obj.getMinVol()+
" "+obj.getMaxVol();
    }
}

The definition has to make sure that the object and string are convertible from each other.

The parameter annotation would then be as follows indicating the converter class.

package somepackage;

public class SomeAgent{

@Parameter(displayName="Volume", usageName="volume",
  converter=" properties.converter.VolumeConverter")
public Volume getVolume()
{
return volume;
}
public void setVolume(Volume volume)
{
this.volume=volume;
}
private Volume volume = null;
}

If Volume is a simulation parameter, then this has to be included in extended_params.XML in the modelname.rs directory.

<parameters>
<parameter name="sim_vol"
displayName = "Simulation Volume"
type = "properties.Volume"
converter = "properties.converter.VolumeConverter"
defaultValue = "0 100 500" />
</parameters>

It would be more exciting to probe Volume as a category, with its some or all instance variables as subcategory.

Before I write about how to write a RePast S model from scratch, the non-groovy way, let me write something that will lead to the details. Any model needs to know what is has – model descriptor, and how it is – scenario descriptor.

Model descriptors consists of agent definition – java classes, networks, space, grids etc., relation ships between them, watching and watcher triggers, schedule methods etc. Scenario descriptors tell you what the model has. It would say that the grid from the model descriptor is 2D or 3D. It would also tell you from where the agents are loaded – from the scenario loader or some class context loader. It also has charts etc i.e logging information for the model.

So what do you basically need to create a RePast S model ?

1. Define a Model – the Agents, the relationship between agents (which method to schedule when, which agent keeps an eyes on another etc.)

2. Define the Context. RePast S has a default context that spares you from writing a Context class but I will write here to illustrate. Define geometry of the model. Add the agents to that geometry. This is essentially the scenario part.

3. Load the model and run it.

Let us go through each of these steps.

1. Defining the model.

Assuming familiarity with Eclipse, load the Eclipse and create RePast S project and name it GasNodeModel. Create an Agent GasNodeAgent, GasNodeGrid, GasNetwork. The GasNodeGrid will tell the model where the Agent GasNode is going to reside and The GasNetwork will define the interconnection between these agents. Take a look at the Scenario.xml in the directory where model.score lies.

Let me write the agent GasNodeAgent with parameter Pressure and measuredPressure, much the same from the tutorial.

package gasnodemodel;

import repast.simphony.engine.schedule.ScheduledMethod;
import repast.simphony.engine.watcher.Watch;
import repast.simphony.engine.watcher.WatcherTriggerSchedule;
import repast.simphony.parameter.Parameter;
import repast.simphony.ui.probe.ProbeID;

/**
 * @author shefali
 *
 */
public class GasNodeAgent {
  @Parameter (displayName = "Node Pressure", usageName = "pressure")
    public double getPressure() {
        return this.pressure;
    }
    public void setPressure(double pressure) {
        this.pressure = pressure;
    }
    private double pressure = 300;
    @Parameter (displayName = "Measured Pressure", usageName = "measuredPressure")
    public double getMeasuredPressure() {
        return this.measuredPressure;
    }
    public void setMeasuredPressure(double measuredPressure) {
        this.measuredPressure = measuredPressure;
    }
    private double measuredPressure = 0;
    @Watch(
        watcheeClassName = "gasnodemodel.GasNodeAgent",
        watcheeFieldNames = "pressure",
        query = "linked_from",
        whenToTrigger = WatcherTriggerSchedule.LATER,
        scheduleTriggerDelta = 10d,
        triggerCondition = "$watchee.getPressure()<200")
     public void changePressure(gasnodemodel.GasNodeAgent watchedNode) {
               setPressure(watchedNode.getPressure());
    }

    @ScheduledMethod(
        start = 1d,
        interval = 1d,
        shuffle = true
    )
    public void measurePressure() {
            double x = 0;
            int num = 0;
            for (int i=0;i<10;i++) {
            x = x+pressure + Math.random();
            num++;
            }
            setMeasuredPressure(x/num);
   }
  @ProbeID()
    public String toString() {
        return "GasNode";
 }
}

Run your model. Build Displays. It goes all well! That’s all you need to make a non-groovy model.

But what if my model agents are fixed ? Yeap, lets create a context. Quite the one in SimpleHappy.

2. Define the Context.

Let me write a GasNodeContext class.

package gasnodemodel;

import repast.simphony.context.Context;
import repast.simphony.context.space.graph.NetworkFactoryFinder;
import repast.simphony.context.space.grid.GridFactoryFinder;
import repast.simphony.dataLoader.ContextBuilder;
import repast.simphony.space.grid.StickyBorders;
import repast.simphony.space.graph.Network;
import repast.simphony.space.grid.GridBuilderParameters;
import repast.simphony.space.grid.RandomGridAdder;

/**
 * @author shefali
 */
public class GasNodeContext implements ContextBuilder<GasNodeAgent> {

    private int gasNodes = 3;
    public Context<GasNodeAgent> build(Context<GasNodeAgent> context) {
    Network<GasNodeAgent> network = NetworkFactoryFinder.createNetworkFactory(null).createNetwork("GasNetwork", context, true);
    GridFactoryFinder.createGridFactory(null).createGrid("GasNodeGrid", context,
                GridBuilderParameters.singleOccupancy2D(new RandomGridAdder<GasNodeAgent>(), new StickyBorders(), 30, 30));
        GasNodeAgent gasnode = new GasNodeAgent();
        context.add(gasnode);
        GasNodeAgent prev = gasnode;
        GasNodeAgent  agent = null;
        for (int i = 0; i < gasNodes - 1; i++) {
            agent = new GasNodeAgent();
            context.add(agent);
            network.addEdge(prev, agent);
            prev = agent;
        }
        network.addEdge(agent, gasnode);
        return context;
    }

    public int getNumNodes() {
        return gasNodes;
    }

    public void setNumNodes(int numNodes) {
        this.gasNodes = numNodes;
    }
}

Lets run it. It wont work. If you look on the left pane the data loader is Score Context Builder, RePast`s default. It determines where to load data from, from scenario.xml. Let go back to this scenario.xml. It will have an element:

<repast.simphony.dataLoader.engine.ScoreDataLoaderAction context=”GasNodeModel” file=”repast.simphony.dataLoader.engine.ScoreDataLoaderAction_0.xml” />

You would need to change one last thing to get those ‘fixed’ agents in your display. Change the above line to:

<repast.simphony.dataLoader.engine.ClassNameDataLoaderAction context=“GasNodeModel” file=“repast.simphony.dataLoader.engine.ClassNameDataLoaderAction_0.xml” />

Create a file named repast.simphony.dataLoader.engine.ClassNameDataLoaderAction_0.xml in gasnodemodel.rs directory and add the line:

<string>gasnodemodel.GasNodeContext</string>

That’s to it.

The RePast S runtime system needs to know from where to load agents, and in what to load agents. That’s what scenario.xml tells the model.

Happy creating POJO Agents !!

Expression evaluation is probably the most common text book example, and a popular application of those tree walks. Recently, while writing a parallel version for the same I had to quickly jot down a sequential version using stack and post order walk. The tree is implemented as an array that has its index, and index of left and right children. The reason to use it as an array is to facilitate parallel version for the same using multi-threading. Here is the code for the sequential version.

void postorder(INFO curr_index)
{
if(curr_index!=-1)
{
  postorder(exp[curr_index].left);
  postorder(exp[curr_index].right);
  if(exp[curr_index].op==NIL)
    s.item[++s.top]=exp[curr_index].c;
  else{
       switch(exp[curr_index].op)
       {
 	case ADD:
         result = s.item[s.top--] + s.item[s.top--];
         s.item[++s.top] = result;
         break;
        case SUB:
         result = - s.item[s.top--] + s.item[s.top--];
	 s.item[++s.top] = result;
         break;
        case MULT:
         result = s.item[s.top--] * s.item[s.top--];
         s.item[++s.top] = result;
         break;
       }/*switch*/ 
      }/*else*/
 }/*if*/
}/*postorder*/

Parallel computing is use of multiple resources to solve a computational problem. The prime reason for using parallel computing is the need for speed. Dividing a problem and then distributing it on different processors definitely gives a boost towards solution. The motivation to use parallel computing is to reduce wall clock time and to make solutions to large problems available in feasible time. Making efficient use of local and remote processors, overcoming memory considerations, concurrency are additional reasons for "why parallel".

Of various parallel Programming model, the ones of particular interest in this post are: Thread Model and Message Passing Model.

Thread Model

• A single process has  multiple execution paths.
• Associated with shared memory architectures.
• POSIX threads and OpenMP are implementation of threads.

 

Talking about OpenMP – Open specifications for Multi Processing

It is based on existence of multiple threads in shared memory architecture. Single process consists of multiple threads. The Programming model is explicit and hence programmer has full control over the parallelism. It is an API to implement multi-threading, shared memory parallelism. Data sharing is implicit due to shared memory architecture. It follows a dynamic parallelism, meaning new threads can be spawned dynamically.

Message Passing Model – MPI – Message Passing Interface

• MPI is specification targeted towards distributed memory architectures.
• It consists of set of processes having their own memory space.
• Communication is explicit and is done by sending messages using send and receive.
• Programming model is explicit and programmer has to identify parallelism.
• It does not have dynamic parallelism, i.e the number of processes created is static and new ones cannot be created at runtime.

Illustration demonstrating the difference.

Last assignment of this term, last question of it and this one goes like this: Show that a maximum flow in a flow-network G = (V,E) can always be found by sequence of at most |E| augmenting paths.

Let me defragment the question and talk about what is what and then give an intuitive solution.

G is a graph represeting a flow-network with V as set of vertices and E that of edges. |E| is the total number of edges in this graph, or flow-network, G. An augmenting path is a simple path in G, that can accomodate more flow without violating the capacity constraints on an edge. The problem is to prove that we can find maximum flow in G, in atmost |E| sequences of such augmenting paths.

The most intuitive solution is reverse Ford-Fulkerson. What does this algorithm do? It starts by making flow on every edge 0, thus making the total flow 0. It then iterates through a path p from s, source to sink, t as long as there is an augmenting path. When there are no more augmenting paths it terminates and gives the maximum flow, |f|. It calculates this by adding the residual capacity of each edge.

So, in order to solve our problem we go reverse by subtracting this capacity, reducing one edge’s flow to 0 each time, untill we get a total flow of 0. This can happen when flow along all the edges in the path is 0, since there are only |E| edges, we get a sequence of atmost |E| augmenting paths. I think there can be a formal proof too.

Ford-Fulkerson(G,s,t)

1. for each edge (u,v) in E(G)
2. do f[u,v] = 0 and f[v,u] = 0
3. while there exists a path p from s to t in the residual network G(f)
do c = min(c(u,v)-f(u,v): (u,v) is in p)
for each edge (u,v) in p
do f[u,v] += c and f[v,u] = – f[u,v]

The Reverse-Ford-Fulkerson will know the maximum flow, say it is |f[0]| and the path associated with this flow, say P[0]. Let P be the set of all the augmenting paths that we had.

and the Reverse-Ford-Fulkerson is

1. Let i = 0 and P = NULL.
2. while |f[0]| > 0
i++
R[i] = min ( f(u,v): (u,v) as an edge in P[i-1] )
|f[i]| = |f[i-1]| – R[i]
P = P U {P[i]}
return P.length

In the above algorithm, the line 5 reduces the flow along every edge in the path P[i-1] by R[i] and also makes the flow in one of the edge in that path as 0. Every such iteration reduces the flow of the network untill it reaches 0 and making the flow along one of the edge 0.( we hence reach the first 2 steps of the Ford-Fulkerson algorithm). Since there are |E| edges, the length of P returned is atmost |E|.