gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/gecode/support/dynamic-stack.icc

@@ -0,0 +1,167 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2007-09-19 09:51:28 +0200 (Wed, 19 Sep 2007) $ by $Author: schulte $
+ *     $Revision: 5048 $
+ *
+ *  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 arbitrary number of elements
+   *
+   * \ingroup FuncSupport
+   */
+  template <class T>
+  class DynamicStack {
+  private:
+    /// Current size of the stack
+    int limit;
+    /// Top of stack
+    int tos;
+    /// Elements on stack
+    T*  stack;
+    /// Resize stack (increase size)
+    void resize(void);
+  public:
+    /// Initialize stack with \a n elements
+    DynamicStack(int n=64);
+    /// Release memory
+    ~DynamicStack(void);
+
+    /// Test whether stack is empty
+    bool empty(void) const;
+    /// Pop topmost element from stack and return it
+    T pop(void);
+    /// Return top of stack
+    T& top(void);
+    /// Push element on stack
+    void push(T);
+
+
+    /// Return number of entries currently on stack
+    int entries(void) const;
+    /** \brief Return entry at position \a i
+     *
+     * Position 0 corresponds to the element first pushed,
+     * whereas position \c entries()-1 corresponds to the
+     * element pushed last.
+     */
+    T& operator[](int i);
+    /** \brief Return entry at position \a i
+     *
+     * Position 0 corresponds to the element first pushed,
+     * whereas position \c entries()-1 corresponds to the
+     * element pushed last.
+     */
+    const T& operator[](int i) const;
+
+    /// Return size of stack
+    size_t size(void) const;
+  };
+
+
+  template <class T>
+  void
+  DynamicStack<T>::resize(void) {
+    int nl = (limit * 3) / 2;
+    stack = Memory::brealloc<T>(stack,
+                                static_cast<size_t>(limit),
+                                static_cast<size_t>(nl));
+    limit = nl;
+  }
+
+  template <class T>
+  forceinline
+  DynamicStack<T>::DynamicStack(int n)
+    : limit(n), tos(0), stack(Memory::bmalloc<T>(static_cast<size_t>(n))) {}
+
+  template <class T>
+  forceinline
+  DynamicStack<T>::~DynamicStack(void) {
+    Memory::free(stack);
+  }
+
+  template <class T>
+  forceinline T
+  DynamicStack<T>::pop(void) {
+    return stack[--tos];
+  }
+
+  template <class T>
+  forceinline T&
+  DynamicStack<T>::top(void) {
+    return stack[tos-1];
+  }
+
+  template <class T>
+  forceinline void
+  DynamicStack<T>::push(T x) {
+    stack[tos++] = x;
+    if (tos==limit)
+      resize();
+  }
+
+  template <class T>
+  forceinline bool
+  DynamicStack<T>::empty(void) const {
+    return tos==0;
+  }
+
+  template <class T>
+  forceinline int
+  DynamicStack<T>::entries(void) const {
+    return tos;
+  }
+
+  template <class T>
+  forceinline T&
+  DynamicStack<T>::operator[](int i) {
+    return stack[i];
+  }
+
+  template <class T>
+  forceinline const T&
+  DynamicStack<T>::operator[](int i) const {
+    return stack[i];
+  }
+
+  template <class T>
+  forceinline size_t
+  DynamicStack<T>::size(void) const {
+    return (static_cast<size_t>(limit) * sizeof(T)) + sizeof(DynamicStack<T>);
+  }
+
+}}
+
+// STATISTICS: support-any

data/ext/gecode-2.1.1/gecode/support/exception.cc

@@ -0,0 +1,65 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  Last modified:
+ *     $Date: 2007-09-11 13:54:00 +0200 (Tue, 11 Sep 2007) $ by $Author: schulte $
+ *     $Revision: 4969 $
+ *
+ *  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 "gecode/support.hh"
+
+namespace Gecode {
+
+  /*
+   * Base class for exceptions
+   *
+   */
+  Exception::Exception(const char* l, const char* i) throw() {
+    int j = 0;
+    while ((*l != 0) && (j < li_max))
+      li[j++] = *(l++);
+    if (j < li_max)
+      li[j++] = ':';
+    if (j < li_max)
+      li[j++] = ' ';
+    while ((*i != 0) && (j < li_max))
+      li[j++] = *(i++);
+    li[j] = 0;
+  }
+  const char*
+  Exception::what(void) const throw() {
+    return &li[0];
+  }
+
+}
+
+// STATISTICS: support-any

data/ext/gecode-2.1.1/gecode/support/exception.icc

