예제 #1
0
distance_label_t *graph_find_path(graph_t *g,char *time, void *from, void *to)
{
    assert(graph_has_node(g, from) && graph_has_node(g, to));
    list_t *visited = list_new();
    list_t *distanceLabels = list_new();
    iter_t *it;
    for (it = iter(g->nodes); !iter_done(it); iter_next(it))
        {
            distance_label_t *dl = calloc(1, sizeof(distance_label_t));
            dl->dist = -1;
            dl->label = iter_get(it);
            dl->path = NULL;
	    dl->path_edges = NULL;
	    dl->arrival_time = time;
            list_add(distanceLabels, dl);
        }
    iter_free(it);
    get_distance_label(distanceLabels, from, g->comp)->path = list_new();
    get_distance_label(distanceLabels, from, g->comp)->path_edges = list_new();
    dijkstra(g, from, to, visited, distanceLabels);
    distance_label_t *best = get_distance_label(distanceLabels, to, g->comp);
    assert(best);
    free_distancelabels(g->comp,distanceLabels,best);
    list_free(visited);

    graph_print_trip(g,time,from,best);
    
    return best;
}
예제 #2
0
void *get_min_distance_node(list_t *distanceLabels, comparator_t comp,
                            list_t *visited)
{
    assert(distanceLabels);

    int minDist = -1;
    void *minLabel = NULL;
    iter_t *it;
    for (it = iter(distanceLabels); !iter_done(it); iter_next(it))
        {
            distance_label_t *itdl = iter_get(it);
            if (itdl->dist == -1) // inte varit där
                {
                    continue;
                }
            if (list_has(visited, comp, itdl->label)) // finns redan i visited, abort
                {
                    continue;
                }
            if (minDist == -1 || itdl->dist < minDist)// om inte ändrats en enda gång eller nya distansen 'r mindre än förra minsta distans.
                {
                    minDist = itdl->dist;
                    minLabel = itdl->label;
                }
        }
    iter_free(it);
    return minLabel;
}
예제 #3
0
파일: iternsym.c 프로젝트: Rainwin2015/C
VEC	*iter_spgmres(SPMAT *A, SPMAT *B, VEC *b, double tol,
                  VEC *x, int k, int limit, int *steps)
