gecoder-with-gecode 0.7.1

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

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

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

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