gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/int/branch/assign.cc

@@ -0,0 +1,83 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-07-19 12:57:59 +0200 (Wed, 19 Jul 2006) $ by $Author: schulte $
+ *     $Revision: 3402 $
+ *
+ *  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 "gecode/int/branch.hh"
+
+namespace Gecode { namespace Int { namespace Branch {
+
+  size_t
+  AssignDesc::size(void) const {
+    return sizeof(*this);
+  }
+
+
+  bool
+  Assign::status(const Space*) const {
+    for (int i = pos; i<x.size(); i++)
+      if (!x[i].assigned()) {
+	pos = i;
+	return true;
+      }
+    return false;
+  }
+  ExecStatus
+  Assign::commit(Space* home, const BranchingDesc* _d, unsigned int) {
+    const AssignDesc* d = static_cast<const AssignDesc*>(_d);
+    return me_failed(x[d->pos()].eq(home,d->val())) ? ES_FAILED : ES_OK;
+  }
+
+
+  Actor*
+  AssignMin::copy(Space* home, bool share) {
+    return new (home) AssignMin(home,share,*this);
+  }
+  const BranchingDesc*
+  AssignMin::description(const Space*) const {
+    assert(!x[pos].assigned());
+    return new AssignDesc(this, pos, x[pos].min());
+  }
+
+
+  Actor*
+  AssignMed::copy(Space* home, bool share) {
+    return new (home) AssignMed(home,share,*this);
+  }
+  const BranchingDesc*
+  AssignMed::description(const Space*) const {
+    assert(!x[pos].assigned());
+    return new AssignDesc(this, pos, x[pos].med());
+  }
+
+
+  Actor*
+  AssignMax::copy(Space* home, bool share) {
+    return new (home) AssignMax(home,share,*this);
+  }
+  const BranchingDesc*
+  AssignMax::description(const Space*) const {
+    assert(!x[pos].assigned());
+    return new AssignDesc(this, pos, x[pos].max());
+  }
+
+}}}
+
+// STATISTICS: int-branch
+

data/ext/gecode-1.3.1/gecode/int/branch/assign.icc

@@ -0,0 +1,76 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-07-18 15:18:31 +0200 (Tue, 18 Jul 2006) $ by $Author: schulte $
+ *     $Revision: 3388 $
+ *
+ *  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 Int { namespace Branch {
+
+  /*
+   * Branching descriptions for assignments with position and value
+   *
+   */
+  forceinline
+  AssignDesc::AssignDesc(const Branching* b, const int p, const int n)
+    : BranchingDesc(b,1), _pos(p), _val(n) {}
+  forceinline int
+  AssignDesc::pos(void) const {
+    return _pos;
+  }
+  forceinline int
+  AssignDesc::val(void) const {
+    return _val;
+  }
+
+
+  forceinline
+  Assign::Assign(Space* home, bool share, Assign& b)
+    : Branching(home,share,b), pos(b.pos) {
+    x.update(home,share,b.x);
+  }
+  forceinline
+  Assign::Assign(Space* home, ViewArray<IntView>& x1)
+    : Branching(home), x(x1), pos(0) {}
+
+
+  forceinline
+  AssignMin::AssignMin(Space* home, bool share, AssignMin& b)
+    : Assign(home,share,b) {}
+  forceinline
+  AssignMin::AssignMin(Space* home, ViewArray<IntView>& x)
+    : Assign(home,x) {}
+
+  forceinline
+  AssignMed::AssignMed(Space* home, bool share, AssignMed& b)
+    : Assign(home,share,b) {}
+  forceinline
+  AssignMed::AssignMed(Space* home, ViewArray<IntView>& x)
+    : Assign(home,x) {}
+
+
+  forceinline
+  AssignMax::AssignMax(Space* home, bool share, AssignMax& b)
+    : Assign(home,share,b) {}
+  forceinline
+  AssignMax::AssignMax(Space* home, ViewArray<IntView>& x)
+    : Assign(home,x) {}
+
+}}}
+
+// STATISTICS: int-branch
+

