yinspire 0.1.0

data/lib/Algorithms/IndexedBinaryHeap.h

@@ -0,0 +1,90 @@
+/*
+ * An Indexed Binary Heap
+ *
+ * Copyright (c) 2007, 2008 by Michael Neumann (mneumann@ntecs.de)
+ *
+ * The Indexed Binary Heap keeps track of the indices of it's elements
+ * stored in the heap to allow efficient updating of their priorities. 
+ *
+ * The requirement was to modify an elements priority. In a regular
+ * implicit binary heap this is an inefficient operation as the element
+ * has to be found prior to modifying it's priority.  And finding an
+ * element is O(n) in an implicit binary heap due to it's non sorted
+ * nature (i.e. can't apply binary search). By keeping track of the
+ * elements index and storing this value inside the elements structure,
+ * the complexity of modifying an elements priority is reduced to 
+ * O(log n) in the worst-case! 
+ *
+ * NOTE: Index 0 of the elements array is unused.  It's the index that
+ * should be used to denote that an element is NOT actually present in
+ * the binary heap.
+ *
+ * See documentation of BinaryHeap as well.
+ *
+ * Example:
+ *
+ *   struct E
+ *   {
+ *     float schedule_at;
+ *     unsigned int schedule_index;
+ *
+ *     inline static bool less(const E& e1, const E& e2)
+ *     {
+ *       return e1.schedule_at < e2.schedule_at;
+ *     }
+ *
+ *     inline static unsigned int& index(const E& e)
+ *     {
+ *       return e.schedule_index;
+ *     }
+ *   };
+ *
+ *   IndexedBinaryHeap<E, MemoryAllocator> heap;
+ *   ...
+ *
+ */
+
+#ifndef __YINSPIRE__INDEXED_BINARY_HEAP__
+#define __YINSPIRE__INDEXED_BINARY_HEAP__
+
+#include "BinaryHeap.h"
+
+template <typename E, class Acc=E>
+struct BinaryHeapIndexer
+{
+  static inline void index_changed(E& e, unsigned int i) 
+  {
+    Acc::index(e) = i;
+  }
+};
+
+
+template <typename E, class Alloc, class Acc=E, unsigned int MIN_CAPA=1024> 
+class IndexedBinaryHeap : public BinaryHeap<E, Alloc, Acc, BinaryHeapIndexer<E, Acc>, MIN_CAPA>
+{
+    typedef unsigned int I; // index type
+    typedef BinaryHeap<E, Alloc, Acc, BinaryHeapIndexer<E, Acc>, MIN_CAPA> super;
+    typedef BinaryHeapIndexer<E, Acc> Idx;
+
+  public:
+
+    void
+      update(const E& element)
+      {
+        I i = Acc::index(element);
+        if (i == 0)
+        {
+          super::push(element);
+        }
+        else
+        {
+          // FIXME: use propagate up/down instead
+          Idx::index_changed(this->elements[i], 0);  // detach from heap
+          I bubble = super::move_bubble_down(i);
+          super::insert_and_bubble_up(bubble, element); 
+        }
+      }
+
+};
+
+#endif

data/lib/Algorithms/PairingHeap.h