#endif
{
    ITER *ip;

    ip = iter_get(0,0);
    ip->Ax = (Fun_Ax) sp_mv_mlt;
    ip->A_par = (void *) A;
    if (B) {
        ip->Bx = (Fun_Ax) sp_mv_mlt;
        ip->B_par = (void *) B;
    }
    else {
        ip->Bx = (Fun_Ax) NULL;
        ip->B_par = NULL;
    }
    ip->k = k;
    ip->limit = limit;
    ip->info = (Fun_info) NULL;
    ip->b = b;
    ip->eps = tol;
    ip->x = x;
    iter_gmres(ip);
    x = ip->x;
    if (steps) *steps = ip->steps;
    ip->shared_x = ip->shared_b = TRUE;
    iter_free(ip);   /* release only ITER structure */
    return x;
}
예제 #4
0
void graph_foreach_edge(graph_t *g, void_fun3_t f)
{
    iter_t *it;
    for (it = iter(g->edges); !iter_done(it); iter_next(it))
        {
            edge_t  *e = iter_get(it);
            f(e->from, e->to, e->label);
        }
    iter_free(it);
}
예제 #5
0
void dijkstra(graph_t *g, void *current, void *to, list_t *visited,
              list_t *distanceLabels)
{
    assert(g);
    assert(current);
    assert(to);
    assert(visited);
    assert(distanceLabels);
    while (true)
      {
	if (!list_has(visited, g->comp, current))
	  {
	    list_t *unvisited_neighs = unvisited_neighbors(g, current, visited);
	    distance_label_t *here =
	      get_distance_label(distanceLabels, current, g->comp);
	    
	    iter_t *it;
	    for (it = iter(unvisited_neighs); !iter_done(it); iter_next(it))
	      {
		void *neigh = iter_get(it);
		
		int line = list_quickest_line(g->nodes, current, neigh, here->arrival_time);
		//	printf("med linje:%i i dijkstra\n",line);
		      
		assert(line);
		edge_t *edge = graph_get_edge(g,line,current,here->path_edges);
		assert(edge);
		list_t *tentativePath = list_clone(here->path);
		list_t *tentativeEdgePath = list_clone(here->path_edges);
		list_add(tentativePath, neigh);
		list_add(tentativeEdgePath, edge);

		char *bussDepart = list_next_dep_time(g->nodes,current,neigh,line,here->arrival_time);
		assert(bussDepart);
		int total_distance = graph_add_penalty(edge, here->arrival_time, bussDepart);// egen rad
		
		char *new_arrival_time = add_duration(bussDepart, network_get_dur(edge->label)); //egen rad
		//free(bussDepart);	        				  
		update_distance(distanceLabels, neigh, g->comp, here->dist + total_distance,
				tentativePath, tentativeEdgePath, new_arrival_time); //la till new_arrival_tim. ost-bågen borde gå in här!!
	      }
	    iter_free(it);
	    list_free(unvisited_neighs);
	  }
	list_add(visited, current);
	
	if (g->comp(current, to))
	  {
	    return;
	  }
	
	current = get_min_distance_node(distanceLabels, g->comp, visited);
	assert(current);
      }
}
예제 #6
0
void graph_print_trip (graph_t *g, char *time,char *from, distance_label_t *dl)
{

  printf("\nTrip start:%s\n",time);

  
  char *tmp_t = time;
  iter_t *it;
  char*tmp_fr;
  char*tmp_to;

  /*iter_t *it2;
  for (it2 = iter(dl->path_edges); !iter_done(it2); iter_next(it2))
    {
      void *tmp_v = iter_get(it2);
      edge_t *tmp_e = tmp_v;
      puts(tmp_e->from);
      puts(tmp_e->to);
    }
  iter_free(it2);
  */ 
  for (it = iter(dl->path_edges); !iter_done(it); iter_next(it))
    {
      void *tmp_v = iter_get(it);
      edge_t *tmp_e = tmp_v;
      int line = network_get_line(tmp_e->label);

      // printf("\n\n\n%s\n",tmp_e->to);

      if(!tmp_fr) tmp_fr = from;

      // printf("linje:%i !%s!",line,tmp_fr);
      
      if(g->comp(tmp_fr,tmp_e->from))tmp_to = tmp_e->to;
      
      else{tmp_to = tmp_e->from;}

      //printf(" - !%s! - tid:%s\n",tmp_to,tmp_t);
      
      char *buss_dep = list_next_dep_time(g->nodes,tmp_fr,tmp_to,line,tmp_t);
      char *arr_time = add_duration(buss_dep, network_get_dur(tmp_e->label));
      int durr = network_get_dur(tmp_e->label);
      printf("@ %s: #%i %s --(%i)--> %s\n",buss_dep ,line ,tmp_fr ,durr ,tmp_to );
      tmp_fr = tmp_to;
      tmp_t = arr_time;
      assert(tmp_fr);
      assert(tmp_t);
	}
    puts("_____________________________________________________________");
    printf("this trip took from:%s to:%s and %i minutes to complete.\n",time,dl->arrival_time,dl->dist+1);
    iter_free(it);
}
예제 #7
0
파일: iternsym.c 프로젝트: Rainwin2015/C
MAT	*iter_sparnoldi(SPMAT *A, VEC *x0, int m, Real *h_rem, MAT *Q, MAT *H)
#endif
{
    ITER *ip;

    ip = iter_get(0,0);
    ip->Ax = (Fun_Ax) sp_mv_mlt;
    ip->A_par = (void *) A;
    ip->x = x0;
    ip->k = m;
    iter_arnoldi_iref(ip,h_rem,Q,H);
    ip->shared_x = ip->shared_b = TRUE;
    iter_free(ip);   /* release only ITER structure */
    return H;
}
예제 #8
0
파일: itersym.c 프로젝트: Rainwin2015/C
void    iter_splanczos(SPMAT *A, int m, VEC *x0, 
		       VEC *a, VEC *b, Real *beta2, MAT *Q)
