Esempio n. 1
0
/* principale */
int main(){
	int i, j;
	graphe g;
	g.n=4;
	int pere[g.n];
	int lambda[g.n];
	/*initialiser graphe*/
	graphe_init(&g);	

	addArc(0,1,&g,2);
	addArc(0,2,&g,3);
	addArc(1,4,&g,7);
	addArc(2,4,&g,8);

	affiche(&g);
	/*dfsx0
	dfsx0(&g, &x0, &suffixe[]);*/
	/*explore
	explore(&g, &x, &marque[MAX_VERTEX_NUM], &suffixe[MAX_VERTEX_NUM], &k);
	*/
	Dijkstra(&g, 0, pere, lambda);
	printf("\n\n\n");
	for(i =0; i<3; i++){
		printf("père de %d:%d et lambda :%d\n",i,pere[i],lambda[i]);
	}
	return 0;
}
Esempio n. 2
0
void GridGraph::resize(int rows, int cols) {
    reset();
    rows_ = rows;
    cols_ = cols;

    for (int y = 0; y < rows; ++y) {
        for (int x = 0; x < cols; ++x) {
            VertexNumber v = getVertex(y, x);
            if (x < cols - 1) addArc(v, v + 1);
            if (y < rows - 1) addArc(v, v + cols);
        }
    }

    arcs.resize((rows - 1) * (cols - 1));

    for (int y = 0; y < rows - 1; ++y) {
        for (int x = 0; x < cols - 1; ++x) {
            auto& a = arcs[(cols - 1) * y + x];
            a.resize(4);
            a[0] = getArc(getVertex(y, x), getVertex(y, x + 1));
            a[1] = getArc(getVertex(y, x), getVertex(y + 1, x));
            a[2] = getArc(getVertex(y, x + 1), getVertex(y + 1, x + 1));
            a[3] = getArc(getVertex(y + 1, x), getVertex(y + 1, x + 1));
        }
    }

    setup();
}
Esempio n. 3
0
// Adds an undirected edge to the Graph G from u to v
// Pre: 1 <= u <= getOrder(G), 1 <= v <= getOrder(G)
void addEdge(Graph G, int u, int v) {
   if(u < 1 || u > getOrder(G) || v < 1 || v > getOrder(G)) {
     printf("Graph Error: calling addEdge() with verticies out of bounds\n");
     exit(1); 
   }
   addArc(G, u, v);
   addArc(G, v, u);
   G->size--;
}
Esempio n. 4
0
/* Pre: 1<=u<=n, 1<=v<=n */
void addEdge(Graph G, int u, int v){
	if(G == NULL){
		printf("Graph Error: calling addEdge() on NULL Graph reference!\n");
		exit(1);
	}else if(u<1 || u>getOrder(G) || v<1 || v>getOrder(G)){
		printf("Graph Error: a vertex is not within bounds of the Graph!\n");
		exit(1);
	}
	addArc(G,u,v);
	addArc(G,v,u);
}
Esempio n. 5
0
    void MFGraph::add_terminals()
    {
        int rightMostStart = -1;
        int rightMostEnd = -1;
        
        
        // find childless nodes
        for (ListDigraph::NodeIt n(mfGraph); n != INVALID; ++n) {
            if (countOutArcs(mfGraph, n) == 0) {
                childless[n] = true;
                if (read_map[n] && read_map[n]->start() > rightMostStart) {
                    rightMostStart = read_map[n]->start();
                    rightMostEnd = rightMostStart + read_map[n]->length();
                    //          std::cout << "rightMostEnd" << rightMostEnd << std::endl;
                    
                }
            }
        }
        
        int leftMostStart = rightMostStart;
        // find parentless nodes
        for (ListDigraph::NodeIt n(mfGraph); n != INVALID; ++n) {
            if (countInArcs(mfGraph, n) == 0) {
                parentless[n] = true;
                if (read_map[n] && read_map[n]->start() < leftMostStart) {
                    leftMostStart = read_map[n]->start();
                }
            }
        }
        
        // now add the fake source and sink
        MethylRead *source_read = new MethylRead(leftMostStart - 1, 1);
        source = addNode("s", 0, source_read);
        fake[source] = true;
        for (ListDigraph::NodeIt n(mfGraph); n != INVALID; ++n) {
            if (parentless[n]) {
                addArc(source, n, read_map[n]->start() - source_read->start());
            }
        }
       // MethylRead *sink_read = new MethylRead(rightMostStart , rightMostEnd- rightMostStart+1);
        MethylRead *sink_read = new MethylRead(rightMostEnd + 1 , 1);

        sink = addNode("t", 0, sink_read);
        fake[sink] = true;
        for (ListDigraph::NodeIt n(mfGraph); n != INVALID; ++n) {
            if (childless[n]) {
                
                addArc(n, sink, sink_read->start() - read_map[n]->start());
                //addArc(n, sink, 1);
            }
        }
    }
