gecoder-with-gecode 0.7.1 → 0.8.0

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

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

@@ -1,131 +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_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

@@ -1,157 +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_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

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