gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/gecode/cpltset/view/cpltset.icc

@@ -0,0 +1,420 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-01-24 13:05:13 +0100 (Thu, 24 Jan 2008) $ by $Author: tack $
+ *     $Revision: 5974 $
+ *
+ *  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 { namespace CpltSet {
+
+  /*
+   * Constructors and access
+   *
+   */
+
+  forceinline
+  CpltSetView::CpltSetView(void) {}
+
+  forceinline
+  CpltSetView::CpltSetView(const CpltSetVar& y)
+    : VarViewBase<CpltSetVarImp>(y.var()) { }
+
+  /*
+   * Set information
+   *
+   */
+
+
+  forceinline unsigned int
+  CpltSetView::glbSize(void) const { return varimp->glbSize(); }
+
+  forceinline unsigned int
+  CpltSetView::lubSize(void) const { return varimp->lubSize(); }
+
+  forceinline unsigned int
+  CpltSetView::unknownSize(void) const { return varimp->unknownSize(); }
+  
+  forceinline unsigned int
+  CpltSetView::cardMin(void) const { return varimp->cardMin(); }
+
+  forceinline unsigned int
+  CpltSetView::cardMax(void) const { return varimp->cardMax(); }
+
+  forceinline int
+  CpltSetView::lubMin(void) const { return varimp->lubMin(); }
+
+  forceinline int
+  CpltSetView::lubMax(void) const { return varimp->lubMax(); }
+
+  forceinline int
+  CpltSetView::lubMinN(int n) const { return varimp->lubMinN(n); }
+
+  forceinline int
+  CpltSetView::lubMaxN(int n) const { return varimp->lubMaxN(n); }
+
+  forceinline int
+  CpltSetView::glbMin(void) const { return varimp->glbMin(); }
+
+  forceinline int
+  CpltSetView::glbMax(void) const { return varimp->glbMax(); }
+
+
+
+  /*
+   * Bdd information
+   *
+   */
+
+
+  forceinline unsigned int
+  CpltSetView::offset(void)  const { return varimp->offset(); }
+
+  forceinline unsigned int
+  CpltSetView::tableWidth(void)  const { return varimp->tableWidth(); }
+
+  forceinline bdd
+  CpltSetView::element(int i)  const { return varimp->element(i); }
+
+  forceinline bdd
+  CpltSetView::elementNeg(int i)  const { return varimp->elementNeg(i); }
+
+  forceinline int
+  CpltSetView::initialLubMin(void)  const { return varimp->initialLubMin(); }
+
+  forceinline int
+  CpltSetView::initialLubMax(void)  const { return varimp->initialLubMax(); }
+  
+  forceinline bdd 
+  CpltSetView::dom(void) const {  return varimp->dom(); };
+
+
+  /*
+   * Domain tests
+   *
+   */
+
+  forceinline bool
+  CpltSetView::assigned(void)  const { return varimp->assigned(); }
+
+  forceinline bool
+  CpltSetView::contains(int i) const { return (varimp->knownIn(i)); }
+  
+  forceinline bool
+  CpltSetView::notContains(int i) const { return (varimp->knownOut(i)); }
+
+  /*
+   * Tells
+   *
+   */
+
+  forceinline ModEvent 
+  CpltSetView::cardinality(Space* home, int l, int u) {
+    return varimp->cardinality(home, l, u);
+  }
+
+  forceinline ModEvent
+  CpltSetView::cardMin(Space* home, unsigned int m) {
+    return varimp->cardMin(home, m);
+  }
+
+  forceinline ModEvent
+  CpltSetView::cardMax(Space* home, unsigned int m) {
+    return varimp->cardMax(home, m);
+  }
+
+  forceinline ModEvent
+  CpltSetView::include(Space* home, int from, int to) { 
+    return varimp->include(home, from, to);
+  }
+
+  forceinline ModEvent
+  CpltSetView::include(Space* home, int n) { return varimp->include(home, n); }
+
+  template <class I> ModEvent
+  CpltSetView::includeI(Space* home, I& iter) { return varimp->includeI(home, iter); }
+
+  forceinline ModEvent
+  CpltSetView::exclude(Space* home, int from, int to) { 
+    return varimp->exclude(home, from, to);
+  }
+
+  forceinline ModEvent
+  CpltSetView::exclude(Space* home, int n) { return varimp->exclude(home, n); }
+
+  template <class I> ModEvent
+  CpltSetView::excludeI(Space* home, I& iter) { return varimp->excludeI(home, iter); }
+
+  forceinline ModEvent
+  CpltSetView::intersect(Space* home,int from, int to) {
+    return varimp->intersect(home,from,to);
+  }
+
+  forceinline ModEvent
+  CpltSetView::intersect(Space* home,int n) { return varimp->intersect(home,n); }
+
+  template <class I> ModEvent
+  CpltSetView::intersectI(Space* home, I& iter) { 
+    return varimp->intersectI(home, iter);
+  }
+
+  forceinline ModEvent
+  CpltSetView::nq(Space* home, int v) { return varimp->nq(home, v); }
+
+  forceinline ModEvent
+  CpltSetView::nq(Space* home, int a, int b) { return varimp->nq(home, a, b); }
+
+  template <class I>
+  forceinline ModEvent
+  CpltSetView::nqI(Space* home, I& i) { return varimp->nqI(home, i); }
+
+  forceinline ModEvent
+  CpltSetView::eq(Space* home, int v) { return varimp->eq(home, v); }
+
+  forceinline ModEvent
+  CpltSetView::eq(Space* home, int a, int b) { return varimp->eq(home, a, b); }
+  
+  template <class I>
+  forceinline ModEvent
+  CpltSetView::eqI(Space* home, I& i) { return varimp->eqI(home, i); }
+
+  forceinline ModEvent 
+  CpltSetView::intersect(Space* home, bdd& d) {
+    return varimp->intersect(home, d);
+  }
+
+  /*
+   * Cloning
+   *
+   */
+
+  forceinline void
+  CpltSetView::update(Space* home, bool share, CpltSetView& y) {
+    varimp = y.varimp->copy(home,share);
+  }
+
+  /*
+   * Serialization
+   *
+   */
+  forceinline Reflection::Arg*
+  CpltSetView::spec(const Space* home, Reflection::VarMap& m) const {
+    return varimp->spec(home, m);
+  }
+  inline Support::Symbol
+  CpltSetView::type(void) {
+    return Support::Symbol("CpltSet::CpltSetView");
+  }
+
+  /*
+   * Delta information for advisors
+   *
+   */
+
+  forceinline ModEvent
+  CpltSetView::modevent(const Delta* d) { return CpltSetVarImp::modevent(d); }
+
+  /// Iterator for the values in the greatest lower bound of a CpltSetView
+  template <>
+  class GlbValues<CpltSetView> : public GlbValues<CpltSetVarImp*> {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    GlbValues(void);
+    /// Initialize with ranges for variable implementation \a x
+    GlbValues(const CpltSetView& x);
+    /// Initialize with ranges for variable implementation \a x
+    void init(const CpltSetView& x);
+    //@}    
+  };
+
+  forceinline
+  GlbValues<CpltSetView>::GlbValues(void) {}
+
+  forceinline
+  GlbValues<CpltSetView>::GlbValues(const CpltSetView& x) 
+    : GlbValues<CpltSetVarImp*>(x.var()) {}
+
+  forceinline void
+  GlbValues<CpltSetView>::init(const CpltSetView& x) {
+    GlbValues<CpltSetVarImp*>::init(x.var());
+  }
+}
+  namespace Set {
+  /// Range iterator for greatest lower bound of CpltSet view
+  template <>
+  class GlbRanges<CpltSet::CpltSetView> : public Set::GlbRanges<CpltSet::CpltSetVarImp*> {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    GlbRanges(void);
+    /// Initialize with ranges for variable implementation \a x
+    GlbRanges(const CpltSet::CpltSetView& x);
+    /// Initialize with ranges for variable implementation \a x
+    void init(const CpltSet::CpltSetView& x);
+    //@}    
+  };
+
+  forceinline
+  GlbRanges<CpltSet::CpltSetView>::GlbRanges(void) {}
+
+  forceinline
+  GlbRanges<CpltSet::CpltSetView>::GlbRanges(const CpltSet::CpltSetView& x) 
+    : GlbRanges<CpltSet::CpltSetVarImp*>(x.var()) {}
+
+  forceinline void
+  GlbRanges<CpltSet::CpltSetView>::init(const CpltSet::CpltSetView& x) {
+    GlbRanges<CpltSet::CpltSetVarImp*>::init(x.var());
+  }
+
+  /// Range iterator for least upper bound of CpltSet view
+  template <>
+  class LubRanges<CpltSet::CpltSetView> : public Set::LubRanges<CpltSet::CpltSetVarImp*> {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    LubRanges(void);
+    /// Initialize with ranges for variable implementation \a x
+    LubRanges(const CpltSet::CpltSetView& x);
+    /// Initialize with ranges for variable implementation \a x
+    void init(const CpltSet::CpltSetView& x);
+    //@}    
+  };
+
+  forceinline
+  LubRanges<CpltSet::CpltSetView>::LubRanges(void) {}
+
+  forceinline
+  LubRanges<CpltSet::CpltSetView>::LubRanges(const CpltSet::CpltSetView& x) 
+    : Set::LubRanges<CpltSet::CpltSetVarImp*>(x.var()) {}
+
+  forceinline void
+  LubRanges<CpltSet::CpltSetView>::init(const CpltSet::CpltSetView& x) {
+    Set::LubRanges<CpltSet::CpltSetVarImp*>::init(x.var());
+  }
+  }
+  namespace CpltSet {
+  /**
+   * \brief %Value iterator for least upper bound of singleton set view
+   * \ingroup TaskActorSetView
+   */
+  template <>
+  class LubValues<CpltSetView> : public LubValues<CpltSetVarImp*> {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    LubValues(void);
+    /// Initialize with ranges for view \a x
+    LubValues(const CpltSetView& x);
+    /// Initialize with ranges for view \a x
+    void init(const CpltSetView& x);
+    //@}
+  };
+
+  forceinline
+  LubValues<CpltSetView>::LubValues(void) {}
+
+  forceinline
+  LubValues<CpltSetView>::LubValues(const CpltSetView& x) 
+  : LubValues<CpltSetVarImp*>(x.var()) {}
+
+  forceinline void
+  LubValues<CpltSetView>::init(const CpltSetView& x) {
+    LubValues<CpltSetVarImp*>::init(x.var());
+  }
+
+
+  /// Iterator for the unknown values of a CpltSetView
+  template <>
+  class UnknownValues<CpltSetView> : public UnknownValues<CpltSetVarImp*> {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    UnknownValues(void);
+    /// Initialize with ranges for variable implementation \a x
+    UnknownValues(const CpltSetView& x);
+    /// Initialize with ranges for variable implementation \a x
+    void init(const CpltSetView& x);
+    //@}    
+  };
+
+  forceinline
+  UnknownValues<CpltSetView>::UnknownValues(void) {}
+
+  forceinline
+  UnknownValues<CpltSetView>::UnknownValues(const CpltSetView& x) 
+    : UnknownValues<CpltSetVarImp*>(x.var()) {}
+
+  forceinline void
+  UnknownValues<CpltSetView>::init(const CpltSetView& x) {
+    UnknownValues<CpltSetVarImp*>::init(x.var());
+  }
+  }
+  namespace Set {
+  /// Range iterator for the unknown set of CpltSet view
+  template <>
+  class UnknownRanges<CpltSet::CpltSetView> : public Set::UnknownRanges<CpltSet::CpltSetVarImp*> {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    UnknownRanges(void);
+    /// Initialize with ranges for variable implementation \a x
+    UnknownRanges(const CpltSet::CpltSetView& x);
+    /// Initialize with ranges for variable implementation \a x
+    void init(const CpltSet::CpltSetView& x);
+    //@}    
+  };
+
+  forceinline
+  UnknownRanges<CpltSet::CpltSetView>::UnknownRanges(void) {}
+
+  forceinline
+  UnknownRanges<CpltSet::CpltSetView>::UnknownRanges(const CpltSet::CpltSetView& x) 
+    : Set::UnknownRanges<CpltSet::CpltSetVarImp*>(x.var()) {}
+
+  forceinline void
+  UnknownRanges<CpltSet::CpltSetView>::init(const CpltSet::CpltSetView& x) {
+    Set::UnknownRanges<CpltSet::CpltSetVarImp*>::init(x.var());
+  }
+  }
+
+}
+
+
+// STATISTICS: cpltset-var

