yinspire 0.1.0

data/lib/Algorithms/BinaryHeap.h

@@ -0,0 +1,265 @@
+/*
+ * An implicit Binary Heap.
+ *
+ * Copyright (c) 2007, 2008 by Michael Neumann (mneumann@ntecs.de)
+ *
+ * NOTE: We start counting from 1 in the elements array!
+ *
+ * Template parameters:
+ *
+ *   E:        Element type
+ *   Alloc:    Allocator
+ *   Acc:      Accessor struct. Defines ordering relation (less).
+ *   MIN_CAPA: minimum number of elements
+ *
+ * Example:
+ *
+ *   struct Acc
+ *   {
+ *     static inline bool less(const int& a, const int& b)
+ *     {
+ *       return a < b;
+ *     }
+ *   };
+ *
+ *   BinaryHeap<int, MemoryAllocator, Acc> heap;
+ *   heap.push(4);
+ *   heap.pop();
+ *   ...
+ *
+ */
+
+#ifndef __YINSPIRE__BINARY_HEAP__
+#define __YINSPIRE__BINARY_HEAP__
+
+#include <assert.h>
+
+/*
+ * This is used to be able to keep track of
+ * an elements index in the IndexedBinaryHeap subclass.
+ * Unused in this class.
+ */
+template <typename E>
+struct BinaryHeapDummyIndexer
+{
+  static inline void index_changed(E& e, unsigned int i) 
+  {
+    /* DUMMY */
+  }
+};
+
+template <typename E, class Alloc, class Acc=E, class Idx=BinaryHeapDummyIndexer<E>, unsigned int MIN_CAPA=1024>
+class BinaryHeap
+{
+    typedef unsigned int I; // index type
+
+  public:
+
+      BinaryHeap()
+      {
+        this->capacity = 0;
+        this->size_ = 0;
+        this->elements = NULL; // we do lazy allocation!
+      }
+
+      ~BinaryHeap()
+      {
+        if (this->elements != NULL)
+        {
+          Alloc::free(this->elements+1);
+        }
+        this->elements = NULL;
+      }
+
+    inline E&
+      top() const
+      {
+        assert(this->size > 0);
+        return this->elements[1];  
+      }
+
+    void
+      pop()
+      {
+        remove(1);
+      }
+
+    inline void
+      remove(I i)
+      {
+        assert(i <= this->size_);
+
+        // 
+        // Element i is removed from the heap and as such becomes
+        // a "bubble" (free element). Move the bubble until
+        // the bubble becomes a leaf element. 
+        //
+        Idx::index_changed(this->elements[i], 0);  // detach from heap
+        I bubble = move_bubble_down(i);
+
+        //
+        // Now take the last element and insert it at the position of
+        // the bubble. In case the bubble is already the last element we
+        // are done.
+        //
+        if (bubble != this->size_)
+        {
+          insert_and_bubble_up(bubble, this->elements[this->size_]);
+        }
+        --this->size_;
+      }
+
+    void
+      push(const E& element)
+      {
+        if (this->size_ >= this->capacity) resize(2*this->capacity);
+        insert_and_bubble_up(++this->size_, element);
+      }
+
+    inline I
+      size() const
+      {
+        return this->size_;
+      }
+
+    inline bool
+      empty() const
+      {
+        return (this->size_ == 0);
+      }
+    
+    /*
+     * Returns NULL or a pointer to the parent of +element+.
+     */
+    E*
+      find_parent(const E& element)
+      {
+        I i;
+
+        //
+        // Find the position of the first element that is less than +element+.
+        // 
+        for (i = this->size_; i != 0 && Acc::less(element, this->elements[i]); i /= 2);
+
+        return (i == 0 ? NULL : &this->elements[i]); 
+      }
+
+    /*
+     * Iterate over all elements (non-destructive)
+     */
+    void
+      each(void (*yield)(const E&, void*), void *data)
+      {
+        for (I i=1; i <= this->size_; i++)
+        {
+          yield(this->elements[i], data);
+        }
+      }
+ 
+  protected:
+
+    /*
+     * Insert +element+ into the heap beginning from
+     * +i+ and searching upwards to the root for the 
+     * right position (heap ordered) to insert.
+     *
+     * Element at index +i+ MUST be empty, i.e. unused!
+     */
+    inline void
+      insert_and_bubble_up(I i, const E& element)
+      {
+        for (;i >= 2 && Acc::less(element, this->elements[i/2]); i /= 2)
+        {
+          store_element(i, this->elements[i/2]);
+        }
+
+        // finally store it into the determined hole
+        store_element(i, element);
+      }
+
+    /*
+     * Move the bubble (empty element) at +i+ down in direction
+     * to the leaves. When the bubble reaches a leaf, stop and
+     * return the index of the leaf element which is now empty.
+     */
+    inline I 
+      move_bubble_down(I i)
+      {
+        const I sz = this->size_;
+        I right_child = i * 2 + 1;
+
+        while (right_child <= sz) 
+        {
+          if (Acc::less(this->elements[right_child-1], this->elements[right_child]))
+          {
+            --right_child; // minimum child is left child
+          }
+
+          store_element(i, this->elements[right_child]);
+          i = right_child;
+          right_child = i * 2 + 1;
+        }
+
+        //
+        // Edge case (comparison with the last element)
+        //
+        if (right_child-1 == sz)
+        {
+          store_element(i, this->elements[right_child-1]);
+          i = right_child-1;
+        }
+
+        return i;
+      }
+
+    /*
+     * The 0'th element is never used (accessed), so 
+     * we allocate only "capacity" elements (instead of capacity+1)
+     * and move the pointer one element before the begin of the 
+     * allocated memory. 
+     */
+    void
+      resize(I new_capacity)
+      {
+        E *new_elements;
+
+        if (new_capacity < MIN_CAPA) this->capacity = MIN_CAPA;  
+        else this->capacity = new_capacity;
+
+        //
+        // We do lazy allocation!
+        //
+        if (this->elements != NULL)
+        {
+          new_elements = Alloc::realloc_n(this->elements+1, this->capacity);
+        }
+        else
+        {
+          new_elements = Alloc::alloc_n(this->capacity);
+        }
+
+        assert(new_elements != NULL);
+        assert(this->capacity >= this->size);
+
+        //
+        // move pointer so that we "introduce" a zero'th 
+        // element.
+        //
+        this->elements = new_elements-1;
+      }
+
+    inline void
+      store_element(I i, const E& element)
+      {
+        this->elements[i] = element;
+        Idx::index_changed(this->elements[i], i); 
+      }
+
+  protected:
+
+    I  size_;
+    E *elements;
+    I  capacity;
+};
+
+#endif