data/ext/gecode-1.3.1/gecode/int/branch/select-val.icc

@@ -0,0 +1,104 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3512 $
+ *
+ *  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 Int { namespace Branch {
+
+  forceinline int
+  ValMin::val(const Space*, IntView x) const {
+    return x.min();
+  }
+  forceinline ModEvent
+  ValMin::tell(Space* home, unsigned int a, IntView x, int n) {
+    return (a == 0) ? x.eq(home,n) : x.gr(home,n);
+  }
+
+
+  forceinline int
+  ValMed::val(const Space*, IntView x) const {
+    return x.med();
+  }
+  forceinline ModEvent
+  ValMed::tell(Space* home, unsigned int a, IntView x, int n) {
+    return (a == 0) ? x.eq(home,n) : x.nq(home,n);
+  }
+
+
+  forceinline int
+  ValMax::val(const Space*, IntView x) const {
+    return x.max();
+  }
+  forceinline ModEvent
+  ValMax::tell(Space* home, unsigned int a, IntView x, int n) {
+    return (a == 0) ? x.eq(home,n) : x.le(home,n);
+  }
+
+
+  forceinline int
+  ValSplitMin::val(const Space*, IntView x) const {
+    return (x.width() == 2) ? x.min() : ((x.min()+x.max()) / 2);
+  }
+  forceinline ModEvent
+  ValSplitMin::tell(Space* home, unsigned int a, IntView x, int n) {
+    return (a == 0) ? x.lq(home,n) : x.gr(home,n);
+  }
+
+
+  forceinline int
+  ValSplitMax::val(const Space*, IntView x) const {
+    return (x.width() == 2) ? x.min() : ((x.min()+x.max()) / 2);
+  }
+  forceinline ModEvent
+  ValSplitMax::tell(Space* home, unsigned int a, IntView x, int n) {
+    return (a == 0) ? x.gr(home,n) : x.lq(home,n);
+  }
+
+
+  template <class SelView>
+  void
+  create(Space* home, ViewArray<IntView>& x, BvalSel vals) {
+    switch (vals) {
+    case BVAL_MIN:
+      (void) new (home) ViewValBranching<IntView,int,SelView,ValMin>(home,x);
+      break;
+    case BVAL_MED:
+      (void) new (home) ViewValBranching<IntView,int,SelView,ValMed>(home,x);
+      break;
+    case BVAL_MAX:
+      (void) new (home) ViewValBranching<IntView,int,SelView,ValMax>(home,x);
+      break;
+    case BVAL_SPLIT_MIN:
+      (void) new (home)
+	ViewValBranching<IntView,int,SelView,ValSplitMin>(home,x);
+      break;
+    case BVAL_SPLIT_MAX:
+      (void) new (home)
+	ViewValBranching<IntView,int,SelView,ValSplitMax>(home,x);
+      break;
+    default:
+      throw UnknownBranching("Int::branch");
+    }
+  }
+
+}}}
+
+
+// STATISTICS: int-branch
+

data/ext/gecode-1.3.1/gecode/int/branch/select-view.icc

