/// \{
/// Removes an edge from the graph.
///
/// Complexity: O(m)
///
/// \param[in] e Edge to remove
/// \param[in] type Type of edge to add
/// \return true on success, false otherwise
///
/// \note This function performs boundary check.
bool remove(edge e, edge::type type = edge::type::uni)
{
if ((e.from >= n) || (e.to >= n))
return false;
remove_vertex(m[e.from], e.to);
if (type == edge::type::bi)
remove_vertex(m[e.to], e.from);
return true;
}
void cleanup_graph(FUNCTION *func)
{
GRAPH *graph = func->graph;
int i;
restart:
for (i = 2; i < tree_num_children(graph); i++)
{
NODE *vertex = tree_get_child(graph, i);
if (vertex == NULL)
continue;
if (!find_in_hash(graph->forward, vertex, sizeof(void *))
|| !find_in_hash(graph->backward, vertex, sizeof(void *)))
{
//printf(" dead-end: ");
//tree_print(vertex, 2);
}
if (tree_is_type(vertex, STMT_PASS))
{
HASH *subhash = get_from_hash(graph->forward, vertex, sizeof(void *));
HASH_ITERATOR iter;
hash_iterator(subhash, &iter);
if (hash_iterator_valid(&iter))
{
NODE *successor = iter.entry->key;
EDGE_TYPE type = (EDGE_TYPE) iter.entry->data;
replace_backward(graph, vertex, successor, type);
remove_edge(graph, vertex, successor);
remove_vertex(graph, vertex);
goto restart;
}
}
else if (tree_is_type(vertex, STMT_JOIN))
{
HASH *subhash = get_from_hash(graph->forward, vertex, sizeof(void *));
if (subhash->num != 1)
error("Join does not have exactly 1 successor");
HASH_ITERATOR iter;
hash_iterator(subhash, &iter);
if (hash_iterator_valid(&iter))
{
NODE *successor = iter.entry->key;
EDGE_TYPE type = (EDGE_TYPE) iter.entry->data;
replace_backward(graph, vertex, successor, type);
remove_edge(graph, vertex, successor);
remove_vertex(graph, vertex);
goto restart;
}
}
}
}
/** Construct a reversed copy of an arbitrary NGHolder, mapping starts to
* accepts. */
void reverseHolder(const NGHolder &g_in, NGHolder &g) {
// Make the BGL do the grunt work.
ue2::unordered_map<NFAVertex, NFAVertex> vertexMap;
boost::transpose_graph(g_in.g, g.g,
orig_to_copy(boost::make_assoc_property_map(vertexMap)).
vertex_index_map(get(&NFAGraphVertexProps::index, g_in.g)));
// The transpose_graph operation will have created extra copies of our
// specials. We have to rewire their neighbours to the 'real' specials and
// delete them.
NFAVertex start = vertexMap[g_in.acceptEod];
NFAVertex startDs = vertexMap[g_in.accept];
NFAVertex accept = vertexMap[g_in.startDs];
NFAVertex acceptEod = vertexMap[g_in.start];
// Successors of starts.
for (const auto &e : out_edges_range(start, g)) {
NFAVertex v = target(e, g);
add_edge(g.start, v, g[e], g);
}
for (const auto &e : out_edges_range(startDs, g)) {
NFAVertex v = target(e, g);
add_edge(g.startDs, v, g[e], g);
}
// Predecessors of accepts.
for (const auto &e : in_edges_range(accept, g)) {
NFAVertex u = source(e, g);
add_edge(u, g.accept, g[e], g);
}
for (const auto &e : in_edges_range(acceptEod, g)) {
NFAVertex u = source(e, g);
add_edge(u, g.acceptEod, g[e], g);
}
// Remove our impostors.
clear_vertex(start, g);
remove_vertex(start, g);
clear_vertex(startDs, g);
remove_vertex(startDs, g);
clear_vertex(accept, g);
remove_vertex(accept, g);
clear_vertex(acceptEod, g);
remove_vertex(acceptEod, g);
// Renumber so that g's properties (number of vertices, edges) are
// accurate.
g.renumberVertices();
g.renumberEdges();
assert(num_vertices(g) == num_vertices(g_in));
assert(num_edges(g) == num_edges(g_in));
}
int Graph::fuse_vertices(int u, int v, bool contract_edge = false){
int i;
if(simple != true){
fatal_error("%s: called on a non-simple graph!\n", __FUNCTION__);
}
if((nodes[u].label == -1) || (nodes[v].label == -1) ){
fatal_error(
"%s: Cannot remove edge (%d, %d) as one of its vertices is undefined!\n",
__FUNCTION__, u, v);
}
vector<bool> neighbors(capacity);
fill(neighbors.begin(), neighbors.end(), false);
list<int>::iterator it;
if(v == u){ //maybe don't need this
return false;
}
bool foundv = false;
for(it = nodes[u].nbrs.begin(); it != nodes[u].nbrs.end(); ++it){
neighbors[*it] = true;
if(*it == v){
foundv = true;
}
}
if(contract_edge){ // for fuse_vertices alone, don't need to be neighbours. for contract_edge you do
if(foundv == false){
return false;
}
}
for(it = nodes[v].nbrs.begin(); it != nodes[v].nbrs.end(); ++it){
neighbors[*it] = true;
}
remove_vertex(u);
remove_vertex(v);
nodes[u].label = next_label;
next_label++;
num_nodes++;
for(i = 0; i < capacity; i++){
if((i != u) && (i != v) ){
if(neighbors[i] == true){
nodes[i].nbrs.push_back(u);
nodes[u].nbrs.push_back(i);
degree[u]++;
degree[i]++;
num_edges++;
}
}
}
return u;
} // fuse_vertices
void collapse_vertices(V b, V a, G& g)
{
auto be = boost::adjacent_vertices(b, g);
for (auto beit = be.first; beit != be.second; ++beit)
add_edge(a, *beit, g);
remove_vertex(b, g);
}
void Dijkstra(int p, int w[N][N], int d[N])
{
int i, u, x, k;
int j, m;
struct vertices U, V;
set_vertices(&V, FALSE);
set_vertices(&U, TRUE);
for (i = 0; i < N; i++) {
d[i] = M;
}
d[p] = 0;
printf("(3)\n");
printf(" (a)\n");
while (remain(&U)) {
u = select_min(d, &U); /* (ア) */
/* (3)(a) */
printf(" u == %d\n", u);
add_vertex(u, &V);
remove_vertex(u, &U);
for (x = 0; x < N; x++) {
if (w[u][x] < M && member(x, &U)) {
k = d[u] + w[u][x];
if (k < d[x]) {
d[x] = k;
}
}
}
}
}
void Graph::aggregate_vertexs(void)
{
unsigned int i, j;
Vertex *first = NULL;
for(i = 0; i < vertexs.size(); i++) {
// find first child node
for(j = i+1; j < vertexs.size(); j++) {
if(has_edge(vertexs[i], vertexs[j])) {
first = vertexs[j++];
break;
}
}
while(j < vertexs.size()) {
if(has_edge(vertexs[i], vertexs[j])) {
if(first->info.syscall_no == vertexs[j]->info.syscall_no
/* && same_edges(first, vertexs[j]) */) {
/*
std::cout<<"Removed\n";
std::cout<<vertexs[i]->index<<", sc="<<vertexs[i]->info.syscall_no;
std::cout<<std::endl;
std::cout<<first->index<<", sc="<<first->info.syscall_no;
std::cout<<std::endl;
std::cout<<vertexs[j]->index<<", sc="<<vertexs[j]->info.syscall_no;
std::cout<<std::endl;
*/
remove_vertex(vertexs[j]);
}
else
first = vertexs[j++];
} else {
j++;
}
}
}
}
int main(int argc, char* argv[]) {
Adjacency_Matrix* g = (Adjacency_Matrix*) malloc(sizeof(Adjacency_Matrix));
Adjacency_Matrix* tp;
int* adjacency;
empty_graph(g);
int option, v, a1, a2;
do {
menu();
scanf("%d", &option);
switch (option) {
case INSERT_VERTEX:
printf("How many vertex would you like to insert? ");
scanf("%d", &v);
insert_vertex(g, v);
break;
case REMOVE_VERTEX:
printf("Which vertex would you like to remove? ");
scanf("%d", &v);
remove_vertex(g, v);
break;
case INSERT_ARC:
printf("First vertex: ");
scanf("%d", &a1);
printf("Second vertex: ");
scanf("%d", &a2);
insert_arc(g, a1, a2, 1);
break;
case REMOVE_ARC:
printf("First vertex: ");
scanf("%d", &a1);
printf("Second vertex: ");
scanf("%d", &a2);
remove_arc(g, a1, a2);
break;
case VERTEX_ADJACENCY:
printf("Which vertex would you like to verify adjacency?");
scanf("%d", &v);
adjacency = get_adjacency(g, v);
print_adjacency(adjacency);
free(adjacency);
pause();
break;
case TRANSPOSE_GRAPH:
tp = transpose_graph(g);
print_graph(tp);
free(tp);
pause();
break;
case PRINT_GRAPH:
print_graph(g);
pause();
break;
}
} while (option != EXIT);
return 0;
}
void constraints() {
v = add_vertex(g);
clear_vertex(v, g);
remove_vertex(v, g);
p = add_edge(u, v, g);
remove_edge(u, v, g);
remove_edge(e, g);
}
void AlnGraphBoost::reapNodes() {
int reapCount = 0;
std::sort(_reaperBag.begin(), _reaperBag.end());
std::vector<VtxDesc>::iterator curr = _reaperBag.begin();
for (; curr != _reaperBag.end(); ++curr) {
assert(_g[*curr].backbone==false);
remove_vertex(*curr-reapCount++, _g);
}
}
void MergeAllParents::mergeAll(std::pair<ParentsIterator,ParentsIterator> pair,
VertexID child,
set<VertexID> &A,
set<VertexID> &B)
{
set<VertexID> parents2;
set<VertexID> parents1;
set<VertexID>::iterator pit,Aelt,Belt;
ParentsIterator p,p_end,p2,p2_end;
InEdgeIterator e,e_end;
for (tie(p,p_end) = pair; p != p_end; p++) {
if (*p != m_invartask) {
parents1.insert(*p);
}
}
for (pit=parents1.begin(); pit != parents1.end(); pit++) {
addContainsTask(child,*pit);
for (tie(p2,p2_end) = parents(*pit,*m_taskgraph); p2 != p2_end; p2++) {
if (parents1.find(*pit) == parents1.end() && *p2 != m_invartask)
parents2.insert(*p2);
}
// Add edge from parents^2 to child
for(tie(e,e_end) = in_edges(*pit,*m_taskgraph); e != e_end; e++) {
// Adding edge here invalidates pair iterators
if (parents1.find(source(*e,*m_taskgraph)) == parents1.end()) {
EdgeID newEdge = add_edge(source(*e,*m_taskgraph),child,m_taskgraph);
ResultSet &set = getResultSet(newEdge,m_taskgraph);
ResultSet &oldSet = getResultSet(*e,m_taskgraph);
set.make_union(&oldSet);
}
}
}
// Add edge from new node to all in A
for (Aelt=A.begin(); Aelt != A.end(); Aelt++) {
add_edge(child,*Aelt,m_taskgraph);
}
// Can not iterate through pair since add_edge above invalidates that
// iterator.
for (pit=parents1.begin(); pit != parents1.end(); pit++) {
if (B.find(*pit) == B.end() && *pit != m_invartask) {
(*m_taskRemoved)[*pit] = true;
clear_vertex(*pit,*m_taskgraph);
remove_vertex(*pit,*m_taskgraph);
}
}
// Remove edges from elts in B to child, the elts are already dupl. into child.
for (Belt = B.begin(); Belt != B.end(); Belt++) {
remove_edge(*Belt,child,*m_taskgraph);
}
}
void
remove_vertex_and_renumber_indices(vertex_iterator i)
{
vertex_iterator j = next(i), end = vertices(m_graph).second;
vertex_index_type n = get(vertex_index, m_graph, *i);
// remove the offending vertex and renumber everything after
remove_vertex(*i);
m_max_vertex_index = renumber_vertex_indices(j, end, n);
}
void BondGraph::_ClearAtoms () {
// Remove all the vertices.
Vertex_it vi, vi_end, next;
tie(vi, vi_end) = vertices(_graph);
for (next = vi; vi != vi_end; vi = next) {
++next;
remove_vertex(*vi, _graph);
}
return;
}
/*
Erasing graph, include all nodes and edges,
except for mempool, freelist.
*/
void GRAPH::erasure()
{
IS_TRUE(m_pool != NULL, ("Graph must be initialized before clone."));
//Collect edge, vertex data structure into free-list
//for allocation on demand.
INT c;
for (VERTEX * v = m_vertexs.get_first(c);
v != NULL; v = m_vertexs.get_next(c)) {
remove_vertex(v);
}
}
bool CSimpleUGraph< ObjT, Compare >::RemoveVertex( const ObjT & oV )
{
typename DataVertexMapT::iterator pMapPos = oDataToVertexMap.find( oV );
if( pMapPos == oDataToVertexMap.end() )
return false;
Vertex u = pMapPos->second;
clear_vertex ( u, oBoostGraph );
remove_vertex( u, oBoostGraph );
return true;
}
void KCoreGraph::apply_coreness() {
/* Not optimal, obviously */
for (unsigned int i=0; i<neighbourhoods.size(); i++) {
if ((neighbourhoods.at(i) != NULL) && (((int)(neighbourhoods.at(i)->size)) < k)) {
remove_vertex(i);
allid->remove(i);
propagate();
}
}
};
void KCoreGraph::propagate() {
int elt;
/* Remove vertices in "tbr" until it becomes empty */
/* Note : vertices whose degree falls below k during the process are removed as well */
while (!tbr->empty()) {
elt = tbr->head();
tbr->remove(elt);
remove_vertex(elt);
allid->remove(elt);
}
};
bool are_uwv_ok(const VertexListGraph& graph, Vertex uwv[]) {
// Checking whether the FIRST and THIRD are not heighbors.
typedef typename graph_traits<VertexListGraph>::adjacency_iterator AdjIterator;
AdjIterator n_v, n_vend;
for(tie(n_v, n_vend) = adjacent_vertices(uwv[FIRST], graph); n_v != n_vend; ++n_v) {
if(uwv[THIRD] == *n_v)
return false;
}
// Removing FIRST and THIRD, then checking whether graph remains connected.
VertexListGraph temp_graph;
copy_graph(graph, temp_graph);
clear_vertex(uwv[FIRST], temp_graph);
clear_vertex(uwv[THIRD], temp_graph);
remove_vertex(uwv[FIRST], temp_graph);
remove_vertex(uwv[THIRD], temp_graph);
return is_graph_connected(temp_graph);
}
/**
* Calculate min cut using random_contraction
* @input n Array size
* @input arr Array
* @return mincut
*/
int random_contraction(int n, int **arr)
{
int cur = n;
int a, b;
while (cur > 2) {
random_sel(&a, &b, cur);
group(arr, a, b, cur);
remove_vertex(arr, b, cur);
cur--;
}
return arr[1][0];
}
inline
void remove_branch( const typename graph_traits<Graph>::vertex_descriptor& u,
Graph& g) {
typedef typename graph_traits<Graph>::out_edge_iterator EdgeIter;
typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
std::vector<Vertex> v_list; v_list.reserve(out_degree(u, g));
EdgeIter ei, ei_end;
for( boost::tie(ei, ei_end) = out_edges(u,g); ei != ei_end; ++ei)
v_list.push_back(target(*ei,g));
for( typename std::vector<Vertex>::iterator it = v_list.begin(); it != v_list.end(); ++it)
remove_branch(*it, g);
clear_vertex(u, g);
remove_vertex(u, g);
};
/*
Perform DFS to seek for unreachable node.
Return true if some nodes removed.
*/
bool DGRAPH::remove_unreach_node(UINT entry_id)
{
if (get_vertex_num() == 0) return false;
bool removed = false;
BITSET visited;
_remove_unreach_node(entry_id, visited);
INT c;
for (VERTEX * v = get_first_vertex(c);
v != NULL; v = get_next_vertex(c)) {
if (!visited.is_contain(VERTEX_id(v))) {
remove_vertex(v);
removed = true;
}
}
return removed;
}
void clear_graph(NGHolder &h) {
NGHolder::vertex_iterator vi, ve;
for (tie(vi, ve) = vertices(h); vi != ve;) {
NFAVertex v = *vi;
++vi;
clear_vertex(v, h);
if (!is_special(v, h)) {
remove_vertex(v, h);
}
}
assert(num_vertices(h) == N_SPECIALS);
// Recreate special stylised edges.
add_edge(h.start, h.startDs, h);
add_edge(h.startDs, h.startDs, h);
add_edge(h.accept, h.acceptEod, h);
}
void SingleChildMerge::mergeTasks(VertexID n1, VertexID n2)
{
VertexID p,c;
OutEdgeIterator oute,oute_end;
InEdgeIterator ine,ine_end;
tie(p,c)=determineParent(n1,n2);
set<VertexID> parents,children;
set<VertexID>::iterator child;
for (tie(ine,ine_end)=in_edges(p,*m_taskgraph); ine != ine_end; ++ine) {
assert(p != source(*ine,*m_taskgraph));
parents.insert(source(*ine,*m_taskgraph));
}
for (tie(oute,oute_end)= out_edges(c,*m_taskgraph); oute != oute_end; ++oute) {
assert(c != target(*oute,*m_taskgraph));
children.insert(target(*oute,*m_taskgraph));
}
// Add edges from newtask = p to children and update costs.
for(child = children.begin(); child != children.end(); ++child) {
EdgeID newEdge,oldEdge;
bool tmp;
tie(newEdge,tmp)= add_edge(p,*child,*m_taskgraph);
tie(oldEdge,tmp) = edge(c,*child,*m_taskgraph);
//cerr << "old cost: " << getCommCost(oldEdge) << endl;
setCommCost(newEdge,
getCommCost(oldEdge),m_taskgraph);
}
addContainsTask(p,c); // Need to store that c is in p to be able to
// go back to orig task graph when generating code.
// Remove task and edges to the task
(*m_taskRemoved)[c]=true;
clear_vertex(c,*m_taskgraph);
remove_vertex(c,*m_taskgraph);
}
static int i386ify_assignment(MODULE *module, FUNCTION *func, NODE *vertex)
{
int changed = 0;
GRAPH *graph = func->graph;
VARIABLE *dest = tree_get_child(vertex, 0);
EXPRESSION *expr = tree_get_child(vertex, 1);
int source_line = CAST_TO_AST(vertex)->source_line;
if (is_unary_op(expr))
changed |= i386ify_unary_operation(module, func, vertex);
if (is_binary_op(expr))
changed |= i386ify_binary_operation(module, func, vertex);
/* Expand tuple assignments. */
if (tree_is_type(dest, EXPR_TUPLE) && tree_num_children(dest) >= 1)
{
int i;
NODE *last = NULL;
if (tree_num_children(dest) != tree_num_children(expr))
error("Source and destinations have different cardinality!");
for (i = 0; i < tree_num_children(dest); i++)
{
VARIABLE *dest2 = tree_get_child(dest, i);
VARIABLE *src2 = tree_get_child(expr, i);
STATEMENT *new_assign = make_assignment(CAST_TO_EXPRESSION(dest2), CAST_TO_EXPRESSION(src2), source_line);
add_vertex(graph, CAST_TO_NODE(new_assign));
if (last)
add_edge(graph, last, CAST_TO_NODE(new_assign), 0);
else
replace_backward(graph, vertex, CAST_TO_NODE(new_assign), 0);
last = CAST_TO_NODE(new_assign);
}
replace_forward(graph, vertex, last, 0);
remove_vertex(graph, vertex);
changed |= 1;
}
return changed;
}
BOOST_AUTO_TEST_CASE_TEMPLATE( intint_bgl_mutable_graph_test, Graph, intint_graphtest_types )
{
typedef typename boost::graph_traits<Graph>::vertex_descriptor Vertex;
typedef typename boost::graph_traits<Graph>::vertex_iterator VertexIter;
typedef typename boost::graph_traits<Graph>::edge_descriptor Edge;
typedef typename boost::graph_traits<Graph>::edge_iterator EdgeIter;
typedef typename boost::graph_traits<Graph>::out_edge_iterator OutEdgeIter;
typedef typename boost::graph_traits<Graph>::in_edge_iterator InEdgeIter;
Graph g;
Vertex v_root = Vertex();
BOOST_CHECK_NO_THROW( v_root = add_vertex(g) );
BOOST_CHECK_EQUAL( num_vertices(g), 1);
BOOST_CHECK_NO_THROW( remove_vertex(v_root,g) );
BOOST_CHECK_EQUAL( num_vertices(g), 0);
BOOST_CHECK_NO_THROW( v_root = add_vertex(1, g) );
g[v_root] = 1;
BOOST_CHECK_EQUAL( g[v_root], 1 );
int vp_rc[] = {2,3,4,5};
int ep_rc[] = {1002,1003,1004,1005};
Vertex v_rc[4];
Edge e_rc[4];
for(int i = 0; i < 4; ++i) {
BOOST_CHECK_NO_THROW( v_rc[i] = add_vertex(g) );
g[ v_rc[i] ] = vp_rc[i];
BOOST_CHECK_EQUAL( g[ v_rc[i] ], vp_rc[i] );
bool edge_added_success = false;
BOOST_CHECK_NO_THROW( boost::tie(e_rc[i],edge_added_success) = add_edge(v_root, v_rc[i], g) );
BOOST_CHECK( edge_added_success );
g[ e_rc[i] ] = ep_rc[i];
BOOST_CHECK_EQUAL( g[ e_rc[i] ], ep_rc[i] );
};
BOOST_CHECK_EQUAL( num_vertices(g), 5 );
int vp_rc1c[] = {6,7,8,9};
int ep_rc1c[] = {2006,2007,2008,2009};
Vertex v_rc1c[4];
Edge e_rc1c[4];
for(std::size_t i = 0; i < 4; ++i) {
BOOST_CHECK_NO_THROW( v_rc1c[i] = add_vertex(vp_rc1c[i], g) );
BOOST_CHECK_EQUAL( g[ v_rc1c[i] ], vp_rc1c[i] );
bool edge_added_success = false;
BOOST_CHECK_NO_THROW( boost::tie(e_rc1c[i],edge_added_success) = add_edge(v_rc[0], v_rc1c[i], ep_rc1c[i], g) );
BOOST_CHECK( edge_added_success );
BOOST_CHECK_EQUAL( g[ e_rc1c[i] ], ep_rc1c[i] );
};
BOOST_CHECK_EQUAL( num_vertices(g), 9 );
BOOST_CHECK_EQUAL( g[v_root], 1 );
{
OutEdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei,ei_end) = out_edges(v_root,g) );
std::vector<int> e_list;
for(; ei != ei_end; ++ei) {
if(is_edge_valid(*ei,g)) {
BOOST_CHECK_EQUAL( g[*ei], (g[source(*ei,g)] * 1000 + g[target(*ei,g)]) );
e_list.push_back(g[*ei]);
};
};
std::sort(e_list.begin(), e_list.end());
BOOST_CHECK_EQUAL( e_list[0], 1002);
BOOST_CHECK_EQUAL( e_list[1], 1003);
BOOST_CHECK_EQUAL( e_list[2], 1004);
BOOST_CHECK_EQUAL( e_list[3], 1005);
InEdgeIter iei, iei_end;
BOOST_CHECK_NO_THROW( boost::tie(iei, iei_end) = in_edges(v_rc[0], g) );
BOOST_CHECK( iei != iei_end );
BOOST_CHECK_EQUAL( g[*iei], 1002);
++iei;
BOOST_CHECK( iei == iei_end );
BOOST_CHECK_NO_THROW( boost::tie(ei,ei_end) = out_edges(v_rc[0],g) );
std::vector<int> e_list2;
for(; ei != ei_end; ++ei) {
if(is_edge_valid(*ei,g)) {
BOOST_CHECK_EQUAL( g[*ei], (g[source(*ei,g)] * 1000 + g[target(*ei,g)]) );
e_list2.push_back(g[*ei]);
};
};
std::sort(e_list2.begin(), e_list2.end());
BOOST_CHECK_EQUAL( e_list2[0], 2006);
BOOST_CHECK_EQUAL( e_list2[1], 2007);
BOOST_CHECK_EQUAL( e_list2[2], 2008);
BOOST_CHECK_EQUAL( e_list2[3], 2009);
};
int vp_rc2c[] = {10,11,12,13};
int ep_rc2c[] = {3010,3011,3012,3013};
Vertex v_rc2c[4];
Edge e_rc2c[4];
for(std::size_t i = 0; i < 4; ++i) {
#ifdef RK_ENABLE_CXX0X_FEATURES
BOOST_CHECK_NO_THROW( v_rc2c[i] = add_vertex(std::move(vp_rc2c[i]), g) );
#else
BOOST_CHECK_NO_THROW( v_rc2c[i] = add_vertex(vp_rc2c[i], g) );
#endif
bool edge_added_success = false;
#ifdef RK_ENABLE_CXX0X_FEATURES
BOOST_CHECK_NO_THROW( boost::tie(e_rc2c[i],edge_added_success) = add_edge(v_rc[1], v_rc2c[i], ep_rc2c[i], g) );
#else
BOOST_CHECK_NO_THROW( boost::tie(e_rc2c[i],edge_added_success) = add_edge(v_rc[1], v_rc2c[i], ep_rc2c[i], g) );
#endif
BOOST_CHECK( edge_added_success );
};
BOOST_CHECK_EQUAL( num_vertices(g), 13 );
{
OutEdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei,ei_end) = out_edges(v_rc[1],g) );
std::vector<int> e_list;
std::vector<int> vp_list;
for(; ei != ei_end; ++ei) {
if(is_edge_valid(*ei,g)) {
BOOST_CHECK_EQUAL( g[*ei], (g[source(*ei,g)] * 1000 + g[target(*ei,g)]) );
e_list.push_back(g[*ei]);
vp_list.push_back(g[target(*ei,g)]);
};
};
std::sort(e_list.begin(), e_list.end());
BOOST_CHECK_EQUAL( e_list[0], 3010);
BOOST_CHECK_EQUAL( e_list[1], 3011);
BOOST_CHECK_EQUAL( e_list[2], 3012);
BOOST_CHECK_EQUAL( e_list[3], 3013);
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 10);
BOOST_CHECK_EQUAL( vp_list[1], 11);
BOOST_CHECK_EQUAL( vp_list[2], 12);
BOOST_CHECK_EQUAL( vp_list[3], 13);
};
BOOST_CHECK_NO_THROW( clear_vertex(v_rc[0],g) );
BOOST_CHECK_EQUAL( out_degree(v_rc[0], g), 0 );
BOOST_CHECK_EQUAL( in_degree(v_rc[0], g), 0 );
BOOST_CHECK_EQUAL( out_degree(v_root, g), 3 );
BOOST_CHECK_EQUAL( in_degree(v_rc1c[0], g), 0 );
BOOST_CHECK_EQUAL( in_degree(v_rc1c[1], g), 0 );
BOOST_CHECK_EQUAL( in_degree(v_rc1c[2], g), 0 );
BOOST_CHECK_EQUAL( in_degree(v_rc1c[3], g), 0 );
BOOST_CHECK_EQUAL( num_vertices(g), 13 );
{
VertexIter vi, vi_end;
BOOST_CHECK_NO_THROW( boost::tie(vi, vi_end) = vertices(g) );
std::vector<int> vp_list;
for(; vi != vi_end; ++vi)
if( is_vertex_valid(*vi, g) )
vp_list.push_back( g[*vi] );
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 1 );
BOOST_CHECK_EQUAL( vp_list[1], 2 );
BOOST_CHECK_EQUAL( vp_list[2], 3 );
BOOST_CHECK_EQUAL( vp_list[3], 4 );
BOOST_CHECK_EQUAL( vp_list[4], 5 );
BOOST_CHECK_EQUAL( vp_list[5], 6 );
BOOST_CHECK_EQUAL( vp_list[6], 7 );
BOOST_CHECK_EQUAL( vp_list[7], 8 );
BOOST_CHECK_EQUAL( vp_list[8], 9 );
BOOST_CHECK_EQUAL( vp_list[9], 10 );
BOOST_CHECK_EQUAL( vp_list[10], 11 );
BOOST_CHECK_EQUAL( vp_list[11], 12 );
BOOST_CHECK_EQUAL( vp_list[12], 13 );
};
BOOST_CHECK_EQUAL( num_edges(g), 7 );
{
EdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei, ei_end) = edges(g) );
std::vector<int> ep_list;
for(; ei != ei_end; ++ei)
if( is_edge_valid(*ei, g) )
ep_list.push_back( g[*ei] );
std::sort(ep_list.begin(), ep_list.end());
BOOST_CHECK_EQUAL( ep_list[0], 1003 );
BOOST_CHECK_EQUAL( ep_list[1], 1004 );
BOOST_CHECK_EQUAL( ep_list[2], 1005 );
BOOST_CHECK_EQUAL( ep_list[3], 3010 );
BOOST_CHECK_EQUAL( ep_list[4], 3011 );
BOOST_CHECK_EQUAL( ep_list[5], 3012 );
BOOST_CHECK_EQUAL( ep_list[6], 3013 );
};
BOOST_CHECK_NO_THROW( remove_edge(v_rc[1], v_rc2c[2], g) );
BOOST_CHECK_EQUAL( num_vertices(g), 13 );
{
VertexIter vi, vi_end;
BOOST_CHECK_NO_THROW( boost::tie(vi, vi_end) = vertices(g) );
std::vector<int> vp_list;
for(; vi != vi_end; ++vi) {
if( is_vertex_valid(*vi, g) ) {
vp_list.push_back( g[*vi] );
};
};
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 1 );
BOOST_CHECK_EQUAL( vp_list[1], 2 );
BOOST_CHECK_EQUAL( vp_list[2], 3 );
BOOST_CHECK_EQUAL( vp_list[3], 4 );
BOOST_CHECK_EQUAL( vp_list[4], 5 );
BOOST_CHECK_EQUAL( vp_list[5], 6 );
BOOST_CHECK_EQUAL( vp_list[6], 7 );
BOOST_CHECK_EQUAL( vp_list[7], 8 );
BOOST_CHECK_EQUAL( vp_list[8], 9 );
BOOST_CHECK_EQUAL( vp_list[9], 10 );
BOOST_CHECK_EQUAL( vp_list[10], 11 );
BOOST_CHECK_EQUAL( vp_list[11], 12 );
BOOST_CHECK_EQUAL( vp_list[12], 13 );
};
BOOST_CHECK_EQUAL( num_edges(g), 6 );
{
EdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei, ei_end) = edges(g) );
std::vector<int> ep_list;
for(; ei != ei_end; ++ei) {
if( is_edge_valid(*ei, g) ) {
ep_list.push_back( g[*ei] );
};
};
std::sort(ep_list.begin(), ep_list.end());
BOOST_CHECK_EQUAL( ep_list[0], 1003 );
BOOST_CHECK_EQUAL( ep_list[1], 1004 );
BOOST_CHECK_EQUAL( ep_list[2], 1005 );
BOOST_CHECK_EQUAL( ep_list[3], 3010 );
BOOST_CHECK_EQUAL( ep_list[4], 3011 );
BOOST_CHECK_EQUAL( ep_list[5], 3013 );
};
BOOST_CHECK_NO_THROW( remove_edge(e_rc2c[3], g) );
BOOST_CHECK_EQUAL( num_vertices(g), 13 );
{
VertexIter vi, vi_end;
BOOST_CHECK_NO_THROW( boost::tie(vi, vi_end) = vertices(g) );
std::vector<int> vp_list;
for(; vi != vi_end; ++vi) {
if( is_vertex_valid(*vi, g) ) {
vp_list.push_back( g[*vi] );
};
};
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 1 );
BOOST_CHECK_EQUAL( vp_list[1], 2 );
BOOST_CHECK_EQUAL( vp_list[2], 3 );
BOOST_CHECK_EQUAL( vp_list[3], 4 );
BOOST_CHECK_EQUAL( vp_list[4], 5 );
BOOST_CHECK_EQUAL( vp_list[5], 6 );
BOOST_CHECK_EQUAL( vp_list[6], 7 );
BOOST_CHECK_EQUAL( vp_list[7], 8 );
BOOST_CHECK_EQUAL( vp_list[8], 9 );
BOOST_CHECK_EQUAL( vp_list[9], 10 );
BOOST_CHECK_EQUAL( vp_list[10], 11 );
BOOST_CHECK_EQUAL( vp_list[11], 12 );
BOOST_CHECK_EQUAL( vp_list[12], 13 );
};
BOOST_CHECK_EQUAL( num_edges(g), 5 );
{
EdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei, ei_end) = edges(g) );
std::vector<int> ep_list;
for(; ei != ei_end; ++ei) {
if( is_edge_valid(*ei, g) ) {
ep_list.push_back( g[*ei] );
};
};
std::sort(ep_list.begin(), ep_list.end());
BOOST_CHECK_EQUAL( ep_list[0], 1003 );
BOOST_CHECK_EQUAL( ep_list[1], 1004 );
BOOST_CHECK_EQUAL( ep_list[2], 1005 );
BOOST_CHECK_EQUAL( ep_list[3], 3010 );
BOOST_CHECK_EQUAL( ep_list[4], 3011 );
};
BOOST_CHECK_NO_THROW( clear_vertex(v_rc2c[0], g) );
BOOST_CHECK_NO_THROW( remove_vertex(v_rc2c[0], g) );
BOOST_CHECK_EQUAL( num_vertices(g), 12 );
{
VertexIter vi, vi_end;
BOOST_CHECK_NO_THROW( boost::tie(vi, vi_end) = vertices(g) );
std::vector<int> vp_list;
for(; vi != vi_end; ++vi) {
if( is_vertex_valid(*vi, g) ) {
vp_list.push_back( g[*vi] );
};
};
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 1 );
BOOST_CHECK_EQUAL( vp_list[1], 2 );
BOOST_CHECK_EQUAL( vp_list[2], 3 );
BOOST_CHECK_EQUAL( vp_list[3], 4 );
BOOST_CHECK_EQUAL( vp_list[4], 5 );
BOOST_CHECK_EQUAL( vp_list[5], 6 );
BOOST_CHECK_EQUAL( vp_list[6], 7 );
BOOST_CHECK_EQUAL( vp_list[7], 8 );
BOOST_CHECK_EQUAL( vp_list[8], 9 );
BOOST_CHECK_EQUAL( vp_list[9], 11 );
BOOST_CHECK_EQUAL( vp_list[10], 12 );
BOOST_CHECK_EQUAL( vp_list[11], 13 );
};
BOOST_CHECK_EQUAL( num_edges(g), 4 );
{
EdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei, ei_end) = edges(g) );
std::vector<int> ep_list;
for(; ei != ei_end; ++ei) {
if( is_edge_valid(*ei, g) ) {
ep_list.push_back( g[*ei] );
};
};
std::sort(ep_list.begin(), ep_list.end());
BOOST_CHECK_EQUAL( ep_list[0], 1003 );
BOOST_CHECK_EQUAL( ep_list[1], 1004 );
BOOST_CHECK_EQUAL( ep_list[2], 1005 );
BOOST_CHECK_EQUAL( ep_list[3], 3011 );
};
};
void App::mouseClick(int x, int y)
{
if (x < SCREEN_WIDTH)
{
x /= cellSize;
y /= cellSize;
if (tryb == dodaj)
{
if (tableMap[x][y].color != 0x78AB46)
{
tableMap[x][y].color = 0x78AB46;
//tableMap[(x/cellSize)+1][(y/cellSize)].color = 0x78AB46;
//tableMap[(x/cellSize)+1][(y/cellSize)+1].color = 0x78AB46;
//tableMap[(x/cellSize)][(y/cellSize)+1].color = 0x78AB46;
// dodanie wierzcho³ka
MapNode *node = map.nodeTab[x][y];
MapVertex v = add_vertex(*node, map.mapNodeGraph);
map.XYToGraphNodeMap[coords(x, y)] = v;
//EDGES
//up
if (map.XYToGraphNodeMap.find(coords(x, y - 1)) != map.XYToGraphNodeMap.end()) {
add_edge(v, map.XYToGraphNodeMap[coords(x, y - 1)], 1, map.mapNodeGraph);
add_edge(map.XYToGraphNodeMap[coords(x, y - 1)], v, 1, map.mapNodeGraph);
}
//down
if (map.XYToGraphNodeMap.find(coords(x, y + 1)) != map.XYToGraphNodeMap.end()) {
add_edge(v, map.XYToGraphNodeMap[coords(x, y + 1)], 1, map.mapNodeGraph);
add_edge(map.XYToGraphNodeMap[coords(x, y + 1)], v, 1, map.mapNodeGraph);
}
//left
if (map.XYToGraphNodeMap.find(coords(x + 1, y)) != map.XYToGraphNodeMap.end()) {
add_edge(v, map.XYToGraphNodeMap[coords(x + 1, y)], 1, map.mapNodeGraph);
add_edge(map.XYToGraphNodeMap[coords(x + 1, y)], v, 1, map.mapNodeGraph);
}
//right
if (map.XYToGraphNodeMap.find(coords(x -1, y)) != map.XYToGraphNodeMap.end()) {
add_edge(v, map.XYToGraphNodeMap[coords(x - 1, y)], 1, map.mapNodeGraph);
add_edge(map.XYToGraphNodeMap[coords(x - 1, y)], v, 1, map.mapNodeGraph);
}
}
}
else
{
if (tableMap[x][y].color != 0x000000)
{
tableMap[x][y].color = 0x000000;
//tableMap[(x/cellSize)+1][(y/cellSize)+1].color = 0x000000;
//tableMap[(x/cellSize)+1][(y/cellSize)].color = 0x000000;
//tableMap[(x/cellSize)][(y/cellSize)+1].color = 0x000000;
clear_vertex(map.XYToGraphNodeMap[coords(x, y)], map.mapNodeGraph);
remove_vertex(map.XYToGraphNodeMap[coords(x, y)], map.mapNodeGraph);
map.XYToGraphNodeMap.erase(coords(x, y));
map.refreshMapping(map.XYToGraphNodeMap, map.mapNodeGraph);
}
}
//seekerBot.Path = seekerBot.pathfindingComponent.updatePath(map.mapNodeGraph, seekerBot.Path, Pathfinder::manhattanDistanceHeuristic);
seekerBot.Path = map.findPath(map.mapNodeGraph, map.XYToGraphNodeMap[coords(0, 0)], map.XYToGraphNodeMap[coords(10, 10)], Map::manhattanDistanceHeuristic);
//map.pathToCoords(seekerBot.Path, map.mapNodeGraph);
}
}
int main() {
enum Options {INSERE_VERTEX = 1, REMOVE_VERTEX = 2, INSERE_ARESTA = 3, REMOVE_ARESTA = 4,
CALCULA_DISTANCIA = 5, GRAFO_CONEXO = 6, GRAFO_CONSISTENTE = 7};
char answer, origem[TAM_MAX], destino[TAM_MAX];
char input_name[TAM_MAX], output_name[TAM_MAX];
int option, type;
float peso;
FILE *input = NULL, *output = NULL;
TpGrafo grafo;
TpVertex vertex1;
printf("Digite o nome do arquivo de entrada:\n");
scanf("%[^\n]", input_name);
getchar();
input = fopen(input_name, "r");
printf("Digite o nome do arquivo de saida:\n");
scanf("%[^\n]", output_name);
getchar();
output = fopen(output_name, "w");
assert(input != NULL && output != NULL);
le_grafo(input, &grafo);
printf("\nPrograma para realizar operacoes sobre um grafo.\n\n");
printf("Digite a operacao que deseja realizar:\n");
printf("[1] Insere vertice.\n");
printf("[2] Remove vertice.\n");
printf("[3] Insere aresta.\n");
printf("[4] Remove aresta.\n");
printf("[5] Calcula distancia.\n");
printf("[6] Verifica se o grafo e conexo.\n");
printf("[7] Verifica se o grafo e consistente.\n");
printf("[8] Sai da aplicacao.\n");
scanf("%d", &option);
getchar();
while(option < 1 || option > 8) {
printf("Valor invalido. Tente novamente.\n");
printf("[1] Insere vertice.\n");
printf("[2] Remove vertice.\n");
printf("[3] Insere aresta.\n");
printf("[4] Remove aresta.\n");
printf("[5] Calcula distancia.\n");
printf("[6] Verifica se o grafo e conexo.\n");
printf("[7] Verifica se o grafo e consistente.\n");
printf("[8] Sai da aplicacao.\n");
scanf("%d", &option);
getchar();
}
while(option != 8) {
switch (option) {
case INSERE_VERTEX:
printf("Digite o nome do vertice que sera inserido:\n");
fgets(vertex1.nome, TAM_MAX, stdin);
vertex1.id = grafo.numero_vertices;
printf("O vertice e origem [s/n]?\n");
scanf("%c", &answer);
while(answer != 's' && answer != 'n') {
printf("Resposta invalida. Tente novamente.\n");
printf("O vertice e origem [s/n]?\n");
scanf("%c", &answer);
}
answer == 's'? type = ORIGEM: type = NAO_ORIGEM;
insere_vertex(&grafo, vertex1, type);
break;
case REMOVE_VERTEX:
printf("Deseja proceder com a operacao [s/n]? O grafo pode se tornar inconsistente.\n");
while(answer != 's' && answer != 'n') {
printf("Resposta invalida. Tente novamente.\n");
printf("Deseja proceder com a operacao [s/n]? O grafo pode se tornar inconsistente.\n");
scanf("%c", &answer);
}
if(answer == 'n') {
break;
}
printf("Digite o nome do vertice que sera retirado:\n");
fgets(vertex1.nome, TAM_MAX, stdin);
remove_vertex(&grafo, &vertex1, vertex1.nome);
break;
case INSERE_ARESTA:
printf("Digite o nome da origem da aresta que sera criada:\n");
fgets(origem, TAM_MAX, stdin);
printf("Digite o nome do destino da aresta que sera criada:\n");
fgets(destino, TAM_MAX, stdin);
printf("Digite o peso entre os vertices:n");
scanf("%f", &peso);
insere_aresta(&grafo, origem, destino, peso);
break;
case REMOVE_ARESTA:
printf("Digite o nome da origem da aresta que sera retirada:\n");
fgets(origem, TAM_MAX, stdin);
printf("Digite o nome do destino da aresta que sera retirada:\n");
fgets(destino, TAM_MAX, stdin);
remove_aresta(&grafo, origem, destino);
break;
case CALCULA_DISTANCIA:
printf("Digite o nome da origem para o calculo da distancia:\n");
fgets(origem, TAM_MAX, stdin);
printf("Digite o nome do destino para o calculo da distancia:\n");
fgets(destino, TAM_MAX, stdin);
calculaDistancia(&grafo, origem, destino);
break;
case GRAFO_CONEXO:
grafoConexo(&grafo) == EXIT_SUCCESS? printf("O grafo e conexo.\n"): printf("O grafo nao e conexo.\n");
break;
case GRAFO_CONSISTENTE:
grafoConsistente(&grafo) == EXIT_SUCCESS? printf("O grafo e consistente.\n"): printf("O grafo nao e consistente.\n");
break;
default:
printf("ERRO!\n");
}
printf("Digite a operacao que deseja realizar:\n");
printf("[1] Insere vertice.\n");
printf("[2] Remove vertice.\n");
printf("[3] Insere aresta.\n");
printf("[4] Remove aresta.\n");
printf("[5] Calcula distancia.\n");
printf("[6] Verifica se o grafo e conexo.\n");
printf("[7] Verifica se o grafo e consistente.\n");
printf("[8] Sai da aplicacao.\n");
scanf("%d", &option);
getchar();
while(option < 1 || option > 8) {
printf("Valor invalido. Tente novamente.\n");
printf("[1] Insere vertice.\n");
printf("[2] Remove vertice.\n");
printf("[3] Insere aresta.\n");
printf("[4] Remove aresta.\n");
printf("[5] Calcula distancia.\n");
printf("[6] Verifica se o grafo e conexo.\n");
printf("[7] Verifica se o grafo e consistente.\n");
printf("[8] Sai da aplicacao.\n");
scanf("%d", &option);
getchar();
}
}
escreve_grafo(output, &grafo);
destroi_grafo(&grafo);
printf("Fim da execucao da aplicacao.\n");
printf("Pressione a tecla 'enter' para encerrar.\n");
getchar();
return 0;
}
void remove_vertex(NFAVertex v, NGHolder &h) {
remove_vertex(v, h.g);
assert(!h.isValidNumVertices || h.numVertices > 0);
h.numVertices--;
}
// WARNING: not a standard function
void del_neuron(vertex_desc_t& vertex) {
clear_vertex(vertex, this->_g);
remove_vertex(vertex, this->_g);
}
