gecoder-with-gecode 0.7.1 → 0.8.0

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

@@ -1,255 +0,0 @@
-/*
- *  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

@@ -1,193 +0,0 @@
-/*
- *  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

@@ -1,240 +0,0 @@
-/*
- *  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