gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/support/block-allocator.hh

@@ -0,0 +1,152 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-04-11 15:58:37 +0200 (Tue, 11 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3188 $
+ *
+ *  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_BLOCK_ALLOCATOR_HH__
+#define __GECODE_SUPPORT_BLOCK_ALLOCATOR_HH__
+
+#include "gecode/kernel.hh"
+
+namespace Gecode { namespace Support {
+
+  /**
+   * \brief Manage memory organized into block lists (allocator)
+   *
+   * The allocation policy is to free all memory allocated when
+   * the block allocator is deleted.
+   *
+   * Requires \code #include "gecode/support/block-allocator.hh" \endcode
+   * \ingroup FuncSupport
+   */
+  template <class T>
+  class BlockAllocator {
+  private:
+    /// One block of memory
+    class Block {
+    public:
+      static const int blocksize = 512;
+      T      b[blocksize];
+      Block* next;
+    };
+    /// Pointer to current block
+    Block* b;
+    /// Pointer to next part of block (decreasing)
+    T*     n;
+    /// Size of allocated blocks
+    size_t _size;
+    /// Allocate additional block
+    void allocate(void);
+  public:
+    /// Initialize
+    BlockAllocator(void);
+    /// Free all allocated blocks
+    ~BlockAllocator(void);
+    /// Return memory of size required by \a T
+    T* operator()(void);
+    /// Return size of memory required by allocator
+    size_t size(void) const;
+  };
+
+  /**
+   * \brief Client for block allocator of type \a T
+   *
+   * Provides memory management for objects of type \a T.
+   *
+   * Requires \code #include "gecode/support/block-allocator.hh" \endcode
+   * \ingroup FuncSupport
+   */
+  template <class T>
+  class BlockClient {
+  public:
+    /// Allocate memory from block allocator \a ba
+    static void* operator new(size_t s, BlockAllocator<T>& ba);
+    /// Noop (memory freed only when block allocator deleted)
+    static void  operator delete(void*, BlockAllocator<T>& ba);
+    /// Noop (memory freed only when block allocator deleted)
+    static void  operator delete(void*);
+  };
+
+
+
+  template <class T>
+  forceinline
+  BlockAllocator<T>::BlockAllocator(void) {
+    b = reinterpret_cast<Block*>(Memory::malloc(sizeof(Block)));
+    b->next = NULL;
+    n       = &b->b[Block::blocksize];
+    _size = sizeof(Block);
+  }
+
+  template <class T>
+  forceinline
+  BlockAllocator<T>::~BlockAllocator(void) {
+    while (b != NULL) {
+      Block* f = b; b = b->next;
+      Memory::free(f);
+    }
+  }
+
+  template <class T>
+  forceinline T*
+  BlockAllocator<T>::operator()(void) {
+    T* t = --n;
+    if (t == &b->b[0])
+      allocate();
+    return t;
+  }
+
+  template <class T>
+  void
+  BlockAllocator<T>::allocate(void) {
+    // Allocate another block
+    Block* nb = reinterpret_cast<Block*>(Memory::malloc(sizeof(Block)));
+    nb->next = b; b = nb;
+    n = &nb->b[Block::blocksize];
+    _size += sizeof(Block);
+  }
+
+  template <class T>
+  forceinline size_t
+  BlockAllocator<T>::size(void) const {
+    return _size;
+  }
+
+
+
+  template <class T>
+  forceinline void
+  BlockClient<T>::operator delete(void*, BlockAllocator<T>&) {
+  }
+  template <class T>
+  forceinline void
+  BlockClient<T>::operator delete(void*) {
+  }
+  template <class T>
+  forceinline void*
+  BlockClient<T>::operator new(size_t s, BlockAllocator<T>& ba) {
+    assert(s == sizeof(T));
+    return ba();
+  }
+
+}}
+
+#endif
+
+// STATISTICS: support-any

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

@@ -0,0 +1,131 @@
+/*
+ *  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_DYNAMICARRAY_HH__
+#define __GECODE_SUPPORT_DYNAMICARRAY_HH__
+
+#include "gecode/kernel.hh"
+
+#include <algorithm>
+#include <cassert>
+
+namespace Gecode { namespace Support {
+
+  /**
+   * \brief Array with arbitrary number of elements
+   *
+   * Requires \code #include "gecode/support/dynamic-array.hh" \endcode
+   * \ingroup FuncSupport
+   */
+  template <class T>
+  class DynamicArray {
+  private:
+    /// Size of array
+    int n;
+    /// Array elements
+    T*  x;
+    /// Resize to at least \a n + 1 elements
+    void resize(int n);
+  public:
+    /// Initialize with size \a m
+    DynamicArray(int m = 32);
+    /// Copy elements from array \a a
+    DynamicArray(const DynamicArray<T>& a);
+    /// Release memory
+    ~DynamicArray(void);
+
+    /// Assign array (copy elements from \a a)
+    const DynamicArray<T>& operator =(const DynamicArray<T>& a);
+
+    /// Return element at position \a i (possibly resize)
+    T& operator[](int i);
+    /// Return element at position \a i
+    const T& operator [](int) const;
+
+    /// Cast in to pointer of type \a T
+    operator T*(void);
+  };
+
+
+  template <class T>
+  forceinline
+  DynamicArray<T>::DynamicArray(int m)
+    : n(m), x(Memory::bmalloc<T>(n)) {}
+
+  template <class T>
+  forceinline
+  DynamicArray<T>::DynamicArray(const DynamicArray<T>& a)
+    : n(a.n), x(Memory::bmalloc<T>(n)) {
+    (void) Memory::bcopy<T>(x,a.x,n);
+  }
+
+  template <class T>
+  forceinline
+  DynamicArray<T>::~DynamicArray(void) {
+    Memory::free(x);
+  }
+
+  template <class T>
+  forceinline const DynamicArray<T>&
+  DynamicArray<T>::operator =(const DynamicArray<T>& a) {
+    if (this != &a) {
+      if (n < a.n) {
+	Memory::free(x); n = a.n; x = Memory::bmalloc<T>(n);
+      }
+      (void) Memory::bcopy(x,a.x,n);
+    }
+    return *this;
+  }
+
+  template <class T>
+  void
+  DynamicArray<T>::resize(int i) {
+    int m = std::max(i+1, (3*n)/2);
+    x = Memory::brealloc(x,n,m);
+    n = m;
+  }
+
+  template <class T>
+  forceinline T&
+  DynamicArray<T>::operator [](int i) {
+    if (i >= n) resize(i);
+    assert(n > i);
+    return x[i];
+  }
+
+  template <class T>
+  forceinline const T&
+  DynamicArray<T>::operator [](int i) const {
+    assert(n > i);
+    return x[i];
+  }
+
+  template <class T>
+  forceinline
+  DynamicArray<T>::operator T*(void) {
+    return x;
+  }
+
+}}
+
+#endif
+
+// STATISTICS: support-any