/*main------------------------------------------------------------------------*/
int main(int argc, char* argv[]) {

    //input validation
    if (argc != 2) {
        printf("Usage: %s output\n", argv[0]);
        exit(1);
    }

    //open file
    FILE *out;
    out = fopen(argv[1], "w");

    //new graph
    Graph G = newGraph(10);
    Graph T;
    List S = newList();
    int i;
    for (i = 1; i <= 9; i++) {
        addArc(G, i, i + 1);
    }
    addArc(G, 1, 2);

    //add graph and print out the adjacency fields
    for (i = 1; i <= getOrder(G); i++) {
        append(S, i);
    }
    fprintf(out, "\nThe adjacency list of G is:\n");
    printGraph(out, G);

    //Run DFS and get the transpose
    DFS(G, S);
    T = transpose(G);
    fprintf(out, "\nTranspose of G is:\n");
    printGraph(out, T);

    //print out fields
    fprintf(out, "Order of G is %d\n", getOrder(G));
    fprintf(out, "Size of G is %d.\n", getSize(G));
    fprintf(out, "Parent of 10 is %d.\n", getParent(G, 10));
    fprintf(out, "Parent of 3 is %d.\n", getParent(G, 3));
    fprintf(out, "Discover time of 1 is %d.\n", getDiscover(G, 1));
    fprintf(out, "Finish time of 1 is %d.\n", getFinish(G, 1));
    fprintf(out, "Discover time of 9 is %d.\n", getDiscover(G, 9));
    fprintf(out, "Finish time of 9 is %d.\n", getFinish(G, 9));

    //close file
    fclose(out);

    //exit
    return (0);
}
void SimpleDirectedGraph::deleteNode(int nodeId, bool always_add_shortcut) {
	Node& node = m_nodes[nodeId];
	if (node.m_deleted) return;  // Already deleted node.
	// Delete the links from other nodes to this node.
	for (size_t i = 0; i < node.m_predecessors.size(); ++i) {
		deleteArcFromSuccessors(node.m_predecessors[i], nodeId);
	}
	for (size_t i = 0; i < node.m_successors.size(); ++i) {
		deleteArcFromPredecessors(nodeId, node.m_successors[i]);
	}
	// Add shortcut arcs.
	for (size_t j = 0; j < node.m_predecessors.size(); ++j) {
		for (size_t i = 0; i < node.m_successors.size(); ++i) {
			if (always_add_shortcut) {
				addArc(node.m_predecessors[j], node.m_successors[i]);
			} else {
				addShortcutArcIfNeeded(node.m_predecessors[j], node.m_successors[i]);
			}
		}
	}
	// Clear the node.
	node.m_deleted = true;
	node.m_predecessors.clear();
	node.m_successors.clear();
}
Esempio n. 8
0
TransCFG::TransCFG(FuncId funcId,
                   const ProfData* profData,
                   const SrcDB& srcDB,
                   const TcaTransIDMap& jmpToTransID) {
  assertx(profData);

  // add nodes
  for (auto tid : profData->funcProfTransIDs(funcId)) {
    assertx(profData->transRegion(tid) != nullptr);
    // This will skip DV Funclets if they were already
    // retranslated w/ the prologues:
    if (!profData->optimized(profData->transSrcKey(tid))) {
      int64_t weight = profData->absTransCounter(tid);
      addNode(tid, weight);
    }
  }

  // add arcs
  for (TransID dstId : nodes()) {
    SrcKey dstSK = profData->transSrcKey(dstId);
    RegionDesc::BlockPtr dstBlock = profData->transRegion(dstId)->entry();
    FTRACE(5, "TransCFG: adding incoming arcs in dstId = {}\n", dstId);
    TransIDSet predIDs = findPredTrans(dstId, profData, srcDB, jmpToTransID);
    for (auto predId : predIDs) {
      if (hasNode(predId)) {
        auto predPostConds =
          profData->transRegion(predId)->blocks().back()->postConds();
        SrcKey predSK = profData->transSrcKey(predId);
        if (preCondsAreSatisfied(dstBlock, predPostConds) &&
            predSK.resumed() == dstSK.resumed()) {
          FTRACE(5, "TransCFG: adding arc {} -> {} ({} -> {})\n",
                 predId, dstId, showShort(predSK), showShort(dstSK));
          addArc(predId, dstId, TransCFG::Arc::kUnknownWeight);
        }
      }
    }
  }

  // infer arc weights
  bool changed;
  do {
    changed = false;
    for (TransID tid : nodes()) {
      int64_t nodeWeight = weight(tid);
      if (inferredArcWeight(inArcs(tid),  nodeWeight)) changed = true;
      if (inferredArcWeight(outArcs(tid), nodeWeight)) changed = true;
    }
  } while (changed);

  // guess weight for non-inferred arcs
  for (TransID tid : nodes()) {
    for (auto arc : outArcs(tid)) {
      if (arc->weight() == Arc::kUnknownWeight) {
        arc->setGuessed();
        int64_t arcWgt = std::min(weight(arc->src()), weight(arc->dst())) / 2;
        arc->setWeight(arcWgt);
      }
    }
  }
}
Esempio n. 9
0
// addEdge(): inserts a new edge joining u to v and v to u (bidirectional)
// Preconditions: 1<=u<=getOrder(G), 1<=v<=getOrder(G)
void addEdge(Graph G, int u, int v) {
    if(G == NULL) {
        printf("Graph Error: calling addEdge() on NULL Graph reference\n");
        exit(1);
    }
    if(u<1 || u>getOrder(G)) {
        printf("Graph Error: calling addEdge() with out of bounds 'u' value\n");
        exit(1);
    }
    if(v<1 || v>getOrder(G)) {
        printf("Graph Error: calling addEdge() with out of bounds 'v' value\n");
        exit(1);
    }
    addArc(G, u, v);
    addArc(G, v, u);
}
Esempio n. 10
0
int main() {
	int n, m;
	while (EOF != scanf("%d%d", &n, &m)) {
		if (n == 0) break;
		memset(V, 0, sizeof(V));
		nA = 0;
		for (int i = 0, a, b; i < m; ++i) {
			scanf("%d%d", &a, &b);
			addArc(a-1, b-1);
		}
		init_sc_tarjan();
		for (int i = 0; i < n; ++i) {
			if (vis[i] == 0) sc_tarjan(i);
		}
		memset(oud, 0, sizeof(oud));
		for (int i = 0; i < n; ++i) {
			int u = id[i];
			for (Arc *a = V[i]; a; a = a->next) {
				int v = id[a->to];
				if (u != v) {
					++oud[u];
				}
			}
		}
		bool first = true;
		for (int i = 0; i < n; ++i) {
			if (oud[id[i]] == 0) {
				if (first) first = false;
				else putchar(' ');
				printf("%d", i + 1);
			}
		}
		puts("");
	}
}
Esempio n. 11
0
void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius)
{
    FloatPoint p0(m_path.currentPosition());

    FloatPoint p1p0((p0.x() - p1.x()), (p0.y() - p1.y()));
    FloatPoint p1p2((p2.x() - p1.x()), (p2.y() - p1.y()));
    float p1p0_length = sqrtf(p1p0.x() * p1p0.x() + p1p0.y() * p1p0.y());
    float p1p2_length = sqrtf(p1p2.x() * p1p2.x() + p1p2.y() * p1p2.y());

    double cos_phi = (p1p0.x() * p1p2.x() + p1p0.y() * p1p2.y()) / (p1p0_length * p1p2_length);

    // The points p0, p1, and p2 are on the same straight line (HTML5, 4.8.11.1.8)
    // We could have used areCollinear() here, but since we're reusing
    // the variables computed above later on we keep this logic.
    if (qFuzzyCompare(qAbs(cos_phi), 1.0)) {
        m_path.lineTo(p1);
        return;
    }

    float tangent = radius / tan(acos(cos_phi) / 2);
    float factor_p1p0 = tangent / p1p0_length;
    FloatPoint t_p1p0((p1.x() + factor_p1p0 * p1p0.x()), (p1.y() + factor_p1p0 * p1p0.y()));

    FloatPoint orth_p1p0(p1p0.y(), -p1p0.x());
    float orth_p1p0_length = sqrt(orth_p1p0.x() * orth_p1p0.x() + orth_p1p0.y() * orth_p1p0.y());
    float factor_ra = radius / orth_p1p0_length;

    // angle between orth_p1p0 and p1p2 to get the right vector orthographic to p1p0
    double cos_alpha = (orth_p1p0.x() * p1p2.x() + orth_p1p0.y() * p1p2.y()) / (orth_p1p0_length * p1p2_length);
    if (cos_alpha < 0.f)
        orth_p1p0 = FloatPoint(-orth_p1p0.x(), -orth_p1p0.y());

    FloatPoint p((t_p1p0.x() + factor_ra * orth_p1p0.x()), (t_p1p0.y() + factor_ra * orth_p1p0.y()));

    // calculate angles for addArc
    orth_p1p0 = FloatPoint(-orth_p1p0.x(), -orth_p1p0.y());
    float sa = acos(orth_p1p0.x() / orth_p1p0_length);
    if (orth_p1p0.y() < 0.f)
        sa = 2 * piDouble - sa;

    // anticlockwise logic
    bool anticlockwise = false;

    float factor_p1p2 = tangent / p1p2_length;
    FloatPoint t_p1p2((p1.x() + factor_p1p2 * p1p2.x()), (p1.y() + factor_p1p2 * p1p2.y()));
    FloatPoint orth_p1p2((t_p1p2.x() - p.x()), (t_p1p2.y() - p.y()));
    float orth_p1p2_length = sqrtf(orth_p1p2.x() * orth_p1p2.x() + orth_p1p2.y() * orth_p1p2.y());
    float ea = acos(orth_p1p2.x() / orth_p1p2_length);
    if (orth_p1p2.y() < 0)
        ea = 2 * piDouble - ea;
    if ((sa > ea) && ((sa - ea) < piDouble))
        anticlockwise = true;
    if ((sa < ea) && ((ea - sa) > piDouble))
        anticlockwise = true;

    m_path.lineTo(t_p1p0);

    addArc(p, radius, sa, ea, anticlockwise);
}
Esempio n. 12
0
void process (Graph graph, char** linebuf) {
   for (int i = 1;;) {
      char *row, *col;
      row = __strtok_r (linebuf[i++], " ", &col);
      if (atoi (row) == 0 && atoi (col) == 0) break;
      addArc (graph, atoi (row), atoi (col));
   }
}
Esempio n. 13
0
void RegionDesc::copyArcsFrom(const RegionDesc& srcRegion) {
  for (auto const b : srcRegion.m_blocks) {
    auto bid = b->id();
    for (auto succId : srcRegion.succs(bid)) {
      addArc(bid, succId);
    }
  }
}
Esempio n. 14
0
void SimpleDirectedGraph::addShortcutArcIfNeeded(int source, int target) {
	SimpleDirectedGraph::BFIterator it(*this, 2, true);
	it.addNode(source);
	int node;
	while (it.read(&node)) {
		if (node == target) return;
	}
	addArc(source, target);
}
Esempio n. 15
0
int main()
{
	int runs, n, m;
	scanf("%d", &runs);
	while (runs--) {
		nA = 0;
		memset(V, 0, sizeof(V));
		scanf("%d%d", &n, &m);
		for (int i = 0, a, b; i < m; ++i) {
			scanf("%d%d", &a, &b);
			addArc(a, b);
		}
		init_tarjan();
		for (int i = 1; i <= n; ++i) {
			if (vis[i] == 0) {
				tarjan(i);
			}
		}
		memset(mat, 0, sizeof(mat));
		memset(ind, 0, sizeof(ind));
		for (int i = 1; i <= n; ++i) {
			for (Arc *a = V[i]; a; a = a->next) {
				int u = id[i], v = id[a->to];
				if (u != v && false == mat[u][v]) {
					mat[u][v] = true;
					++ind[v];
				}
			}
		}
		// top sort
		top = -1;
		for (int i = 0; i < sc_cnt; ++i) {
			if (ind[i] == 0) vstack[++top] = i;
		}
		int cnt = 0;
		while (cnt < sc_cnt) {
			int u = vstack[top--];
			ord[cnt++] = u;
			for (int v = 0; v < sc_cnt; ++v) {
				if (mat[u][v]) {
					--ind[v];
					if (ind[v] == 0) vstack[++top] = v;
				}
			}
		}
		bool ans = true;
		for (int i = 0; i < cnt-1; ++i) {
			if (false == mat[ord[i]][ord[i+1]]) {
				ans = false;
				break;
			}
		}
		puts(ans ? "Yes" : "No");
	}
	return 0;
}
Esempio n. 16
0
void Path::addPieSegment (const float x, const float y,
                          const float width, const float height,
                          const float fromRadians,
                          const float toRadians,
                          const float innerCircleProportionalSize)
{
    float radiusX = width * 0.5f;
    float radiusY = height * 0.5f;
    const Point<float> centre (x + radiusX, y + radiusY);

    startNewSubPath (centre.getPointOnCircumference (radiusX, radiusY, fromRadians));
    addArc (x, y, width, height, fromRadians, toRadians);

    if (std::abs (fromRadians - toRadians) > float_Pi * 1.999f)
    {
        closeSubPath();

        if (innerCircleProportionalSize > 0)
        {
            radiusX *= innerCircleProportionalSize;
            radiusY *= innerCircleProportionalSize;

            startNewSubPath (centre.getPointOnCircumference (radiusX, radiusY, toRadians));
            addArc (centre.x - radiusX, centre.y - radiusY, radiusX * 2.0f, radiusY * 2.0f, toRadians, fromRadians);
        }
    }
    else
    {
        if (innerCircleProportionalSize > 0)
        {
            radiusX *= innerCircleProportionalSize;
            radiusY *= innerCircleProportionalSize;

            addArc (centre.x - radiusX, centre.y - radiusY, radiusX * 2.0f, radiusY * 2.0f, toRadians, fromRadians);
        }
        else
        {
            lineTo (centre);
        }
    }

    closeSubPath();
}
Esempio n. 17
0
TransCFG::TransCFG(FuncId funcId,
                   const ProfData* profData,
                   const SrcDB& srcDB,
                   const TcaTransIDMap& jmpToTransID) {
  assert(profData);

  // add nodes
  for (TransID tid = 0; tid < profData->numTrans(); tid++) {
    if (profData->transKind(tid) == TransProfile &&
        profData->transRegion(tid) != nullptr &&
        profData->transFuncId(tid) == funcId) {
      int64_t counter = profData->transCounter(tid);
      int64_t weight  = RuntimeOption::EvalJitPGOThreshold - counter;
      addNode(tid, weight);
    }
  }

  // add arcs
  for (TransID dstId : nodes()) {
    SrcKey dstSK = profData->transSrcKey(dstId);
    const SrcRec* dstSR = srcDB.find(dstSK);
    FTRACE(5, "TransCFG: adding incoming arcs in dstId = {}\n", dstId);
    TransIDSet predIDs = findPredTrans(dstSR, jmpToTransID);
    for (auto predId : predIDs) {
      if (hasNode(predId)) {
        FTRACE(5, "TransCFG: adding arc {} -> {}\n", predId, dstId);
        addArc(predId, dstId, TransCFG::Arc::kUnknownWeight);
      }
    }
  }

  // infer arc weights
  bool changed;
  do {
    changed = false;
    for (TransID tid : nodes()) {
      int64_t nodeWeight = weight(tid);
      if (inferredArcWeight(inArcs(tid),  nodeWeight)) changed = true;
      if (inferredArcWeight(outArcs(tid), nodeWeight)) changed = true;
    }
  } while (changed);

  // guess weight or non-inferred arcs
  for (TransID tid : nodes()) {
    for (auto arc : outArcs(tid)) {
      if (arc->weight() == Arc::kUnknownWeight) {
        arc->setGuessed();
        int64_t arcWgt = std::min(weight(arc->src()), weight(arc->dst())) / 2;
        arc->setWeight(arcWgt);
      }
    }
  }
}
ResidualNetwork::ResidualNetwork(const FlowNetwork &g)
											                      : ResidualNetwork(g.getNumNodes()) {
	// FlowNetwork stores each arc once
	for (const Arc &arc : g) {
		addArc(arc.getSrcId(), arc.getDstId(), arc.getCapacity(), arc.getCost());
	}

	// clone balances
	for (uint32_t id = 1; id <= num_nodes; id++) {
		balances[id] = g.getBalance(id);
	}
}
Esempio n. 19
0
File: pb1.c Progetto: iulianR/labs
void readG (Graph &g)
{
	int n;
	scanf("%d", &n);
	initG(g, n);
	int v, w, cost;
	while (1) {
		scanf("%d", &v);
		if (v == 0)
			break;
		scanf("%d %d", &w, &cost);
		addArc(g, v, w, cost);
	}
}
Esempio n. 20
0
void xsCanvasContext::arc(float x, float y, float radius, float startAngle, float endAngle, xsBool anticlockwise)
{
	//MTK support only 0-360 angle.
	xsArc *arc = static_cast<xsArc *>(xsArc::createInstance());
	arc ->x = x;
	arc ->y = y;
	arc ->radius = radius;
	arc ->startAngle = startAngle;
	arc ->endAngle = endAngle;
	arc ->anticlockwise = anticlockwise;
	arc ->lineWidth = lineWidth;
	arc ->strokeColor = strokeColor;
	arc ->fillColor = fillColor;
	addArc(arc);
}
Esempio n. 21
0
GraphRef copyGraph(GraphRef G){
   int i, j;
   GraphRef Q = newGraph(G->order);

   for(i=1;i<=G->order;i++){
      if(!isEmpty(G->adj[i])){
         moveTo(G->adj[i], 0);
         for(j=0;j<getLength(G->adj[i]);j++){
            addArc(Q, i, getCurrent(G->adj[i]));
            if(j<getLength(G->adj[i])-1){
               moveNext(G->adj[i]);
            }
         }
      }
   }
   return(Q);
}
//Returns a reference to a new graph object representing the transpose of G
Graph transpose(Graph G){
	if( G == NULL ) {
      		printf("Graph Error: calling transpose() on NULL Graph reference\n");
      		exit(1);
	}
	Graph H;
	H=newGraph(getOrder(G));
	for(int i=1; i <= getOrder(G); i++) {
		if(length(G->vneighbor[i]) != 0) {
			moveTo(G->vneighbor[i], 0);
			while(getIndex(G->vneighbor[i]) > -1) {
				addArc(H, getElement(G->vneighbor[i]),i);
				moveNext(G->vneighbor[i]);
			}
		}
	}
	return H;
}
Esempio n. 23
0
void Graph::readAdjacencyList(std::istream& is) {
    reset();
    VertexNumber v1 = 1;
    VertexNumber v2;
    vMax = v1;

    while (is) {
        char c;
        while (isspace(c = is.get())) {
            if (c == '\n') ++v1;
        }
        if (!is) break;
        is.unget();
        is >> v2;
        if (v1 < v2) addArc(v1, v2);
    }

    setup();
}
Esempio n. 24
0
    void MFGraph::regularize()
    {
//        
//        int rightMostEnd = -1;
//        // find childless nodes
//        for (ListDigraph::NodeIt n(mfGraph); n != INVALID; ++n) {
//            if (countOutArcs(mfGraph, n) == 0) {
//                childless[n] = true;
//                if (read_map[n] && read_map[n]->start() > rightMostStart) {
//                    rightMostEnd = rightMostStart + read_map[n]->length();
//                    
//                }
//            }
//        }

        // add the lambda edges
        int lamcnt = 0;
        for (ListDigraph::InArcIt arc(mfGraph, sink); arc != INVALID; ++arc, ++lamcnt) {
            std::stringstream nodename;
            nodename << "lambda_" << lamcnt;
            ListDigraph::Node newNode = addNode(nodename.str(), 0);
            ListDigraph::Node node = mfGraph.source(arc);
            
            MethylRead read = MethylRead(*read_map[node]);
            int start = read_map[node]->start();
            int end = read_map[node]->end();
            
            //int newEnd = max(start, min(end, rightMostEnd - rLen));
            
            //ListDigraph::Arc newArc = addArc(node, newNode, 1);
            ListDigraph::Arc newArc = addArc(node, newNode, end - start + 1);
            
            mfGraph.changeSource(arc, newNode);
            
            childless[node] = false;
            childless[newNode] = true;
        }
    }
