gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/support/shared-array.hh

@@ -0,0 +1,255 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:05:34 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3514 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#ifndef __GECODE_SUPPORT_SHARED_ARRAY_HH__
+#define __GECODE_SUPPORT_SHARED_ARRAY_HH__
+
+#include "gecode/kernel.hh"
+
+#include <algorithm>
+
+namespace Gecode { namespace Support {
+
+  /**
+   * \brief Shared array with arbitrary number of elements
+   *
+   * Sharing is implemented by reference counting: the same elements
+   * are shared among several objects.
+   *
+   * If the template parameter \a fd is true, the destructors of all objects
+   * in the array will be called when the array is deallocated, i.e. when
+   * its reference count drops to zero.
+   *
+   * Requires \code #include "gecode/support/shared-array.hh" \endcode
+   * \ingroup FuncSupport
+   */
+  template <class T, bool fd=false>
+  class SharedArray {
+  private:
+    /// Information for array elements
+    class Object {
+    public:
+      /// Reference count
+      unsigned int use;
+      /// Number of elements
+      int n;
+      /// Start of elements
+      T   a[1];
+
+      /// Allocate new information for \a n elements
+      static Object* allocate(int n);
+      /// Create copy of elements
+      Object* copy(void) const;
+
+      /// Register new object
+      void subscribe(void);
+      /// Delete object
+      void release(void);
+    };
+    /// The object referenced
+    Object* sao;
+  public:
+    /// Initialize as empty array
+    SharedArray(void);
+    /// Initialize as array with \a n elements
+    SharedArray(int n);
+    /// Initialize from shared array \a a (share elements)
+    SharedArray(const SharedArray<T,fd>& a);
+    /// Initialize from shared array \a a (share elements)
+    const SharedArray& operator=(const SharedArray&);
+
+    /// Update this array from array \a a (share elements if \a share is true)
+    void update(bool share, SharedArray& a);
+
+    /// Delete array (elements might be still in use)
+    ~SharedArray(void);
+
+    /// Access element at position \a i
+    T& operator[](int i);
+    /// Access element at position \a i
+    const T& operator[](int i) const;
+
+    /// Return number of elements
+    int size(void) const;
+    /// Change size to \a n
+    void size(int n);
+
+    /// Shrink array to \a n elements
+    void shrink(int n);
+    /// Ensure that array has at least \a n elements
+    void ensure(int n);
+  };
+
+
+  template <class T, bool fd>
+  forceinline typename SharedArray<T,fd>::Object*
+  SharedArray<T,fd>::Object::allocate(int n) {
+    assert(n>0);
+    Object* o = reinterpret_cast<Object*>
+      (Memory::malloc(sizeof(T)*(n-1) + sizeof(Object)));
+    o->use = 1;
+    o->n   = n;
+    return o;
+  }
+
+  template <class T, bool fd>
+  forceinline typename SharedArray<T,fd>::Object*
+  SharedArray<T,fd>::Object::copy(void) const {
+    assert(n>0);
+    Object* o = allocate(n);
+    for (int i=n; i--;)
+      new (&(o->a[i])) T(a[i]);
+    return o;
+  }
+
+  template <class T, bool fd>
+  forceinline void
+  SharedArray<T,fd>::Object::subscribe(void) {
+    use++;
+  }
+
+  template <class T, bool fd>
+  forceinline void
+  SharedArray<T,fd>::Object::release(void) {
+    if (--use == 0) {
+      if (fd)
+	for (int i=n; i--;)
+	  a[i].~T();
+      Memory::free(this);
+    }
+  }
+
+
+  template <class T, bool fd>
+  forceinline
+  SharedArray<T,fd>::SharedArray(void) : sao(NULL) {}
+
+  template <class T, bool fd>
+  forceinline
+  SharedArray<T,fd>::SharedArray(int n) {
+    sao = (n>0) ? Object::allocate(n) : NULL;
+  }
+  template <class T, bool fd>
+  forceinline
+  SharedArray<T,fd>::SharedArray(const SharedArray<T,fd>& a) {
+    sao = a.sao;
+    if (sao != NULL)
+      sao->subscribe();
+  }
+
+  template <class T, bool fd>
+  forceinline
+  SharedArray<T,fd>::~SharedArray(void) {
+    if (sao != NULL)
+      sao->release();
+  }
+
+  template <class T, bool fd>
+  forceinline const SharedArray<T,fd>&
+  SharedArray<T,fd>::operator=(const SharedArray<T,fd>& a) {
+    if (this != &a) {
+      if (sao != NULL)
+	sao->release();
+      sao = a.sao;
+      if (sao != NULL)
+	sao->subscribe();
+    }
+    return *this;
+  }
+
+  template <class T, bool fd>
+  inline void
+  SharedArray<T,fd>::update(bool share, SharedArray<T,fd>& a) {
+    if (sao != NULL)
+      sao->release();
+    if (share) {
+      sao = a.sao;
+      if (sao != NULL)
+	sao->subscribe();
+    } else {
+      sao = (a.sao == NULL) ? NULL : a.sao->copy();
+    }
+  }
+
+  template <class T, bool fd>
+  forceinline T&
+  SharedArray<T,fd>::operator[](int i) {
+    return sao->a[i];
+  }
+
+  template <class T, bool fd>
+  forceinline const T&
+  SharedArray<T,fd>::operator[](int i) const {
+    return sao->a[i];
+  }
+
+  template <class T, bool fd>
+  forceinline int
+  SharedArray<T,fd>::size(void) const {
+    return (sao == NULL) ? 0 : sao->n;
+  }
+
+  template <class T, bool fd>
+  forceinline void
+  SharedArray<T,fd>::size(int n) {
+    if (n==0) {
+      if (sao != NULL)
+	sao->release();
+      sao = NULL;
+    } else {
+      sao->n = n;
+    }
+  }
+
+  template <class T, bool fd>
+  inline void
+  SharedArray<T,fd>::shrink(int n) {
+    assert(n < sao->n);
+    Object* nsao = Object::allocate(n);
+    for (int i = n; i--; )
+      new (&(nsao->a[i])) T(sao->a[i]);
+    sao->release();
+    sao = nsao;
+  }
+
+  template <class T, bool fd>
+  inline void
+  SharedArray<T,fd>::ensure(int n) {
+    if (sao == NULL) {
+      if (n>0)
+	sao = Object::allocate(n);
+      return;
+    }
+    if (n >= sao->n) {
+      int m = std::max(2*sao->n,n);
+      Object* nsao = Object::allocate(m);
+      for (int i = sao->n; i--; )
+	new (&(nsao->a[i])) T(sao->a[i]);
+      sao->release();
+      sao = nsao;
+    }
+  }
+
+}}
+
+#endif
+
+// STATISTICS: support-any

