gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/gecode/int/extensional/tuple-set.cc

@@ -0,0 +1,285 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 2007
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:31:51 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7288 $
+ *
+ *  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/int.hh"
+
+namespace {
+
+  typedef ::Gecode::TupleSet::Tuple Tuple;
+
+  /**
+   * \brief Full Tuple compare
+   */
+  class FullTupleCompare {
+    int arity;
+  public:
+    forceinline
+    FullTupleCompare(int a) : arity(a) {}
+    forceinline bool
+    operator()(const Tuple& a, const Tuple& b) {
+      for (int i = 0; i < arity; ++i) {
+        if (a[i] < b[i]) {
+          return true;
+        }
+        if (a[i] > b[i]) {
+          return false;
+        }
+      }
+      return true;
+    }
+  };
+
+  /**
+   * \brief Tuple compared lexicographically on (element pos, full
+   * order).
+   *
+   * Assumes that the tuples are sorted in order in memory.
+   */
+  class TuplePosCompare {
+  private:
+    int pos;
+  public:
+    forceinline
+    TuplePosCompare(int p) : pos(p) {}
+
+    forceinline bool
+    operator()(const Tuple& a, const Tuple& b) {
+      if (a[pos] == b[pos]) return a < b;
+      return a[pos] < b[pos];
+    }
+  };
+
+}
+
+
+std::ostream&
+operator<<(std::ostream& os, const Gecode::TupleSet& ts) {
+  os << "Number of tuples: " << ts.tuples() << std::endl
+     << "Tuples:" << std::endl;
+  for (int i = 0; i < ts.tuples(); ++i) {
+    os << '\t';
+    for (int j = 0; j < ts.arity(); ++j) {
+      os.width(3);
+      os << " " << ts[i][j];
+    }
+    os << std::endl;
+  }
+  return os;
+}
+
+namespace Gecode {
+
+  void
+  TupleSet::TupleSetI::finalize(void) {
+    assert(!finalized());
+    assert(tuples == NULL);
+
+    // Add final largest tuple
+    IntArgs ia(arity);
+    for (int i = arity; i--; ) ia[i] = Int::Limits::max+1;
+    int real_min = min, real_max = max;
+    add(ia);
+    min = real_min; max = real_max;
+
+    // Domainsize
+    domsize = max - min + 1;
+
+    // Allocate tuple indexing data-structures
+    tuples = Memory::bmalloc<Tuple*>(arity);
+    tuple_data = Memory::bmalloc<Tuple>(size*arity+1);
+    tuple_data[size*arity] = NULL;
+    nullptr = tuple_data+(size*arity);
+
+    // Rearrange the tuples for faster comparisons.
+    for (int i = arity; i--; )
+      tuples[i] = tuple_data + (i * size);
+    for (int i = size; i--; )
+      tuples[0][i] = data + (i * arity);
+
+    FullTupleCompare ftc(arity);
+    Support::quicksort(tuples[0], size, ftc);
+    assert(tuples[0][size-1][0] == ia[0]);
+    int* new_data = Memory::bmalloc<int>(size*arity);
+    for (int t = size; t--; ) {
+      for (int i = arity; i--; ) {
+        new_data[t*arity + i] = tuples[0][t][i];
+      }
+    }
+
+    Memory::free(data);
+    data = new_data;
+    excess = -1;
+
+    // Set up indexing structure
+    for (int i = arity; i--; )
+      for (int t = size; t--; )
+        tuples[i][t] = data + (t * arity);
+    for (int i = arity; i-->1; ) {      
+      TuplePosCompare tpc(i);
+      Support::quicksort(tuples[i], size, tpc);
+    }
+
+    // Set up initial last-structure
+    last = Memory::bmalloc<Tuple*>(domsize*arity);
+    for (int i = arity; i--; ) {
+      Tuple* t = tuples[i];
+      for (int d = 0; d < domsize; ++d) {
+        while (t && *t && (*t)[i] < min+d) {
+          ++t;
+        }
+        if (t && *t && (*t)[i] == min+d) {
+          last[(i*domsize) + d] = t;
+          ++t;
+        } else {
+          last[(i*domsize) + d] = nullptr;
+        }
+      }
+    }
+    
+    assert(finalized());
+  }
+
+  void
+  TupleSet::TupleSetI::resize(void) {
+    assert(excess == 0);
+    int ndatasize = static_cast<int>(1+size*1.5);
+    data = Memory::brealloc<int>(data, size * arity, 
+                                 ndatasize * arity);
+    excess = ndatasize - size;
+  }
+
+  SharedHandle::Object*
+  TupleSet::TupleSetI::copy(void) const {
+    assert(finalized());
+    TupleSetI* d  = new TupleSetI;
+    d->arity      = arity;
+    d->size       = size;
+    d->excess     = excess;
+    d->min        = min;
+    d->max        = max;
+    d->domsize    = domsize;
+
+    // Table data
+    d->data = Memory::bmalloc<int>(size*arity);
+    memcpy(&d->data[0], &data[0], sizeof(int)*size*arity);
+
+    // Indexing data
+    d->tuples = Memory::bmalloc<Tuple*>(arity);
+    d->tuple_data = Memory::bmalloc<Tuple>(size*arity+1);
+    d->tuple_data[size*arity] = NULL;
+    d->nullptr = d->tuple_data+(size*arity);
+
+    // Rearrange the tuples for faster comparisons.
+    for (int i = arity; i--; )
+      d->tuples[i] = d->tuple_data + (i * size);
+    for (int a = arity; a--; ) {
+      for (int i = size; i--; ) {
+        d->tuples[a][i] = d->data + (tuples[a][i]-data);
+      }
+    }
+
+    // Last data
+    d->last = Memory::bmalloc<Tuple*>(domsize*arity);
+    for (int i = domsize+arity; i--; ) {
+      d->last[i] = d->tuple_data + (last[i]-tuple_data);
+    }
+
+    return d;
+  }
+
+  TupleSet::TupleSetI::~TupleSetI(void) {
+    excess = -2;
+    Memory::free(tuples);
+    Memory::free(tuple_data);
+    Memory::free(data);
+    Memory::free(last);
+  }  
+
+
+  TupleSet::TupleSet(Reflection::VarMap& vm, Reflection::Arg* arg) {
+    if (arg->isSharedReference()) {
+      TupleSetI* d = 
+        static_cast<TupleSetI*>(vm.getSharedObject(arg->toSharedReference()));
+      object(d);
+      return;
+    }
+    
+    Reflection::IntArrayArg* a = arg->toSharedObject()->toIntArray();
+
+    // All done... Construct the table
+
+    int arity = (*a)[0];
+    int n_tuples = (a->size() - 1) / arity;
+    assert(n_tuples*arity == a->size()-1);
+    int pos = 1;
+    IntArgs ia(arity);
+    for (int i = n_tuples; i--; ) {
+      for (int j = 0; j < arity; ++j) {
+        ia[j] = (*a)[pos++];
+      }
+      add(ia);
+    }
+    finalize();
+
+    vm.putMasterObject(object());
+  }
+
+  Reflection::Arg*
+  TupleSet::spec(Reflection::VarMap& vm) const {
+    int sharedIndex = vm.getSharedIndex(object());
+    if (sharedIndex >= 0)
+      return Reflection::Arg::newSharedReference(sharedIndex);
+    Reflection::IntArrayArg* a = 
+      Reflection::Arg::newIntArray(static_cast<int>(1+arity()*tuples()));
+
+    (*a)[0] = arity();
+
+    int pos = 1;
+    for (int i = 0; i < tuples(); ++i) {
+      for (int j = 0; j < arity(); ++j) {
+        (*a)[pos++] = (*this)[i][j];
+      }
+    }
+
+    vm.putMasterObject(object());
+    return Reflection::Arg::newSharedObject(a);    
+  }
+
+}
+
+// STATISTICS: int-prop
+

