dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/extensional/tuple-set.cpp

@@ -0,0 +1,222 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 2007
+ *
+ *  Last modified:
+ *     $Date: 2010-07-15 01:46:18 +1000 (Thu, 15 Jul 2010) $ by $Author: schulte $
+ *     $Revision: 11192 $
+ *
+ *  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 {
+  private:
+    /// The arity of the tuples to compare
+    int arity;
+  public:
+    /// Initialize with arity \a a
+    forceinline
+    FullTupleCompare(int a) : arity(a) {}
+    /// Strict comparison of tuples \a a and \a b
+    forceinline bool
+    operator ()(const Tuple& a, const Tuple& b) {
+      for (int i = 0; i < arity; i++)
+        if (a[i] < b[i])
+          return true;
+        else if (a[i] > b[i])
+          return false;
+      return a < b;
+    }
+  };
+
+  /**
+   * \brief Tuple compared lexicographically on (element pos, full
+   * order).
+   *
+   * Assumes that the tuples are sorted in order in memory.
+   */
+  class TuplePosCompare {
+  private:
+    /// Position of tuple
+    int pos;
+  public:
+    /// Initialize with position \a p
+    forceinline
+    TuplePosCompare(int p) : pos(p) {}
+    /// Perform strict comparison of tuples \a a and \a b
+    forceinline bool
+    operator ()(const Tuple& a, const Tuple& b) {
+      if (a[pos] == b[pos])
+        return a < b;
+      else
+        return a[pos] < b[pos];
+    }
+  };
+
+}
+
+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 = static_cast<unsigned int>(max - min) + 1;
+
+    // Allocate tuple indexing data-structures
+    tuples = heap.alloc<Tuple*>(arity);
+    tuple_data = heap.alloc<Tuple>(size*arity+1);
+    tuple_data[size*arity] = NULL;
+    nullpointer = 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 = heap.alloc<int>(size*arity);
+    for (int t = size; t--; )
+      for (int i = arity; i--; )
+        new_data[t*arity + i] = tuples[0][t][i];
+
+    heap.rfree(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 = heap.alloc<Tuple*>(domsize*arity);
+    for (int i = arity; i--; ) {
+      Tuple* t = tuples[i];
+      for (unsigned int d = 0; d < domsize; ++d) {
+        while (t && *t && (*t)[i] < static_cast<int>(min+d)) {
+          ++t;
+        }
+        if (t && *t && (*t)[i] == static_cast<int>(min+d)) {
+          last[(i*domsize) + d] = t;
+          ++t;
+        } else {
+          last[(i*domsize) + d] = nullpointer;
+        }
+      }
+    }
+
+    assert(finalized());
+  }
+
+  void
+  TupleSet::TupleSetI::resize(void) {
+    assert(excess == 0);
+    int ndatasize = static_cast<int>(1+size*1.5);
+    data = heap.realloc<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 = heap.alloc<int>(size*arity);
+    heap.copy(&d->data[0], &data[0], size*arity);
+
+    // Indexing data
+    d->tuples = heap.alloc<Tuple*>(arity);
+    d->tuple_data = heap.alloc<Tuple>(size*arity+1);
+    d->tuple_data[size*arity] = NULL;
+    d->nullpointer = 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 = heap.alloc<Tuple*>(domsize*arity);
+    for (int i = static_cast<int>(domsize)*arity; i--; ) {
+      d->last[i] = d->tuple_data + (last[i]-tuple_data);
+    }
+
+    return d;
+  }
+
+  TupleSet::TupleSetI::~TupleSetI(void) {
+    excess = -2;
+    heap.rfree(tuples);
+    heap.rfree(tuple_data);
+    heap.rfree(data);
+    heap.rfree(last);
+  }
+
+}
+
+// STATISTICS: int-prop
+

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/extensional/tuple-set.hpp