data/ext/gecode-1.3.1/gecode/support/sort.hh

@@ -0,0 +1,193 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:05:34 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3514 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#ifndef __GECODE_SUPPORT_SORT_HH__
+#define __GECODE_SUPPORT_SORT_HH__
+
+#include <algorithm>
+
+namespace Gecode { namespace Support {
+
+  /// Exchange elements according to order
+  template <class Type, class LessThan>
+  forceinline void
+  exchange(Type &a, Type &b, LessThan &lt) {
+    if (lt(b,a)) std::swap(a,b);
+  }
+
+  /// Perform quicksort only for more elements
+  int const QuickSortCutoff = 20;
+
+  /// Maximal stacksize quicksort ever needs
+  static const int QuickSortStack_maxsize = 32;
+
+  /// Static stack for quicksort
+  template <class Type>
+  class QuickSortStack {
+  private:
+    Type** tos;
+    Type*  stack[2*QuickSortStack_maxsize];
+  public:
+    QuickSortStack(void);
+    bool empty(void) const;
+    void push(Type*, Type*);
+    void pop(Type*&, Type*&);
+  };
+
+  template <class Type>
+  forceinline
+  QuickSortStack<Type>::QuickSortStack(void) : tos(&stack[0]) {
+    *(tos++) = 0;
+  }
+
+  template <class Type>
+  forceinline bool
+  QuickSortStack<Type>::empty(void) const {
+    return !*(tos-1);
+  }
+
+  template <class Type>
+  forceinline void
+  QuickSortStack<Type>::push(Type* l, Type* r) {
+    *(tos++) = l; *(tos++) = r;
+  }
+
+  template <class Type>
+  forceinline void
+  QuickSortStack<Type>::pop(Type*& l, Type*& r) {
+    r = *(--tos); l = *(--tos);
+  }
+
+  /// Standard insertion sort
+  template <class Type, class LessThan>
+  inline void
+  insertion(Type* l, Type* r, LessThan &lt) {
+    for (Type* i = r; i > l; i--)
+      exchange(*(i-1),*i,lt);
+    for (Type* i = l+2; i <= r; i++) {
+      Type* j = i;
+      Type v = *i;
+      while (lt(v,*(j-1))) {
+	*j = *(j-1); j--;
+      }
+      *j = v;
+    }
+  }
+
+  /// Standard partioning
+  template <class Type, class LessThan>
+  inline Type*
+  partition(Type* l, Type* r, LessThan &lt) {
+    Type* i = l-1;
+    Type* j = r;
+    Type v = *r;
+    while (true) {
+      while (lt(*(++i),v));
+      while (lt(v,*(--j))) if (j == l) break;
+	if (i >= j) break;
+	std::swap(*i,*j);
+    }
+    std::swap(*i,*r);
+    return i;
+  }
+
+  /// Standard quick sort
+  template <class Type, class LessThan>
+  inline void
+  quicksort(Type* l, Type* r, LessThan &lt) {
+    QuickSortStack<Type> s;
+    s.push(l,r);
+    while (!s.empty()) {
+      s.pop(l,r);
+    nopush:
+      if (r-l <= QuickSortCutoff)
+	continue;
+      std::swap(*(l+((r-l) >> 1)),*(r-1));
+      exchange(*l,*(r-1),lt);
+      exchange(*l,*r,lt);
+      exchange(*(r-1),*r,lt);
+      Type* i = partition(l+1,r-1,lt);
+      if (i-l > r-i) {
+	s.push(l,i-1); l=i+1; goto nopush;
+      } else {
+	s.push(i+1,r); r=i-1; goto nopush;
+      }
+    }
+  }
+
+  /*
+   * These are the routines to be used
+   *
+   */
+
+  /**
+   * \brief Insertion sort
+   *
+   * Sorts by insertion the \a n first elements of array \a x according
+   * to the order \a lt as instance of class \a LessThan. The class
+   * \a LessThan must implement the single member function
+   * \code bool operator()(const Type&, const Type&) \endcode
+   * for comparing elements.
+   *
+   * The algorithm is largely based on the following book:
+   * Robert Sedgewick, Algorithms in C++, 3rd edition, 1998, Addison Wesley.
+   *
+   * Requires \code #include "gecode/support/sort.hh" \endcode
+   * \ingroup FuncSupport
+   */
+  template <class Type, class LessThan>
+  forceinline void
+  insertion(Type* x, int n, LessThan &lt) {
+    if (n < 2)
+      return;
+    insertion(x,x+n-1,lt);
+  }
+
+  /**
+   * \brief Quicksort
+   *
+   * Sorts with quicksort the \a n first elements of array \a x according
+   * to the order \a lt as instance of class \a LessThan. The class
+   * \a LessThan must implement the single member function
+   * \code bool operator()(const Type&, const Type&) \endcode
+   * for comparing elements.
+   *
+   * The algorithm is largely based on the following book:
+   * Robert Sedgewick, Algorithms in C++, 3rd edition, 1998, Addison Wesley.
+   *
+   * Requires \code #include "gecode/support/sort.hh" \endcode
+   * \ingroup FuncSupport
+   */
+  template <class Type, class LessThan>
+  forceinline void
+  quicksort(Type* x, int n, LessThan &lt) {
+    if (n < 2)
+      return;
+    if (n > QuickSortCutoff)
+      quicksort(x,x+n-1,lt);
+    insertion(x,x+n-1,lt);
+  }
+
+}}
+
+#endif
+
+// STATISTICS: support-any