data/ext/gecode-2.1.1/gecode/cpltset/view/print.cc

@@ -0,0 +1,166 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2006
+ *
+ *  Last modified:
+ *     $Date: 2007-11-06 15:09:01 +0100 (Tue, 06 Nov 2007) $ by $Author: tack $
+ *     $Revision: 5205 $
+ *
+ *  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/cpltset.hh"
+#include "gecode/support/buddy/kernel.h"
+
+namespace Gecode { namespace CpltSet {
+
+  /* 
+   * Printing a bound
+   *
+   */
+  template <class I>
+  static void
+  printBound(std::ostream& os, I& r) {
+    os << '{';
+    while (r()) {
+      if (r.min() == r.max()) {
+        os << r.min();
+      } else if (r.min()+1 == r.max()) {
+        os << r.min() << "," << r.max();
+      } else {
+        os << r.min() << ".." << r.max();
+      }
+      ++r;
+      if (!r()) break;
+      os << ',';
+    }
+    os << '}';
+  }
+
+  /// Print the domain represented by \a r to \a os
+  bool printBddDom(std::ostream& os, int off, int min, int width, bool first,
+                   char* profile, bdd& r) {
+    if (r == bdd_true())
+    {
+      if (!first)
+        os << ",";
+      bool assigned = true;
+      int last = -1;
+      int lastUnknown = -1;
+      for (int i = 0; i<width; i++) {
+        if (profile[i] < 0) {
+          assigned = false; lastUnknown = i;
+        }
+        if (profile[i] == 1) {
+          last = i; lastUnknown = i;
+        }
+      }
+      if (assigned) {
+        os << "{";
+        for (int i = 0; i<=last; i++) {
+          if (profile[i] == 1)
+            os << min+i << (i<last ? "," : "");
+        }
+        os << "}";
+      } else {
+        os << "{";
+        for (int i = 0; i<=last; i++) {
+          if (profile[i] == 1)
+            os << min+i << (i<last ? "," : "");
+        }
+        os << "}..{";
+        for (int i = 0; i<=lastUnknown; i++) {
+          if (profile[i] != 0)
+            os << min+i << (i<lastUnknown ? "," : "");
+        }
+        os << "}";
+      }
+      return false;
+    }
+
+    if (r == bdd_false())
+      return first;
+
+    if (bdd_low(r) != bdd_false()) {
+      profile[bddlevel2var[r.getlevel()]-off] = 0;
+      for (int v=bdd_low(r).getlevel()-1 ; v>r.getlevel() ; --v) {
+        profile[bddlevel2var[v]-off] = -1;
+      }
+      bdd rlow = bdd_low(r);
+      first = printBddDom(os, off, min, width, first, profile, rlow);
+    }
+
+    if (bdd_high(r) != bdd_false()) {
+      profile[bddlevel2var[r.getlevel()]-off] = 1;
+      for (int v=bdd_high(r).getlevel()-1 ; v>r.getlevel() ; --v) {
+        profile[bddlevel2var[v]-off] = -1;
+      }
+      bdd rhigh = bdd_high(r);
+      first = printBddDom(os, off, min, width, first, profile, rhigh);
+    }
+    return first;
+  }
+
+}}
+
+using namespace Gecode;
+using namespace Gecode::CpltSet;
+
+/**
+ * \brief Print set variable view
+ * \relates Gecode::CpltSet::CpltSetView
+ */
+std::ostream&
+operator<<(std::ostream& os, const CpltSetView& x) {
+  bool assigned = x.assigned();
+  if (assigned) {
+    GlbValues<CpltSetView> glb(x);
+    Iter::Values::ToRanges<GlbValues<CpltSetView> > glbr(glb);
+    printBound(os, glbr);
+  } else {
+    bdd dom = x.dom();
+    os << "{";
+    char* profile = Memory::bmalloc<char>(x.tableWidth());
+    for (int i=x.tableWidth(); i--;)
+      profile[i] = -1;
+    printBddDom(os, x.offset(), x.initialLubMin(), x.tableWidth(), true, 
+                profile, dom);
+    Memory::free(profile);
+    os << "}";
+  }
+  return os;
+}
+
+std::ostream&
+operator<< (std::ostream& os, const CpltSetVar& x) {
+  CpltSetView xv(x);
+  return os << xv;
+}
+
+// STATISTICS: cpltset-var