@@ -0,0 +1,82 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2007-12-06 14:09:40 +0100 (Thu, 06 Dec 2007) $ by $Author: tack $
+ *     $Revision: 5608 $
+ *
+ *  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 <exception>
+
+namespace Gecode {
+
+  /**
+   * \brief %Exception: Base-class for exceptions
+   * \ingroup FuncThrow
+   */
+  class GECODE_SUPPORT_EXPORT Exception : public std::exception {
+  private:
+    static const int li_max = 128;
+    char li[li_max+1];
+  public:
+    /// Initialize with location \a l and information \a i
+    Exception(const char* l, const char* i) throw ();
+    /// Return information
+    virtual const char* what(void) const throw();
+  };
+
+
+  /**
+   * \defgroup FuncThrowSupport Support exceptions
+   * \ingroup FuncThrow
+   */
+
+  //@{
+  /// %Exception: %Memory exhausted
+  class GECODE_VTABLE_EXPORT MemoryExhausted : public Exception {
+  public:
+    /// Initialize
+    MemoryExhausted(void);
+  };
+  //@}
+
+  /*
+   * Classes for exceptions raised by support
+   *
+   */
+  inline
+  MemoryExhausted::MemoryExhausted(void)
+    : Exception("Memory","Heap memory exhausted") {}
+
+}
+
+// STATISTICS: support-any

data/ext/gecode-2.1.1/gecode/support/macros.icc

@@ -0,0 +1,103 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-01-15 19:46:56 +0100 (Tue, 15 Jan 2008) $ by $Author: schulte $
+ *     $Revision: 5885 $
+ *
+ *  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.
+ *
+ */
+
+/// Concatenate \a R and \a LINE
+#define GECODE_CAT2(R,LINE) R ## LINE
+/// Concatenate macro-expanded \a R and \a LINE
+#define GECODE_CAT(R,LINE) GECODE_CAT2(R,LINE)
+/// Generate fresh name with prefix P
+#define GECODE_FRESH(P) GECODE_CAT(_GECODE_ ## P, __LINE__)
+
+/**
+ * \def GECODE_NEVER
+ * \brief Assert that this command is never executed
+ *
+ * This is preferred over assert(false) as it is used for optimization,
+ * if supported by a compiler (for example, Microsoft Visual C++).
+ *
+ */
+
+#if defined(_MSC_VER) && defined(NDEBUG)
+
+#define GECODE_NEVER __assume(false);
+
+#else
+
+#define GECODE_NEVER assert(false);
+
+#endif
+
+/**
+ * \def GECODE_NOT_NULL
+ * \brief Assert that a pointer is never NULL
+ *
+ * This is preferred over assert as it is used for optimization,
+ * if supported by a compiler (for example, Microsoft Visual C++).
+ *
+ */
+
+#if defined(_MSC_VER) && defined(NDEBUG)
+
+#define GECODE_NOT_NULL(p) __assume(p != NULL);
+
+#else
+
+#define GECODE_NOT_NULL(p) assert(p != NULL);
+
+#endif
+
+/**
+ * \def GECODE_ASSUME
+ * \brief Assert certain property
+ *
+ * This might be used for optimization as well (for example, 
+ * Microsoft Visual C++), otherwise it behaves like any
+ * assert.
+ *
+ */
+
+#if defined(_MSC_VER) && defined(NDEBUG)
+
+#define GECODE_ASSUME(p) __assume((p));
+
+#else
+
+#define GECODE_ASSUME(p) assert((p));
+
+#endif
+
+// STATISTICS: support-any

data/ext/gecode-2.1.1/gecode/support/map.icc