data/ext/gecode-1.3.1/gecode/support/static-pqueue.hh

@@ -0,0 +1,240 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:05:34 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3514 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#ifndef __GECODE_SUPPORT_PQUEUE_HH__
+#define __GECODE_SUPPORT_PQUEUE_HH__
+
+#include "gecode/kernel.hh"
+
+#include <cassert>
+#include <algorithm>
+
+/*
+ * The shared queue
+ *
+ */
+
+namespace Gecode { namespace Support {
+
+  /**
+   * \brief Simple fixed-size priority queue
+   *
+   * The order is implemented by an instance of the class \a Less which
+   * must provide the single member function
+   * \code bool operator()(const T&, const T&) \endcode
+   * for comparing elements.
+   *
+   * Requires \code #include "gecode/support/static-pqueue.hh" \endcode
+   * \ingroup FuncSupport
+   */
+  template <class T, class Less>
+  class PQueue  {
+  private:
+    /// The class holding the shared queue (organized as heap)
+    class SharedPQueue  {
+    public:
+      /// Number of elements currently in queue
+      int n;
+      /// Maximal size
+      int size;
+      /// How many references to shared queue exist
+      unsigned int ref;
+      /// Order used for elements
+      Less l;
+      /// Elements (will be most likely more than one)
+      T pq[1];
+
+      /// Allocate queue with \a n elements
+      static SharedPQueue* allocate(int n, const Less& l);
+      /// Reorganize after smallest element has changed
+      void fixdown(void);
+      /// Reorganize after element at position \a n has changed
+      void fixup(int n);
+    };
+    /// Handle to shared queue
+    SharedPQueue* spq;
+
+  public:
+    /// Default constructor (creates empty queue)
+    PQueue(void);
+    /// Create for \a n elements and order \a l
+    PQueue(int n, const Less& l);
+    /// Initialize for \a n elements and order \a l
+    void init(int, const Less&);
+    /// Assign queue from queue \a p (elements are shared)
+    PQueue(const PQueue& p);
+    /// Assign queue from queue \a p (elements are shared)
+    const PQueue& operator=(const PQueue&);
+    /// Release queue
+    ~PQueue(void);
+
+    /// Test whether queue is empty
+    bool empty(void) const;
+    /// Insert element \a x according to order
+    void insert(const T& x);
+    /// Remove smallest element
+    void remove(void);
+    /// Provide access to smallest element
+    T& top(void);
+    /// Reorder queue after smallest element has changed (might not be smallest any longer)
+    void fix(void);
+
+    /// Update this queue from queue \a p (share elements if \a share is true)
+    void update(const PQueue<T,Less>& p, bool share);
+  };
+
+  template <class T, class Less>
+  forceinline typename PQueue<T,Less>::SharedPQueue*
+  PQueue<T,Less>::SharedPQueue::allocate(int n, const Less& l) {
+    SharedPQueue* spq
+      = reinterpret_cast<SharedPQueue*>
+      (Memory::malloc(sizeof(SharedPQueue) + (n-1)*sizeof(T)));
+    spq->size = n;
+    spq->n    = 0;
+    spq->ref  = 1;
+    spq->l    = l;
+    return spq;
+  }
+
+  template <class T, class Less>
+  forceinline void
+  PQueue<T,Less>::SharedPQueue::fixdown(void) {
+    int k = 0;
+    while ((k << 1) < n) {
+      int j = k << 1;
+      if (j < n-1 && l(pq[j],pq[j+1]))
+	j++;
+      if (!l(pq[k],pq[j]))
+	break;
+      std::swap(pq[k], pq[j]);
+      k = j;
+    }
+  }
+
+  template <class T, class Less>
+  forceinline void
+  PQueue<T,Less>::SharedPQueue::fixup(int k) {
+    while (k > 0 && l(pq[k >> 1],pq[k])) {
+      std::swap(pq[k],pq[k >> 1]);
+      k >>= 1;
+    }
+  }
+
+  template <class T, class Less>
+  forceinline
+  PQueue<T,Less>::PQueue(void)
+    : spq(NULL) {}
+
+  template <class T, class Less>
+  forceinline
+  PQueue<T,Less>::PQueue(int n, const Less& l)
+    : spq(SharedPQueue::allocate(n,l)) {}
+
+  template <class T, class Less>
+  forceinline void
+  PQueue<T,Less>::init(int n, const Less& l) {
+    spq = SharedPQueue::allocate(n,l);
+  }
+
+  template <class T, class Less>
+  forceinline
+  PQueue<T,Less>::PQueue(const PQueue<T,Less>& p)
+    : spq(p.spq) {
+    if (spq != NULL)
+      spq->ref++;
+  }
+
+  template <class T, class Less>
+  forceinline const PQueue<T,Less>&
+  PQueue<T,Less>::operator =(const PQueue<T,Less>& p) {
+    if (this != &p) {
+      if ((spq != NULL) && (--spq->ref == 0))
+	Memory::free(spq);
+      spq = p.spq;
+      if (spq != NULL)
+	spq->ref++;
+    }
+    return *this;
+  }
+
+  template <class T, class Less>
+  forceinline void
+  PQueue<T,Less>::update(const PQueue<T,Less>& p, bool share) {
+    if (share) {
+      spq = p.spq;
+      if (spq != NULL)
+	spq->ref++;
+    } else {
+      if (p.spq != NULL) {
+	spq = allocate(p.spq->n,p.spq->l);
+      } else {
+	spq = NULL;
+      }
+    }
+  }
+
+  template <class T, class Less>
+  forceinline
+  PQueue<T,Less>::~PQueue(void) {
+    if ((spq != NULL) && (--spq->ref == 0))
+      Memory::free(spq);
+  }
+
+  template <class T, class Less>
+  forceinline bool
+  PQueue<T,Less>::empty(void) const {
+    return (spq == NULL) || (spq->n == 0);
+  }
+
+
+  template <class T, class Less>
+  forceinline void
+  PQueue<T,Less>::insert(const T& x) {
+    spq->pq[spq->n++] = x;
+    spq->fixup(spq->n-1);
+  }
+
+  template <class T, class Less>
+  forceinline void
+  PQueue<T,Less>::remove(void) {
+    spq->pq[0] = spq->pq[--spq->n];
+    spq->fixdown();
+  }
+
+  template <class T, class Less>
+  forceinline T&
+  PQueue<T,Less>::top(void) {
+    return spq->pq[0];
+  }
+
+  template <class T, class Less>
+  forceinline void
+  PQueue<T,Less>::fix(void) {
+    spq->fixdown();
+  }
+
+}}
+
+#endif
+
+// STATISTICS: support-any