Find Motive

NEW 2010 A CD : www.productionsdoz.com This is an hommage to the great and wonderfull brazilian guitarist: Baden POWELL, with a valse “valsa sem nome” but we can call it “BADEN” out of respect for his memory a good blog : www.brazil-on-guitar.de
Video Rating: 4 / 5

SEMTech Solutions Website

North Billerica, MA (PRWEB) May 21, 2009

SEMTech Solutions, a leading supplier of used Scanning Electron Microscopes (SEMs) and SEM analytical lab services, announces the launching of its new website designed for both buyers and sellers. The website is located at www.semtechsolutions.com.

Used SEM buyers will appreciate the listing of scanning electron microscopes from various manufacturers. The Find-Your-SEM utility is for buyers that can’t locate a specific SEM. Buyers are prompted for specific SEM details based on their application and price range. SEMTech Solutions will aggressively work with those customers seeking a best match, based on their SEM requirements.

The Sell-Your-SEM utility offers equipment owners a convenient way to list their SEM on a website dedicated to scanning electron microscopy. The Sell-Your-SEM feature is ideal for organizations that do not have the time, the resources, and most importantly, the network needed to sell their equipment. In addition, SEMTech Solutions can work with the seller to incorporate its Finance-Your-SEM package as an incentive to help move your SEM as quickly as possible.

With the release of this new web site, SEMTech Solution’s goal is to make the user’s experience informative, logical and intuitive.

About SEMTech Solutions, Inc.

SEMTech Solutions is a leading supplier of used SEMs and SEM-EDS services. In addition, we are also a North American sales and service representation company handling new scientific instrumentation that specializes in electron beam technology (Electron Beam Lithography systems, LN2-free Silicon Drift EDX detectors, 3D Roughness Analyzing SEMs, etc.). With over 200 years combined SEM experience, our sales and service engineers located throughout the U.S. are committed to our customers. Our growing customer install base consists of over 150 organizations, ranging from start-ups to Fortune 100 companies.

###

Question by silky: write a program for the implementation of breadth first search on a graph?
MCA @nd sem “data and file structures”

Best answer:

Answer by ammassridhar
import java.util.Vector;

public class BreadthFirstSearch extends SearchApplet {

public void init() {

// Define a test network before calling the super class ‘init’:
addNode(“0″, 0.0f, 0.0f);
addNode(“1″, 1.0f, 1.0f);
addNode(“2″, 5.0f, 2.0f);
addNode(“3″, 2.0f, 5.0f);
addNode(“4″, 7.0f, 5.0f);
addNode(“5″, 8.0f, 8.0f);
addNode(“6″, 10.0f, 5.0f);
addNode(“7″, 8.0f, 2.0f);
addNode(“8″, 12.0f, 8.0f);
addNode(“9″, 13.0f, 5.0f);

addLink(0,1);
addLink(1,2);
addLink(2,3);
addLink(2,4);
addLink(4,5);
addLink(4,6);
addLink(6,8);
addLink(8,9);
addLink(2,7);
addLink(7,9);

// Now that we have defined the network to search, we
// can now call the super class init:
super.init();
}

/** findPath – abstract method in super class */
// Breadth first search algorithm from “Algorithms”
// (Cormen, Leiserson, Rivest) page 460:
public int [] findPath(int node_1, int node_2) { // return an array of node indices
System.out.println(“Entered BreadthFirstSearch.findPath(” +
node_1 + “, ” + node_2 + “)”);
if (node_1 == node_2) {
repaintPath(null, 0);
return null;
}
// data structures for depth first search:
boolean [] visitedFlag = new boolean[numNodes];
float [] distanceToNode = new float[numNodes];
int [] predecessor = new int[numNodes];
Queue queue = new Queue(numNodes + 2);

// data structures for graphical display (only):
int [] display_path = new int[2 * numNodes + 1];
int num_display_path = 0;

for (int i=0; i visitedFlag[i] = false;
distanceToNode[i] = 10000000.0f;
predecessor[i] = -1;
}

visitedFlag[node_1] = true;
distanceToNode[node_1] = 0.0f;
queue.enqueue(node_1);
outer:while (queue.isEmpty() == false) {
int head = queue.head();
int [] connected = connected_nodes(head);
if (connected != null) {
for (int i=0; i if (visitedFlag[connected[i]] == false) {
distanceToNode[connected[i]] = distanceToNode[head] + 1.0f;
predecessor[connected[i]] = head;
queue.enqueue(connected[i]);
display_path[num_display_path++] = head;
display_path[num_display_path++] = connected[i];
repaintPath(display_path, num_display_path);
if (connected[i] == node_2) break outer; // we are done
}
}
visitedFlag[head] = true;
queue.dequeue(); // ignore return value
}
}
// now calculate the shortest path from the predecessor array:
int [] ret = new int[numNodes + 1];
int count = 0;
ret[count++] = node_2;
for (int i=0; i ret[count] = predecessor[ret[count - 1]];
count++;
if (ret[count - 1] == node_1) break; // back to starting node
}
num_display_path = 0;
int [] ret2 = new int[count];
for (int i=0; i ret2[i] = ret[count - 1 - i];
if (i > 0) { // re-calculate the plot display points:
display_path[num_display_path++] = ret2[i-1];
display_path[num_display_path++] = ret2[i];
}
}
// now re-calculate the display path points:
repaintPath(display_path, num_display_path);
return ret2;
}

// Queue algorithm from “Algorithms” (Cormen, Leiserson, Rivest) page 202:
protected class Queue {
public Queue(int num) {
queue = new int[num];
head = tail = 0;
len = num;
}
public Queue() {
this(400);
}
private int [] queue;
int tail, head, len;
public void enqueue(int n) {
queue[tail] = n;
if (tail >= (len – 1)) {
tail = 0;
} else {
tail++;
}
}
public int dequeue() {
int ret = queue[head];
if (head >= (len – 1)) {
head = 0;
} else {
head++;
}
return ret;
}
public boolean isEmpty() {
return head == (tail + 1);
}
public int head() {
return queue[head];
}
}

protected int [] connected_nodes(int node) {
int [] ret = new int[SearchApplet.MAX];
int num = 0;

for (int n=0; n boolean connected = false;
// See if there is a link between node 'node' and 'n':
for (int i=0; i if (link_1[i] == node) {
if (link_2[i] == n) {
connected = true;
break;
}
}
if (link_2[i] == node) {
if (link_1[i] == n) {
connected = true;
break;
}
}
}
if (connected) {
ret[num++] = n;
}
}
if (num == 0) return null;
int [] ret2 = new int[num];
for (int i=0; i ret2[i] = ret[i];
}
return ret2;
}

private int [] path = new int[SearchApplet.MAX];
private int num_path = 0;

private int [] copy_path(int [] path, int num_to_copy) {
int [] ret = new int[SearchApplet.MAX];
for (int i=0; i ret[i] = path[i];
}
return ret;
}

}

What do you think? Answer below!