@@ -0,0 +1,184 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 2007
+ *
+ *  Last modified:
+ *     $Date: 2009-09-30 21:59:39 +1000 (Wed, 30 Sep 2009) $ by $Author: tack $
+ *     $Revision: 9784 $
+ *
+ *  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 <sstream>
+
+namespace Gecode {
+
+  forceinline bool
+  TupleSet::TupleSetI::finalized(void) const {
+    assert(((excess == -1) && (domsize > 0)) ||
+           ((excess != -1) && (domsize == 0)));
+    return excess == -1;
+  }
+
+  forceinline
+  TupleSet::TupleSetI::TupleSetI(void)
+    : arity(-1),
+      size(0),
+      tuples(NULL),
+      tuple_data(NULL),
+      data(NULL),
+      excess(0),
+      min(Int::Limits::max),
+      max(Int::Limits::min),
+      domsize(0),
+      last(NULL),
+      nullpointer(NULL)
+  {}
+
+
+  template<class T>
+  void
+  TupleSet::TupleSetI::add(T t) {
+    assert(arity  != -1); // Arity has been set
+    assert(excess != -1); // Tuples may still be added
+    if (excess == 0) resize();
+    assert(excess >= 0);
+    --excess;
+    int end = size*arity;
+    for (int i = arity; i--; ) {
+      data[end+i] = t[i];
+      if (t[i] < min) min = t[i];
+      if (t[i] > max) max = t[i];
+    }
+    ++size;
+  }
+
+  forceinline
+  TupleSet::TupleSet(void) {
+  }
+
+  forceinline
+  TupleSet::TupleSet(const TupleSet& ts)
+    : SharedHandle(ts) {}
+
+  forceinline TupleSet::TupleSetI*
+  TupleSet::implementation(void) {
+    TupleSetI* imp = static_cast<TupleSetI*>(object());
+    assert(imp);
+    return imp;
+  }
+
+  inline void
+  TupleSet::add(const IntArgs& tuple) {
+    TupleSetI* imp = static_cast<TupleSetI*>(object());
+    if (imp == NULL) {
+      imp = new TupleSetI;
+      object(imp);
+    }
+    assert(imp->arity == -1 ||
+           imp->arity == tuple.size());
+    imp->arity = tuple.size();
+    imp->add(tuple);
+  }
+
+  forceinline void
+  TupleSet::finalize(void) {
+    TupleSetI* imp = static_cast<TupleSetI*>(object());
+    assert(imp);
+    if (!imp->finalized()) {
+      imp->finalize();
+    }
+  }
+
+  forceinline bool
+  TupleSet::finalized(void) const {
+    TupleSetI* imp = static_cast<TupleSetI*>(object());
+    assert(imp);
+    return imp->finalized();
+  }
+
+  forceinline int
+  TupleSet::arity(void) const {
+    TupleSetI* imp = static_cast<TupleSetI*>(object());
+    assert(imp);
+    assert(imp->arity != -1);
+    return imp->arity;
+  }
+  forceinline int
+  TupleSet::tuples(void) const {
+    TupleSetI* imp = static_cast<TupleSetI*>(object());
+    assert(imp);
+    assert(imp->finalized());
+    return imp->size-1;
+  }
+  forceinline TupleSet::Tuple
+  TupleSet::operator [](int i) const {
+    TupleSetI* imp = static_cast<TupleSetI*>(object());
+    assert(imp);
+    assert(imp->finalized());
+    return imp->data + i*imp->arity;
+  }
+  forceinline int
+  TupleSet::min(void) const {
+    TupleSetI* imp = static_cast<TupleSetI*>(object());
+    assert(imp);
+    assert(imp->finalized());
+    return imp->min;
+  }
+  forceinline int
+  TupleSet::max(void) const {
+    TupleSetI* imp = static_cast<TupleSetI*>(object());
+    assert(imp);
+    assert(imp->finalized());
+    return imp->max;
+  }
+
+
+  template<class Char, class Traits, class T>
+  std::basic_ostream<Char,Traits>&
+  operator <<(std::basic_ostream<Char,Traits>& os, const TupleSet& ts) {
+    std::basic_ostringstream<Char,Traits> s;
+    s.copyfmt(os); s.width(0);
+    s << "Number of tuples: " << ts.tuples() << std::endl
+      << "Tuples:" << std::endl;
+    for (int i = 0; i < ts.tuples(); ++i) {
+      s << '\t';
+      for (int j = 0; j < ts.arity(); ++j) {
+        s.width(3);
+        s << " " << ts[i][j];
+      }
+      s << std::endl;
+    }
+    return os << s.str();
+  }
+
+}
+
+// STATISTICS: int-prop
+

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/gcc.cpp

