Exemplo n.º 1
0
int main(void) {


	//Seed the Random number generator
	srand((unsigned)time(0)); 
	int i,j ; 
	struct point pt; 
	float distances1[500] = {0}; 
	float distances2[500] = {0};
	//Two Random Walks

	runTrial(500, distances1, 'U'); 
	graph_new(LINE, distances1, 500, "legend=1st Walk, xlabel=Step Number, ylabel=Distance from the origin"); 
	
	runTrial(500, distances2, 'U'); 
	graph_new(LINE, distances2, 500, "legend=2nd Walk, xlabel=Step Number, ylabel=Distance from the origin, title=2 Random Walks");
	graph_show(); 
	

	//Simulate 300 Random Walks with 500 steps each
	simulate(300,500); 
	simulateEW(300,500);
	simulateBiased(300,500);
	graph_show();



	
	return 0; 

}
Exemplo n.º 2
0
graph_s *border_graph(msw_s *ms)
{
	graph_s *n = graph_new();
	int *r = ms->revealed;
	int *graph_perm = malloc(ms->g->nodes * sizeof(int));
	int j = 0;
	for(int i = 0; i < ms->g->nodes;i++){
		if (r[i] == 0){
			graph_add_node(n,ms->g->node_list[i]);
			graph_perm[i]=j;
			j++;
		}
	}
	int neighb;
	for(int i = 0; i < ms->g->nodes;i++){
		for(int j = 0; j < ms->g->neighb_count[i]; j++){
			neighb = ms->g->neighb_list[i][j]; 
			if (r[i] > 0 && r[neighb] == 0){
				graph_add_arc(n,graph_perm[neighb],i);
			}
		}
	}
	free(graph_perm);
	return n;
}
Exemplo n.º 3
0
void graph_test() {
	graphData* d = graphData_new( 10 );
	graph* g = graph_new( g, 0, 0, 320, 240, 1.f, 1.f );

	mem_free( g );
	mem_free( d );
}
Exemplo n.º 4
0
game_t *game_new(int graph_type, int g_p1, int g_p2, mpq_t p_c)
{
    game_t *game = (game_t *)g_malloc(sizeof(game_t));
    
    game->graph = graph_new(graph_type, g_p1, g_p2);
    
    mpq_init(game->s);
    mpq_set_si(game->s, S_MIN, 1);
    mpq_init(game->t);
    mpq_set_si(game->t, T_MIN, 1);
    mpq_init(game->p_c);
    mpq_set(game->p_c, p_c);
    
    game->initial_config = (int *)g_malloc(sizeof(int) * game->graph->n);
    game->current_config = (int *)g_malloc(sizeof(int) * game->graph->n);
    game->next_config = (int *)g_malloc(sizeof(int) * game->graph->n);
    
    int i;
    for(i = 0; i < game->graph->n; ++i)
    {
        game->initial_config[i] = 0;
        game->current_config[i] = 0;
        game->next_config[i] = 0;
    }
    return game;
}
Exemplo n.º 5
0
/**
 * @brief construct test graph #1
 *
 *        +------->t/2----->------>x/4
 *        |        |^     /        |^
 *        |        ||    /         ||
 *       s/1------ ||---/-->----+  ||
 *        |        ||  /         \ ||
 *        |        V| /           \V|
 *        +------->y/3------------>z/5
 * 
 */
