/**
* This function removes all useless transitions from the given graph. A useless
* transitions is a transition to a state that has no transition.
* Returns 1 the graph becomes empty; 0 otherwise.
*/
static int remove_useless_lexical_transitions(Fst2* fst2,int graph,OptimizedFst2State* optimized_states,
Abstract_allocator prv_alloc) {
int initial=fst2->initial_states[graph];
int last=initial+fst2->number_of_states_per_graphs[graph]-1;
int cleaning_to_do=1;
if (empty_graph(graph,optimized_states,fst2)) {
/* If the graph is already empty, there is nothing to report */
return 0;
}
while (cleaning_to_do) {
cleaning_to_do=0;
for (int i=initial;i<=last;i++) {
OptimizedFst2State s=optimized_states[i];
int removed=remove_useless_transitions(s,optimized_states,fst2,prv_alloc);
if (removed && !cleaning_to_do) {
/* This state may now be useless */
if (is_useless_state(s)) {
/* If this is the case, we will have another round to do on this graph */
cleaning_to_do=1;
}
}
}
}
return empty_graph(graph,optimized_states,fst2);
}
/* generate a connected graph with uniform probability, subject to some
* constraints on the degree of the nodes. */
SEXP ide_cozman_graph(SEXP nodes, SEXP num, SEXP burn_in, SEXP max_in_degree,
SEXP max_out_degree, SEXP max_degree, SEXP connected, SEXP debug) {
SEXP graphlist;
switch(LENGTH(nodes)) {
case 1:
/* there is only one graph with 1 node, and it's empty. */
graphlist = empty_graph(nodes, num);
break;
case 2:
/* Ide-Cozman has no mixing with only 2 nodes, work around with i.i.d.
* sampling.*/
if (isTRUE(connected)) {
graphlist = ic_2nodes(nodes, num, burn_in, max_in_degree,
max_out_degree, max_degree, connected, debug);
break;
}/*THEN*/
default:
graphlist = c_ide_cozman(nodes, num, burn_in, max_in_degree,
max_out_degree, max_degree, connected, debug);
}/*SWITCH*/
return graphlist;
}/*IDE_COZMAN_GRAPH*/
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;
}
struct pg_graph *pg_graph_new(const char *name, struct pg_brick *explore,
struct pg_error **error)
{
struct pg_graph *ret = g_new(struct pg_graph, 1);
ret->name = g_strdup(name);
ret->all = g_hash_table_new_full(g_str_hash, g_str_equal,
NULL, &brick_destroy_cb);
ret->pollable = NULL;
if (explore && pg_graph_explore_ptr(ret, explore, error) < 0) {
empty_graph(ret);
pg_graph_destroy(ret);
return NULL;
}
return ret;
}
/**
* Removes the useless graph calls, i.e. calls to an empty graph or calls
* to a state that has no outgoing transitions.
*/
static int remove_useless_graph_calls(struct opt_graph_call* *l,OptimizedFst2State* optimized_states,Fst2* fst2,
Abstract_allocator prv_alloc) {
int removed=0;
struct opt_graph_call* *tmp=l;
while ((*tmp)!=NULL) {
if (empty_graph((*tmp)->graph_number,optimized_states,fst2)
|| is_useless_state(optimized_states[(*tmp)->transition->state_number])) {
/* We remove the graph call */
removed=1;
struct opt_graph_call* current=(*tmp);
(*tmp)=current->next;
current->next=NULL;
free_opt_graph_call(current,prv_alloc);
} else {
tmp=&((*tmp)->next);
}
}
return removed;
}