data/ext/gecode-2.2.0/gecode/int/gcc.hh

@@ -0,0 +1,329 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004/2005
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:28:48 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7285 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_INT_GCC_HH__
+#define __GECODE_INT_GCC_HH__
+
+#include "gecode/int.hh"
+
+#include "gecode/int/gcc/gccbndsup.icc"
+#include "gecode/int/gcc/graphsup.icc"
+#include "gecode/int/gcc/occur.icc"
+
+/**
+ * \namespace Gecode::Int::GCC
+ * \brief Global cardinality propagators
+ * \note The global cardinality propagator with fixed cardinalities does not
+ *       not support sharing!
+ *
+ */
+
+namespace Gecode { namespace Int { namespace GCC {
+
+  /**
+   * \brief Bounds consistent global cardinality propagator
+   * \par [Reference]
+   *  The algorithm is taken from: \n
+     \verbatim
+     @PROCEEDINGS{quimper-efficient,
+     title     = {An Efficient Bounds Consistency Algorithm
+                  for the Global Cardinality Constraint},
+     year      = {2003},
+     volume    = {2833},
+     address   = {Kinsale, Ireland},
+     month     = {September},
+     author    = {Claude-Guy Quimper and Peter van Beek
+                  and Alejandro L�pez-Ortiz
+                  and Alexander Golynski and Sayyed Bashir Sadjad},
+     booktitle = {Proceedings of the 9th International Conference
+                  on Principles and Practice of
+                  Constraint Programming},
+     pages     = {600--614},
+     url       = {http://ai.uwaterloo.ca/~vanbeek/publications},
+     }
+     @TECHREPORT{quimper-efficientTR,
+     author      = {Claude-Guy Quimper and Peter van Beek
+                    and Alejandro L�pez-Ortiz
+                    and Alexander Golynski and
+                    Sayyed Bashir Sadjad},
+     title       = {An Efficient Bounds Consistency Algorithm
+                    for the Global Cardinality Constraint,
+                    Technical Report},
+     institution = {School of Computer Science,
+                    University of Waterloo, Waterloo, Canada},
+     year        = {2003},
+     url         = {http://ai.uwaterloo.ca/~vanbeek/publications},
+     }
+     \endverbatim
+   *
+   * This implementation uses the code that is provided
+   * by Peter Van Beek:\n
+   * http://ai.uwaterloo.ca/~vanbeek/software/software.html
+   * The code here has only been slightly modified to fit Gecode
+   * (taking idempotent/non-idempotent propagation into account)
+   * and uses a more efficient layout of datastructures (keeping the
+   * number of different arrays small).
+   *
+   * The Bnd class is used to post the propagator and BndImp
+   * is the actual implementation taking shared variables into account.
+   *
+   * Requires \code #include "gecode/int/gcc.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View, class Card, bool isView>
+  class Bnd{
+  public:
+    /**
+     * \brief Post propagator for views \a x and cardinalities \a k
+     *
+     * \a all denotes whether the propagator uses all values occuring
+     * in the domains of the problem views specified in \a x. Also
+     * checks whether \a x and \a k contain shared views.
+     */
+    static  ExecStatus  post(Space* home,
+                             ViewArray<View>& x,
+                             ViewArray<Card>& k);
+  };
+
+  /**
+   * \brief Implementation of the bounds consistent
+   * global cardinality propagator
+   */
+  template <class View, class Card, bool isView, bool shared>
+  class BndImp : public Propagator {
+    friend class Bnd<View, Card, isView>;
+  protected:
+    /// Views on which to perform bounds-propagation
+    ViewArray<View> x;
+    /// Array containing either fixed cardinalities or CardViews
+    ViewArray<Card> k;
+    /**
+     * \brief  Data structure storing the sum of the views lower bounds
+     * Necessary for reasoning about the interval capacities in the
+     * propagation algorithm.
+     */
+    PartialSum<Card>* lps;
+    /// Data structure storing the sum of the views upper bounds
+    PartialSum<Card>* ups;
+    /**
+     * \brief Stores whether cardinalities are all assigned
+     *
+     * If all cardinalities are assigned the propagation algorithm
+     * only has to perform propagation for the upper bounds.
+     */
+    bool card_fixed;
+    /**
+     * \brief Stores whether the minium required occurences of
+     *        the cardinalities are all zero. If so, we do not need
+     *        to perform lower bounds propagation.
+     */
+    bool skip_lbc;
+    /// Constructor for posting
+    BndImp(Space* home, ViewArray<View>&, ViewArray<Card>&, bool, bool);
+    /// Constructor for cloning \a p
+    BndImp(Space* home, bool share, BndImp<View, Card, isView, shared>& p);
+
+  public:
+    /// Destructor
+    virtual size_t dispose(Space* home);
+    /// Return how much extra memory is allocated by the propagator
+    virtual size_t allocated(void) const;
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post propagator according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /// Cost funtion returning dynamic PC_LINEAR_HI.
+    virtual PropCost cost(ModEventDelta med) const;
+    /// Perform propagation
+    virtual ExecStatus  propagate(Space* home, ModEventDelta med);
+  };
+
+  /**
+   * \brief Domain consistent global cardinality propagator
+   * \par [Reference]
+   *  The algorithm is taken from: \n
+   * \anchor CardVarNPCompl
+   \verbatim
+     @PROCEEDINGS{improvedgcc,
+     title     = {Improved Algorithms for the
+                  Global Cardinality Constraint},
+     year      = {2004},
+     volume    = {3528},
+     address   = {Toronto, Canada},
+     month     = {September},
+     author    = {Claude-Guy Quimper and Peter van Beek and
+                  Alejandro L�pez-Ortiz and Alexander Golynski},
+     booktitle = {Proceedings of the 10th International
+                  Conference on Principles and Practice of
+                  Constraint Programming},
+     url       = {http://ai.uwaterloo.ca/~vanbeek/publications},
+     }
+     \endverbatim
+   *
+   * Requires \code #include "gecode/int/gcc.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View, class Card, bool isView>
+  class Dom : public Propagator {
+  protected:
+    /// Views on which to perform domain-propagation
+    ViewArray<View> x;
+    /**
+     * \brief Views used to channel information between \c x and \c k
+     * (\f$ x \subseteq y \f$).
+     */
+    ViewArray<View> y;
+    /// Array containing either fixed cardinalities or CardViews
+    ViewArray<Card> k;
+    /// Propagation is performed on a variable-value graph (used as cache)
+    VarValGraph<View, Card, isView>* vvg;
+    /**
+     * \brief Stores whether cardinalities are all assigned
+     *
+     * If all cardinalities are assigned the propagation algorithm
+     * only has to perform propagation for the upper bounds.
+     */
+    bool card_fixed;
+    /// Constructor for cloning \a p
+    Dom(Space* home, bool share, Dom<View, Card, isView>& p);
+    /// Constructor for posting
+    Dom(Space* home, ViewArray<View>&, ViewArray<Card>&, bool);
+
+  public:
+    /// Destructor including deallocation of variable-value graph
+    virtual size_t dispose(Space* home);
+    /// Return how much extra memory is allocated by the propagator
+    virtual size_t allocated(void) const;
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /**
+     * \brief Cost function
+     *
+     * As the propagation stronlgy depends on the domain size of the
+     * views on which propagation is performed, the propagation costs
+     * are computed as follows, where \c d denotes the size of the
+     * largest domain of a view in \c x:
+     * - dynamic PC_LINEAR_LO ( \f$ d < 6\f$ )
+     * - dynamic PC_LINEAR_HI ( \f$ 6 \leq d < \frac{n}{2} \f$ )
+     * - dynamic PC_QUADRATIC_LO ( \f$ \frac{n}{2} \leq d < n^2 \f$)
+     * - dynamic PC_CUBIC_LO  ( \f$ n^2 \leq d \f$)
+     */
+    virtual PropCost cost(ModEventDelta med) const;
+    /// Perform propagation
+    virtual ExecStatus  propagate(Space* home, ModEventDelta med);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post propagator according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /**
+     * \brief Post propagator for views \a x and cardinalities \a k
+     *
+     * \a all denotes whether the propagator uses all values occuring
+     * in the domains of the problem views specified in \a x.
+     */
+    static  ExecStatus  post(Space* home,
+                             ViewArray<View>& x, ViewArray<Card>& k);
+  };
+
+  /**
+   * \brief Value consistent global cardinality propagator
+   *
+   * Requires \code #include "gecode/int/gcc.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View, class Card, bool isView>
+  class Val : public Propagator {
+  protected:
+    /// Views on which to perform value-propagation
+    ViewArray<View> x;
+    /// Array containing either fixed cardinalities or CardViews
+    ViewArray<Card> k;
+    /// Constructor for cloning \a p
+    Val(Space* home, bool share, Val<View, Card, isView>& p );
+    /// Constructor for posting
+    Val(Space* home, ViewArray<View>&, ViewArray<Card>&);
+
+  public:
+    /// Destructor
+    virtual size_t dispose(Space* home);
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Cost funtion returning dynamic PC_LINEAR_HI.
+    virtual PropCost cost(ModEventDelta med) const;
+    /// Perform propagation
+    virtual ExecStatus  propagate(Space* home, ModEventDelta med);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post propagator according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /**
+     * \brief Post propagator for views \a x and cardinalities \a k
+     *
+     * \a all denotes whether the propagator uses all values occuring
+     * in the domains of the problem views specified in \a x.
+     */
+    static  ExecStatus  post(Space* home,
+                             ViewArray<View>& x, ViewArray<Card>& k);
+  };
+
+}}}
+
+#include "gecode/int/gcc/ubc.icc"
+#include "gecode/int/gcc/lbc.icc"
+#include "gecode/int/gcc/val.icc"
+#include "gecode/int/gcc/bnd.icc"
+#include "gecode/int/gcc/dom.icc"
+
+#endif
+
+
+// STATISTICS: int-prop
+