diff -r c645f4a2a6ae -r de9849252e78 src/work/jacint/fib_heap.h
--- a/src/work/jacint/fib_heap.h	Thu Mar 11 19:24:28 2004 +0000
+++ b/src/work/jacint/fib_heap.h	Thu Mar 11 23:31:13 2004 +0000
@@ -21,11 +21,14 @@
  *void push(Item, Prio) : pushes Item to the heap with priority Prio. Item
  *     mustn't be in the heap.
  *
- *Item top() : returns the Item with least Prio
+ *Item top() : returns the Item with least Prio. 
+ *     Must be called only if heap is nonempty.
  *
  *Prio prio() : returns the least Prio
- *  
+ *     Must be called only if heap is nonempty.
+ *
  *Prio get(Item) : returns Prio of Item
+ *     Must be called only if Item is in heap.
  *
  *void pop() : deletes the Item with least Prio
  *
@@ -65,9 +68,9 @@
     
     std::vector<store> container;
     int minimum;
-    bool blank;
     ItemIntMap &iimap;
     Compare comp;
+    int num_items;
 
     enum state_enum {
       IN_HEAP = 0,
@@ -77,26 +80,23 @@
     
   public :
     
-    FibHeap(ItemIntMap &_iimap) : minimum(), blank(true), iimap(_iimap) {} 
+    FibHeap(ItemIntMap &_iimap) : minimum(), iimap(_iimap), num_items() {} 
     FibHeap(ItemIntMap &_iimap, const Compare &_comp) : minimum(), 
-      blank(true), iimap(_iimap), comp(_comp) {}
+      iimap(_iimap), comp(_comp), num_items() {}
     
     
     int size() const {
-      int s=0;
-      for ( unsigned int i=0; i!=container.size(); ++i )
-	if ( container[i].in ) ++s;
-      return s; 
+      return num_items; 
     }
 
 
-    bool empty() const { return blank; }
+    bool empty() const { return num_items==0; }
 
 
     void set (Item const it, PrioType const value) {
       int i=iimap.get(it);
       if ( i >= 0 && container[i].in ) {
-	if ( !comp(container[i].prio, value) ) decrease(it, value); 
+	if ( comp(value, container[i].prio) ) decrease(it, value); 
 	if ( comp(container[i].prio, value) ) increase(it, value); 
       } else push(it, value);
     }
@@ -118,62 +118,45 @@
 	container[i].marked=false;
       }
 
-      if ( !blank ) {
+      if ( num_items ) {
 	container[container[minimum].right_neighbor].left_neighbor=i;
 	container[i].right_neighbor=container[minimum].right_neighbor;
 	container[minimum].right_neighbor=i;
 	container[i].left_neighbor=minimum;
-	if ( !comp( container[minimum].prio, value) ) minimum=i; 
+	if ( comp( value, container[minimum].prio) ) minimum=i; 
       } else {
 	container[i].right_neighbor=container[i].left_neighbor=i;
 	minimum=i;	
-	blank=false;
       }
       container[i].prio=value;
+      ++num_items;
     }
     
 
     Item top() const {
-      if ( !blank ) { 
-	return container[minimum].name;
-      } else {
-	return Item();
-      }
+      return container[minimum].name;
     }
     
     
     PrioType prio() const {
-      if ( !blank ) { 
-	return container[minimum].prio;
-      } else {
-	return PrioType();
-      }
+      return container[minimum].prio;
     }
     
 
     const PrioType get(const Item& it) const {
-      int i=iimap.get(it);
-      
-      if ( i >= 0 && container[i].in ) { 
-	return container[i].prio;
-      } else {
-	return PrioType();
-      }
+      return container[iimap.get(it)].prio;
     }
 
 
-
-
     void pop() {
       /*The first case is that there are only one root.*/
       if ( container[minimum].left_neighbor==minimum ) {
 	container[minimum].in=false;
-	if ( container[minimum].degree==0 ) blank=true; 
-	else { 
+	if ( container[minimum].degree!=0 ) { 
 	  makeroot(container[minimum].child);
 	  minimum=container[minimum].child;
 	  balance();
-	} 
+	}
       } else {
 	int right=container[minimum].right_neighbor;
 	unlace(minimum);
@@ -193,23 +176,23 @@
 	minimum=right;
 	balance();
       } // the case where there are more roots
+      --num_items;   
     }
 
     
     void erase (const Item& it) {
       int i=iimap.get(it);
       
-      if ( i >= 0 && container[i].in ) { 
-	
-       if ( container[i].parent!=-1 ) {
-	 int p=container[i].parent;
-	 cut(i,p);	    
-	 cascade(p);
-	 minimum=i;     //As if its prio would be -infinity
-       }
-       pop();
-     }
-   }
+      if ( i >= 0 && container[i].in ) { 	
+	if ( container[i].parent!=-1 ) {
+	  int p=container[i].parent;
+	  cut(i,p);	    
+	  cascade(p);
+	}
+	minimum=i;     //As if its prio would be -infinity
+	pop();
+      }
+    }
     
 
     void decrease (Item it, PrioType const value) {
@@ -220,8 +203,8 @@
       if ( p!=-1 && comp(value, container[p].prio) ) {
 	cut(i,p);	    
 	cascade(p);
-	if ( comp(value, container[minimum].prio) ) minimum=i; 
-      }
+      }      
+      if ( comp(value, container[minimum].prio) ) minimum=i; 
     }
    
 
@@ -310,7 +293,7 @@
       }
       
       
-      /*Lacing i to the roots.*/
+      /*Lacing a to the roots.*/
       int right=container[minimum].right_neighbor;
       container[minimum].right_neighbor=a;
       container[a].left_neighbor=minimum;
@@ -392,9 +375,3 @@
   
 } //namespace hugo
 #endif 
-
-
-
-
-
-