dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/support/sort.hpp

@@ -0,0 +1,268 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2009-09-09 05:10:29 +1000 (Wed, 09 Sep 2009) $ by $Author: schulte $
+ *     $Revision: 9692 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <algorithm>
+#include <climits>
+
+namespace Gecode { namespace Support {
+
+  /// Exchange elements according to order
+  template<class Type, class Less>
+  forceinline void
+  exchange(Type &a, Type &b, Less &less) {
+    if (less(b,a)) std::swap(a,b);
+  }
+
+  /// Perform quicksort only for more elements
+  int const QuickSortCutoff = 20;
+
+  /// Static stack for quicksort
+  template<class Type>
+  class QuickSortStack {
+  private:
+    /// Maximal stacksize quicksort ever needs
+    static const int maxsize = sizeof(int) * CHAR_BIT;
+    /// Top of stack
+    Type** tos;
+    /// Stack entries (terminated by NULL entry)
+    Type*  stack[2*maxsize+1];
+  public:
+    /// Initialize stack as empty
+    QuickSortStack(void);
+    /// Test whether stack is empty
+    bool empty(void) const;
+    /// Push two positions \a l and \a r
+    void push(Type* l, Type* r);
+    /// Pop two positions \a l and \a r
+    void pop(Type*& l, Type*& r);
+  };
+
+  template<class Type>
+  forceinline
+  QuickSortStack<Type>::QuickSortStack(void) : tos(&stack[0]) {
+    *(tos++) = NULL;
+  }
+
+  template<class Type>
+  forceinline bool
+  QuickSortStack<Type>::empty(void) const {
+    return *(tos-1) == NULL;
+  }
+
+  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 Less>
+  forceinline void
+  insertion(Type* l, Type* r, Less &less) {
+    for (Type* i = r; i > l; i--)
+      exchange(*(i-1),*i,less);
+    for (Type* i = l+2; i <= r; i++) {
+      Type* j = i;
+      Type v = *i;
+      while (less(v,*(j-1))) {
+        *j = *(j-1); j--;
+      }
+      *j = v;
+    }
+  }
+
+  /// Standard partioning
+  template<class Type, class Less>
+  forceinline Type*
+  partition(Type* l, Type* r, Less &less) {
+    Type* i = l-1;
+    Type* j = r;
+    Type v = *r;
+    while (true) {
+      while (less(*(++i),v)) {}
+      while (less(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 Less>
+  inline void
+  quicksort(Type* l, Type* r, Less &less) {
+    QuickSortStack<Type> s;
+    while (true) {
+      std::swap(*(l+((r-l) >> 1)),*(r-1));
+      exchange(*l,*(r-1),less);
+      exchange(*l,*r,less);
+      exchange(*(r-1),*r,less);
+      Type* i = partition(l+1,r-1,less);
+      if (i-l > r-i) {
+        if (r-i > QuickSortCutoff) {
+          s.push(l,i-1); l=i+1; continue;
+        }
+        if (i-l > QuickSortCutoff) {
+          r=i-1; continue;
+        }
+      } else {
+        if (i-l > QuickSortCutoff) {
+          s.push(i+1,r); r=i-1; continue;
+        }
+        if (r-i > QuickSortCutoff) {
+          l=i+1; continue;
+        }
+      }
+      if (s.empty())
+        break;
+      s.pop(l,r);
+    }
+  }
+
+  /// Comparison class for sorting using \a <
+  template<class Type>
+  class Less {
+  public:
+    bool operator ()(const Type& lhs, const Type& rhs) {
+      return lhs < rhs;
+    }
+  };
+
+  /**
+   * \brief Insertion sort
+   *
+   * Sorts by insertion the \a n first elements of array \a x according
+   * to the order \a l as instance of class \a Less. The class
+   * \a Less must implement the single member function
+   * \code bool operator ()(const Type&, const Type&) \endcode
+   * for comparing elements. Note that the order must be strict, that
+   * is: comparing an element with itself must return false.
+   *
+   * The algorithm is largely based on the following book:
+   * Robert Sedgewick, Algorithms in C++, 3rd edition, 1998, Addison Wesley.
+   *
+   * \ingroup FuncSupport
+   */
+  template<class Type, class Less>
+  forceinline void
+  insertion(Type* x, int n, Less &l) {
+    if (n < 2)
+      return;
+    assert(!l(x[0],x[0]));
+    insertion(x,x+n-1,l);
+  }
+
+  /**
+   * \brief Insertion sort
+   *
+   * Sorts by insertion the \a n first elements of array \a x according
+   * to the order \a <.
+   *
+   * The algorithm is largely based on the following book:
+   * Robert Sedgewick, Algorithms in C++, 3rd edition, 1998, Addison Wesley.
+   *
+   * \ingroup FuncSupport
+   */
+  template<class Type>
+  forceinline void
+  insertion(Type* x, int n) {
+    if (n < 2)
+      return;
+    Less<Type> l;
+    assert(!l(x[0],x[0]));
+    insertion(x,x+n-1,l);
+  }
+
+  /**
+   * \brief Quicksort
+   *
+   * Sorts with quicksort the \a n first elements of array \a x according
+   * to the order \a l as instance of class \a Less. The class
+   * \a Less must implement the single member function
+   * \code bool operator ()(const Type&, const Type&) \endcode
+   * for comparing elements. Note that the order must be strict, that
+   * is: comparing an element with itself must return false.
+   *
+   * The algorithm is largely based on the following book:
+   * Robert Sedgewick, Algorithms in C++, 3rd edition, 1998, Addison Wesley.
+   *
+   * \ingroup FuncSupport
+   */
+  template<class Type, class Less>
+  forceinline void
+  quicksort(Type* x, int n, Less &l) {
+    if (n < 2)
+      return;
+    assert(!l(x[0],x[0]));
+    if (n > QuickSortCutoff)
+      quicksort(x,x+n-1,l);
+    insertion(x,x+n-1,l);
+  }
+
+  /**
+   * \brief Quicksort
+   *
+   * Sorts with quicksort the \a n first elements of array \a x according
+   * to the order \a <.
+   *
+   * The algorithm is largely based on the following book:
+   * Robert Sedgewick, Algorithms in C++, 3rd edition, 1998, Addison Wesley.
+   *
+   * \ingroup FuncSupport
+   */
+  template<class Type>
+  forceinline void
+  quicksort(Type* x, int n) {
+    if (n < 2)
+      return;
+    Less<Type> l;
+    assert(!l(x[0],x[0]));
+    if (n > QuickSortCutoff)
+      quicksort(x,x+n-1,l);
+    insertion(x,x+n-1,l);
+  }
+
+}}
+
+// STATISTICS: support-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/support/static-stack.hpp

@@ -0,0 +1,148 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2009-09-09 05:10:29 +1000 (Wed, 09 Sep 2009) $ by $Author: schulte $
+ *     $Revision: 9692 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+namespace Gecode { namespace Support {
+
+  /**
+   * \brief Stack with fixed number of elements
+   *
+   * \ingroup FuncSupport
+   */
+  template<class T, class A>
+  class StaticStack {
+  private:
+    /// Allocator
+    A& a;
+    /// Number of elements
+    int n;
+    /// Top of stack
+    unsigned int tos;
+    /// Stack space
+    T* stack;
+  public:
+    /// Initialize for \a n elements
+    StaticStack(A& a, int n);
+    /// Release memory
+    ~StaticStack(void);
+
+    /// Reset stack (pop all elements)
+    void reset(void);
+    /// Test whether stack is empty
+    bool empty(void) const;
+    /// Return number of entries currently on stack
+    int entries(void) const;
+
+    /// Pop topmost element from stack and return it
+    T pop(void);
+    /// Return element on top of stack
+    T& top(void) const;
+    /// Return element that has just been popped
+    T& last(void) const;
+    /// Push element \a x on top of stack
+    void push(const T& x);
+
+  private:
+    /// Allocate memory from heap (disabled)
+    static void* operator new(size_t s) throw() { (void) s; return NULL; }
+    /// Free memory allocated from heap (disabled)
+    static void  operator delete(void* p) { (void) p; };
+    /// Copy constructor (disabled)
+    StaticStack(const StaticStack& s) : a(s.a) {}
+    /// Assignment operator (disabled)
+    const StaticStack& operator =(const StaticStack&) { return *this; }
+  };
+
+  template<class T, class A>
+  forceinline
+  StaticStack<T,A>::StaticStack(A& a0, int n0)
+    : a(a0), n(n0), tos(0), stack(a.template alloc<T>(n)) {}
+
+  template<class T, class A>
+  forceinline
+  StaticStack<T,A>::~StaticStack(void) {
+    a.free(stack,n);
+  }
+
+  template<class T, class A>
+  forceinline bool
+  StaticStack<T,A>::empty(void) const {
+    return tos==0;
+  }
+
+  template<class T, class A>
+  forceinline int
+  StaticStack<T,A>::entries(void) const {
+    return tos;
+  }
+
+  template<class T, class A>
+  forceinline void
+  StaticStack<T,A>::reset(void) {
+    tos = 0;
+  }
+
+  template<class T, class A>
+  forceinline T
+  StaticStack<T,A>::pop(void) {
+    assert((tos > 0) && (tos <= static_cast<unsigned int>(n)));
+    return stack[--tos];
+  }
+
+  template<class T, class A>
+  forceinline T&
+  StaticStack<T,A>::top(void) const {
+    assert((tos > 0) && (tos <= static_cast<unsigned int>(n)));
+    return stack[tos-1];
+  }
+
+  template<class T, class A>
+  forceinline T&
+  StaticStack<T,A>::last(void) const {
+    assert((tos >= 0) && (tos < static_cast<unsigned int>(n)));
+    return stack[tos];
+  }
+
+  template<class T, class A>
+  forceinline void
+  StaticStack<T,A>::push(const T& x) {
+    assert(tos < static_cast<unsigned int>(n));
+    stack[tos++] = x;
+  }
+
+}}
+
+// STATISTICS: support-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/support/thread.hpp

@@ -0,0 +1,272 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2009
+ *
+ *  Bugfixes provided by:
+ *     David Rijsman <david.rijsman@quintiq.com>
+ *
+ *  Last modified:
+ *     $Date: 2010-05-11 20:29:52 +1000 (Tue, 11 May 2010) $ by $Author: tack $
+ *     $Revision: 10939 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifdef GECODE_THREADS_WINDOWS
+
+#ifndef NOMINMAX
+#  define NOMINMAX
+#endif
+
+#ifndef _WIN32_WINNT
+#  define _WIN32_WINNT 0x400
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+
+#endif
+
+#ifdef GECODE_THREADS_PTHREADS
+
+#include <pthread.h>
+
+#endif
+
+/**
+ * \defgroup FuncSupportThread Simple thread and synchronization support
+ *
+ * This is very simplistic, just enough for parallel search engines. Do
+ * not mistake it for a full-fledged thread package.
+ *
+ * If the platform supports threads, the macro GECODE_HAS_THREADS is 
+ * defined. If threads are not supported, all classes are
+ * still available, but are noops with the exception of trying to
+ * create a new thread which will throw an exception.
+ *
+ *
+ * \ingroup FuncSupport
+ */  
+
+namespace Gecode { namespace Support {
+
+  /**
+   * \brief A mutex for mutual exclausion among several threads
+   * 
+   * It is not specified whether the mutex is recursive or not.
+   * Likewise, there is no guarantee of fairness among the
+   * blocking threads.
+   *
+   * \ingroup FuncSupportThread
+   */
+  class Mutex {
+  private:
+#ifdef GECODE_THREADS_WINDOWS
+    /// Use a simple but more efficient critical section on Windows
+    CRITICAL_SECTION w_cs;
+#endif
+#ifdef GECODE_THREADS_PTHREADS
+    /// The Pthread mutex
+    pthread_mutex_t p_m;
+#endif
+  public:
+    /// Initialize mutex
+    Mutex(void);
+    /// Acquire the mutex and possibly block
+    void acquire(void);
+    /// Try to acquire the mutex, return true if succesful
+    bool tryacquire(void);
+    /// Release the mutex
+    void release(void);
+    /// Delete mutex
+    ~Mutex(void);
+    /// Allocate memory from heap
+    static void* operator new(size_t s);
+    /// Free memory allocated from heap
+    static void  operator delete(void* p);
+  private:
+    /// A mutex cannot be copied
+    Mutex(const Mutex&) {}
+    /// A mutex cannot be assigned
+    void operator=(const Mutex&) {}
+  };
+
+  /**
+   * \brief A lock as a scoped frontend for a mutex
+   *
+   * \ingroup FuncSupportThread
+   */
+  class Lock {
+  private:
+    /// The mutex used for the lock
+    Mutex& m;
+  public:
+    /// Enter lock
+    Lock(Mutex& m0);
+    /// Leave lock
+    ~Lock(void);
+  private:
+    /// A lock cannot be copied
+    Lock(const Lock& l) : m(l.m) {}
+    /// A lock cannot be assigned
+    void operator=(const Lock&) {}
+  };
+
+  /**
+   * \brief An event for synchronization
+   * 
+   * An event can be waited on by a single thread until the event is
+   * signalled.
+   *
+   * \ingroup FuncSupportThread
+   */
+  class Event {
+  private:
+#ifdef GECODE_THREADS_WINDOWS
+    /// The Windows specific handle to an event
+    HANDLE w_h;    
+#endif
+#ifdef GECODE_THREADS_PTHREADS
+    /// The Pthread mutex
+    pthread_mutex_t p_m;
+    /// The Pthread condition variable
+    pthread_cond_t p_c;
+    /// Whether the event is signalled
+    bool p_s;
+#endif
+  public:
+    /// Initialize event
+    Event(void);
+    /// Signal the event
+    void signal(void);
+    /// Wait until the event becomes signalled
+    void wait(void);
+    /// Delete event
+    ~Event(void);
+  private:
+    /// An event cannot be copied
+    Event(const Event&) {}
+    /// An event cannot be assigned
+    void operator=(const Event&) {}
+  };
+
+  /**
+   * \brief An interface for objects that can be run by a thread
+   *
+   * \ingroup FuncSupportThread
+   */
+  class Runnable {
+  public:
+    /// The function that is executed when the thread starts
+    virtual void run(void) = 0;
+    /// Destructor
+    virtual ~Runnable(void) {}
+    /// Allocate memory from heap
+    static void* operator new(size_t s);
+    /// Free memory allocated from heap
+    static void  operator delete(void* p);
+  };
+
+  /**
+   * \brief Simple threads
+   *
+   * Threads cannot be created, only runnable objects can be submitted
+   * for execution by a thread. Threads are pooled to avoid
+   * creation/destruction of threads as much as possible.
+   *
+   * \ingroup FuncSupportThread
+   */
+  class Thread {
+  public:
+    /// A real thread
+    class Run {
+    public:
+      /// Next idle thread
+      Run* n;
+      /// Runnable object to execute
+      Runnable* r;
+      /// Event to wait for next runnable object to execute
+      Event e;
+      /// Mutex for synchronization
+      Mutex m;
+      /// Create a new thread
+      GECODE_SUPPORT_EXPORT Run(Runnable* r);
+      /// Infinite loop for execution
+      GECODE_SUPPORT_EXPORT void exec(void);
+      /// Run a runnable object
+      void run(Runnable* r);
+      /// Allocate memory from heap
+      static void* operator new(size_t s);
+      /// Free memory allocated from heap
+      static void  operator delete(void* p);
+    };
+    /// Mutex for synchronization
+    GECODE_SUPPORT_EXPORT static Mutex m;
+    /// Idle runners
+    GECODE_SUPPORT_EXPORT static Run* idle;
+  public:
+    /**
+     * \brief Construct a new thread and run \a r
+     *
+     * After \a r terminates, \a r is deleted. After that, the thread
+     * terminates.
+     *
+     * If the operatins system does not support any threads, throws an
+     * exception of type Support::OperatingSystemError.
+     */
+    static void run(Runnable* r);
+    /// Put current thread to sleep for \a ms milliseconds
+    static void sleep(unsigned int ms);
+    /// Return number of processing units (1 if information not available)
+    static unsigned int npu(void);
+  private:
+    /// A thread cannot be copied
+    Thread(const Thread&) {}
+    /// A thread cannot be assigned
+    void operator=(const Thread&) {}
+  };
+
+}}
+
+#ifdef GECODE_THREADS_WINDOWS
+#include <gecode/support/thread/windows.hpp>
+#endif
+#ifdef GECODE_THREADS_PTHREADS
+#include <gecode/support/thread/pthreads.hpp>
+#endif
+#ifndef GECODE_HAS_THREADS
+#include <gecode/support/thread/none.hpp>
+#endif
+
+#include <gecode/support/thread/thread.hpp>
+
+// STATISTICS: support-any