gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-1.3.1/gecode/iter/virtual-ranges.icc

@@ -1,126 +0,0 @@
-/*
- *  Main authors:
- *     Guido Tack <tack@gecode.org>
- *
- *  Copyright:
- *     Guido Tack, 2006
- *
- *  Last modified:
- *     $Date: 2006-07-14 13:46:14 +0200 (Fri, 14 Jul 2006) $ by $Author: tack $
- *     $Revision: 3363 $
- *
- *  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.
- *
- */
-
-namespace Gecode { namespace Iter { namespace Ranges { namespace Virt {
-
-  /**
-   * \brief Abstract base class for range iterators
-   *
-   * Requires \code #include "gecode/iter.hh" \endcode
-   * \ingroup FuncIterRangesVirt
-   */
-  class Iterator {
-  public:
-    /// \name Iteration control
-    //@{
-    /// Move iterator to next range (if possible)
-    virtual void operator++(void) = 0;
-    /// Test whether iterator is still at a range or done
-    virtual bool operator()(void) = 0;
-    //@}
-    /// \name Range access
-    //@{
-    /// Return smallest value of range
-    virtual int min(void) const = 0;
-    /// Return largest value of range
-    virtual int max(void) const = 0;
-    /// Return width of range (distance between minimum and maximum)
-    virtual unsigned int width(void) const = 0;
-    //@}
-
-    /// Virtual destructor
-    virtual ~Iterator(void);
-  };
-
-  forceinline
-  Iterator::~Iterator(void) {}
-
-  /**
-   * \brief Adaptor class to virtualize any iterator
-   *
-   * Provides an iterator with virtual member functions for any template-based
-   * iterator.
-   *
-   * Requires \code #include "gecode/iter.hh" \endcode
-   * \ingroup FuncIterRangesVirt
-   */
-  template <class I>
-  class RangesTemplate : public Iterator {
-  private:
-    /// The template-based iterator
-    I i;
-  public:
-    /// \name Constructors and initialization
-    //@{
-    /// Initialize with iterator \a i
-    RangesTemplate(I& i);
-    /// Initialize with iterator \a i
-    void init(I& i);
-    //@}
-    /// \name Iteration control
-    //@{
-    /// Move iterator to next range (if possible)
-    virtual void operator++(void);
-    /// Test whether iterator is still at a range or done
-    virtual bool operator()(void);
-    //@}
-
-    /// \name Range access
-    //@{
-    /// Return smallest value of range
-    virtual int min(void) const;
-    /// Return largest value of range
-    virtual int max(void) const;
-    /// Return width of range (distance between minimum and maximum)
-    virtual unsigned int width(void) const;
-    //@}
-  };
-
-  template <class I>
-  RangesTemplate<I>::RangesTemplate(I& i0) : i(i0) {}
-
-  template <class I>
-  void
-  RangesTemplate<I>::init(I& i0) { i=i0; }
-
-  template <class I>
-  bool
-  RangesTemplate<I>::operator()(void) { return i(); }
-
-  template <class I>
-  void
-  RangesTemplate<I>::operator++(void) { ++i; }
-
-  template <class I>
-  int
-  RangesTemplate<I>::min(void) const { return i.min(); }
-
-  template <class I>
-  int
-  RangesTemplate<I>::max(void) const { return i.max(); }
-
-  template <class I>
-  unsigned int
-  RangesTemplate<I>::width(void) const { return i.width(); }
-
-}}}}
-
-// STATISTICS: iter-any

data/ext/gecode-1.3.1/gecode/kernel.hh

