static void fh_dump(struct fibheap *a, Edge **res)
{
int i;
int n = a->fh_n;
for (i=n-1; i>=0; i--)
res[i] = (Edge *) fh_extractmin(a);
}
int main(void)
{
struct fibheap *a;
void *arr[10];
int i;
a = fh_makekeyheap();
for (i=1 ; i < 8 ; i++)
{
arr[i]= fh_insertkey(a,0,(void *)i);
printf("adding: 0 %d \n",i);
}
printf(" \n");
fh_replacekey(a, arr[1],-2);
fh_replacekey(a, arr[4],-3);
fh_replacekey(a, arr[7],-5);
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %d\n\n", (int)fh_extractmin(a));
fh_replacekey(a, arr[3],-2);
fh_replacekey(a, arr[6],-1);
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %d\n\n", (int)fh_extractmin(a));
fh_replacekey(a, arr[1],-9);
fh_replacekey(a, arr[5],-3);
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %d\n\n", (int)fh_extractmin(a));
fh_replacekey(a, arr[2],-4);
fh_replacekey(a, arr[5],-5);
fh_replacekey(a, arr[6],-3);
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %d\n\n", (int)fh_extractmin(a));
fh_replacekey(a, arr[2],-6);
fh_replacekey(a, arr[6],-6);
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %d\n\n", (int)fh_extractmin(a));
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %d\n\n", (int)fh_extractmin(a));
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %d\n\n", (int)fh_extractmin(a));
fh_deleteheap(a);
return 0;
}
static void admitNewWiggleIteratorsIntoPlay(Multiplexer * multi) {
while (fh_notempty(multi->starts) && fh_min(multi->starts) == multi->start) {
int index = fh_extractmin(multi->starts);
WiggleIterator * wi = multi->iters[index];
fh_insert(multi->finishes, wi->finish, index);
multi->inplay[index] = true;
multi->values[index] = wi->value;
multi->inplay_count++;
}
}
static void popClosingWiggleIterators(Multiplexer * multi) {
while (fh_notempty(multi->finishes) && fh_min(multi->finishes) == multi->finish) {
int index = fh_extractmin(multi->finishes);
WiggleIterator * wi = multi->iters[index];
pop(wi);
multi->inplay[index] = false;
multi->inplay_count--;
multi->values[index] = wi->default_value;
if (!wi->done && !strcmp(wi->chrom, multi->chrom))
fh_insert(multi->starts, wi->start, index);
}
}
/* Maintain a fixed size heap */
static void fh_insert_fixed(struct fibheap *a, Edge *i, Edge **cur_min)
{
if (a->fh_n < HEAP_SIZE)
{
fh_insert(a, (void *)i);
}
else
{
if (edge_cmpr(cur_min, i) < 0)
{
/* Remove least value and renew */
fh_extractmin(a);
fh_insert(a, (void *)i);
/* Keep a memory of the current min */
*cur_min = (Edge *)fh_min(a);
}
}
}
// Removes the node with the shortest key, then returns it.
struct node_st *removeNextNodeFromHeap(FibHeap * heap)
{
return (struct node_st *) fh_extractmin(heap);
}
// Removes the node with the shortest key, then returns it.
unsigned int removeNextNodeFromHeap ( FibHeap * heap )
{
return ( unsigned int ) fh_extractmin ( heap );
}
void perform_front_propagation_2d(T_callback_intert_node callback_insert_node)
{
// create the Fibonacci heap
struct fibheap* open_heap = fh_makeheap();
fh_setcmp(open_heap, compare_points);
double h = 1.0/n;
// initialize points
for( int i=0; i<n; ++i )
for( int j=0; j<p; ++j )
{
D_(i,j) = GW_INFINITE;
S_(i,j) = kFar;
Q_(i,j) = -1;
}
// record all the points
heap_pool = new fibheap_el*[n*p];
memset( heap_pool, NULL, n*p*sizeof(fibheap_el*) );
// inialize open list
point_list existing_points;
for( int k=0; k<nb_start_points; ++k )
{
int i = (int) start_points_(0,k);
int j = (int) start_points_(1,k);
if( D_( i,j )==0 )
ERROR_MSG("start_points should not contain duplicates.");
point* pt = new point( i,j );
existing_points.push_back( pt ); // for deleting at the end
heap_pool_(i,j) = fh_insert( open_heap, pt ); // add to heap
if( values==NULL )
D_( i,j ) = 0;
else
D_( i,j ) = values[k];
S_( i,j ) = kOpen;
Q_(i,j) = k;
}
// perform the front propagation
int num_iter = 0;
bool stop_iteration = GW_False;
while( !fh_isempty(open_heap) && num_iter<nb_iter_max && !stop_iteration )
{
num_iter++;
// current point
point& cur_point = * ((point*) fh_extractmin( open_heap ));
int i = cur_point.i;
int j = cur_point.j;
heap_pool_(i,j) = NULL;
S_(i,j) = kDead;
stop_iteration = end_points_reached(i,j);
/*
char msg[200];
sprintf(msg, "Cool %f", Q_(i,j) );
WARN_MSG( msg );
*/
CHECK_HEAP;
// recurse on each neighbor
int nei_i[4] = {i+1,i,i-1,i};
int nei_j[4] = {j,j+1,j,j-1};
for( int k=0; k<4; ++k )
{
int ii = nei_i[k];
int jj = nei_j[k];
bool bInsert = true;
if( callback_insert_node!=NULL )
bInsert = callback_insert_node(i,j,ii,jj);
// check that the contraint distance map is ok
if( ii>=0 && jj>=0 && ii<n && jj<p && bInsert )
{
double P = h/W_(ii,jj);
// compute its neighboring values
double a1 = GW_INFINITE;
int k1 = -1;
if( ii<n-1 )
{
bool bParticipate = true;
if( callback_insert_node!=NULL )
bParticipate = callback_insert_node(ii,jj,ii+1,jj);
if( bParticipate )
{
a1 = D_(ii+1,jj);
k1 = Q_(ii+1,jj);
}
}
if( ii>0 )
{
bool bParticipate = true;
if( callback_insert_node!=NULL )
bParticipate = callback_insert_node(ii,jj,ii-1,jj);
if( bParticipate )
{
if( D_(ii-1,jj)<a1 )
k1 = Q_(ii-1,jj);
a1 = GW_MIN( a1, D_(ii-1,jj) );
}
}
double a2 = GW_INFINITE;
int k2 = -1;
if( jj<p-1 )
{
bool bParticipate = true;
if( callback_insert_node!=NULL )
bParticipate = callback_insert_node(ii,jj,ii,jj+1);
if( bParticipate )
{
a2 = D_(ii,jj+1);
k2 = Q_(ii,jj+1);
}
}
if( jj>0 )
{
bool bParticipate = true;
if( callback_insert_node!=NULL )
bParticipate = callback_insert_node(ii,jj,ii,jj-1);
if( bParticipate )
{
if( D_(ii,jj-1)<a2 )
k2 = Q_(ii,jj-1);
a2 = GW_MIN( a2, D_(ii,jj-1) );
}
}
if( a1>a2 ) // swap so that a1<a2
{
double tmp = a1; a1 = a2; a2 = tmp;
int tmpi = k1; k1 = k2; k2 = tmpi;
}
// update its distance
// now the equation is (a-a1)^2+(a-a2)^2 = P, with a >= a2 >= a1.
double A1 = 0;
if( P*P > (a2-a1)*(a2-a1) )
{
double delta = 2*P*P-(a2-a1)*(a2-a1);
A1 = (a1+a2+sqrt(delta))/2.0;
}
else
A1 = a1 + P;
if( ((int) S_(ii,jj)) == kDead )
{
// check if action has change. Should not happen for FM
// if( A1<D_(ii,jj) )
// WARN_MSG("The update is not monotone");
#if 1
if( A1<D_(ii,jj) ) // should not happen for FM
{
D_(ii,jj) = A1;
// update the value of the closest starting point
//if( GW_ABS(a1-A1)<GW_ABS(a2-A1) && k1>=0 )
Q_(ii,jj) = k1;
//else
// Q_(ii,jj) = k2;
//Q_(ii,jj) = Q_(i,j);
}
#endif
}
else if( ((int) S_(ii,jj)) == kOpen )
{
// check if action has change.
if( A1<D_(ii,jj) )
{
D_(ii,jj) = A1;
// update the value of the closest starting point
//if( GW_ABS(a1-A1)<GW_ABS(a2-A1) && k1>=0 )
Q_(ii,jj) = k1;
//else
// Q_(ii,jj) = k2;
//Q_(ii,jj) = Q_(i,j);
// Modify the value in the heap
fibheap_el* cur_el = heap_pool_(ii,jj);
if( cur_el!=NULL )
fh_replacedata( open_heap, cur_el, cur_el->fhe_data ); // use same data for update
else
ERROR_MSG("Error in heap pool allocation.");
}
}
else if( ((int) S_(ii,jj)) == kFar )
{
if( D_(ii,jj)!=GW_INFINITE )
ERROR_MSG("Distance must be initialized to Inf");
if( L==NULL || A1<=L_(ii,jj) )
{
S_(ii,jj) = kOpen;
// distance must have change.
D_(ii,jj) = A1;
// update the value of the closest starting point
//if( GW_ABS(a1-A1)<GW_ABS(a2-A1) && k1>=0 )
Q_(ii,jj) = k1;
//else
// Q_(ii,jj) = k2;
//Q_(ii,jj) = Q_(i,j);
// add to open list
point* pt = new point(ii,jj);
existing_points.push_back( pt );
heap_pool_(ii,jj) = fh_insert( open_heap, pt ); // add to heap
}
}
else
ERROR_MSG("Unkwnown state.");
} // end switch
} // end for
} // end while
// char msg[200];
// sprintf(msg, "Cool %f", Q_(100,100) );
// WARN_MSG( msg );
// free heap
fh_deleteheap(open_heap);
// free point pool
for( point_list::iterator it = existing_points.begin(); it!=existing_points.end(); ++it )
GW_DELETE( *it );
// free fibheap pool
GW_DELETEARRAY(heap_pool);
}
int
main(void)
{
#if !TESTCASE
struct fibheap_el *w;
#else
int e, j, k;
#endif
struct fibheap *a;
int i, x;
a = fh_makeheap();
fh_setcmp(a, cmp);
srandom(time(NULL));
#if TESTCASE
#if VERBOSE
printf("inserting: ");
#endif
e = 0;
for (i = 0; i < COUNT; i++) {
#if VERBOSE
if (i)
printf(", ");
#endif
fh_insert(a, (void *)(x = random()/10));
#if VERBOSE
printf("%d", x);
#endif
if (i - e > DIF) {
k = random() % MAXEXT;
for (j = 0; j < k; j++, e++)
printf("throwing: %d\n", (int)fh_extractmin(a));
}
}
#if VERBOSE
printf("\nremaining: %d\n", COUNT - e);
printf("extracting: ");
#endif
for (i = 0; i < COUNT - e; i++) {
#if VERBOSE
if (i)
printf(", ");
printf("%d", (int)fh_extractmin(a));
#else
fh_extractmin(a);
#endif
}
#if VERBOSE
printf("\n");
#endif
if ((int)fh_extractmin(a) == 0)
printf("heap empty!\n");
else {
printf("heap not empty! ERROR!\n");
exit(1);
}
#else
w = fh_insert(a, (void *)6);
printf("adding: %d\n", 6);
fh_insert(a, (void *)9);
printf("adding: %d\n", 9);
fh_insert(a, (void *)1);
printf("adding: %d\n", 1);
for(i = 0; i < 5; i++) {
x = random()/10000;
printf("adding: %d\n", x);
fh_insert(a, (void *)x);
}
fh_insert(a, (void *)4);
printf("adding: %d\n", 4);
fh_insert(a, (void *)8);
printf("adding: %d\n", 8);
printf("first: %d\n", (int)fh_extractmin(a));
printf("deleting: %d\n", (int)fh_delete(a, w));
printf("first: %d\n", (int)fh_extractmin(a));
printf("first: %d\n", (int)fh_extractmin(a));
printf("first: %d\n", (int)fh_extractmin(a));
printf("first: %d\n", (int)fh_extractmin(a));
printf("first: %d\n", (int)fh_extractmin(a));
for(i = 0; i < 5; i++) {
x = random()/10000;
printf("adding: %d\n", x);
fh_insert(a, (void *)x);
}
printf("first: %d\n", (int)fh_extractmin(a));
printf("first: %d\n", (int)fh_extractmin(a));
printf("first: %d\n", (int)fh_extractmin(a));
printf("first: %d\n", (int)fh_extractmin(a));
printf("first: %d\n", (int)fh_extractmin(a));
#endif
fh_deleteheap(a);
return 0;
}
int
main(void) {
struct fibheap *a;
void *arr[10];
int i;
a = fh_makekeyheap();
for (i=1 ; i < 10 ; i++)
{
arr[i]= fh_insertkey(a,0,int_to_pointer(i));
printf("adding: 0 %d \n",i);
}
printf(" \n");
fh_replacekey(a, arr[1],-38);
fh_replacekey(a, arr[7],-34);
printf("wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %lld\n\n", pointer_to_ll(fh_extractmin(a)));
fh_replacekey(a, arr[2],-55);
fh_replacekey(a, arr[5],-56);
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %lld\n\n", pointer_to_ll(fh_extractmin(a)));
fh_replacekey(a, arr[4],-1);
fh_replacekey(a, arr[2],-102);
fh_replacekey(a, arr[6],-1);
fh_replacekey(a, arr[9],-1);
fh_replacekey(a, arr[8],-4);
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %lld\n\n", pointer_to_ll(fh_extractmin(a)));
fh_replacekey(a, arr[3],-74);
fh_replacekey(a, arr[8],-55);
fh_replacekey(a, arr[4],-2);
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %lld\n\n", pointer_to_ll(fh_extractmin(a)));
fh_replacekey(a, arr[4],-3);
fh_replacekey(a, arr[6],-2);
fh_replacekey(a, arr[7],-99);
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %lld\n\n", pointer_to_ll(fh_extractmin(a)));
fh_replacekey(a, arr[6],-3);
fh_replacekey(a, arr[4],-4);
fh_replacekey(a, arr[8],-94);
fh_replacekey(a, arr[9],-2);
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %lld\n\n", pointer_to_ll(fh_extractmin(a)));
fh_replacekey(a, arr[6],-4);
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %lld\n\n", pointer_to_ll(fh_extractmin(a)));
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %lld\n\n", pointer_to_ll(fh_extractmin(a)));
/*fh_replacekey(a, arr[9],-3);*/
printf("Wert(minkey) %d\n",fh_minkey(a));
printf("Knoten: %lld\n\n", pointer_to_ll(fh_extractmin(a)));
/*fh_replacekey(a, arr[9],-49);*/
fh_deleteheap(a);
return 0;
}
int main(void)
{
struct fibheap *a;
void *arr[10];
int i;
a = fh_makekeyheap();
for (i=1 ; i < 10 ; i++)
{
arr[i]= fh_insertkey(a,0,(void *)i);
printf("adding: 0 %d \n",i);
}
printf(" \n");
fh_replacekey(a, arr[1],-1);
fh_replacekey(a, arr[6],-1);
fh_replacekey(a, arr[4],-1);
fh_replacekey(a, arr[2],-1);
fh_replacekey(a, arr[8],-1);
printf("value(minkey) %d\n",fh_minkey(a));
printf("id: %d\n\n", (int)fh_extractmin(a));
fh_replacekey(a, arr[7],-33);
/* -> node 7 becomes root node, but is still pointed to by node 6 */
fh_replacekey(a, arr[4],-36);
fh_replacekey(a, arr[3],-1);
fh_replacekey(a, arr[9],-81);
printf("value(minkey) %d\n",fh_minkey(a));
printf("id: %d\n\n", (int)fh_extractmin(a));
fh_replacekey(a, arr[6],-68);
fh_replacekey(a, arr[2],-69);
printf("value(minkey) %d\n",fh_minkey(a));
printf("id: %d\n\n", (int)fh_extractmin(a));
fh_replacekey(a, arr[1],-52);
fh_replacekey(a, arr[3],-2);
fh_replacekey(a, arr[4],-120);
fh_replacekey(a, arr[5],-48);
printf("value(minkey) %d\n",fh_minkey(a));
printf("id: %d\n\n", (int)fh_extractmin(a));
fh_replacekey(a, arr[3],-3);
fh_replacekey(a, arr[5],-63);
printf("value(minkey) %d\n",fh_minkey(a));
printf("id: %d\n\n", (int)fh_extractmin(a));
fh_replacekey(a, arr[5],-110);
fh_replacekey(a, arr[7],-115);
printf("value(minkey) %d\n",fh_minkey(a));
printf("id: %d\n\n", (int)fh_extractmin(a));
fh_replacekey(a, arr[5],-188);
printf("value(minkey) %d\n",fh_minkey(a));
printf("id: %d\n\n", (int)fh_extractmin(a));
fh_replacekey(a, arr[3],-4);
printf("value(minkey) %d\n",fh_minkey(a));
printf("id: %d\n\n", (int)fh_extractmin(a));
printf("value(minkey) %d\n",fh_minkey(a));
printf("id: %d\n\n", (int)fh_extractmin(a));
fh_deleteheap(a);
return 0;
}
void perform_dijkstra_propagation(T_callback_insert_node callback_insert_node = NULL)
{
// create the Fibonacci heap
struct fibheap* open_heap = fh_makeheap();
fh_setcmp(open_heap, compare_points);
// initialize points
for( int i=0; i<n; ++i )
{
D[i] = GW_INFINITE;
S[i] = kFar;
}
// record all the points
heap_pool = new fibheap_el*[n];
memset( heap_pool, NULL, n*sizeof(fibheap_el*) );
// inialize open list
for( int k=0; k<nb_start_points; ++k )
{
int i = (int) start_points[k];
if( D[i]==0 )
mexErrMsgTxt("start_points should not contain duplicates.");
heap_pool[i] = fh_insert( open_heap, (void*) i ); // add to heap
D[i] = 0;
S[i] = kOpen;
}
// perform the front propagation
int num_iter = 0;
bool stop_iteration = GW_False;
while( !fh_isempty(open_heap) && num_iter<nb_iter_max && !stop_iteration )
{
num_iter++;
// current point
int i = (int) fh_extractmin( open_heap );
heap_pool[i] = NULL;
S[i] = kDead;
stop_iteration = end_points_reached(i);
CHECK_HEAP;
// index in irs[jcs[k]]...irs[jcs[k+1]-1] are the node connected to node k
// values are W[jcs[k]]...W[jcs[k]-1]
// recurse on each neighbor of i
for( int k=jcs[i]; k<jcs[i+1]; ++k )
{
int ii = irs[k];
double P = W[k]; // graph weight
bool bInsert = true;
if( callback_insert_node!=NULL )
bInsert = callback_insert_node(ii,ii);
if( ii>=0 && ii<n && bInsert )
{
// compute its neighboring values
double a1 = D[i] + P;
if( ((int) S[ii]) == kDead )
{
// check if action has change. Should not happen for Dijkstra
if( a1<D[ii] )
mexWarnMsgTxt("The update is not monotone");
#if 1
if( a1<D[ii] ) // should not happen for FM
D[ii] = a1;
#endif
}
else if( ((int) S[ii]) == kOpen )
{
// check if action has change.
if( a1<D[ii] )
{
D[ii] = a1;
// Modify the value in the heap
fibheap_el* cur_el = heap_pool[ii];
if( cur_el!=NULL )
fh_replacedata( open_heap, cur_el, cur_el->fhe_data ); // use same data for update
else
mexErrMsgTxt("Error in heap pool allocation.");
}
}
else if( ((int) S[ii]) == kFar )
{
if( D[ii]!=GW_INFINITE )
mexErrMsgTxt("Distance must be initialized to Inf");
S[ii] = kOpen;
// distance must have change.
D[ii] = a1;
// add to open list
heap_pool[ii] = fh_insert( open_heap, (void*) ii ); // add to heap
}
else
mexErrMsgTxt("Unkwnown state.");
} // end switch
} // end for
} // end while
// free heap
fh_deleteheap(open_heap);
// free fibheap pool
GW_DELETEARRAY(heap_pool);
}
