dep-selector-libgecode 1.0.0.alpha.0

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

@@ -0,0 +1,249 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2012-02-22 16:04:20 +1100 (Wed, 22 Feb 2012) $ by $Author: tack $
+ *     $Revision: 12537 $
+ *
+ *  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 {
+
+  /*
+   * Integer sets
+   *
+   */
+  forceinline
+  IntSet::IntSet(void) {}
+
+  /**
+   * \brief Integer set initialization
+   *
+   * Helper class to allow partial specialization of
+   * template member function.
+   *
+   */
+  template<class I>
+  class IntSetInit {
+  public:
+    static void init(IntSet& s, I& i) {
+      Support::DynamicArray<IntSet::Range,Heap> d(heap);
+      int n=0;
+      unsigned int size = 0;
+      while (i()) {
+        d[n].min = i.min(); d[n].max = i.max(); size += i.width();
+        ++n; ++i;
+      }
+      if (n > 0) {
+        IntSet::IntSetObject* o = IntSet::IntSetObject::allocate(n);
+        for (int j=n; j--; )
+          o->r[j]=d[j];
+        o->size = size;
+        s.object(o);
+      }
+    }
+  };
+
+  template<>
+  class IntSetInit<IntSet> {
+  public:
+    static void init(IntSet& s, const IntSet& i) {
+      s.object(i.object());
+    }
+  };
+
+  template<class I>
+  IntSet::IntSet(I& i) {
+    IntSetInit<I>::init(*this,i);
+  }
+
+  forceinline
+  IntSet::IntSet(const int r[][2], int n) {
+    init(r,n);
+  }
+
+  forceinline
+  IntSet::IntSet(const int r[], int n) {
+    init(r,n);
+  }
+
+  forceinline
+  IntSet::IntSet(int n, int m) {
+    init(n,m);
+  }
+
+  forceinline int
+  IntSet::min(int i) const {
+    assert(object() != NULL);
+    return static_cast<IntSetObject*>(object())->r[i].min;
+  }
+
+  forceinline int
+  IntSet::max(int i) const {
+    assert(object() != NULL);
+    return static_cast<IntSetObject*>(object())->r[i].max;
+  }
+
+  forceinline unsigned int
+  IntSet::width(int i) const {
+    assert(object() != NULL);
+    IntSetObject* o = static_cast<IntSetObject*>(object());
+    return static_cast<unsigned int>(o->r[i].max-o->r[i].min)+1;
+  }
+
+  forceinline int
+  IntSet::ranges(void) const {
+    IntSetObject* o = static_cast<IntSetObject*>(object());
+    return (o == NULL) ? 0 : o->n;
+  }
+
+  forceinline bool
+  IntSet::in(int n) const {
+    IntSetObject* o = static_cast<IntSetObject*>(object());
+    if ((o == NULL) || (n < o->r[0].min) || (n > o->r[o->n-1].max))
+      return false;
+    else
+      return o->in(n);
+  }
+
+  forceinline int
+  IntSet::min(void) const {
+    IntSetObject* o = static_cast<IntSetObject*>(object());
+    return (o == NULL) ? Int::Limits::max : o->r[0].min;
+  }
+
+  forceinline int
+  IntSet::max(void) const {
+    IntSetObject* o = static_cast<IntSetObject*>(object());
+    return (o == NULL) ? Int::Limits::min : o->r[o->n-1].max;
+  }
+
+  forceinline unsigned int
+  IntSet::size(void) const {
+    IntSetObject* o = static_cast<IntSetObject*>(object());
+    return (o == NULL) ? 0 : o->size;
+  }
+
+  forceinline unsigned int
+  IntSet::width(void) const {
+    return static_cast<unsigned int>(max()-min()+1);
+  }
+
+
+  /*
+   * Range iterator for integer sets
+   *
+   */
+
+  forceinline
+  IntSetRanges::IntSetRanges(void) {}
+  forceinline
+  void
+  IntSetRanges::init(const IntSet& s) {
+    int n = s.ranges();
+    if (n > 0) {
+      i = &static_cast<IntSet::IntSetObject*>(s.object())->r[0]; e = i+n;
+    } else {
+      i = e = NULL;
+    }
+  }
+  forceinline
+  IntSetRanges::IntSetRanges(const IntSet& s) { init(s); }
+
+
+  forceinline void
+  IntSetRanges::operator ++(void) {
+    i++;
+  }
+  forceinline bool
+  IntSetRanges::operator ()(void) const {
+    return i<e;
+  }
+
+  forceinline int
+  IntSetRanges::min(void) const {
+    return i->min;
+  }
+  forceinline int
+  IntSetRanges::max(void) const {
+    return i->max;
+  }
+  forceinline unsigned int
+  IntSetRanges::width(void) const {
+    return static_cast<unsigned int>(i->max - i->min) + 1;
+  }
+
+  /*
+   * Value iterator for integer sets
+   *
+   */
+  forceinline
+  IntSetValues::IntSetValues(void) {}
+
+  forceinline
+  IntSetValues::IntSetValues(const IntSet& s) {
+    IntSetRanges r(s);
+    Iter::Ranges::ToValues<IntSetRanges>::init(r);
+  }
+
+  forceinline void
+  IntSetValues::init(const IntSet& s) {
+    IntSetRanges r(s);
+    Iter::Ranges::ToValues<IntSetRanges>::init(r);
+  }
+
+  template<class Char, class Traits>
+  std::basic_ostream<Char,Traits>&
+  operator <<(std::basic_ostream<Char,Traits>& os, const IntSet& is) {
+    std::basic_ostringstream<Char,Traits> s;
+    s.copyfmt(os); s.width(0);
+    s << '{';
+    for (int i = 0; i < is.ranges(); ) {
+      int min = is.min(i);
+      int max = is.max(i);
+      if (min == max)
+        s << min;
+      else
+        s << min << ".." << max;
+      i++;
+      if (i < is.ranges())
+        s << ',';
+    }
+    s << '}';
+    return os << s.str();
+  }
+
+}
+
+// STATISTICS: int-var
+

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