@@ -0,0 +1,169 @@
+/*
+ * Implementation of a Pairing Heap
+ *
+ * Copyright (c) 2007, 2008 by Michael Neumann (mneumann@ntecs.de)
+ *
+ * Requirements for "ACC": 
+ *
+ *   struct ACC {
+ *     inline static bool less(const T*, const T*); 
+ *     inline static T*& next(T*);
+ *     inline static T*& previous(T*);
+ *     inline static T*& child(T*);
+ *   }
+ *
+ */
+
+#ifndef __YINSPIRE__PAIRING_HEAP__
+#define __YINSPIRE__PAIRING_HEAP__
+
+template <class T, class ACC=T>
+class PairingHeap
+{
+  public:
+
+    PairingHeap()
+    {
+      this->root = NULL;
+      this->size_ = 0;
+    }
+
+    bool
+      empty() const
+      {
+        return (this->root == NULL);
+      }
+
+    unsigned int
+      size() const
+      {
+        return this->size_;
+      }
+
+    T*
+      top() const
+      {
+        return this->root;
+      }
+
+    void
+      pop()
+      {
+        T* current;
+        T* last;
+        T* r1;
+        T* r2;
+
+        --this->size_;
+
+        if (ACC::child(this->root) != NULL)
+        {
+          // remove parent pointer from left-most child node
+          ACC::previous(ACC::child(this->root)) = NULL;
+
+          current = ACC::child(this->root);
+          last = NULL;
+
+          // left-to-right pass
+          while (current != NULL)
+          {
+            r1 = current;
+            r2 = ACC::next(current);
+
+            if (r2 == NULL)
+            {
+              // no need to "meld", because we're at the end
+              ACC::previous(r1) = last;
+              last = current;
+              current = NULL;
+            }
+            else
+            {
+              current = ACC::next(r2);
+
+              ACC::next(r1) = NULL;
+              ACC::previous(r1) = NULL;
+              ACC::next(r2) = NULL;
+              ACC::previous(r2) = NULL;
+
+              r1 = meld(r1, r2);
+              ACC::previous(r1) = last;
+              last = r1;
+            }
+          }
+
+          this->root = last;
+          current = ACC::previous(last);
+
+          // make it a clean root-node
+          ACC::next(this->root) = NULL;
+          ACC::previous(this->root) = NULL;	
+
+          // right-to-left pass 
+          while (current != NULL)
+          {
+            r2 = current;
+
+            current = ACC::previous(r2);
+            ACC::previous(r2) = NULL; // make it a clean root-node
+
+            this->root = meld(this->root, r2);
+          }
+        }
+        else
+        {
+          this->root = NULL;
+        }
+      }
+
+    /*
+     * Insert a new element into the Pairing Heap.
+     */
+    void
+      push(T* node)
+      {
+        ACC::next(node) = NULL;
+        ACC::previous(node) = NULL; // == NULL means it's a root node
+        ACC::child(node) = NULL;
+
+        ++this->size_;
+
+        this->root = empty() ? node : meld(this->root, node);
+      }
+
+  private:
+
+    /*
+     * Meld two Pairing Heaps
+     */
+    T*
+      meld(T* root1, T* root2)
+      {
+        if (ACC::less(root2, root1))
+        {
+          T* tmp = root1;
+          root1 = root2;
+          root2 = tmp;
+        }
+
+        // root2 becomes the leftmost node of root1
+        ACC::previous(root2) = root2;  // "parent" pointer for leftmost child
+        ACC::next(root2) = ACC::child(root1);
+
+        if (ACC::child(root1) != NULL)
+        {
+          // assign double linked-list
+          ACC::previous(ACC::child(root1)) = root2;
+        }
+        ACC::child(root1) = root2;
+        return root1;
+      }
+
+  private:
+
+    T* root;
+    unsigned int size_;
+
+};
+
+#endif

data/lib/Allocators/ChunkedFreelistAllocator.h

@@ -0,0 +1,96 @@
+/*
+ * A chunked freelist Allocator
+ *
+ * Copyright (c) 2007, 2008 by Michael Neumann (mneumann@ntecs.de)
+ *
+ * Memory is allocated in chunks of size +chunk_size+. Chunks are never
+ * freed except when the destructor is called.
+ */
+
+#ifndef __YINSPIRE__CHUNKED_FREELIST_ALLOCATOR__
+#define __YINSPIRE__CHUNKED_FREELIST_ALLOCATOR__
+
+#include <assert.h>
+
+template <class T, class ACC = T>
+class ChunkedFreelistAllocator
+{
+
+    template <class TT>
+    struct Chunk
+    {
+      Chunk<TT> *next_chunk;
+      TT *array; 
+    };
+
+  public:
+
+    ChunkedFreelistAllocator(unsigned int chunksize)
+    {
+      this->freelist = NULL;
+      this->chunklist = NULL;
+      this->chunksize = chunksize;
+    }
+
+    T*
+      allocate()
+      {
+
+        // alloc new chunk if no more free elements are available
+        if (this->freelist == NULL) alloc_chunk();
+
+        assert(this->freelist != NULL);
+
+        T* e = this->freelist; 
+        this->freelist = ACC::next(e);
+        ACC::next(e) = NULL;
+
+        return e;
+      }
+
+    void
+      free(T* e)
+      {
+        //assert(ACC::next(e) == NULL);
+        ACC::next(e) = this->freelist;
+        this->freelist = e;
+      }
+
+    void
+      free_list(T* first, T* last)
+      {
+        assert(last != NULL);
+        //assert(ACC::next(first) == NULL);
+        ACC::next(last) = this->freelist; 
+        this->freelist = first;
+      }
+
+  protected:
+
+    void
+      alloc_chunk()
+      {
+        Chunk<T> *new_chunk = new Chunk<T>;
+        new_chunk->next_chunk = this->chunklist;
+        this->chunklist = new_chunk;
+
+        new_chunk->array = new T[this->chunksize]; 
+
+        // put all elements of new chunk on freelist
+        for (unsigned int i=0; i<this->chunksize-1; i++)
+        {
+          ACC::next(&new_chunk->array[i]) = &new_chunk->array[i+1];
+        }
+
+        ACC::next(&new_chunk->array[this->chunksize-1]) = this->freelist;
+        this->freelist = &new_chunk->array[0];
+      }
+
+  private:
+
+    T *freelist;
+    Chunk<T> *chunklist;
+    unsigned int chunksize;
+};
+
+#endif