data/lib/Algorithms/CalendarQueue.h

@@ -0,0 +1,257 @@
+/*
+ * A Calendar Queue implementation.
+ *
+ * Copyright (c) 2007, 2008 by Michael Neumann (mneumann@ntecs.de)
+ *
+ * Template parameters:
+ *
+ *   E: Element type
+ *   ACC: Accessor
+ *     priority -> real
+ *     next -> E*&
+ *   real: precision type
+ * 
+ */
+
+#ifndef __YINSPIRE__CALENDAR_QUEUE__
+#define __YINSPIRE__CALENDAR_QUEUE__
+
+#include <assert.h>
+
+template <typename E, class ACC = E, typename real=float>
+class CalendarQueue
+{
+    typedef unsigned int I; // index type
+
+  public:
+
+    CalendarQueue(real year_width=1.0)
+    {
+      this->size_ = 0;
+      this->year_width = year_width;
+      this->day_width = year_width;
+
+      this->current_year = 0;
+      this->current_day = 0;
+
+      this->num_days = 1;
+      this->days = new E*[1];
+      this->days[0] = NULL;
+    }
+
+    inline I
+      size() const
+      {
+        return this->size_;
+      }
+
+    inline bool
+      empty() const
+      {
+        return (this->size_ == 0);
+      }
+
+    void
+      push(E *element)
+      {
+        const real priority = ACC::priority(element); 
+
+        assert(priority >= 0.0);
+
+        if (++this->size_ > 2*this->num_days) resize_double();
+
+        // map priority to a day
+        I day = ((I)(priority / this->day_width)) % this->num_days;
+
+        // and sort element into that day
+        insert_sorted(day, element);
+
+        //
+        // in case that the newly inserted element is smaller than the
+        // currently smallest value we have to change the current year 
+        // and day.
+        //
+        if (priority < min_start())
+        {
+          this->current_day  = day;
+          this->current_year = (I)(priority / this->year_width);
+        }
+      }
+
+    inline real min_start() const { return day_start() + year_start(); }
+    inline real day_start() const { return this->current_day * this->day_width; }
+    inline real year_start() const { return this->current_year * this->year_width; }
+ 
+    E*
+      pop()
+      {
+        assert(this->size_ > 0);
+
+        if (--this->size_ < this->num_days/2 && this->num_days > 1) resize_half();
+
+        real priority;
+        real min_priority = INFINITY;
+        real max_value_this_year = (this->current_year+1)*this->year_width;
+        E *top;
+        I i;
+
+        for (i = this->current_day; i < this->num_days; i++)
+        {
+          top = this->days[i];
+          if (top != NULL)
+          {
+            priority = ACC::priority(top);
+
+            if (priority < max_value_this_year)
+            {
+              // remove top element
+              this->days[i] = ACC::next(top); 
+              this->current_day = i;
+              ACC::next(top) = NULL;
+              return top;
+            }
+            if (priority < min_priority) min_priority = priority;
+          }
+        }
+
+        //
+        // continue with the first element up to this->current_day
+        //
+        for (i = 0; i < this->current_day; i++)
+        {
+          top = this->days[i];
+          if (top != NULL)
+          {
+            priority = ACC::priority(top);
+            if (priority < min_priority) min_priority = priority;
+          }
+        }
+
+        this->current_year = (I)(min_priority / this->year_width);
+        this->current_day  = (I)(min_priority / this->day_width) % this->num_days;
+
+        top = this->days[this->current_day];
+        this->days[this->current_day] = ACC::next(top); 
+        ACC::next(top) = NULL;
+
+        return top;
+      }
+
+  protected:
+
+    void
+      insert_sorted(I day, E *element)
+      {
+        E *curr = this->days[day];
+        E *prev = NULL; 
+        const real priority = ACC::priority(element);
+
+        //
+        // Find the first element that is >= +element+.
+        // Insert +element+ *before* that element.
+        //
+        while (curr != NULL && ACC::priority(curr) < priority)
+        {
+          prev = curr;
+          curr = ACC::next(curr);
+        }
+
+        ACC::next(element) = curr;
+
+        if (prev != NULL) ACC::next(prev) = element;
+        else              this->days[day] = element;
+      }
+
+    /*
+     * Each day is split into two days.
+     */
+    void
+      resize_double()
+      {
+        E **new_days = new E*[2*this->num_days];
+
+        const real dw = this->day_width / 2.0;
+        E* c[2];
+
+        for (I i = 0; i < this->num_days; i++)
+        {
+          c[0] = new_days[i*2]   = NULL;
+          c[1] = new_days[i*2+1] = NULL;
+          for (E *curr = this->days[i]; curr != NULL; curr = ACC::next(curr))
+          {
+            const I day = (I)(ACC::priority(curr) / dw) % 2;
+            if (c[day] != NULL)
+            {
+              ACC::next(c[day]) = curr; 
+            }
+            else
+            {
+              new_days[i*2+day] = curr; 
+            }
+            c[day] = curr;
+          }
+
+          if (c[0] != NULL) ACC::next(c[0]) = NULL;
+          if (c[1] != NULL) ACC::next(c[1]) = NULL;
+        }
+
+        delete [] this->days;
+
+        this->days = new_days;
+        this->num_days *= 2;
+        this->day_width /= 2.0;
+        this->current_year = 0;
+        this->current_day = 0;
+      }
+
+    // TODO: merge
+    void
+      resize_half()
+      {
+        resize(this->num_days/2, this->day_width*2.0);
+      }
+
+    void
+      resize(I new_num_days, real new_day_width)
+      {
+        E **old_days = this->days;
+        this->days = new E*[new_num_days];
+        E *element;
+
+        // initialize this->days to NULL
+        for (I i = 0; i < new_num_days; i++) this->days[i] = NULL;
+
+        for (I i = 0; i < this->num_days; i++)
+        {
+          for (E *curr = old_days[i]; curr != NULL; )
+          {
+            const I day = ((I)(ACC::priority(curr) / new_day_width)) % new_num_days;
+            element = curr; 
+            curr = ACC::next(curr);
+            insert_sorted(day, element);
+          }
+        }
+
+        delete[] old_days;
+
+        this->num_days = new_num_days;
+        this->day_width = new_day_width;
+        this->current_year = 0;
+        this->current_day = 0;
+      }
+
+  private:
+
+    I size_;
+
+    I num_days;
+    E** days;
+
+    real day_width;
+    real year_width;
+
+    I current_year;
+    I current_day;
+};
+
+#endif