@@ -0,0 +1,51 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2008
+ *
+ *  Last modified:
+ *     $Date: 2012-02-22 16:04:20 +1100 (Wed, 22 Feb 2012) $ by $Author: tack $
+ *     $Revision: 12537 $
+ *
+ *  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.
+ *
+ */
+
+namespace Gecode {
+
+  template<>
+  class IntSetInit<IntArgs> {
+  public:
+    static void init(IntSet& s, const IntArgs& i) {
+      s.init(&i[0],i.size());
+    }
+  };
+
+}
+
+// STATISTICS: int-var
+

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

@@ -0,0 +1,167 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2009-12-03 06:42:32 +1100 (Thu, 03 Dec 2009) $ by $Author: schulte $
+ *     $Revision: 10174 $
+ *
+ *  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 Gecode {
+
+  IntSet::IntSetObject*
+  IntSet::IntSetObject::allocate(int n) {
+    IntSetObject* o = new IntSetObject;
+    o->n = n;
+    o->r = heap.alloc<Range>(n);
+    return o;
+  }
+
+  SharedHandle::Object*
+  IntSet::IntSetObject::copy(void) const {
+    IntSetObject* o = allocate(n);
+    o->size = size;
+    for (int i=n; i--; )
+      o->r[i]=r[i];
+    return o;
+  }
+
+  bool
+  IntSet::IntSetObject::in(int n) const {
+    int l = 0;
+    int r = this->n - 1;
+
+    while (l <= r) {
+      int m = l + (r - l) / 2;
+      if ((this->r[m].min <= n) && (n <= this->r[m].max)) {
+        return true;
+      } else if (l == r) {
+        return false;
+      } else if (n < this->r[m].min) {
+        r=m-1;
+      } else {
+        l=m+1;
+      }
+    }
+    return false;
+  }
+
+  IntSet::IntSetObject::~IntSetObject(void) {
+    heap.free<Range>(r,n);
+  }
+
+  /// Sort ranges according to increasing minimum
+  class IntSet::MinInc {
+  public:
+    bool operator ()(const Range &x, const Range &y);
+  };
+
+  forceinline bool
+  IntSet::MinInc::operator ()(const Range &x, const Range &y) {
+    return x.min < y.min;
+  }
+
+  void
+  IntSet::normalize(Range* r, int n) {
+    if (n > 0) {
+      // Sort ranges
+      {
+        MinInc lt_mi;
+        Support::quicksort<Range>(r, n, lt_mi);
+      }
+      // Conjoin continuous ranges
+      {
+        int min = r[0].min;
+        int max = r[0].max;
+        int i = 1;
+        int j = 0;
+        while (i < n) {
+          if (max+1 < r[i].min) {
+            r[j].min = min; r[j].max = max; j++;
+            min = r[i].min; max = r[i].max; i++;
+          } else {
+            max = std::max(max,r[i].max); i++;
+          }
+        }
+        r[j].min = min; r[j].max = max;
+        n=j+1;
+      }
+      IntSetObject* o = IntSetObject::allocate(n);
+      unsigned int s = 0;
+      for (int i=n; i--; ) {
+        s += static_cast<unsigned int>(r[i].max-r[i].min+1);
+        o->r[i]=r[i];
+      }
+      o->size = s;
+      object(o);
+    }
+  }
+
+  void
+  IntSet::init(const int r[], int n) {
+    Range* dr = heap.alloc<Range>(n);
+    for (int i=n; i--; ) {
+      dr[i].min=r[i]; dr[i].max=r[i];
+    }
+    normalize(&dr[0],n);
+    heap.free(dr,n);
+  }
+
+  void
+  IntSet::init(const int r[][2], int n) {
+    Range* dr = heap.alloc<Range>(n);
+    int j = 0;
+    for (int i=n; i--; )
+      if (r[i][0] <= r[i][1]) {
+        dr[j].min=r[i][0]; dr[j].max=r[i][1]; j++;
+      }
+    normalize(&dr[0],j);
+    heap.free(dr,n);
+  }
+
+  void
+  IntSet::init(int n, int m) {
+    if (n <= m) {
+      IntSetObject* o = IntSetObject::allocate(1);
+      o->r[0].min = n; o->r[0].max = m;
+      o->size = static_cast<unsigned int>(m - n + 1);
+      object(o);
+    }
+  }
+
+  const IntSet IntSet::empty;
+
+}
+
+// STATISTICS: int-var
+