data/lib/Allocators/MemoryAllocator.h

@@ -0,0 +1,45 @@
+#ifndef __YINSPIRE__MEMORY_ALLOCATOR__
+#define __YINSPIRE__MEMORY_ALLOCATOR__
+
+#include <stdlib.h>
+
+/*
+ * Provides some basic utility functions for allocating and releasing
+ * memory.
+ */
+template <typename T> 
+class MemoryAllocator
+{
+  public:
+
+    inline static T*
+      alloc_n(size_t n)
+      {
+        T* ptr = (T*) calloc(n, sizeof(T));
+        if (ptr == NULL)
+        {
+          throw "memory allocation failed";
+        }
+        return ptr;
+      }
+
+    inline static T*
+      realloc_n(T* old_ptr, size_t n)
+      {
+        T* ptr = (T*) realloc(old_ptr, sizeof(T)*n);
+        if (ptr == NULL)
+        {
+          throw "memory allocation failed";
+        }
+        return ptr;
+      }
+
+    inline static void
+      free(T* ptr)
+      {
+        ::free(ptr);
+      }
+
+};
+
+#endif

data/lib/Allocators/RubyMemoryAllocator.h

@@ -0,0 +1,37 @@
+#ifndef __YINSPIRE__RUBY_MEMORY_ALLOCATOR__
+#define __YINSPIRE__RUBY_MEMORY_ALLOCATOR__
+
+#include "ruby.h"
+#include <stdlib.h>
+
+/*
+ * Provides some basic utility functions for allocating and releasing
+ * memory.
+ */
+template <typename T> 
+class MemoryAllocator
+{
+  public:
+
+    inline static T*
+      alloc_n(size_t n)
+      {
+        return ALLOC_N(T, n);
+      }
+
+    inline static T*
+      realloc_n(T* old_ptr, size_t n)
+      {
+        REALLOC_N(old_ptr, T, n);
+        return old_ptr;
+      }
+
+    inline static void
+      free(T* ptr)
+      {
+        ::free(ptr);
+      }
+
+};
+
+#endif

data/lib/Yinspire.rb

@@ -0,0 +1,69 @@
+require 'cplus2ruby'
+
+Cplus2Ruby.add_type_alias 'real'  => 'float'
+Cplus2Ruby.add_type_alias 'simtime' => 'float'
+Cplus2Ruby.add_type_alias 'uint'  => 'unsigned int'
+Cplus2Ruby.settings :default_body_when_nil => 'THROW("abstract method");'
+
+Infinity = 1.0/0.0
+
+Cplus2Ruby << %{
+  #include <assert.h>
+  #include <math.h>
+  #include "Algorithms/Array.h"
+  #include "Algorithms/BinaryHeap.h"
+  #include "Algorithms/IndexedBinaryHeap.h"
+  #include "Allocators/RubyMemoryAllocator.h"
+
+  #define real_exp expf
+  #define real_fabs fabsf
+
+  #define THROW(str) rb_raise(rb_eRuntimeError, str)
+
+  #define MIN(a,b) ((a) < (b) ? (a) : (b))
+  #define MAX(a,b) ((a) > (b) ? (a) : (b))
+  
+  #define Infinity INFINITY
+}
+
+def assert(cond)
+  raise "assertion failed" unless cond
+end
+
+class Simulator; cplus2ruby end
+class NeuralEntity; cplus2ruby end
+
+# Forward declarations
+class Neuron < NeuralEntity; end
+class Synapse < NeuralEntity; end
+
+require 'Yinspire/Core/Simulator'
+require 'Yinspire/Core/NeuralEntity'
+require 'Yinspire/Core/Neuron'
+require 'Yinspire/Core/Synapse'
+
+module Yinspire
+  ROOT = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+  LIB_DIR = File.expand_path(File.dirname(__FILE__))
+
+  def self.commit(file, force_compilation=false)
+    cflags = "-DNDEBUG -O3 -fomit-frame-pointer -Winline -Wall -I#{LIB_DIR} -I${PWD}"
+    ldflags = ""
+    Cplus2Ruby.commit(file, force_compilation, cflags, ldflags)
+
+    Cplus2Ruby.model.entities.each do |klass|
+      next unless klass.ancestors.include?(NeuralEntity) 
+      NeuralEntity.entity_type_map[klass.name] = klass 
+      NeuralEntity.entity_type_map_reverse[klass] = klass.name
+      lc = NeuralEntity.entity_ann_load_cache[klass] = Hash.new
+      dc = NeuralEntity.entity_ann_dump_cache[klass] = Array.new
+
+      klass.recursive_annotations.each {|name, h|
+        next unless h[:marshal]
+        lc[name.to_sym] = lc[name.to_s] = :"#{name}="
+        dc << name.to_sym 
+      }
+    end
+  end
+
+end # module Yinspire