@@ -0,0 +1,207 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2007
+ *
+ *  Last modified:
+ *     $Date: 2007-12-10 11:40:09 +0100 (Mon, 10 Dec 2007) $ by $Author: schulte $
+ *     $Revision: 5654 $
+ *
+ *  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 Hash map
+    *
+    * This class is used as a symbol table. \a Key objects must
+    * have a hash function (see String class as an example).
+    */
+  template <class Key, class Value>
+  class Map {
+  private:
+    /// Key-value pairs stored in the hash table
+    class Pair {
+    public:
+      Key k; Value v;
+      Pair(const Key& k0, const Value& v0) : k(k0), v(v0) {}
+    };
+    
+    /// The actual table
+    Pair** a;
+    /// The size of the table (approximately \f$2^n\f$)
+    int n;
+    /// How many table entries are actually used
+    int usage;
+    /// Compute the actual size from \a n
+    int modulo(void) const;
+    /// Resize and rehash the table
+    void rehash(void);
+  public:
+    /// Constructor
+    Map(void);
+    /// Insert \a v at key \a k
+    void put(const Key& k, Value v);
+    /// Check if entry with key \a k exists and return it in \a v
+    bool get(const Key& k, Value& v) const;
+    /// Destructor
+    GECODE_MSC_VIRTUAL ~Map(void);
+  };
+  
+  /// Hash table for strings
+  template <class Value>
+  class SymbolMap : public Map<Symbol,Value> {
+  };
+
+  /// Pointer wrapper class to make pointers hashable
+  template <class P>
+  class Pointer {
+  protected:
+    /// The actual pointer
+    P* p;
+  public:
+    /// Constructor
+    Pointer(P* p0) : p(p0) {}
+    /// Cast
+    P* operator()(void) { return p; }
+    /// Comparison
+    bool operator==(const Pointer<P>& p0) const { 
+      return p == p0.p; 
+    }
+    /// Hash function
+    int hash(int m) const {
+      return static_cast<unsigned int>(reinterpret_cast<ptrdiff_t>(p)) % m;
+    }
+  };
+  
+  /// Hash table for pointers
+  template <class P, class Value>
+  class PtrMap : public Map<Pointer<P>,Value> {
+  };
+  
+  /*
+   * Implementation
+   *
+   */
+  
+  template <class Key, class Value>
+  forceinline int
+  Map<Key,Value>::modulo(void) const {
+    const int primes[] = { 17, 47, 1021, 2039, 4093, 8191,
+                           16381, 32749, 65521, 131071,
+                           262139, 524287, 1048573, 2097143,
+                           4194301, 8388593 };
+    return primes[n];
+  }
+  
+  template <class Key, class Value>
+  Map<Key,Value>::Map(void) : n(0), usage(0) {
+    a = static_cast<Pair**>(Memory::malloc(sizeof(Pair*)*modulo()));
+    for (int i=modulo(); i--; )
+      a[i] = NULL;
+  }
+  
+  template <class Key, class Value>
+  void
+  Map<Key,Value>::rehash(void) {
+    int oldM = modulo();
+    n++;
+    Pair** olda = a;
+    a = static_cast<Pair**>(Memory::malloc(sizeof(Pair*)*modulo()));
+    for (int i=modulo(); i--; )
+      a[i] = NULL;
+    for (int i=oldM; i--;) {
+      if (olda[i] != NULL) {
+        int j = olda[i]->k.hash(modulo());
+        for (; j < modulo() && a[j] != NULL; j++) {}
+        if (j >= modulo()) {
+          for (j=0; a[j] != NULL; j++) {}
+          assert(j<olda[i]->k.hash(modulo()));
+        }
+        assert(j < modulo());
+        assert(a[j] == NULL);
+        a[j] = olda[i];
+      }
+    }
+#ifndef NDEBUG
+    int actualUsage = 0;
+    for (int i=modulo(); i--;)
+      if (a[i]) actualUsage++;
+    assert(actualUsage == usage);
+#endif
+    Memory::free(olda);
+  }
+  
+  template <class Key, class Value>
+  void
+  Map<Key,Value>::put(const Key& k, Value v) {
+    // If more than 75% are used, make some room
+    if (usage * 3 >= modulo() * 2)
+      rehash();
+      
+    int i = k.hash(modulo());
+    for (; i < modulo() && a[i] != NULL; i++) {}
+    if (i >= modulo()) {
+      for (i=0; a[i] != NULL; i++) {}
+      assert(i<k.hash(modulo()));
+    }
+    assert(i < modulo());
+    assert(a[i] == NULL);
+    a[i] = new Pair(k,v);
+    usage++;
+  }
+  
+  template <class Key, class Value>
+  inline bool
+  Map<Key,Value>::get(const Key& k, Value& v) const {
+    int i=k.hash(modulo());
+    for (; i<modulo() && a[i] != NULL; i++) {
+      if (a[i]->k == k) {
+        v = a[i]->v; return true;
+      }
+    }
+    if (i >= modulo()) {
+      for (i=0; a[i] != NULL; i++) {
+        if (a[i]->k == k) {
+          v = a[i]->v; return true;
+        }        
+      }
+    }
+    return false;
+  }
+  
+  template <class Key, class Value>
+  Map<Key,Value>::~Map(void) {
+    for (int i=modulo(); i--; )
+      delete a[i];
+    Memory::free(a);
+  }
+
+}}
+
+// STATISTICS: support-any