static GRAPH_T* graph_1_get (void)
{
   GRAPH_T* g;

   g = graph_new (GRAPH_DIRECTED_T, GRAPH_INT_T);
   fprintf (stderr, "* inserting e1(1,2)\n");
   graph_add_i (g, "e1", 1, NULL, 2, NULL, 10, DS_TRUE);
   fprintf (stderr, "* inserting e2(1,3)\n");   
   graph_add_i (g, "e2", 1, NULL, 3, NULL, 5, DS_TRUE);
   fprintf (stderr, "* inserting e3(2,4)\n");      
   graph_add_i (g, "e3", 2, NULL, 4, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e4(2,3)\n");         
   graph_add_i (g, "e4", 2, NULL, 3, NULL, 2, DS_TRUE);
   fprintf (stderr, "* inserting e5(3,2)\n");            
   graph_add_i (g, "e5", 3, NULL, 2, NULL, 3, DS_TRUE);
   fprintf (stderr, "* inserting e6(3,4)\n");            
   graph_add_i (g, "e6", 3, NULL, 4, NULL, 9, DS_TRUE);
   fprintf (stderr, "* inserting e7(3,5)\n");            
   graph_add_i (g, "e7", 3, NULL, 5, NULL, 2, DS_TRUE);
   fprintf (stderr, "* inserting e8(4,5)\n");            
   graph_add_i (g, "e8", 4, NULL, 5, NULL, 4, DS_TRUE);
   fprintf (stderr, "* inserting e9(5,4)\n");               
   graph_add_i (g, "e9", 5, NULL, 4, NULL, 6, DS_TRUE);
   fprintf (stderr, "* inserting e10(5,1)\n");               
   graph_add_i (g, "e10", 5, NULL, 1, NULL, 7, DS_TRUE);

   return g;   
}
Exemplo n.º 6
0
void simulateEW(int numSims, int numSteps) {

        int sim;
        float lastPointX[numSims];
        float lastPointY[numSims];
        float average[numSteps];
        memset(average,0,numSteps * sizeof(float));
        int step;


        for (sim = 0; sim < numSims; sim++) {

                struct point final_xy;
                final_xy = runTrial(numSteps, average, 'L');

                //Add to the average array

                lastPointX[sim] = final_xy.x;
                lastPointY[sim] = final_xy.y;


        }

        for (step=0; step < numSteps; step++)
                average[step] = average[step] / (float) numSims;
        graph_new(LINE, average, numSteps, "legend=EW Walk,title=Repititive Simulations,xlabel=Step Number,ylabel=Distance(averaged)");
        graph_xy(SCATTER,lastPointX,lastPointY, numSims, "legend=End Points(EW Walk), title=Last Point in each Trial, xlabel=x-coordinate, ylabel=y-coordinate");
	printf("Final Distance EW:%f\n", average[numSteps - 1] );

}
Exemplo n.º 7
0
/**
 * @brief construct test graph #4
 *
 */
static GRAPH_T* graph_4_get (void)
{
   GRAPH_T* g;
   
   g = graph_new (GRAPH_DIRECTED_T, GRAPH_INT_T);
   /* insert edge start */
   fprintf (stderr, "* inserting e1(1,2)\n");
   graph_add_i (g, "e1", 1, NULL, 2, NULL, 1, DS_TRUE);

   fprintf (stderr, "* inserting e2(2,3)\n");
   graph_add_i (g, "e2", 2, NULL, 3, NULL, 1, DS_TRUE);

   fprintf (stderr, "* inserting e3(3,4)\n");
   graph_add_i (g, "e3", 3, NULL, 4, NULL, 1, DS_TRUE);

   fprintf (stderr, "* inserting e4(4,5)\n");
   graph_add_i (g, "e4", 4, NULL, 5, NULL, 1, DS_TRUE);
   
   fprintf (stderr, "* inserting e5(5,1)\n");
   graph_add_i (g, "e5", 5, NULL, 1, NULL, 1, DS_TRUE);

   fprintf (stderr, "* inserting e6(3,5)\n");
   graph_add_i (g, "e6", 3, NULL, 5, NULL, 2, DS_TRUE);

   fprintf (stderr, "* inserting e7(3,1)\n");
   graph_add_i (g, "e7", 3, NULL, 1, NULL, 1, DS_TRUE);
   
   /* insert edge end */
   return g;   
}
Exemplo n.º 8
0
int main(int argc, char ** argv) {
	if(argc == 2){ 
		Graph * g = graph_new(4, 4, 0);
		Path * d;
		Mst * m;
		int i, src;
		if(graph_file_insert(g, argv[1])){
			printf("Graph loaded from file\n");
			m = graph_mst_kruskal(g);
			printf("\nMST calulated using Kruskal's algorithm: \n");
			for(i =0; i < m->e; i++)
				printf("%d --%d-- %d\n",  m->edge[i].src, m->edge[i].weight, m->edge[i].dest);
			printf("\n");
			src = 2;
			d = graph_dijkstra(g, src);	
			printf("\nShortest distance from: %d to\n", src);
			for(i =0; i < (g->V); i++)
				if(d->distance[i] != INT_MAX && d->distance[i] != INT_MIN)
					printf("%d: %d\n", i, d->distance[i]);
		}
		else
			printf("Specified parameters of graph do not match that from given file\n");
	}
	else printf("Usage : ./example <filename.txt>\n");
	return 0;
}
Exemplo n.º 9
0
graph_t* MatrixToGraph(double *adjac_mtx_ptr, int iGraphOrder)
{
    int i, j, idx;
    graph_t *ptrGraph;
    
    /* Initialize the graph that we want to return. */
    ptrGraph = graph_new(iGraphOrder);
    
    /* Loop through the adjacency matrix to create the graph.  We assume
     * that the adjacency matrix is symmetric and only consider the super-
     * diagonals of the matrix. */
    /* The indexing here seems flipped, but it's due to the translation
     * between MATLAB and C element ordering. */
    for (j = 0; j < iGraphOrder; j++)
        for (i = j + 1; i < iGraphOrder; i++)
        {
            /* The matrix adj_mtx is stored as a 1-dimensional array, so
             * we must convert the coordinate (i, j) to the corresponding
             * 1-dimensional index. */
            idx = j + i * iGraphOrder;
            
            /* If the entry of the adjacency matrix is a 1, we want to add
             * an edge to our graph. */
            if(adjac_mtx_ptr[idx] == 1)
                GRAPH_ADD_EDGE(ptrGraph, i, j);
        }
    
    /* Just to be cautios, ensure that we've produced a valid graph. */
    ASSERT(graph_test(ptrGraph, NULL));
    
    return ptrGraph;
}
Exemplo n.º 10
0
graph_t *KCoreGraph::subgraph(IntStack *vset) {
	
	assert(!vset->empty());
	
	graph_t *g = graph_new(maxsize());
	IntStack *nb;
	
	int val,preval,val2,preval2;
	
	val = vset->head();
	preval = val-1;
	while (val != preval) {
		nb = neighbourhoods.at(val);
		if (!nb->empty()) {
			val2 = nb->head();
			preval2 = val2-1;
			while (val2 != preval2) {
				if ((val > val2) && vset->contain(val2)) GRAPH_ADD_EDGE(g,val,val2);
				preval2 = val2;
				val2 = nb->next(preval2);
			}
		}
		preval = val;
		val = vset->next(preval);
	}
	
	return g;
};
Exemplo n.º 11
0
/**
 * This routine creates an NxM graph and returns it to the user.
 *
 * @param [in] N the number of rows in the matrix
 * @param [in] M the numner of columns in the matrix
 * @return A valid GRAPH_T* if successful, NULL otherwise
 */
GRAPH_T* matrix_create
    (
    const unsigned long N,
    const unsigned long M
    )
    {
    unsigned long vid;
    //unsigned long tmp;
#define label "edge"    
    GRAPH_T* matrix;
    
    if (NULL == (matrix = graph_new (GRAPH_UNDIRECTED_T, GRAPH_INT_T)))
        return NULL;
    
    for (vid = 1; vid <= N*M; vid++) /**< generate integer vertex indices */
    {
       /**< creating the left-right edges */
       if (vid%M != 1)               
          graph_add_i (matrix, label, vid, NULL, vid-1, NULL, 1, DS_TRUE);
       /**< creating the right edge */
       //if (vid%M != 0)
       // graph_add_i (matrix, label, vid, NULL, vid+1, NULL, 1, DS_TRUE);
        /**< creating the up edge */
       //if (vid > M)
       // graph_add_i (matrix, label, vid, NULL, vid-M, NULL, 1, DS_TRUE);
       /**< creating the up-down edge */
       if (vid <= (M*(N-1)))
          graph_add_i (matrix, label, vid, NULL, vid+M, NULL, 1, DS_TRUE);        
    }
    return matrix;
    }
Exemplo n.º 12
0
/**
 * @brief Testing construction of a directed graph.
 *
 *       1-->2  ->3-->>4 
 *       |   | /  | /  |
 *       |   |/   |/   |
 *       v   v    v    v
 *       5   6--->7--->8
 *           |
 *           |
 *           V
 *           9
 */
void tc_directed_main (void)
{
   GRAPH_T* g;
   void* vtx;
   EDGE_T* e;
   char* ctx = NULL;
   unsigned long no = 0;
   
   fprintf (stderr, "graph test #1\n");
   g = graph_new (GRAPH_DIRECTED_T, GRAPH_INT_T);
   fprintf (stderr, "* inserting e1(1,2)\n");
   graph_add_i (g, "e1", 1, NULL, 2, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e2(1,5)\n");   
   graph_add_i (g, "e2", 1, NULL, 5, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e3(2,6)\n");      
   graph_add_i (g, "e3", 2, NULL, 6, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e4(6,7)\n");         
   graph_add_i (g, "e4", 6, NULL, 7, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e5(3,7)\n");            
   graph_add_i (g, "e5", 3, NULL, 7, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e6(3,4)\n");            
   graph_add_i (g, "e6", 3, NULL, 4, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e7(7,8)\n");            
   graph_add_i (g, "e7", 7, NULL, 8, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e8(4,8)\n");            
   graph_add_i (g, "e8", 4, NULL, 8, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e9(6,3)\n");               
   graph_add_i (g, "e9", 6, NULL, 3, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e10(7,4)\n");               
   graph_add_i (g, "e10", 7, NULL, 4, NULL, 1, DS_TRUE);
   if (GPH_ERR_EDGE_EXISTS == graph_add_i (g, "e11", 4, NULL, 7, NULL, 1, DS_TRUE))
      fprintf (stderr, "edge exists\n");
   fprintf (stderr, "* inserting e10(7,4)\n");               
   graph_add_i (g, "e12", 6, NULL, 9, NULL, 1, DS_TRUE);
   
   fprintf (stderr, "Done inserting edges\n");
   tc_graph_edge_print (g);
   tc_graph_vertex_print (g);

   vertex_print_3 (g);
   //return (0);
   printf ("DDDD\n");
   vtx = graph_vertex_find_i (g, 6);
   printf ("DDDD = %lu\n", ((VTX_D_T*)vtx)->no);
   while (no < ((VTX_D_T*)vtx)->no)
   {
      e = graph_vertex_next_edge_get (g, vtx, &ctx);
      DEBUG_EDGE_PRINT_I(g,e);
      no++;
   }

   fprintf (stderr, "Starting BFS\n");
   bfs (g, 6, bfs_directed_func);

   fprintf (stderr, "Starting DFS\n");
   dfs (g, 2, bfs_directed_func);   
}
Exemplo n.º 13
0
int
cook_web(string_list_ty *wlp)
{
    int             retval;
    graph_ty        *gp;
    graph_build_status_ty gb_status;

    /*
     * set interrupts to catch
     *
     * Note that tee(1) [see listing.c] must ignore them
     * for the generated messages to appear in the log file.
     */
    trace(("cook(wlp = %08lX)\n{\n", wlp));
    desist_enable();

    /*
     * Build the dependency graph.
     */
    retval = 0;
    gp = graph_new();
    gb_status = graph_build_list(gp, wlp, graph_build_preference_error, 0);
    if (option_test(OPTION_REASON))
        graph_print_statistics(gp);
    switch (gb_status)
    {
    case graph_build_status_error:
        retval = 1;
        break;

    case graph_build_status_backtrack:
        /* assert(0); */
        retval = 1;
        break;

    case graph_build_status_success:
        break;
    }

    /*
     * Walk the dependency graph.
     */
    if (retval == 0)
        graph_walk_web(gp);

    /*
     * Release any resources held by the graph.
     */
    graph_delete(gp);

    /*
     * Return the result to the caller.
     */
    trace(("return %d;\n", retval));
    trace(("}\n"));
    return retval;
}
Exemplo n.º 14
0
int main(int argc,char *argv[]) {


	int num_houses,num_schools;
	int u,v,weight;
	

	if(scanf("%d %d",&num_houses,&num_schools) != 2) {
		printError();
	}

	
	Graph *g = graph_new(num_houses+num_schools);
	g->num_houses = num_houses;
	g->num_schools = num_schools;
	g->number_of_vertices = num_houses+num_schools;

	while(scanf("%d %d %d",&u,&v,&weight) == 3) {

		if(u < 0 || v < 0 
		|| u>=(g->number_of_vertices) || v>=(g->number_of_vertices) || weight < 0){
			printError();
		}
		else {
			// the 0 represents unvisted 
			graph_add_edge(g,u,v,0);
			graph_add_edge(g,v,u,0);
			//adding weights 
			g->vertices[u].edges[g->vertices[u].num_edges-1].weight = weight;
			g->vertices[v].edges[g->vertices[v].num_edges-1].weight = weight;
		}

	}
	// checking if graph is connected 
	if(!graph_check_connected(g,0)) {
		fprintf(stderr, "Graph is not connected\n");
		exit(EXIT_FAILURE);
	}

	
	Universe *Uni = create_all_sets(g->num_schools,g->num_houses);

	//running Dijkstra on each school vertex
	for(int i=num_houses;i<g->number_of_vertices;i++) {

		Dijkstra(g,i,Uni,min_func);

	}

	setCover(Uni,g->num_houses);



	free_graph(g);
	
	return 0;
}
Exemplo n.º 15
0
static void
draw_chart (CutPDFReport *report, CutRunContext *run_context)
{
    GogGraph *graph;

    graph = graph_new("Test result report", run_context);
    cairo_translate(report->context, 100, 50);
    gog_graph_render_to_cairo(graph, report->context, 400, 300);
    g_object_unref(graph);
}
Exemplo n.º 16
0
graph_t *mkGraphABCDE()
{
    graph_t *g = graph_new(streq);
    graph_add_node(g, strdup("A"));
    graph_add_node(g, strdup("B"));
    graph_add_node(g, strdup("C"));
    graph_add_node(g, strdup("D"));
    graph_add_node(g, strdup("E"));
    return g;
}
Exemplo n.º 17
0
int 
main(int argc, char** argv)
{

     int ncpu = (int)sysconf(_SC_NPROCESSORS_ONLN);
#ifdef DEBUG
     printf ("Configured for %d CPU\n",ncpu);
#endif     


     Graph *graph = graph_new (1024);
     if (argc > 0){
	  read_case_file (graph, argv [1]);
     }

     int num_threads = ncpu + 1;

     nodes = graph_get_nodes (graph);
     num_nodes = graph_get_num_nodes (graph);

     int i;
     for (i = 0;i<num_nodes;i++){
	  qsort (&nodes[i]->edges[0], nodes[i]->num_edges, sizeof (GraphEdge*), cmp_edges_by_weight);
     }


     int elem_per_thread = (num_nodes / num_threads) + 1;

     int **arr = malloc (sizeof (int*) * num_threads); 
     for (i = 0; i < num_threads; i++){
	  arr[i] = malloc (sizeof (int) * (elem_per_thread + 2));
	  arr[i][0] = i;
	  arr[i][1] = 0;
     }

     for (i = 0; i < num_nodes; i++){
	  int y = i % num_threads;
	  int x = arr[y][1] + 2;
	  arr[y][x] = i;
	  arr[y][1] = arr[y][1] + 1;
     }


     pthread_t tids[num_threads];
     for (i = 0; i < num_threads;i++){
	  pthread_create (&tids[i], NULL, &pthread_main, arr[i]);
     }
     for (i = 0; i < num_threads; i++){
	  pthread_join (tids[i], NULL);
     }

     if (best_found_path)
	  print_solution (best_found_path);
     return 0;
}
Exemplo n.º 18
0
void bfs_main (void)
{
   GRAPH_T* g;
   void* vtx;
   EDGE_T* e;
   char* ctx = NULL;
   unsigned long no = 0;
   
   fprintf (stderr, "[START] breadth-first search test \n");
   g = graph_new (GRAPH_UNDIRECTED_T, GRAPH_INT_T);
   fprintf (stderr, "* inserting e1(1,2)\n");
   graph_add_i (g, "e1", 1, NULL, 2, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e2(1,5)\n");   
   graph_add_i (g, "e2", 1, NULL, 5, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e3(2,6)\n");      
   graph_add_i (g, "e3", 2, NULL, 6, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e4(6,7)\n");         
   graph_add_i (g, "e4", 6, NULL, 7, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e5(3,7)\n");            
   graph_add_i (g, "e5", 3, NULL, 7, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e6(3,4)\n");            
   graph_add_i (g, "e6", 3, NULL, 4, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e7(7,8)\n");            
   graph_add_i (g, "e7", 7, NULL, 8, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e8(4,8)\n");            
   graph_add_i (g, "e8", 4, NULL, 8, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e9(6,3)\n");               
   graph_add_i (g, "e9", 6, NULL, 3, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e10(7,4)\n");               
   graph_add_i (g, "e10", 7, NULL, 4, NULL, 1, DS_TRUE);
   if (GPH_ERR_EDGE_EXISTS == graph_add_i (g, "e10", 4, NULL, 7, NULL, 1, DS_TRUE))
      fprintf (stderr, "edge exists\n");
   fprintf (stderr, "Done inserting edges\n");
   //graph_edge_print (g);
   //graph_vertex_print (g);

   vertex_print_2 (g);

   vtx = graph_vertex_find_i (g, 7);
   while (no < ((VTX_UD_T*)vtx)->no)
   {
      e = graph_vertex_next_edge_get (g, vtx, &ctx);
      DEBUG_EDGE_PRINT_I(g,e);
      no++;
   }

   fprintf (stderr, "Starting BFS\n");
   bfs (g, 2, bfs_vertex_func);

   fprintf (stderr, "Starting DFS\n");
   dfs (g, 2, bfs_vertex_func);

   fprintf (stderr, "[END] breadth-first search test \n");   
}
Exemplo n.º 19
0
int main(void) {
   
    int d = 0;
    int i = 0;
    int x = 0;
    graph my_graph = NULL;


    if (1 == scanf("%d", &d)) {
        my_graph = graph_new(d);
    }
    while (2 == scanf("%d%d", &i, &x)) {
        graph_add_edge(my_graph, i, x);
    }

    /*
    graph my_graph = graph_new(8);

    graph_bi_add_edge(my_graph, 0, 1);
    graph_bi_add_edge(my_graph, 0, 4);
    
    graph_bi_add_edge(my_graph, 1, 0);
    graph_bi_add_edge(my_graph, 1, 5);
    
    graph_bi_add_edge(my_graph, 2, 3);
    graph_bi_add_edge(my_graph, 2, 5);
    graph_bi_add_edge(my_graph, 2, 6);
    
    graph_bi_add_edge(my_graph, 3, 2);
    graph_bi_add_edge(my_graph, 3, 6);
    graph_bi_add_edge(my_graph, 3, 7);
    
    graph_bi_add_edge(my_graph, 4, 0);

    graph_bi_add_edge(my_graph, 5, 1);
    graph_bi_add_edge(my_graph, 5, 2);
    graph_bi_add_edge(my_graph, 5, 6);

    graph_bi_add_edge(my_graph, 6, 2);
    graph_bi_add_edge(my_graph, 6, 3);
    graph_bi_add_edge(my_graph, 6, 5);
    graph_bi_add_edge(my_graph, 6, 7);

    graph_bi_add_edge(my_graph, 7, 3);
    graph_bi_add_edge(my_graph, 7, 6);
    */
    
    graph_dfs(my_graph);
    graph_print(my_graph);
    graph_free(my_graph);
    return EXIT_SUCCESS;
}
Exemplo n.º 20
0
/**
 * @brief construct test graph #2
 *
 */
static GRAPH_T* graph_2_get (void)
{
   GRAPH_T* g;
   
   g = graph_new (GRAPH_DIRECTED_T, GRAPH_INT_T);
   fprintf (stderr, "* inserting e1(1,2)\n");
   graph_add_i (g, "e1", 1, NULL, 2, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e2(1,3)\n");   
   graph_add_i (g, "e2", 1, NULL, 3, NULL, 3, DS_TRUE);
   fprintf (stderr, "* inserting e3(1,11)\n");      
   graph_add_i (g, "e3", 1, NULL, 11, NULL, 1, DS_TRUE);
   //fprintf (stderr, "* inserting e4(2,4)\n");         
   //graph_add_i (g, "e4", 2, NULL, 4, NULL, 10, DS_TRUE);
   fprintf (stderr, "* inserting e5(2,7)\n");            
   graph_add_i (g, "e5", 2, NULL, 7, NULL, 2, DS_TRUE);
   fprintf (stderr, "* inserting e6(3,5)\n");            
   graph_add_i (g, "e6", 3, NULL, 5, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e7(3,4)\n");            
   graph_add_i (g, "e7", 3, NULL, 4, NULL, 4, DS_TRUE);
   //fprintf (stderr, "* inserting e8(4,3)\n");            
   //graph_add_i (g, "e8", 4, NULL, 3, NULL, 4, DS_TRUE);
   fprintf (stderr, "* inserting e9(4,8)\n");               
   graph_add_i (g, "e9", 4, NULL, 8, NULL, 2, DS_TRUE);
   fprintf (stderr, "* inserting e10(4,9)\n");               
   graph_add_i (g, "e10", 4, NULL, 9, NULL, 6, DS_TRUE);

   fprintf (stderr, "* inserting e11(5,6)\n");               
   graph_add_i (g, "e11", 5, NULL, 6, NULL, 2, DS_TRUE);
   fprintf (stderr, "* inserting e12(6,4)\n");               
   graph_add_i (g, "e12", 6, NULL, 4, NULL, 1, DS_TRUE);

   fprintf (stderr, "* inserting e13(6,9)\n");               
   graph_add_i (g, "e13", 6, NULL, 9, NULL, 5, DS_TRUE);
   fprintf (stderr, "* inserting e14(7,3)\n");               
   graph_add_i (g, "e14", 7, NULL, 3, NULL, 1, DS_TRUE);

   fprintf (stderr, "* inserting e15(7,10)\n");               
   graph_add_i (g, "e15", 7, NULL, 10, NULL, 1, DS_TRUE);
   fprintf (stderr, "* inserting e16(8,9)\n");               
   graph_add_i (g, "e16", 8, NULL, 9, NULL, 2, DS_TRUE);

   fprintf (stderr, "* inserting e17(10,4)\n");               
   graph_add_i (g, "e17", 10, NULL, 4, NULL, 2, DS_TRUE);
   fprintf (stderr, "* inserting e18(10,8)\n");               
   graph_add_i (g, "e18", 10, NULL, 8, NULL, 2, DS_TRUE);

   fprintf (stderr, "* inserting e19(11,5)\n");               
   graph_add_i (g, "e19", 11, NULL, 5, NULL, 1, DS_TRUE);

   return g;
}
Exemplo n.º 21
0
int main(int argc, char *argv[]) {
  struct graph *g = graph_new();
  if (g) {
    graph_join(g, 12, 34);
    graph_join(g, 34, 12);
    graph_join(g, 11, 9);
    graph_join(g, 9, 100);
    graph_join(g, 25, 89);
    graph_join(g, 100, 100);
    graph_dump(g);
    graph_destroy(g);
  }

  return 0;
}
Exemplo n.º 22
0
Quark *graph_next(Quark *project)
{
    Quark *f, *g;
    
    if (!project) {
        return NULL;
    }
    
    f = frame_new(project);
    g = graph_new(f);
    if (g && number_of_graphs(project) == 1) {
        Project *pr = project_get_data(project);
        pr->cg = g;
    }
    return g;
}
Exemplo n.º 23
0
// -----------------------------------------------------------------------------
PyObject* graph_create_spanning_tree(PyObject* self, PyObject* pyobject) {
   INIT_SELF_GRAPH();
   Graph* g;
   if(is_NodeObject(pyobject))
      g = so->_graph->create_spanning_tree(((NodeObject*)pyobject)->_node);
   else {
      GraphDataPyObject a(pyobject);
      g = so->_graph->create_spanning_tree(&a);
   }
   if(g == NULL) {
      PyErr_SetString(PyExc_TypeError, "Graph Type does not match");
      return NULL;
   }

   return (PyObject*)graph_new(g);
}
Exemplo n.º 24
0
END_TEST

int main() {

  g = graph_new();

  mu_run_test(test_add_nodes);
  mu_run_test(test_edge);

  graph_toNeato(g, "graph.dot");
  printf("Fichier .dot en sortie : graph.dot\n");
  graph_free(g);

  mu_summary();
  return __tests_failed;
}
Exemplo n.º 25
0
int main(int argc, char **argv) {
	GRAPH *g = graph_new(NODES_MAX);
	int i;
	names = calloc(NODES_MAX, sizeof(char **));

	srand(time(NULL));

	for (i = 0; i < NODES_MAX; i++)
		graph_add_node(g);
	for (i = 0; i < NODES_MAX; i++) {
		graph_add_link(g, i, i / 4, 1, 1);
	}
		

	fprintf(stderr, "Found %i nodes\n", determine_links(g, 0));

	return 0;
}
Exemplo n.º 26
0
int main(void) {

   float data[POINTS];
   int i;
   for (i = 0; i < POINTS; ++i) {

       //Generate a lognormal random variate with underlying normal parameters as
       //mean = 0 and standard deviation = 1
 
       data[i] = lognormal(1.0, 0.5);
       

   }

   graph_init();
   graph_new(HIST, data, POINTS, "xlabel=value,ylabel=prbability,title=Lognormal Distribution"); 
   graph_show();


}
Exemplo n.º 27
0
/* Convert an igraph graph to a Cliquer graph */
static void igraph_to_cliquer(const igraph_t *ig, graph_t **cg) {
    igraph_integer_t vcount, ecount;
    int i;

    if (igraph_is_directed(ig))
      IGRAPH_WARNING("Edge directions are ignored for clique calculations");

    vcount = igraph_vcount(ig);
    ecount = igraph_ecount(ig);

    *cg = graph_new(vcount);

    for (i=0; i < ecount; ++i) {
        long s, t;
        s = IGRAPH_FROM(ig, i);
        t = IGRAPH_TO(ig, i);
        if (s != t)
            GRAPH_ADD_EDGE(*cg, s, t);
    }
}
Exemplo n.º 28
0
static g_graph mv_cnf_to_graph(mv_cnf input)
{
    register unsigned int ix, iy, iz = 0;

    g_graph result = graph_new();

    for (ix = 0; ix < input->clauses->sz; ix++) {
	graph_node_add(result, graph_node_new(ix));
    }

    for (ix = 0; ix < input->clauses->sz; ix++) {
	for (iy = ix + 1; iy < input->clauses->sz; iy++) {
	    if (mv_clause_shares_variables(input->clauses->arr[ix], input->clauses->arr[iy]) > 0) {
		graph_edge_add(result, graph_edge_new(iz++, ix, iy));
	    }
	}
    }

    return result;
}
Exemplo n.º 29
0
int main(int argc, char *argv[]) {
    int v1;
    int v2;
    graph g;
    char option; 
    int size = 0;
    graph_t type = DIRECTED;
    const char *optstring = "s:";

    while((option = getopt(argc, argv, optstring)) != EOF) {
        switch(option) {
            case 's':
                size = atoi(optarg);
                break;
            default:
                printf("input the number of vertices\n");
                return EXIT_FAILURE;
        }
    }

    g = graph_new(size);
    while(2==scanf("%d%d", &v1, &v2)) {
        g = graph_add_edge(g, v1, v2, type);
    }
    /**
    g = graph_add_edge(g, 0, 1, type);
    g = graph_add_edge(g, 0, 4, type);
    g = graph_add_edge(g, 5, 1, type);
    g = graph_add_edge(g, 5, 2, type);
    g = graph_add_edge(g, 5, 6, type);
    g = graph_add_edge(g, 6, 2, type);
    g = graph_add_edge(g, 6, 3, type);
    g = graph_add_edge(g, 6, 7, type);
    g = graph_add_edge(g, 3, 2, type);
    g = graph_add_edge(g, 3, 7, type);
    */
    graph_print(g);
    graph_dfs(g);
    g = graph_free(g);
    return EXIT_SUCCESS;
}
Exemplo n.º 30
0
int main()
{
    int t;
    int s;
    for(s=0;s<10;s++) {
	int width = (lrand48()%8)+1;
	graph_t*g = graph_new(width*width);
	for(t=0;t<width*width;t++) {
	    int x = t%width;
	    int y = t/width;
	    int w = 1;
#define R (lrand48()%32)
	    if(x>0) graph_add_edge(&g->nodes[t], &g->nodes[t-1], R, R);
	    if(x<width-1) graph_add_edge(&g->nodes[t], &g->nodes[t+1], R, R);
	    if(y>0) graph_add_edge(&g->nodes[t], &g->nodes[t-width], R, R);
	    if(y<width-1) graph_add_edge(&g->nodes[t], &g->nodes[t+width], R, R);
	}
	
	int x = graph_maxflow(g, &g->nodes[0], &g->nodes[width*width-1]);
	printf("max flow: %d\n", x);
	graph_delete(g);
    }
}