#endif
{	
   ITER *ip;
   
   ip = iter_get(0,0);
   ip->shared_x = ip->shared_b = TRUE;
   ip->Ax = (Fun_Ax) sp_mv_mlt;
   ip->A_par = (void *) A;
   ip->x = x0;
   ip->k = m;
   iter_lanczos(ip,a,b,beta2,Q);	
   iter_free(ip);   /* release only ITER structure */
}
예제 #9
0
bool graph_is_edge_visited(list_t *visited_edges, comparator_t comp, edge_t *edge)
{
  iter_t *it;
  for (it = iter(visited_edges); !iter_done(it); iter_next(it))
    {
      edge_t *temp_edge = iter_get(it);
      if (comp(temp_edge, edge))
	{
	  iter_free(it);
	  return true;
	}
    }
  iter_free(it);
  return false;
}
예제 #10
0
void start_find_select(void*) {
    RandomChoice choice(/*rand_,*/ size());

    for(iter_rewind(); !iter_end(); iter_inc(), ++choice) {
        if(choice.choose()) {
            iter_get(find_s_, find_p_, find_o_);
            iter_free();

            timer_->set_timer<App, &App::start_find>(1000, this, 0);
            return;
        }
        ++choice;
    }

    debug_->debug("!fnd %d %d", (int)choice.elements, (int)choice.current);
}
예제 #11
0
파일: itersym.c 프로젝트: Rainwin2015/C
VEC    *iter_splanczos2(SPMAT *A, int m, VEC *x0, VEC *evals, VEC *err_est)
#endif
{	
   ITER *ip;
   VEC *a;
   
   ip = iter_get(0,0);
   ip->Ax = (Fun_Ax) sp_mv_mlt;
   ip->A_par = (void *) A;
   ip->x = x0;
   ip->k = m;
   a = iter_lanczos2(ip,evals,err_est);	
   ip->shared_x = ip->shared_b = TRUE;
   iter_free(ip);   /* release only ITER structure */
   return a;
}
예제 #12
0
bool graph_has_edge(graph_t *g, void *from, void *to, void **label)
{
    iter_t *it;
    for (it = iter(g->edges); !iter_done(it); iter_next(it))
        {
            edge_t  *e = iter_get(it);
	    if ((g->comp(from, e->from) && g->comp(to, e->to)) || (g->comp(from, e->to) && g->comp(to, e->from)))
	      {
		*label = e->label;
		iter_free(it);
		return true;
	      }
        }
    *label = NULL;
    iter_free(it);
    return false;
}
예제 #13
0
void testITER_GET()
{
    list_t *l = list_new();
    for (int i = 0; i < 3; ++i)
        {
            int *x = malloc(sizeof(int));
            *x = i;
            list_add(l, x);
        }

    iter_t *it = iter(l);
    int *first = iter_get(it);
    CU_ASSERT_EQUAL(*first, 0);
    iter_free(it);

    list_foreach(l, free);
    list_free(l);
}
예제 #14
0
list_t *unvisited_neighbors(graph_t *g, void *current, list_t *visited)
{
    list_t *neighs = graph_find_neighbors(g, current);

    list_t *unvisited_neighs = list_new();
    iter_t *nit;
    for (nit = iter(neighs); !iter_done(nit); iter_next(nit))
        {
            void *neigh = iter_get(nit);
            if (!list_has(visited, g->comp, neigh))
                {
                    list_add(unvisited_neighs, neigh);
                }
        }
    iter_free(nit);
    list_free(neighs);
    return unvisited_neighs;
}
예제 #15
0
list_t *graph_find_neighbors(graph_t *g, void *node)
{
    list_t *ret = list_new();
    iter_t *eit;
    for (eit = iter(g->edges); !iter_done(eit); iter_next(eit))
        {
            edge_t  *e = iter_get(eit);
            if (g->comp(e->from, node))
                {
                    list_add(ret, e->to);
                }
	    else if (g->comp(e->to, node))
	      {
		list_add(ret, e->from);
	      }
        }
    iter_free(eit);
    return ret;
}
예제 #16
0
distance_label_t *get_distance_label(list_t *distanceLabels, void *lbl,
                                     comparator_t comp)
{
    assert(distanceLabels);
    assert(lbl);
    assert(comp);
    iter_t *dliter;
    for (dliter = iter(distanceLabels); !iter_done(dliter); iter_next(dliter))
        {
            distance_label_t *dl = iter_get(dliter);
            if (comp(dl->label, lbl))
                {
		  //printf("Did find distance label for %s: path is: %p\n", lbl, dl->path);

                    iter_free(dliter);
                    return dl;
                }
        }
    //       printf("did not find distance label for %s\n", lbl);
    iter_free(dliter);
    return NULL;
}
예제 #17
0
void *graph_get_edge(graph_t *g,int line, void *node_el, list_t *visited_edges)// Egen Funktion
{
  iter_t *it;
  for (it = iter(g->edges); !iter_done(it); iter_next(it))
    {
      edge_t  *e = iter_get(it);
      if(
	 ( (g->comp(node_el,e->from) || g->comp(node_el,e->to) )
	 &&
	   (!graph_is_edge_visited(visited_edges, g->comp, e))
	 &&
	 (network_comp_line(e->label,line))
	   ))
	{
	  void *temp_edge = e;
	  iter_free(it);
	  assert(temp_edge);
	  return temp_edge;
	}
    }
	  iter_free(it);
  return NULL;
}
예제 #18
0
파일: itersym.c 프로젝트: Rainwin2015/C
VEC  *iter_spcg(SPMAT *A, SPMAT *LLT, VEC *b, double eps, VEC *x,
		int limit, int *steps)