data/ext/gecode-1.3.1/gecode/support/dynamic-stack.hh

@@ -0,0 +1,157 @@
+/*
+ *  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_DYNAMIC_STACK_HH__
+#define __GECODE_SUPPORT_DYNAMIC_STACK_HH__
+
+#include "gecode/kernel.hh"
+
+namespace Gecode { namespace Support {
+
+  /**
+   * \brief Stack with arbitrary number of elements
+   *
+   * Requires \code #include "gecode/support/dynamic-stack.hh" \endcode
+   * \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,limit,nl);
+    limit = nl;
+  }
+
+  template <class T>
+  forceinline
+  DynamicStack<T>::DynamicStack(int n)
+    : limit(n), tos(0), stack(Memory::bmalloc<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 (limit * sizeof(T)) + sizeof(DynamicStack<T>);
+  }
+
+}}
+
+#endif
+
+// STATISTICS: support-any

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

@@ -0,0 +1,100 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *     Mikael Lagerkvist, 2005
+ *
+ *  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_RANDOM_HH__
+#define __GECODE_SUPPORT_RANDOM_HH__
+
+#define GECODE_RAND_MAX
+
+namespace Gecode { namespace Support {
+
+  /** \brief Template for linear congruential generators.
+   *
+   * This class template defines a simple class for linear
+   * congruential generators.
+   *
+   * The values used for calculation shouldbe specified so that
+   *
+   * Requires \code #include "gecode/support/random.hh" \endcode
+   * \ingroup FuncSupport
+   */
+  template<unsigned int m, unsigned int a, unsigned int q, unsigned int r>
+  class LinearCongruentialGenerator {
+    int s;
+    unsigned int next() {
+      s = a*(s%q) - r*(s/q);
+      if (s<0) s += m;
+      int res = s;
+      if (s==0) s = 1;
+      return res;
+    }
+  public:
+    // The maximum size of random numbers generated.
+    const unsigned long rand_max;
+
+    /// Construct the generator instance.
+    LinearCongruentialGenerator(int _seed = 1)
+      : rand_max(1UL<<31) {
+      seed(_seed);
+    }
+    /// Set the current seed
+    void seed(unsigned int _seed) {
+      s = _seed % m;
+      if (s == 0) s = 1;
+    }
+    /// Get the current seed
+    unsigned int seed(void) const {
+      return s;
+    }
+    /// Returns a reandom integer from the interval [0..n)
+    unsigned int operator()(unsigned int n) {
+      unsigned long x1 = next() & ((1<<16)-1);
+      unsigned long x2 = next() & ((1<<16)-1);
+      if (n < 2) return 0;
+      double d = static_cast<double>(((x1<<16) | x2)%rand_max) / rand_max;
+      int val = static_cast<int>(n * d);
+      return (val < static_cast<int>(n)) ? val : (n-1);
+    }
+  };
+
+
+  /** \brief Default choice of values for the linear congruential
+   * generator.
+   *
+   * While this pseudo-random number generator is not a good source of
+   * randomness, it is still an acceptable choice for many
+   * applications. The choice of values is taken from D. E. Knuth,
+   * The Art of Computer Programming, Vol 2, Seminumerical Algorithms,
+   * 3rd edition.
+   *
+   * Requires \code #include "gecode/support/random.hh" \endcode
+   * \ingroup FuncSupport
+   */
+  typedef LinearCongruentialGenerator<2147483647, 48271, 44488, 3399>
+  RandomGenerator;
+
+}}
+
+#endif /* __GECODE_SUPPORT_RANDOM_HH__ */
+
+// STATISTICS: support-any