Esempio n. 25
0
void DRW_Hatch::parseCode(int code, dxfReader *reader){
    switch (code) {
    case 2:
        name = reader->getString();
        break;
    case 70:
        solid = reader->getInt32();
        break;
    case 71:
        associative = reader->getInt32();
        break;
    case 72:        /*edge type*/
        if (ispol){ //if is polyline is a as_bulge flag
            break;
        } else if (reader->getInt32() == 1){ //line
            addLine();
        } else if (reader->getInt32() == 2){ //arc
            addArc();
        } else if (reader->getInt32() == 3){ //elliptic arc
            addEllipse();
        } else if (reader->getInt32() == 4){ //spline
            addSpline();
        }
        break;
    case 10:
        if (pt) pt->basePoint.x = reader->getDouble();
        else if (pline) {
            plvert = pline->addVertex();
            plvert->x = reader->getDouble();
        }
        break;
    case 20:
        if (pt) pt->basePoint.y = reader->getDouble();
        else if (plvert) plvert ->y = reader->getDouble();
        break;
    case 11:
        if (line) line->secPoint.x = reader->getDouble();
        else if (ellipse) ellipse->secPoint.x = reader->getDouble();
        break;
    case 21:
        if (line) line->secPoint.y = reader->getDouble();
        else if (ellipse) ellipse->secPoint.y = reader->getDouble();
        break;
    case 40:
        if (arc) arc->radious = reader->getDouble();
        else if (ellipse) ellipse->ratio = reader->getDouble();
        break;
    case 41:
        scale = reader->getDouble();
        break;
    case 42:
        if (plvert) plvert ->bulge = reader->getDouble();
        break;
    case 50:
        if (arc) arc->staangle = reader->getDouble();
        else if (ellipse) ellipse->staparam = reader->getDouble();
        break;
    case 51:
        if (arc) arc->endangle = reader->getDouble();
        else if (ellipse) ellipse->endparam = reader->getDouble();
        break;
    case 52:
        angle = reader->getDouble();
        break;
    case 73:
        if (arc) arc->isccw = reader->getInt32();
        else if (pline) pline->flags = reader->getInt32();
        break;
    case 75:
        hstyle = reader->getInt32();
        break;
    case 76:
        hpattern = reader->getInt32();
        break;
    case 77:
        doubleflag = reader->getInt32();
        break;
    case 78:
        deflines = reader->getInt32();
        break;
    case 91:
        loopsnum = reader->getInt32();
        looplist.reserve(loopsnum);
        break;
    case 92:
        loop = new DRW_HatchLoop(reader->getInt32());
        looplist.push_back(loop);
        if (reader->getInt32() & 2) {
            ispol = true;
            clearEntities();
            pline = new DRW_LWPolyline;
            loop->objlist.push_back(pline);
        } else ispol = false;
        break;
    case 93:
        if (pline) pline->vertexnum = reader->getInt32();
        else loop->numedges = reader->getInt32();//aqui reserve
        break;
    case 98: //seed points ??
        clearEntities();
        break;
    default:
        DRW_Point::parseCode(code, reader);
        break;
    }
}
int main(int argc, char * argv[]){
   int count=0;
   int u, v, index, sccNum;
   FILE *in, *out;
   char line[MAX_LEN];
   char* token;
   Graph G = NULL;
   Graph T = NULL;
   List S = newList(); // This list is our stack that determins the order of the vertices
   List R = newList();
   // check command line for correct number of arguments
   if( argc != 3 ){
      printf("Usage: %s <input file> <output file>\n", argv[0]);
      exit(1);
   }

   // open files for reading and writing 
   in = fopen(argv[1], "r");
   out = fopen(argv[2], "w");
   if( in==NULL ){
      printf("Unable to open file %s for reading\n", argv[1]);
      exit(1);
   }
   if( out==NULL ){
      printf("Unable to open file %s for writing\n", argv[2]);
      exit(1);
   }

   /* read each line of input file, then count and print tokens */
   // Assemble a graph object G using newGraph() and addArc()
   while(fgets(line, MAX_LEN, in) != NULL)  {
      count++;
	  // char *strtok(char *str, const char *delim) breaks string str into
	  // a series of tokens using the delimitrer delim. This function returns a pointer to the
	  // last token found in string. A null pointer is returned if there are no tokens left to retrieve.
      token = strtok(line, " \n");
	  
	  // int atoi(const char *str), This function returns the converted integral number as an int value.
	  // If no valid conversion could be performed, it returns zero.
	  // It converts char to int.
	  if(count == 1) {
	     // Takes in the first number as a token, sets a graph of that size
	     G = newGraph(atoi(token));
	  }
	  else {
	     // Here we want to read in both numbers
		 u = atoi(token);
		 token = strtok(NULL, " \n");
		 v = atoi(token);
		 if( u != 0 || v != 0) {
		       addArc(G, u, v);
	     }		   
         else if (u == 0 && v == 0) {
		       break;
         }			   
      } 
   }
   // Print the adjacency list representation of G to the output file
   printGraph(out, G);
   fprintf(out, "\n");
   
   // creating our Stack
   for(int i = 1; i <= getOrder(G); i++) {
      append(S, i);
   }
   
   // Run DFS on G and G-Transpose, processing the vertices in the second call
   // by decreasing finish times from the first call
   DFS(G, S);
   T = transpose(G);
   DFS(T, S);
   
   // Determine the strong components of G
   // Print the strong components of G to the output file in topologically sorted order.
   // Everytime a vertex has a NIL parent in the transpose of G, we have a SCC
   sccNum = 0;
   for(int i = 1; i <= getOrder(G); i++) {
      if(getParent(T, i) == NIL) sccNum++;
   }
   
   
   fprintf(out, "G contains %d strongly connected components:\n", sccNum);
   index = 1;
   moveTo(S, length(S) - 1 );
   while(getIndex(S) != -1 && index <= sccNum) {  
	  fprintf(out, "Component %d:", index);
	  while(getParent(T, getElement(S)) != NIL) {
		 prepend(R, getElement(S));
		 movePrev(S);
	  }
	  prepend(R, getElement(S));
	  printReverse(out, T, R);
	  movePrev(S);
	  index++;   
	  fprintf(out, "\n");
   }

   
   freeList(&S);
   freeList(&R);   
   freeGraph(&G);
   freeGraph(&T);   

   /* close files */
   fclose(in);
   fclose(out);

   return(0);
}
Esempio n. 27
0
RegionDescPtr selectHotTrace(HotTransContext& ctx,
                             TransIDSet& selectedSet,
                             TransIDVec* selectedVec /* = nullptr */) {
  auto region = std::make_shared<RegionDesc>();
  TransID tid    = ctx.tid;
  TransID prevId = kInvalidTransID;
  selectedSet.clear();
  if (selectedVec) selectedVec->clear();

  TypedLocations accumPostConds;

  // Maps from BlockIds to accumulated post conditions for that block.
  // Used to determine if we can add branch-over edges by checking the
  // pre-conditions of the successor block.
  hphp_hash_map<RegionDesc::BlockId, TypedLocations> blockPostConds;

  auto numBCInstrs = ctx.maxBCInstrs;
  FTRACE(1, "selectHotTrace: starting with maxBCInstrs = {}\n", numBCInstrs);

  while (!selectedSet.count(tid)) {
    auto rec = ctx.profData->transRec(tid);
    auto blockRegion = rec->region();
    if (blockRegion == nullptr) break;

    // Break if region would be larger than the specified limit.
    if (blockRegion->instrSize() > numBCInstrs) {
      FTRACE(2, "selectHotTrace: breaking region at Translation {} because "
             "size would exceed of maximum translation limit\n", tid);
      break;
    }

    // If the debugger is attached, only allow single-block regions.
    if (prevId != kInvalidTransID && isDebuggerAttachedProcess()) {
      FTRACE(2, "selectHotTrace: breaking region at Translation {} "
             "because of debugger is attached\n", tid);
      break;
    }

    // Break if block is not the first and it corresponds to the main
    // function body entry.  This is to prevent creating multiple
    // large regions containing the function body (starting at various
    // DV funclets).
    if (prevId != kInvalidTransID) {
      auto const func = rec->func();
      auto const bcOffset = rec->startBcOff();
      if (func->base() == bcOffset) {
        FTRACE(2, "selectHotTrace: breaking region because reached the main "
               "function body entry at Translation {} (BC offset {})\n",
               tid, bcOffset);
        break;
      }
    }

    if (prevId != kInvalidTransID) {
      auto sk = rec->srcKey();
      if (ctx.profData->optimized(sk)) {
        FTRACE(2, "selectHotTrace: breaking region because next sk already "
               "optimized, for Translation {}\n", tid);
        break;
      }
    }

    bool hasPredBlock = !region->empty();
    RegionDesc::BlockId predBlockId = (hasPredBlock ?
                                       region->blocks().back().get()->id() : 0);
    auto const& newFirstBlock = blockRegion->entry();
    auto newFirstBlockId = newFirstBlock->id();

    // Add blockRegion's blocks and arcs to region.
    region->append(*blockRegion);
    numBCInstrs -= blockRegion->instrSize();
    assertx(numBCInstrs >= 0);

    if (hasPredBlock) {
      region->addArc(predBlockId, newFirstBlockId);
    }
    selectedSet.insert(tid);
    if (selectedVec) selectedVec->push_back(tid);

    const auto lastSk = rec->lastSrcKey();
    if (breaksRegion(lastSk)) {
      FTRACE(2, "selectHotTrace: breaking region because of last instruction "
             "in Translation {}: {}\n", tid, opcodeToName(lastSk.op()));
      break;
    }

    auto outArcs = ctx.cfg->outArcs(tid);
    if (outArcs.size() == 0) {
      FTRACE(2, "selectHotTrace: breaking region because there's no successor "
             "for Translation {}\n", tid);
      break;
    }

    auto newLastBlock = blockRegion->blocks().back();
    discardPoppedTypes(accumPostConds,
                       blockRegion->entry()->initialSpOffset());
    mergePostConds(accumPostConds, newLastBlock->postConds());
    blockPostConds[newLastBlock->id()] = accumPostConds;

    TransCFG::ArcPtrVec possibleOutArcs;
    for (auto arc : outArcs) {
      auto dstRec = ctx.profData->transRec(arc->dst());
      auto possibleNext = dstRec->region()->entry();
      if (preCondsAreSatisfied(possibleNext, accumPostConds)) {
        possibleOutArcs.emplace_back(arc);
      }
    }

    if (possibleOutArcs.size() == 0) {
      FTRACE(2, "selectHotTrace: breaking region because postcondition check "
             "pruned all successors of Translation {}\n", tid);
      break;
    }

    auto maxWeight = std::numeric_limits<int64_t>::min();
    TransCFG::Arc* maxArc = nullptr;
    for (auto arc : possibleOutArcs) {
      if (arc->weight() >= maxWeight) {
        maxWeight = arc->weight();
        maxArc = arc;
      }
    }
    assertx(maxArc != nullptr);
    prevId = tid;
    tid = maxArc->dst();
  }

  FTRACE(3, "selectHotTrace: before chainRetransBlocks:\n{}\n", show(*region));
  region->chainRetransBlocks();
  FTRACE(3, "selectHotTrace: after chainRetransBlocks:\n{}\n", show(*region));

  return region;
}
Esempio n. 28
0
RegionDescPtr selectHotTrace(TransID triggerId,
                             const ProfData* profData,
                             TransCFG& cfg,
                             TransIDSet& selectedSet,
                             TransIDVec* selectedVec) {
  auto region = std::make_shared<RegionDesc>();
  TransID tid    = triggerId;
  TransID prevId = kInvalidTransID;
  selectedSet.clear();
  if (selectedVec) selectedVec->clear();

  PostConditions accumPostConds;
  // Maps BlockIds to the set of BC offsets for its successor blocks.
  // Used to prevent multiple successors with the same SrcKey for now.
  // This can go away once task #4157613 is done.
  hphp_hash_map<RegionDesc::BlockId, SrcKeySet> succSKSet;

  // Maps from BlockIds to accumulated post conditions for that block.
  // Used to determine if we can add branch-over edges by checking the
  // pre-conditions of the successor block.
  hphp_hash_map<RegionDesc::BlockId, PostConditions> blockPostConds;

  while (!selectedSet.count(tid)) {

    RegionDescPtr blockRegion = profData->transRegion(tid);
    if (blockRegion == nullptr) break;

    // If the debugger is attached, only allow single-block regions.
    if (prevId != kInvalidTransID && isDebuggerAttachedProcess()) {
      FTRACE(2, "selectHotTrace: breaking region at Translation {} "
             "because of debugger is attached\n", tid);
      break;
    }

    // Break if block is not the first and requires reffiness checks.
    // Task #2589970: fix translateRegion to support mid-region reffiness checks
    if (prevId != kInvalidTransID) {
      auto nRefDeps = blockRegion->blocks[0]->reffinessPreds().size();
      if (nRefDeps > 0) {
        FTRACE(2, "selectHotTrace: breaking region because of refDeps ({}) at "
               "Translation {}\n", nRefDeps, tid);
        break;
      }
    }

    // Break if block is not the first and it corresponds to the main
    // function body entry.  This is to prevent creating multiple
    // large regions containing the function body (starting at various
    // DV funclets).
    if (prevId != kInvalidTransID) {
      const Func* func = profData->transFunc(tid);
      Offset  bcOffset = profData->transStartBcOff(tid);
      if (func->base() == bcOffset) {
        FTRACE(2, "selectHotTrace: breaking region because reached the main "
               "function body entry at Translation {} (BC offset {})\n",
               tid, bcOffset);
        break;
      }
    }

    if (prevId != kInvalidTransID) {
      auto sk = profData->transSrcKey(tid);
      if (profData->optimized(sk)) {
        FTRACE(2, "selectHotTrace: breaking region because next sk already "
               "optimized, for Translation {}\n", tid);
        break;
      }
    }

    // Break trace if translation tid cannot follow the execution of
    // the entire translation prevId.  This can only happen if the
    // execution of prevId takes a side exit that leads to the
    // execution of tid.
    if (prevId != kInvalidTransID) {
      Op* lastInstr = profData->transLastInstr(prevId);
      const Unit* unit = profData->transFunc(prevId)->unit();
      OffsetSet succOffs = findSuccOffsets(lastInstr, unit);
      if (!succOffs.count(profData->transSrcKey(tid).offset())) {
        if (HPHP::Trace::moduleEnabled(HPHP::Trace::pgo, 2)) {
          FTRACE(2, "selectHotTrace: WARNING: Breaking region @: {}\n",
                 show(*region));
          FTRACE(2, "selectHotTrace: next translation selected: tid = {}\n{}\n",
                 tid, show(*blockRegion));
          FTRACE(2, "\nsuccOffs = {}\n", folly::join(", ", succOffs));
        }
        break;
      }
    }
    if (region->blocks.size() > 0) {
      auto& newBlock   = blockRegion->blocks.front();
      auto newBlockId  = newBlock->id();
      auto predBlockId = region->blocks.back().get()->id();
      if (!RuntimeOption::EvalHHIRBytecodeControlFlow) {
        region->addArc(predBlockId, newBlockId);
      } else {
      // With bytecode control-flow, we add all forward arcs in the TransCFG
      // that are induced by the blocks in the region, as a simple way
      // to expose control-flow for now.
      // This can go away once Task #4075822 is done.
        auto newBlockSrcKey = blockRegion->blocks.front().get()->start();
        if (succSKSet[predBlockId].count(newBlockSrcKey)) break;
        region->addArc(predBlockId, newBlockId);
        succSKSet[predBlockId].insert(newBlockSrcKey);
        assert(hasTransId(newBlockId));
        auto newTransId = getTransId(newBlockId);
        for (auto iOther = 0; iOther < region->blocks.size(); iOther++) {
          auto other = region->blocks[iOther];
          auto otherBlockId = other.get()->id();
          if (!hasTransId(otherBlockId)) continue;
          auto otherTransId = getTransId(otherBlockId);
          auto otherBlockSrcKey = other.get()->start();
          if (cfg.hasArc(otherTransId, newTransId) &&
              !other.get()->inlinedCallee() &&
              // Task #4157613 will allow the following check to go away
              !succSKSet[otherBlockId].count(newBlockSrcKey) &&
              preCondsAreSatisfied(newBlock, blockPostConds[otherBlockId])) {
            region->addArc(otherBlockId, newBlockId);
            succSKSet[otherBlockId].insert(newBlockSrcKey);
          }
          // When Eval.JitLoops is set, insert back-edges in the
          // region if they exist in the TransCFG.
          if (RuntimeOption::EvalJitLoops &&
              cfg.hasArc(newTransId, otherTransId) &&
              // Task #4157613 will allow the following check to go away
              !succSKSet[newBlockId].count(otherBlockSrcKey)) {
            region->addArc(newBlockId, otherBlockId);
            succSKSet[newBlockId].insert(otherBlockSrcKey);
          }
        }
      }
    }
    region->blocks.insert(region->blocks.end(), blockRegion->blocks.begin(),
                          blockRegion->blocks.end());
    region->arcs.insert(region->arcs.end(), blockRegion->arcs.begin(),
                        blockRegion->arcs.end());
    if (cfg.outArcs(tid).size() > 1) {
      region->setSideExitingBlock(blockRegion->blocks.front()->id());
    }
    selectedSet.insert(tid);
    if (selectedVec) selectedVec->push_back(tid);

    Op lastOp = *(profData->transLastInstr(tid));
    if (breaksRegion(lastOp)) {
      FTRACE(2, "selectHotTrace: breaking region because of last instruction "
             "in Translation {}: {}\n", tid, opcodeToName(lastOp));
      break;
    }

    auto outArcs = cfg.outArcs(tid);
    if (outArcs.size() == 0) {
      FTRACE(2, "selectHotTrace: breaking region because there's no successor "
             "for Translation {}\n", tid);
      break;
    }

    auto lastNewBlock = blockRegion->blocks.back();
    discardPoppedTypes(accumPostConds,
                       blockRegion->blocks[0]->initialSpOffset());
    mergePostConds(accumPostConds, lastNewBlock->postConds());
    blockPostConds[lastNewBlock->id()] = accumPostConds;

    TransCFG::ArcPtrVec possibleOutArcs;
    for (auto arc : outArcs) {
      RegionDesc::BlockPtr possibleNext =
        profData->transRegion(arc->dst())->blocks[0];
      if (preCondsAreSatisfied(possibleNext, accumPostConds)) {
        possibleOutArcs.emplace_back(arc);
      }
    }

    if (possibleOutArcs.size() == 0) {
      FTRACE(2, "selectHotTrace: breaking region because postcondition check "
             "pruned all successors of Translation {}\n", tid);
      break;
    }

    auto maxWeight = std::numeric_limits<int64_t>::min();
    TransCFG::Arc* maxArc = nullptr;
    for (auto arc : possibleOutArcs) {
      if (arc->weight() >= maxWeight) {
        maxWeight = arc->weight();
        maxArc = arc;
      }
    }
    assert(maxArc != nullptr);
    prevId = tid;
    tid = maxArc->dst();
  }

  return region;
}
Esempio n. 29
0
int main (int argc, char* argv[]){
  // temporary string holder
  char line[MAX_LEN];
  // checks for correct command line inputs
  if(argc != 3) {
    printf("Invalid number of inputs");
    exit(1);
  }

  // opens the file
  FILE* input = fopen(argv[1], "r");
  FILE* output = fopen(argv[2], "w");

  // checks if files have been open and or created
  if(input == NULL){ 
    printf("Unable to open file %s for reading\n", argv[1]);
    return 1;
  } else if (output == NULL){
    printf("Unable to open file %s for reading\n", argv[2]);
    return 1;
  }
    
  // read each line of input file, then count and print tokens
  fgets(line, MAX_LEN, input);
  int numVertex = 0;
  sscanf(line, "%d", &numVertex);
  List S = newList();
  for (int i = 1; i <= numVertex; i++) append(S, i);
  // Graph creation
  Graph G = newGraph(numVertex);
  while( fgets(line, MAX_LEN, input) != NULL) {
    int vert1 = 0;
    int vert2 = 0;
    sscanf(line, "%d %d", &vert1, &vert2);
    if(vert1 == 0 && vert2 == 0) break;
    addArc(G, vert1, vert2);
  }

  DFS(G, S);
  fprintf(output, "Adjacency list representation of G:\n");
  printGraph(output, G);

  Graph T = transpose(G);
  DFS(T, S);

  //counts the number of Scc
  int numScc = 0;
  for(moveTo(S, 0); getIndex(S) >= 0; moveNext(S)){
    if(getParent(T, getElement(S)) == NIL) numScc ++ ;
  }
  // puts the components into array list of size # of scc
  List Scc[numScc];
  int i = numScc;
  for(moveTo(S, 0); getIndex(S) >= 0; moveNext(S)){
    if(getParent(T, getElement(S)) == NIL){
      i--;
      Scc[i] = newList();
    }
    if(i == numScc) break;
    append(Scc[i], getElement(S));
  }

  // prints out scc's
  fprintf(output, "\nG contains %d strongly connected components:", numScc);
  for(int j = 0; j < numScc; j++){
    fprintf(output, "\n");
    fprintf(output, "Component %d: ", j + 1);
    printList(output, Scc[j]);
    freeList(&(Scc[j]));
  }
  // frees all the necessary items
  fprintf(output, "\n");
  freeGraph(&G);
  freeGraph(&T);
  freeList(&S);
  fclose(input);
  fclose(output);
  return(0);
}
Esempio n. 30
0
void addEdge(int n1,int n2,graphe *pg, int valeur){
    addArc(n1,n2,pg,valeur);
    addArc(n2,n1,pg,valeur);
}