int main() {
auto gHeap = new cs6771::Graph<std::string,int>{};
// add this data into the graph
gHeap->addNode("a");
gHeap->addNode("b");
gHeap->addNode("c");
gHeap->addNode("d");
gHeap->addEdge("b","a",3);
gHeap->addEdge("b","a",5);
gHeap->addEdge("c","a",3);
std::cout << "original graph" << std::endl;
gHeap->printNodes();
gHeap->printEdges("b");
cs6771::Graph<std::string,int> gHeapCopy;
gHeapCopy.addNode("z");
std::cout << "Graph before copy assignment" << std::endl;
gHeapCopy.printNodes();
gHeapCopy = *gHeap; // copy assignment
gHeap->deleteNode("a");
std::cout << "original graph after delete" << std::endl;
gHeap->printNodes();
gHeap->printEdges("b");
std::cout << "copied graph after delete in other graph" << std::endl;
gHeapCopy.printNodes();
gHeapCopy.printEdges("b");
delete gHeap;
std::cout << "copied graph after other graph is deleted" << std::endl;
gHeapCopy.printNodes();
}
void prim(int startNode)
{
printf("Prim's Algorithm started\n");
int nrVertecesVisited=0,i;
int * visited = (int*)malloc(nrOfVerteces * sizeof(int));
for(i=0; i<nrOfVerteces; i++)
{
visited[i] = UNVISITED;
}
int minCost = 0;
edgeT * edges = (edgeT*) malloc((nrOfVerteces-1) * sizeof(edgeT));
visited[startNode] = VISITED;
while(nrVertecesVisited<nrOfVerteces-1)
{
edgeT minEdge = getMinimumEdgeForCurrentlyVisitedNodes(visited);
visited[minEdge.destination]=VISITED;
edges[nrVertecesVisited++] = minEdge;
minCost+=minEdge.weight;
}
printEdges(edges, nrVertecesVisited);
printf("Cost of MST by Prim's Algorithm: %d\n",minCost);
printf("Prim's algorithm ended\n\n");
}
void Graph::printEdgesInVertices( ) const{
for (const auto & p: *verticesMap){
VertexPtr v = p.second;
printEdges (v);
}
}
void kruskal()
{
int* parent = (int*)malloc(sizeof(int)*nrOfVerteces);
int i, trees = nrOfVerteces, nrEdges = 0;
for(i=0; i<nrOfVerteces; i++)
parent[i] = i;
edgeT minEdge;
edgeT *edges = (edgeT*) malloc(sizeof(edgeT)*(nrOfVerteces-1));
int** copyOfAdjMatrix = getCopyOfAdjecencyMatrix(adjMatrix);
while(trees > 1)
{
minEdge = getMinimumEdgeForAdjacencyMatrix(copyOfAdjMatrix);
removeEdge(copyOfAdjMatrix, minEdge);
if(uni(parent, minEdge.source, minEdge.destination) != 0)
{
trees--;
edges[nrEdges] = minEdge;
nrEdges++;
}
}
printf("\nKruskal:\n");
printEdges(edges, nrOfVerteces-1);
printf("\n");
}
/*
*----------------------------------------------------------
* PrintMenu
*----------------------------------------------------------
*/
void printMenu(int item)
{
switch(item){
case 0:
printVertexInfo();
break;
case 1:
printFacesInfo();
break;
case 2:
printInfoPrim( NumberPrimitives );
break;
case 3:
printActivePrim();
break;
case 4:
printEdges();
break;
case 5:
printCellsInfo();
/*printCellsTimeSplit();*/
break;
default:
break;
}
glutPostRedisplay();
}
void kruskal()
{
printf("Kruskal: \n");
int** matrix=getCopyOfAdjecencyMatrix(adjMatrix);
int* parent=(int*)malloc(nrOfVerteces*sizeof(int));
int i, weight=0;
for(i=0; i<nrOfVerteces; i++)
{
parent[i]=-1;
}
int nrOfEdgesCovered=0;
edgeT* edges=(edgeT*)malloc(sizeof(nrOfVerteces-1));
while(nrOfEdgesCovered<nrOfVerteces-1)
{
edgeT e=getMinimumEdgeForAdjacencyMatrix(matrix);
matrix[e.source][e.destination]=0;
matrix[e.destination][e.source]=0;
int u=getParent(parent, e.source);
int v=getParent(parent, e.destination);
if(uni(parent, u, v))
{
edges[nrOfEdgesCovered]=e;
nrOfEdgesCovered++;
weight+=e.weight;
}
}
printEdges(edges, nrOfEdgesCovered);
printf("\n%d\n", weight);
}
void Graph<Node, Edge>::printEdges(const Node &n) const {
if(!isNode(n)) {
throw std::runtime_error("Could not find node");
}
auto nc = std::find_if(nodes.cbegin(), nodes.cend(), [&n] (const NodeContainer nc) {
return nc.getNode() == n;
});
if(nc != nodes.cend()) {
nc->printEdges();
}
}
void bellmanFord()
{
int n=nrOfVerteces, source, i, j, a;
printf("Bellman-Ford\nsource: ");
scanf("%d", &source);
int* distance=(int*)calloc(n, sizeof(int));
for(i=0; i<n; i++)
{
if(i!=source)
{
distance[i]=MAX;
}
}
int* parent=(int*)malloc(n*sizeof(int));
for(i=0; i<n; i++)
{
parent[i]=(int)NULL;
}
for(a=0; a<2; a++)
for(i=0; i<n; i++)
for(j=0; j<n; j++)
{
if(adjMatrix[i][j]!=0)
{
if(distance[i]+adjMatrix[i][j]<distance[j])
{
distance[j]=distance[i]+adjMatrix[i][j];
parent[j]=i;
}
}
}
edgeT* edges=(edgeT*)calloc(n-1, sizeof(edgeT));
int nrOfEdgesCovered=0;
int weight=0;
for(i=0; i<n; i++)
{
if(i!=source)
{
edges[nrOfEdgesCovered].source=parent[i];
edges[nrOfEdgesCovered].destination=i;
edges[nrOfEdgesCovered].weight=distance[i]-distance[parent[i]];
weight+=edges[nrOfEdgesCovered].weight;
nrOfEdgesCovered++;
}
}
printf("%d\n", weight);
printEdges(edges, nrOfEdgesCovered);
}
void prim(int startNode)
{
int* visited = (int*) calloc(nrOfVerteces, sizeof(int));
edgeT* edges = (edgeT*) malloc ((nrOfVerteces-1) * sizeof(edgeT));
int visNo = 1;
visited[startNode] = 1;
while (visNo < nrOfVerteces) {
edges[visNo-1] = getMinimumEdgeForCurrentlyVisitedNodes(visited);
visNo++;
}
printEdges(edges, nrOfVerteces-1);
}
void kruskal()
{
printf("\nKruskal's algorithm started\n");
int **matrix = getCopyOfAdjecencyMatrix();
int *tag = (int*) malloc (sizeof(int) * nrOfVerteces);
int nrOfEdges = 0, i, minTag, maxTag;
edgeT minEdge;
edgeT *edges = (edgeT*) malloc (sizeof(edgeT) * (nrOfVerteces-1));
for(i=0; i<nrOfVerteces; i++)
tag[i] = i;
while(nrOfEdges < nrOfVerteces-1)
{
minEdge = getMinimumEdgeForAdjacencyMatrix(matrix);
matrix[minEdge.source][minEdge.destination] = -10;
matrix[minEdge.destination][minEdge.source] = -10;
if(tag[minEdge.source] != tag[minEdge.destination])
{
edges[nrOfEdges] = minEdge;
//keep the greater tag
if(tag[minEdge.source] > tag[minEdge.destination])
{
minTag = tag[minEdge.destination];
maxTag = tag[minEdge.source];
}
else
{
minTag = tag[minEdge.source];
minTag = tag[minEdge.destination];
}
//everywhere I find the minTag I will replace it by maxTag
for(i=0; i<nrOfVerteces; i++)
if(tag[i] == minTag)
tag[i] = maxTag;
nrOfEdges+=1; //increment the number of edges that I'have used
}
}
printEdges(edges, nrOfEdges);
printf("Kruskal's algorithm ended\n");
}
void kruskal()
{
printf("\nKruskal starts\n");
int nrOfEdges=0, i, p, t;
edgeT minEdge;
int **matrix=getCopyOfAdjecencyMatrix();
int *parent=(int*)malloc(nrOfVerteces*sizeof(int));
edgeT *edges=(edgeT*)malloc(sizeof(edgeT)*(nrOfVerteces-1));
for(i=0; i<nrOfVerteces; i++)
{
parent[i]=i;
}
while(nrOfEdges<nrOfVerteces-1)
{
minEdge=getMinimumEdgeForAdjacencyMatrix(matrix);
matrix[minEdge.source][minEdge.destination]=0;
matrix[minEdge.destination][minEdge.source]=0;
if (parent[minEdge.source]!=parent[minEdge.destination])
{
edges[nrOfEdges]=minEdge;
if(parent[minEdge.source]>parent[minEdge.destination])
{
p=parent[minEdge.destination];
t=parent[minEdge.source];
}
else
{
p=parent[minEdge.source];
t=parent[minEdge.destination];
}
for(i=0; i<nrOfVerteces; i++)
{
if(parent[i]==p)
{
parent[i]=t;
}
}
nrOfEdges++;
}
}
printEdges(edges, nrOfEdges);
printf("Kruskal stops\n");
}
void kruskal()
{
printf("Kruskal start\n\n");
int i;
int* parent = (int*) malloc (sizeof(int));
edgeT* edges = (edgeT*) malloc ((nrOfVerteces-1) * sizeof(edgeT));
int** adjMatrCpy = getCopyOfAdjecencyMatrix(adjMatrix);
// set each edges as its own tree
for (i = 0; i < nrOfVerteces; i++) {
parent[i] = i;
}
int noOfTrees = nrOfVerteces;
int noOfEdges = 0;
edgeT minE;
while (noOfTrees > 1) {
// find min edge
minE = getMinimumEdgeForAdjacencyMatrix(adjMatrCpy);
// remove min edge
adjMatrCpy[minE.source][minE.destination] = 0;
adjMatrCpy[minE.destination][minE.source] = 0;
// if the minE.u and minE.v are in different trees, unite
if (uni(parent, minE.destination, minE.source)) {
edges[noOfEdges++] = minE;
noOfTrees--;
}
//noOfTrees--;
}
printf("Min Spanning tree edges:\n");
printEdges(edges, nrOfVerteces-1);
free(edges);
printf("\nKruskal end\n\n");
}
void kruskal()
{
printf("Kruskal's algorithm has started\n");
int ** matrix=getCopyOfAdjecencyMatrix();
edgeT *edges=(edgeT*)malloc((nrOfVerteces-1)*sizeof(edgeT));
edgeT minEdge;
int * parent=malloc((nrOfVerteces-1)*sizeof(int));
int nrEdge=0,i;
for (i=0; i<nrEdge; i++) parent[i]=i;
while (nrEdge<nrOfVerteces)
{
minEdge=getMinimumEdgeForAdjacencyMatrix(matrix);
matrix[minEdge.source][minEdge.destination]=0;
matrix[minEdge.destination][minEdge.source]=0;
if (uni(parent,minEdge.source,minEdge.destination))
{
edges[nrEdge]=minEdge;
nrEdge++;
}
}
printEdges(edges,nrEdge);
printf("Kruskal's algorithm has ended\n\n");
}
void prim(int startNode)
{
int *mst;
int nrofCoveredEdges, weight;
edgeT *edges;
mst = (int *)calloc(nrOfVerteces,sizeof(int));
edges = (edgeT *)calloc((nrOfVerteces - 1), sizeof(edgeT));
mst[startNode] = 1;
nrofCoveredEdges = 0;
weight = 0;
while (nrofCoveredEdges < nrOfVerteces-1)
{
edgeT e = getMinimumEdgeForCurrentlyVisitedNodes(mst);
mst [e.destination] = 1;
edges[nrofCoveredEdges]=e;
weight+=e.weight;
nrofCoveredEdges++;
}
printEdges(edges, nrofCoveredEdges);
printf("%d ", weight);
}
void prim(int start)
{
printf("Prim started\n");
int *visited = (int*) malloc (sizeof(int) * nrOfVerteces), i;
for(i=0; i<nrOfVerteces; i++)
visited[i] = UNVISITED;
int nrOfSteps = 0, w = 0;
edgeT *edges = (edgeT*) malloc (sizeof(edgeT) * (nrOfVerteces-1));
visited[start] = VISITED;
while(nrOfSteps < nrOfVerteces-1)
{
edgeT e = getMinimumEdgeForCurrentlyVisitedNodes(visited);
visited[e.destination] = VISITED;
edges[nrOfSteps++] = e;
w+=e.weight;
}
printEdges(edges, nrOfVerteces-1);
printf("Prim ended\n");
}
/*
* print detailed info of given BasicBlock
*/
void printBasicBlock(BasicBlock *block) {
int i, size;
printf("=================================================================\n");
printf("BBL: %3d [ ADDR %lX ]\tdfn = %3d\tCount = %3d ]\n", block->id, block->addr, block->dfn, block->count);
printf("%s\t%s\n", BBL_HAS_FLAG(block, BBL_IS_FUNC_ENTRY)?"FUNC_ENTRY":"-", BBL_HAS_FLAG(block, BBL_IS_FUNC_RET)?"FUNC_RET":"-");
printf("TYPE: ");
switch(block->type){
case BT_FALL_THROUGH:
printf("FALL_THROUGH");
break;
case BT_1_BRANCH:
printf("1_WAY_BRANCH");
break;
case BT_2_BRANCH:
printf("2_WAY_BRANCH");
break;
case BT_N_BRANCH:
printf("N_WAY_BRANCH");
break;
case BT_SCRIPT_INVOKE:
printf("SCRIPT_INVOKE");
break;
case BT_RET:
if(BBL_HAS_FLAG(block, BBL_IS_HALT_NODE)){
//todo: better check
//assert(al_size(block->succs)==0);
printf("HALT");
}
else
printf("RETURN");
break;
case BT_AUG_EXIT:
printf("AUGMENTED_EXIT");
break;
default:
printf("ERROR: unknown block type");
}
printf("\n");
if(block->lastInstr){
assert(block->type!=BT_AUG_EXIT);
printf("Last Instruction:\t%lx %s\n", block->lastInstr->addr, block->lastInstr->opName);
}
/********************* PREDECESSORS ********************/
printf("PREDS: ");
size = al_size(block->preds);
for (i = 0; i < size; i++) {
BasicBlock *next = (BasicBlock *)((BlockEdge *)al_get(block->preds, i))->tail;
printf("%d; ", next->id);
}
printf("\n");
/********************* SUCCESSORS *********************/
printf("SUCCS: ");
size = al_size(block->succs);
for (i = 0; i < size; i++) {
BasicBlock *next = (BasicBlock *)((BlockEdge *)al_get(block->succs, i))->head;
printf("%d; ", next->id);
}
printf("\n");
printEdges(block);
}
void DDGNode::addAntiDependency(DDGNode *dependent, int myIteration, int dependentIteration)
{
insertEdge(dependent, 0, myIteration, dependentIteration, ANTI_DEP);
printEdges();
}
void DDGNode::addFlowDependency(DDGNode *dependent, int myIteration, int dependentIteration)
{
insertEdge(dependent, latency, myIteration, dependentIteration, TRUE_DEP);
printEdges();
}
void DDGNode::addOutputDependency(DDGNode *dependent, int myIteration, int dependentIteration)
{
insertEdge(dependent, latency, myIteration, dependentIteration, OUT_DEP);
printEdges();
}