@@ -0,0 +1,219 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3512 $
+ *
+ *  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 Int { namespace Branch {
+
+  // Select first variable
+  forceinline ViewSelStatus
+  ByNone::init(const Space*, IntView) {
+    return VSS_COMMIT;
+  }
+  forceinline ViewSelStatus
+  ByNone::select(const Space*, IntView) {
+    GECODE_NEVER;
+    return VSS_NONE;
+  }
+
+  // Select variable with smallest min
+  forceinline ViewSelStatus
+  ByMinMin::init(const Space*, IntView x) {
+    min = x.min();
+    return VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByMinMin::select(const Space*, IntView x) {
+    if (x.min() < min) {
+      min = x.min(); return VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+
+  // Select variable with largest min
+  forceinline ViewSelStatus
+  ByMinMax::init(const Space*, IntView x) {
+    min = x.min();
+    return VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByMinMax::select(const Space*, IntView x) {
+    if (x.min() > min) {
+      min = x.min(); return VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+
+  // Select variable with smallest max
+  forceinline ViewSelStatus
+  ByMaxMin::init(const Space*, IntView x) {
+    max = x.max();
+    return VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByMaxMin::select(const Space*, IntView x) {
+    if (x.max() < max) {
+      max = x.max(); return VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+
+  // Select variable with largest max
+  forceinline ViewSelStatus
+  ByMaxMax::init(const Space*, IntView x) {
+    max = x.max();
+    return VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByMaxMax::select(const Space*, IntView x) {
+    if (x.max() > max) {
+      max = x.max(); return VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+
+  // Select variable with smallest size
+  forceinline ViewSelStatus
+  BySizeMin::init(const Space*, IntView x) {
+    size = x.size();
+    return (size == 2) ? VSS_COMMIT : VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  BySizeMin::select(const Space*, IntView x) {
+    if (x.size() < size) {
+      size = x.size();
+      return (size == 2) ? VSS_COMMIT : VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+
+  // Select variable with largest size
+  forceinline ViewSelStatus
+  BySizeMax::init(const Space*, IntView x) {
+    size = x.size();
+    return VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  BySizeMax::select(const Space*, IntView x) {
+    if (x.size() > size) {
+      size = x.size(); return VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+
+  // Select variable with smallest degree (and smallest size in case of ties)
+  forceinline ViewSelStatus
+  ByDegreeMin::init(const Space*, IntView x) {
+    degree = x.degree(); size = x.size();
+    return VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByDegreeMin::select(const Space*, IntView x) {
+    if (x.degree() < degree) {
+      degree = x.degree();
+      size   = x.size();
+      return VSS_SELECT;
+    } else if ((x.degree() == degree) && (x.size() < size)) {
+      size = x.size();
+      return VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+
+  // Select variable with smallest degree (and smallest size in case of ties)
+  forceinline ViewSelStatus
+  ByDegreeMax::init(const Space*, IntView x) {
+    degree = x.degree(); size = x.size();
+    return VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByDegreeMax::select(const Space*, IntView x) {
+    if (x.degree() > degree) {
+      degree = x.degree();
+      size   = x.size();
+      return VSS_SELECT;
+    } else if ((x.degree() == degree) && (x.size() < size)) {
+      size = x.size();
+      return VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+
+  // Select variable with smallest min-regret
+  forceinline ViewSelStatus
+  ByRegretMinMin::init(const Space*, IntView x) {
+    regret = x.regret_min();
+    return (regret == 1) ? VSS_COMMIT : VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByRegretMinMin::select(const Space*, IntView x) {
+    if (x.regret_min() < regret) {
+      regret = x.regret_min();
+      return (regret == 1) ? VSS_COMMIT : VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+
+  // Select variable with largest min-regret
+  forceinline ViewSelStatus
+  ByRegretMinMax::init(const Space*, IntView x) {
+    regret = x.regret_min();
+    return VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByRegretMinMax::select(const Space*, IntView x) {
+    if (x.regret_min() > regret) {
+      regret = x.regret_min(); return VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+
+  // Select variable with smallest max-regret
+  forceinline ViewSelStatus
+  ByRegretMaxMin::init(const Space*, IntView x) {
+    regret = x.regret_max();
+    return (regret == 1) ? VSS_COMMIT : VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByRegretMaxMin::select(const Space*, IntView x) {
+    if (x.regret_max() < regret) {
+      regret = x.regret_max();
+      return (regret == 1) ? VSS_COMMIT : VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+
+  // Select variable with smallest min-regret
+  forceinline ViewSelStatus
+  ByRegretMaxMax::init(const Space*, IntView x) {
+    regret = x.regret_max();
+    return VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByRegretMaxMax::select(const Space*, IntView x) {
+    if (x.regret_max() > regret) {
+      regret = x.regret_max(); return VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+
+}}}
+
+// STATISTICS: int-branch
+