function [G] = cholesky(A)
%This code computes the cholesky decomposition of A.
%A = given matrix.
%G = Lower triangular cholesky decomposition
%Written by: Shefali Kulkarni-Thaker
epsilon = eps;%tolerance
[row,col] = size(A);
%check if matrix is square
if row~=col
    error('Matrix must be square')
end
%check that matrix is not singular - not the best way to do.
if abs(det(A)) < epsilon
    error('Matrix is singular to machine precision and cannot be solved')
end
%check is symmetric and positive definite. 
%Implicitly checks for square matrices.
if ~(all(all(A==A')) && min(eig(A))>0)
    error('Matrix is not SPD to perform Cholesky decomposition');
end
n=row;%size of the matrix
G = zeros(n,n);%Lower triangular matrix
for i = 1:n
    G(i,i) = sqrt(A(i,i) - G(i,:)*G(i,:)');%Calculate diagonals.
    for j = i+1:n
        G(j,i) = (A(j,i) - G(i,:)*G(j,:)')/G(i,i);%column
    end
end
end

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?

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.

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.

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 !

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.

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 !!

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*/

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.