@@ -0,0 +1,172 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004
+ *     Christian Schulte, 2009
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2010-03-04 03:40:32 +1100 (Thu, 04 Mar 2010) $ by $Author: schulte $
+ *     $Revision: 10365 $
+ *
+ *  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/gcc.hh>
+
+namespace Gecode {
+
+  void count(Home home, const IntVarArgs& x,
+             const IntVarArgs& c, const IntArgs& v,
+             IntConLevel icl) {
+    using namespace Int;
+    if (v.size() != c.size())
+      throw ArgumentSizeMismatch("Int::count");
+    if (x.same(home))
+      throw ArgumentSame("Int::count");
+    if (home.failed())
+      return;
+
+    ViewArray<IntView> xv(home, x);
+    ViewArray<GCC::CardView> cv(home, c.size());
+    // set the cardinality
+    for (int i = v.size(); i--; )
+      cv[i].init(c[i],v[i]);
+    switch (icl) {
+    case ICL_BND:
+      GECODE_ES_FAIL( 
+                     (GCC::Bnd<GCC::CardView>::post(home,xv,cv)));
+      break;
+    case ICL_DOM:
+      GECODE_ES_FAIL( 
+                     (GCC::Dom<GCC::CardView>::post(home,xv,cv)));
+      break;
+    default:
+      GECODE_ES_FAIL( 
+                     (GCC::Val<GCC::CardView>::post(home,xv,cv)));
+    }
+  }
+
+  // domain is 0..|cards|- 1
+  void count(Home home, const IntVarArgs& x, const IntVarArgs& c,
+             IntConLevel icl) {
+    IntArgs values(c.size());
+    for (int i = c.size(); i--; )
+      values[i] = i;
+    count(home, x, c, values, icl);
+  }
+
+  // constant cards
+  void count(Home home, const IntVarArgs& x,
+             const IntSetArgs& c, const IntArgs& v,
+             IntConLevel icl) {
+    using namespace Int;
+    if (v.size() != c.size())
+      throw ArgumentSizeMismatch("Int::count");
+    if (x.same(home))
+      throw ArgumentSame("Int::count");
+    for (int i=c.size(); i--; ) {
+      Limits::check(v[i],"Int::count");
+      Limits::check(c[i].min(),"Int::count");
+      Limits::check(c[i].max(),"Int::count");
+    }
+
+    if (home.failed())
+      return;
+
+    ViewArray<IntView> xv(home, x);
+
+    for (int i = v.size(); i--; ) {
+      if (c[i].ranges() > 1) {
+        // Found hole, so create temporary variables
+        ViewArray<GCC::CardView> cv(home, v.size());
+        for (int j = v.size(); j--; )
+          cv[j].init(home,c[j],v[j]);
+        switch (icl) {
+        case ICL_BND:
+          GECODE_ES_FAIL( 
+                         (GCC::Bnd<GCC::CardView>::post(home, xv, cv)));
+          break;
+        case ICL_DOM:
+          GECODE_ES_FAIL( 
+                         (GCC::Dom<GCC::CardView>::post(home, xv, cv)));
+          break;
+        default:
+          GECODE_ES_FAIL( 
+                         (GCC::Val<GCC::CardView>::post(home, xv, cv)));
+        }
+        return;
+      }
+    }
+    
+    // No holes: create CardConsts
+    ViewArray<GCC::CardConst> cv(home, c.size());
+
+    for (int i = c.size(); i--; )
+      cv[i].init(home,c[i].min(),c[i].max(),v[i]);
+
+    switch (icl) {
+    case ICL_BND:
+      GECODE_ES_FAIL(
+                     (GCC::Bnd<GCC::CardConst>::post(home, xv, cv)));
+      break;
+    case ICL_DOM:
+      GECODE_ES_FAIL(
+                     (GCC::Dom<GCC::CardConst>::post(home, xv, cv)));
+      break;
+    default:
+      GECODE_ES_FAIL(
+                     (GCC::Val<GCC::CardConst>::post(home, xv, cv)));
+    }
+  }
+
+  // domain is 0..|cards|- 1
+  void count(Home home, const IntVarArgs& x, const IntSetArgs& c,
+             IntConLevel icl) {
+    IntArgs values(c.size());
+    for (int i = c.size(); i--; )
+      values[i] = i;
+    count(home, x, c, values, icl);
+  }
+
+  void count(Home home, const IntVarArgs& x,
+             const IntSet& c, const IntArgs& v,
+             IntConLevel icl) {
+    IntSetArgs cards(v.size());
+    for (int i = v.size(); i--; )
+      cards[i] = c;
+    count(home, x, cards, v, icl);
+  }
+
+}
+
+// STATISTICS: int-post