#endif
{	
   ITER *ip;
   
   ip = iter_get(0,0);
   ip->Ax = (Fun_Ax) sp_mv_mlt;
   ip->A_par = (void *)A;
   ip->Bx = (Fun_Ax) spCHsolve;
   ip->B_par = (void *)LLT;
   ip->info = (Fun_info) NULL;
   ip->b = b;
   ip->eps = eps;
   ip->limit = limit;
   ip->x = x;
   iter_cg(ip);
   x = ip->x;
   if (steps) *steps = ip->steps;
   ip->shared_x = ip->shared_b = TRUE;
   iter_free(ip);   /* release only ITER structure */
   return x;		
}
예제 #19
0
파일: main.c 프로젝트: jrubill/2101
int main()
{
    list* list1 = list_create();
    list* list2 = list_create();
    list* list3 = list_create();

    int data[] = {1, 2, 3, 4, 5};
    char* strings[] = {"a", "b", "c", "d", "e", "f"};

    int data_size = 5;
    for(int i = 0; i < data_size; i++) {
        list_append(list1, &data[i]);
    }

    int string_size = 6;
    for(int i = 0; i < string_size; i++) {
        list_append(list2, strings[i]);
    }

    iterator* iter1 = iter_create(list1);

    printf("Data List Print Test....\n");

    printf("Data List: ");
    while(!iter_at_end(iter1)) {
        node* n = iter_get(iter1);
        int* val = n->data;
        printf("%d ", *val);
        iter_advance(iter1);
    }
    printf("\n");

    printf("Removing 2nd Element From Data\n");
    iter1 = iter_create(list1);
    iter_advance(iter1);
    iter_remove(iter1);

    printf("Data List: ");
    while(!iter_at_end(iter1)) {
        node* n = iter_get(iter1);
        int* val = n->data;
        printf("%d ", *val);
        iter_advance(iter1);
    }
    printf("\n");

    printf("\n");
    printf("String List Print Test.......\n");

    iterator* iter2 = iter_create(list2);

    printf("Strings List: ");
    while(!iter_at_end(iter2)) {
        node* n = iter_get(iter2);
        char* val = n->data;
        printf("%s ", val);
        iter_advance(iter2);
    }
    printf("\n");

    list_remove_last(list2);

    iter2 = iter_create(list2);
    printf("Removing Last Element from String List\n");
    printf("Strings List: ");
    while(!iter_at_end(iter2)) {
        node* n = iter_get(iter2);
        char* val = n->data;
        printf("%s ", val);
        iter_advance(iter2);
    }
    printf("\n");

    printf("\n");
    printf("Done Printing\n");

    return 0;
}