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;
}
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;
}
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;
}
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;
}
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;
}
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);
}
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);
}
}
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);
}
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;
}
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;
}
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 */
}
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;
}
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;
}
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);
}
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);
}
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;
}
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;
}
void testITERATION()
{
list_t *l = list_new();
for (int i = 0; i < 3; ++i)
{
int *x = malloc(sizeof(int));
*x = i;
list_add(l, x);
}
int count = 0;
iter_t *it;
for (it = iter(l); !iter_done(it); iter_next(it))
{
count++;
}
iter_free(it);
CU_ASSERT_EQUAL(count, list_len(l));
list_foreach(l, free);
list_free(l);
}
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;
}
/*-------------------------------------------------------------------------
* Function: main
*
* Modifications:
* 2/2010; Vailin Choi
* Get the size of user block
*
*-------------------------------------------------------------------------
*/
int
main(int argc, const char *argv[])
{
iter_t iter;
const char *fname = NULL;
hid_t fid = -1;
hid_t fcpl;
struct handler_t *hand = NULL;
H5F_info_t finfo;
int i;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Disable error reporting */
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
/* Initialize h5tools lib */
h5tools_init();
if((hand = parse_command_line(argc, argv))==NULL) {
goto done;
}
fname = argv[opt_ind];
printf("Filename: %s\n", fname);
HDmemset(&iter, 0, sizeof(iter));
fid = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT);
if(fid < 0) {
error_msg("unable to open file \"%s\"\n", fname);
h5tools_setstatus(EXIT_FAILURE);
goto done;
} /* end if */
/* Initialize iter structure */
iter.fid = fid;
if(H5Fget_filesize(fid, &iter.filesize) < 0)
warn_msg("Unable to retrieve file size\n");
HDassert(iter.filesize != 0);
/* Get storge info for file-level structures */
if(H5Fget_info(fid, &finfo) < 0)
warn_msg("Unable to retrieve file info\n");
else {
iter.super_ext_size = finfo.super_ext_size;
iter.SM_hdr_storage_size = finfo.sohm.hdr_size;
iter.SM_index_storage_size = finfo.sohm.msgs_info.index_size;
iter.SM_heap_storage_size = finfo.sohm.msgs_info.heap_size;
} /* end else */
if((fcpl = H5Fget_create_plist(fid)) < 0)
warn_msg("Unable to retrieve file creation property\n");
if(H5Pget_userblock(fcpl, &iter.ublk_size) < 0)
warn_msg("Unable to retrieve userblock size\n");
/* Walk the objects or all file */
if(display_object) {
unsigned u;
u = 0;
while(hand[u].obj) {
if (h5trav_visit(fid, hand[u].obj, TRUE, TRUE, obj_stats, lnk_stats, &iter) < 0)
warn_msg("Unable to traverse object \"%s\"\n", hand[u].obj);
else
print_statistics(hand[u].obj, &iter);
u++;
} /* end while */
} /* end if */
else {
if (h5trav_visit(fid, "/", TRUE, TRUE, obj_stats, lnk_stats, &iter) < 0)
warn_msg("Unable to traverse objects/links in file \"%s\"\n", fname);
else
print_statistics("/", &iter);
} /* end else */
done:
if(hand) {
for (i = 0; i < argc; i++)
if(hand[i].obj) {
free(hand[i].obj);
hand[i].obj=NULL;
}
free(hand);
hand = NULL;
/* Free iter structure */
iter_free(&iter);
if(fid >= 0 && H5Fclose(fid) < 0) {
error_msg("unable to close file \"%s\"\n", fname);
h5tools_setstatus(EXIT_FAILURE);
}
}
leave(h5tools_getstatus());
}
int
check_cg_pc (int n,
int it_max, double it_eps,
int verbose, double tiny)
{
if (verbose != 0)
{
fprintf (stdout,
"==================================================\n"
"check_cg_pc(n=%d): start\n", n);
}
int check = 0;
double max = 0.0;
double *a = (double *)malloc (sizeof (double) * n * n);
double *b = (double *)malloc (sizeof (double) * n);
double *x = (double *)malloc (sizeof (double) * n);
double *x_ = (double *)malloc (sizeof (double) * n);
double *lu = (double *)malloc (sizeof (double) * n * n);
CHECK_MALLOC (a, "check_cg_pc");
CHECK_MALLOC (b, "check_cg_pc");
CHECK_MALLOC (x, "check_cg_pc");
CHECK_MALLOC (x_, "check_cg_pc");
CHECK_MALLOC (lu, "check_cg_pc");
// symmetric matrix
int i, j;
for (i = 0; i < n; i ++)
{
a[i * n + i] = (double)(i+1);
for (j = i+1; j < n; j ++)
{
a[i * n + j] = 1.0/(double)(i+j);
a[j * n + i] = 1.0/(double)(i+j);
}
}
srand48(0);
for (i = 0; i < n; i ++)
{
b[i] = drand48();
}
struct iter *it
= iter_init ("cg", it_max, 0, it_eps, // solver param
n, NULL, 0, // guess
0, NULL); // debug info
CHECK_MALLOC (it, "check_cg_pc");
char label[80];
// cg_
for (i = 0; i < n; i ++)
{
x[i] = 0.0;
}
double t0 = ptime_ms_d ();
cg_ (n, b, x,
local_atimes, (void *)a,
it);
double t1 = ptime_ms_d ();
if (verbose != 0)
{
fprintf (stdout, "cg_ "
"iter = %d, res = %e, CPU time = %f\n",
it->niter, sqrt(it->res2), t1 - t0);
}
// cg_pc with inv_diag()
for (i = 0; i < n; i ++)
{
x_[i] = 0.0;
}
t0 = ptime_ms_d ();
cg_pc (n, b, x_,
local_atimes, (void *)a,
inv_diag, (void *)a,
it);
t1 = ptime_ms_d ();
if (verbose != 0)
{
fprintf (stdout, "cg_pc(diag) "
"iter = %d, res = %e, CPU time = %f\n",
it->niter, sqrt(it->res2), t1 - t0);
}
for (i = 0; i < n; i ++)
{
sprintf (label, "x[%d]", i);
check += compare_max (x[i], x_[i], label, verbose, tiny, &max);
}
// cg_pc with inv_ILU()
for (i = 0; i < n; i ++)
{
x_[i] = 0.0;
}
LU_Gauss (n, a, lu);
t0 = ptime_ms_d ();
cg_pc (n, b, x_,
local_atimes, (void *)a,
inv_ILU, (void *)lu,
it);
t1 = ptime_ms_d ();
if (verbose != 0)
{
fprintf (stdout, "cg_pc(LU) "
"iter = %d, res = %e, CPU time = %f\n",
it->niter, sqrt(it->res2), t1 - t0);
}
for (i = 0; i < n; i ++)
{
sprintf (label, "x[%d]", i);
check += compare_max (x[i], x_[i], label, verbose, tiny, &max);
}
iter_free (it);
free (a);
free (b);
free (x);
free (x_);
free (lu);
if (verbose != 0)
{
fprintf (stdout, " max error = %e vs tiny = %e\n", max, tiny);
if (check == 0) fprintf (stdout, " => PASSED\n\n");
else fprintf (stdout, " => FAILED\n\n");
}
return (check);
}