@@ -1,141 +0,0 @@
-/*
- *  Main authors:
- *     Christian Schulte <schulte@gecode.org>
- *
- *  Contributing authors:
- *     Guido Tack <tack@gecode.org>
- *
- *  Copyright:
- *     Christian Schulte, 2004
- *     Guido Tack, 2004
- *
- *  Last modified:
- *     $Date: 2006-08-24 10:39:08 +0200 (Thu, 24 Aug 2006) $ by $Author: tack $
- *     $Revision: 3558 $
- *
- *  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_KERNEL_HH__
-#define __GECODE_KERNEL_HH__
-
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <cassert>
-
-#include "gecode/config.icc"
-
-/*
- * Support for DLLs under Windows
- *
- */
-
-#if !defined(GECODE_STATIC_LIBS) && \
-    (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
-
-#ifdef GECODE_BUILD_KERNEL
-#define GECODE_KERNEL_EXPORT __declspec( dllexport )
-#else
-#define GECODE_KERNEL_EXPORT __declspec( dllimport )
-#endif
-
-#else
-
-#ifdef GCC_HASCLASSVISIBILITY
-
-#define GECODE_KERNEL_EXPORT __attribute__ ((visibility("default")))
-
-#else
-
-#define GECODE_KERNEL_EXPORT
-
-#endif
-#endif
-
-/**
- * \namespace Gecode
- * \brief Gecode toplevel namespace
- *
- * The Gecode namespace contains nested namespaces for
- * the various submodules (for example Int for the
- * definition of integer propagator classes). Functionality
- * that is used for interfacing (search engines, variables,
- * and so on) or belongs to the %Gecode %Kernel is contained
- * directly in the Gecode namespace.
- *
- */
-
-/*
- * General exceptions and kernel exceptions
- *
- */
-
-#include "gecode/kernel/exception.icc"
-
-
-
-/*
- * Basic kernel services
- *
- */
-
-#include "gecode/kernel/memory.icc"
-#include "gecode/kernel/memory-manager.icc"
-
-
-/*
- * Macros for checking failure
- *
- */
-
-
-#include "gecode/kernel/macros.icc"
-
-/*
- * Gecode kernel
- *
- */
-
-#include "gecode/kernel/core.icc"
-#include "gecode/kernel/modevent.icc"
-
-
-/*
- * Variable views and testing for shared variables
- *
- */
-
-#include "gecode/kernel/view.icc"
-
-
-
-/*
- * Variable and argument arrays
- *
- */
-
-#include "gecode/kernel/array.icc"
-
-
-
-
-/*
- * Common propagator and branching patterns
- *
- */
-
-#include "gecode/kernel/propagator.icc"
-#include "gecode/kernel/branching.icc"
-
-#endif
-
-
-// STATISTICS: kernel-other

data/ext/gecode-1.3.1/gecode/kernel/array.icc

@@ -1,954 +0,0 @@
-/*
- *  Main authors:
- *     Christian Schulte <schulte@gecode.org>
- *     Guido Tack <tack@gecode.org>
- *
- *  Copyright:
- *     Christian Schulte, 2003
- *     Guido Tack, 2004
- *
- *  Last modified:
- *     $Date: 2006-10-10 20:13:50 +0200 (Tue, 10 Oct 2006) $ by $Author: tack $
- *     $Revision: 3741 $
- *
- *  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.
- *
- */
-
-#include <cstdarg>
-#include "gecode/support/sort.hh"
-
-namespace Gecode {
-
-  template <class Var> class VarArray;
-  template <class Var> class VarArgArray;
-
-  /**
-   * \brief %Variable arrays
-   *
-   * %Variable arrays store variables. They are typically used
-   * for storing the variables being part of a solution.
-   *
-   * Never use them for temporary purposes, use argument arrays
-   * instead.
-   * \ingroup TaskVar
-   */
-  template <class Var>
-  class VarArray {
-  protected:
-    /// Number of variables (size)
-    int  n;
-    /// Array of variables
-    Var* x;
-  public:
-    /// \name Constructors and initialization
-    //@{
-    /// Default constructor (array of size 0)
-    VarArray(void);
-    /// Allocate array with \a m variables
-    VarArray(Space*, int m);
-    /// Initialize from variable argument array \a a (copy elements)
-    VarArray(Space*,const VarArgArray<Var>&);
-    /// Initialize from variable array \a a (share elements)
-    VarArray(const VarArray<Var>& a);
-    /// Initialize from variable array \a a (share elements)
-    const VarArray<Var>& operator=(const VarArray<Var>& a);
-    //@}
-
-    /// \name Array size
-    //@{
-    /// Return size of array (number of elements)
-    int size(void) const;
-    //@}
-
-    /// \name Array elements
-    //@{
-    /// Return variable at position \a i
-    Var& operator[](int i);
-    /// Return variable at position \a i
-    const Var& operator[](int i) const;
-    //@}
-
-    /// \name Cloning
-    //@{
-    /**
-     * \brief Update array to be a clone of array \a a
-     *
-     * If \a share is true, sharing is retained for all shared
-     * data structures. Otherwise, for each of them an independent
-     * copy is created.
-     */
-    void update(Space*, bool share, VarArray<Var>& a);
-    //@}
-  private:
-    static void* operator new(size_t);
-    static void  operator delete(void*,size_t);
-  };
-
-
-  /**
-   * \brief View arrays
-   *
-   * View arrays store views. They are typically used for storing the
-   * views with which propagators and branchings compute.
-   * \ingroup TaskActor
-   */
-  template <class View>
-  class ViewArray {
-  private:
-    /// Number of views (size)
-    int  n;
-    /// Views
-    View* x;
-    /// Sort order for views
-    class ViewLess {
-    public:
-      bool operator()(const View&, const View&);
-    };
-    /// Sort \a n views \a x according to \a ViewLess
-    static void sort(View* x, int n);
-  public:
-    /// \name Constructors and initialization
-    //@{
-    /// Default constructor (array of size 0)
-    ViewArray(void);
-    /// Allocate array with \a m variables
-    ViewArray(Space*, int m);
-    /// Initialize from view array \a a (share elements)
-    ViewArray(const ViewArray<View>& a);
-    /// Initialize from view array \a a (copy elements)
-    ViewArray(Space*,const ViewArray<View>& a);
-    /// Initialize from view array \a a (share elements)
-    const ViewArray<View>& operator=(const ViewArray<View>& a);
-    /**
-     * \brief Initialize from variable argument array \a a (copy elements)
-     *
-     * Note that the view type \a View must provide a constructor
-     * for the associated \a Var type.
-     */
-    template <class Var>
-    ViewArray(Space* home, const VarArgArray<Var>& a)
-      : n(a.size()) {
-      // This may not be in the icc file (to satisfy the MS compiler)
-      if (n>0) {
-	x = static_cast<View*>(home->alloc(sizeof(View)*n));
-	for (int i = n; i--; )
-	  x[i] = a[i];
-      } else {
-	x = NULL;
-      }
-    }
-    //@}
-
-    /// \name Array size
-    //@{
-    /// Return size of array (number of elements)
-    int size(void) const;
-    /// Decrease size of array (number of elements)
-    void size(int n);
-    //@}
-
-    /// \name Array elements
-    //@{
-    /// Return view at position \a i
-    View& operator[](int i);
-    /// Return view at position \a i
-    const View& operator[](int i) const;
-    //@}
-
-    /// \name Dependencies
-    //@{
-    /**
-     * \brief Subscribe propagator \a p with propagation condition \a pc to variable
-     *
-     * In case \a process is false, the propagator is just subscribed but
-     * not processed for execution (this must be used when creating
-     * subscriptions during propagation).
-     */
-    void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
-    /// Cancel subscription of propagator \a p with propagation condition \a pc to all views
-    void cancel(Space* home, Propagator* p, PropCond pc);
-    //@}
-
-    /// \name Cloning
-    //@{
-    /**
-     * \brief Update array to be a clone of array \a a
-     *
-     * If \a share is true, sharing is retained for all shared
-     * data structures. Otherwise, for each of them an independent
-     * copy is created.
-     */
-    void update(Space*, bool share, ViewArray<View>& a);
-    //@}
-
-
-    /// \name Moving elements
-    //@{
-    /// Move assigned view from position 0 to position \a i (shift elements to the left)
-    void move_fst(int i);
-    /// Move assigned view from position \c size()-1 to position \a i (truncate array by one)
-    void move_lst(int i);
-    /** \brief Move view from position 0 to position \a i (shift elements to the left)
-     *
-     * Before moving, cancel subscription of propagator \a p with
-     * propagation condition \a pc to view at position \a i.
-     */
-    void move_fst(int i, Space* home, Propagator* p, PropCond pc);
-    /** \brief Move view from position \c size()-1 to position \a i (truncate array by one)
-     *
-     * Before moving, cancel subscription of propagator \a p with
-     * propagation condition \a pc to view at position \a i.
-     */
-    void move_lst(int i, Space* home, Propagator* p, PropCond pc);
-    //@}
-
-    /// \name Dropping elements
-    //@{
-    /// Drop assigned views from positions 0 to \a i-1 from array
-    void drop_fst(int i);
-    /// Drop assigned views from positions \a i+1 to \c size()-1 from array
-    void drop_lst(int i);
-    /** \brief Drop views from positions 0 to \a i-1 from array
-     *
-     * Before moving, cancel subscription of propagator \a p with
-     * propagation condition \a pc to views at positions 0 to \a i-1.
-     */
-    void drop_fst(int i, Space* home, Propagator* p, PropCond pc);
-    /** \brief Drop assigned views from positions \a i+1 to \c size()-1 from array
-     *
-     * Before moving, cancel subscription of propagator \a p with
-     * propagation condition \a pc to views at positions \a i+1 to
-     * \c size()-1.
-     */
-    void drop_lst(int i, Space* home, Propagator* p, PropCond pc);
-    //@}
-
-    /// \name View equality
-    //@{
-    /// Test whether array has same views
-    bool same(void) const;
-    /// Test whether array contains a view being the same as \a y
-    bool same(const View& y) const;
-    /// Remove all duplicate views from array (changes element order)
-    void unique(void);
-    //@}
-
-    /// \name View sharing
-    //@{
-    /// Test whether array has shared views
-    bool shared(void) const;
-    /// Test whether array contains view shared with \a y
-    bool shared(const View& y) const;
-    //@}
-
-  private:
-    static void* operator new(size_t);
-    static void  operator delete(void*,size_t);
-  };
-
-  /**
-   * \brief Base-class for argument arrays
-   *
-   * Argument arrays are used as convenient mechanism of passing arguments
-   * when calling functions as they combine both the size and the elements
-   * of an array. For a small number of elements, memory is allocated by
-   * creating an argument array object. Otherwise the memory is allocated
-   * from the heap.
-   *
-   * This base-class is not to be used directly, use PrimArgArray for
-   * argument arrays of primitive types and VarArgArray for argument
-   * arrays storing variables.
-   */
-  template <class T>
-  class ArgArrayBase {
-  protected:
-    /// Number of elements
-    int n;
-    /// Element array
-    T*  a;
-    /// How much elements are possible inside array
-    static const int onstack_size = 16;
-    /// In-array storage for elements
-    T onstack[onstack_size];
-    /// Allocate memory for \a n elements
-    T* allocate(int n);
-  public:
-    /// \name Constructors and initialization
-    //@{
-    /// Allocate array with \a n elements
-    ArgArrayBase(int n);
-    /// Initialize from argument array \a a (copy elements)
-    ArgArrayBase(const ArgArrayBase<T>& a);
-    /// Initialize from view array \a a (copy elements)
-    const ArgArrayBase<T>& operator=(const ArgArrayBase<T>& a);
-    //@}
-
-    /// \name Array size
-    //@{
-    /// Return size of array (number of elements)
-    int size(void) const;
-    //@}
-
-    /// \name Array elements
-    //@{
-    /// Return element at position \a i
-    T& operator[](int i);
-    /// Return element at position \a i
-    const T& operator[](int i) const;
-    //@}
-
-    /// \name Destructor
-    //@{
-    /// Destructor
-    ~ArgArrayBase(void);
-    //@}
-  private:
-    static void* operator new(size_t);
-    static void  operator delete(void*,size_t);
-  };
-
-
-  /**
-   * \brief Argument array for primtive types
-   *
-   * Argument arrays are used as convenient mechanism of passing arguments
-   * when calling functions as they combine both the size and the elements
-   * of an array. For a small number of elements, memory is allocated by
-   * creating an argument array object. Otherwise the memory is allocated
-   * from the heap.
-   *
-   * \ingroup TaskVar
-   */
-  template <class T>
-  class PrimArgArray : public ArgArrayBase<T> {
-  protected:
-    using ArgArrayBase<T>::a;
-  public:
-    using ArgArrayBase<T>::size;
-    /// \name Constructors and initialization
-    //@{
-    /// Allocate array with \a n elements
-    PrimArgArray(int n);
-    /// Allocate array with \a n elements and initialize with \a e0, ...
-    PrimArgArray(int n, T e0, ...);
-    /// Allocate array with \a n elements and initialize with elements from array \a e
-    PrimArgArray(int n, const T* e);
-    /// Initialize from primitive argument array \a a (copy elements)
-    PrimArgArray(const PrimArgArray<T>& a);
-    //@}
-  };
-
-  /**
-   * \brief Argument array for variables
-   *
-   * Argument arrays are used as convenient mechanism of passing arguments
-   * when calling functions as they combine both the size and the elements
-   * of an array. For a small number of elements, memory is allocated by
-   * creating an argument array object. Otherwise the memory is allocated
-   * from the heap.
-   *
-   * \ingroup TaskVar
-   */
-  template <class Var>
-  class VarArgArray : public ArgArrayBase<Var> {
-  protected:
-    using ArgArrayBase<Var>::a;
-    using ArgArrayBase<Var>::n;
-    /// Sort order for variables
-    class VarLess {
-    public:
-      bool operator()(const Var&, const Var&);
-    };
-  public:
-    using ArgArrayBase<Var>::size;
-    /// \name Constructors and initialization
-    //@{
-    /// Allocate array with \a n elements
-    VarArgArray(int n);
-    /// Initialize from variable argument array \a a (copy elements)
-    VarArgArray(const VarArgArray<Var>& a);
-    /// Initialize from variable array \a a (copy elements)
-    VarArgArray(const VarArray<Var>& a);
-    //@}
-    /// \name Variable equality
-    //@{
-    /// Test whether array contains same variable multiply
-    bool same(void) const;
-    /// Test whether array contains variable \a y
-    bool same(const Var& y) const;
-    /// Test whether all elements from array and \a y contains same variable multiply
-    bool same(const VarArgArray<Var>& y) const;
-    //@}
-  };
-
-  /** \brief Traits of arrays in Gecode
-   *
-   * This class collects the traits of an array in Gecode.
-   * The traits used are the following.
-   *     - <code>typedef Type storage_type</code>  where \c Type is the type
-   *       of an appropriate storage type for this array.
-   *     - <code>typedef Type value_type</code>  where \c Type is the type
-   *       of the elements of this array.
-   *     - <code>typedef Type args_type</code>  where \c Type is the type
-   *       of the appropriate Args-array type (e.g., \c BoolVarArgs if \c A is
-   *       \c BoolVarArray).
-   */
-  template <class A>
-  class ArrayTraits {};
-
-  /*
-   * Implementation
-   *
-   */
-
-  /*
-   * Variable arrays
-   *
-   */
-
-  template <class Var>
-  forceinline
-  VarArray<Var>::VarArray(void) : n(0), x(NULL) {}
-
-  template <class Var>
-  forceinline
-  VarArray<Var>::VarArray(Space* home, int n0)
-    : n(n0) {
-    x = (n>0) ? static_cast<Var*>(home->alloc(sizeof(Var)*n)) : NULL;
-  }
-
-  template <class Var>
-  forceinline
-  VarArray<Var>::VarArray(const VarArray<Var>& a) {
-    n = a.n; x = a.x;
-  }
-
-  template <class Var>
-  forceinline const VarArray<Var>&
-  VarArray<Var>::operator=(const VarArray<Var>& a) {
-    n = a.n; x = a.x;
-    return *this;
-  }
-
-  template <class Var>
-  forceinline int
-  VarArray<Var>::size(void) const {
-    return n;
-  }
-
-  template <class Var>
-  forceinline Var&
-  VarArray<Var>::operator[](int i) {
-    assert((i >= 0) && (i < size()));
-    return x[i];
-  }
-
-  template <class Var>
-  forceinline const Var&
-  VarArray<Var>::operator[](int i) const {
-    assert((i >= 0) && (i < size()));
-    return x[i];
-  }
-
-  template <class Var>
-  forceinline void
-  VarArray<Var>::update(Space* home, bool share, VarArray<Var>& a) {
-    n = a.n;
-    if (n > 0) {
-      x = static_cast<Var*>(home->alloc(sizeof(Var)*n));
-      for (int i = n; i--; )
-	x[i].update(home, share, a.x[i]);
-    } else {
-      x = NULL;
-    }
-  }
-
-  template <class Var>
-  void*
-  VarArray<Var>::operator new(size_t) {
-    return NULL;
-  }
-
-  template <class Var>
-  void
-  VarArray<Var>::operator delete(void*,size_t) {
-  }
-
-  /*
-   * View arrays
-   *
-   */
-
-  template <class View>
-  forceinline
-  ViewArray<View>::ViewArray(void) : n(0), x(NULL) {}
-
-  template <class View>
-  forceinline
-  ViewArray<View>::ViewArray(Space* home, int n0)
-    : n(n0) {
-    x = (n>0) ? static_cast<View*>(home->alloc(sizeof(View)*n)) : NULL;
-  }
-
-  template <class View>
-  ViewArray<View>::ViewArray(Space* home, const ViewArray<View>& a)
-    : n(a.size()) {
-    if (n>0) {
-      x = static_cast<View*>(home->alloc(sizeof(View)*n));
-      for (int i = n; i--; )
-	x[i] = a[i];
-    } else {
-      x = NULL;
-    }
-  }
-
-  template <class View>
-  forceinline
-  ViewArray<View>::ViewArray(const ViewArray<View>& a)
-    : n(a.n), x(a.x) {}
-
-  template <class View>
-  forceinline const ViewArray<View>&
-  ViewArray<View>::operator=(const ViewArray<View>& a) {
-    n = a.n; x = a.x;
-    return *this;
-  }
-
-  template <class View>
-  forceinline int
-  ViewArray<View>::size(void) const {
-    return n;
-  }
-
-  template <class View>
-  forceinline void
-  ViewArray<View>::size(int n0) {
-    n = n0;
-  }
-
-  template <class View>
-  forceinline View&
-  ViewArray<View>::operator[](int i) {
-    assert((i >= 0) && (i < size()));
-    return x[i];
-  }
-
-  template <class View>
-  forceinline const View&
-  ViewArray<View>::operator[](int i) const {
-    assert((i >= 0) && (i < size()));
-    return x[i];
-  }
-
-  template <class View>
-  forceinline void
-  ViewArray<View>::move_fst(int i) {
-    // move x[0] to x[i]
-    assert(x[i].assigned());
-    x[i]=x[0]; x++; n--;
-  }
-
-  template <class View>
-  forceinline void
-  ViewArray<View>::move_lst(int i) {
-    // move x[n-1] to x[i]
-    assert(x[i].assigned());
-    n--; x[i]=x[n];
-  }
-
-  template <class View>
-  forceinline void
-  ViewArray<View>::drop_fst(int i) {
-    // Drop elements from 0..i-1
-    assert(i>=0);
-    x += i; n -= i;
-  }
-
-  template <class View>
-  forceinline void
-  ViewArray<View>::drop_lst(int i) {
-    // Drop elements from i+1..n-1
-    assert(i<n);
-    n = i+1;
-  }
-
-  template <class View>
-  forceinline void
-  ViewArray<View>::move_fst(int i, Space* home, Propagator* p, PropCond pc) {
-    // Move x[0] to x[i]
-    x[i].cancel(home,p,pc);
-    x[i]=x[0]; x++; n--;
-  }
-
-  template <class View>
-  forceinline void
-  ViewArray<View>::move_lst(int i, Space* home, Propagator* p, PropCond pc) {
-    // Move x[n-1] to x[i]
-    x[i].cancel(home,p,pc);
-    n--; x[i]=x[n];
-  }
-
-  template <class View>
-  void
-  ViewArray<View>::drop_fst(int i, Space* home, Propagator* p, PropCond pc) {
-    // Drop elements from 0..i-1
-    assert(i>=0);
-    for (int j=i; j--; )
-      x[j].cancel(home,p,pc);
-    x += i; n -= i;
-  }
-
-  template <class View>
-  void
-  ViewArray<View>::drop_lst(int i, Space* home, Propagator* p, PropCond pc) {
-    // Drop elements from i+1..n-1
-    assert(i<n);
-    for (int j=i+1; j<n; j++)
-      x[j].cancel(home,p,pc);
-    n = i+1;
-  }
-
-  template <class View>
-  void
-  ViewArray<View>::update(Space* home, bool share, ViewArray<View>& y) {
-    n = y.n;
-    if (n > 0) {
-      x = static_cast<View*>(home->alloc(sizeof(View)*n));
-      for (int i = n; i--; )
-	x[i].update(home, share, y.x[i]);
-    } else {
-      x = NULL;
-    }
-  }
-
-  template <class View>
-  void
-  ViewArray<View>::subscribe(Space* home, Propagator* p, PropCond pc, 
-			     bool process) {
-    for (int i = n; i--; )
-      x[i].subscribe(home,p,pc,process);
-  }
-
-  template <class View>
-  void
-  ViewArray<View>::cancel(Space* home, Propagator* p, PropCond pc) {
-    for (int i = n; i--; )
-      x[i].cancel(home,p,pc);
-  }
-
-  template <class View>
-  forceinline bool
-  __before(const View& x, const View& y) {
-    return before(x,y);
-  }
-
-  template <class View>
-  forceinline bool
-  ViewArray<View>::ViewLess::operator()(const View& a, const View& b) {
-    return __before(a,b);
-  }
-
-  template <class View>
-  void
-  ViewArray<View>::sort(View* y, int m) {
-    ViewLess vl;
-    Support::quicksort<View,ViewLess>(y,m,vl);
-  }
-
-  template <class View>
-  forceinline bool
-  __same(const View& x, const View& y) {
-    return same(x,y);
-  }
-  template <class View>
-  forceinline bool
-  __shared(const View& x, const View& y) {
-    return shared(x,y);
-  }
-
-  template <class View>
-  bool
-  ViewArray<View>::same(void) const {
-    if (n < 2)
-      return false;
-    GECODE_AUTOARRAY(View,y,n);
-    for (int i = n; i--; )
-      y[i] = x[i];
-    sort(y,n);
-    for (int i = n-1; i--; )
-      if (__same(y[i+1],y[i]))
-	return true;
-    return false;
-  }
-
-  template <class View>
-  bool
-  ViewArray<View>::same(const View& y) const {
-    for (int i = n; i--; )
-      if (__same(x[i],y))
-	return true;
-    return false;
-  }
-
-  template <class View>
-  void
-  ViewArray<View>::unique(void) {
-    if (n < 2)
-      return;
-    sort(x,n);
-    int j = 0;
-    for (int i = 1; i<n; i++)
-      if (!__same(x[j],x[i]))
-	x[++j] = x[i];
-    n = j+1;
-  }
-
-  template <class View>
-  bool
-  ViewArray<View>::shared(void) const {
-    if (n < 2)
-      return false;
-    GECODE_AUTOARRAY(View,y,n);
-    for (int i = n; i--; )
-      y[i] = x[i];
-    sort(y,n);
-    for (int i = n-1; i--; )
-      if (__shared(y[i+1],y[i]))
-	return true;
-    return false;
-  }
-
-  template <class View>
-  bool
-  ViewArray<View>::shared(const View& y) const {
-    for (int i = n; i--; )
-      if (__shared(x[i],y))
-	return true;
-    return false;
-  }
-
-  template <class View>
-  void*
-  ViewArray<View>::operator new(size_t) {
-    return NULL;
-  }
-
-  template <class View>
-  void
-  ViewArray<View>::operator delete(void*,size_t) {
-  }
-
-
-  /*
-   * Argument arrays: base class
-   *
-   */
-
-  template <class T>
-  forceinline T*
-  ArgArrayBase<T>::allocate(int n) {
-    return (n > onstack_size) ?
-      Memory::bmalloc<T>(n) : &onstack[0];
-  }
-
-  template <class T>
-  forceinline
-  ArgArrayBase<T>::ArgArrayBase(int n0)
-    : n(n0), a(allocate(n0)) {}
-
-  template <class T>
-  inline
-  ArgArrayBase<T>::ArgArrayBase(const ArgArrayBase<T>& aa)
-    : n(aa.n), a(allocate(aa.n)) {
-    for (int i = n; i--; )
-      a[i] = aa.a[i];
-  }
-
-  template <class T>
-  forceinline
-  ArgArrayBase<T>::~ArgArrayBase(void) {
-    if (n > onstack_size)
-      Memory::free(a);
-  }
-
-  template <class T>
-  forceinline const ArgArrayBase<T>&
-  ArgArrayBase<T>::operator=(const ArgArrayBase<T>& aa) {
-    if (&aa != this) {
-      if (n > onstack_size)
-	Memory::free(a);
-      n = aa.n;
-      a = allocate(aa.n);
-      for (int i = n; i--; )
-	a[i] = aa.a[i];
-    }
-    return *this;
-  }
-
-  template <class T>
-  forceinline int
-  ArgArrayBase<T>::size(void) const {
-    return n;
-  }
-
-  template <class T>
-  forceinline T&
-  ArgArrayBase<T>::operator[](int i) {
-    assert((i>=0) && (i < n));
-    return a[i];
-  }
-
-  template <class T>
-  forceinline const T&
-  ArgArrayBase<T>::operator[](int i) const {
-    assert((i>=0) && (i < n));
-    return a[i];
-  }
-
-
-  /*
-   * Argument arrays for primitive types
-   *
-   */
-
-  template <class T>
-  forceinline
-  PrimArgArray<T>::PrimArgArray(int n)
-    : ArgArrayBase<T>(n) {}
-
-  template <class T>
-  PrimArgArray<T>::PrimArgArray(int n, T a0, ...)
-    : ArgArrayBase<T>(n) {
-    va_list args;
-    va_start(args, a0);
-    a[0] = a0;
-    for (int i = 1; i < n; i++)
-      a[i] = va_arg(args,T);
-    va_end(args);
-  }
-
-  template <class T>
-  PrimArgArray<T>::PrimArgArray(int n, const T* a0)
-    : ArgArrayBase<T>(n) {
-    for (int i=n; i--; )
-      a[i] = a0[i];
-  }
-
-  template <class T>
-  PrimArgArray<T>::PrimArgArray(const PrimArgArray<T>& aa)
-    : ArgArrayBase<T>(aa.size()) {
-    for (int i = size(); i--; )
-      a[i] = aa.a[i];
-  }
-
-
-
-  /*
-   * Argument arrays for variables
-   *
-   */
-
-  template <class T>
-  forceinline
-  VarArgArray<T>::VarArgArray(int n)
-    : ArgArrayBase<T>(n) {}
-
-  template <class T>
-  inline
-  VarArgArray<T>::VarArgArray(const VarArgArray<T>& aa)
-    : ArgArrayBase<T>(aa.size()) {
-    for (int i = size(); i--; )
-      a[i] = aa.a[i];
-  }
-
-  template <class T>
-  inline
-  VarArgArray<T>::VarArgArray(const VarArray<T>& x)
-    : ArgArrayBase<T>(x.size()) {
-    for (int i = x.size(); i--; )
-      a[i] = x[i];
-  }
-
-  template <class Var>
-  forceinline bool
-  VarArgArray<Var>::VarLess::operator()(const Var& a, const Var& b) {
-    return a.variable() < b.variable();
-  }
-
-  template <class Var>
-  bool
-  VarArgArray<Var>::same(void) const {
-    if (n < 2)
-      return false;
-    GECODE_AUTOARRAY(Var,y,n);
-    for (int i = n; i--; )
-      y[i] = a[i];
-    VarLess vl;
-    Support::quicksort<Var,VarLess>(y,n,vl);
-    for (int i = n-1; i--; )
-      if (y[i+1].variable() == y[i].variable())
-	return true;
-    return false;
-  }
-
-  template <class Var>
-  bool
-  VarArgArray<Var>::same(const VarArgArray<Var>& y) const {
-    int m = n + y.n;
-    if (m < 2)
-      return false;
-    GECODE_AUTOARRAY(Var,z,m);
-    for (int i = n; i--; )
-      z[i] = a[i];
-    for (int i = y.n; i--; )
-      z[i+n] = y.a[i];
-    VarLess vl;
-    Support::quicksort<Var,VarLess>(z,m,vl);
-    for (int i = m-1; i--; )
-      if (z[i+1].variable() == z[i].variable())
-	return true;
-    return false;
-  }
-
-  template <class Var>
-  bool
-  VarArgArray<Var>::same(const Var& y) const {
-    for (int i = n; i--; )
-      if (a[i].variable() == y.variable())
-	return true;
-    return false;
-  }
-
-
-
-
-
-
-  /*
-   * Interdependent code
-   *
-   */
-
-  template <class Var>
-  inline
-  VarArray<Var>::VarArray(Space* home, const VarArgArray<Var>& a)
-    : n(a.size()) {
-    if (n>0) {
-      x = static_cast<Var*>(home->alloc(sizeof(Var)*n));
-      for (int i = n; i--; )
-	x[i] = a[i];
-    } else {
-      x = NULL;
-    }
-  }
-
-}
-
-// STATISTICS: kernel-other