gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/gecode/int/branch/create-branch.icc

@@ -0,0 +1,190 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 15:48:58 +0200 (Fri, 11 Jul 2008) $ by $Author: schulte $
+ *     $Revision: 7366 $
+ *
+ *  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 Int { namespace Branch {
+
+  template <template <class,class,class,class> class B>
+  void
+  createBranch(Space* home, const IntVarArgs& x,
+               IntVarBranch vars, IntValBranch vals) {
+    ViewArray<IntView> xv(home,x);
+    switch (vars) {
+    case INT_VAR_NONE:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::ByNone>(home,xv,vals); break;
+    case INT_VAR_MIN_MIN:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::ByMinMin>(home,xv,vals); break;
+    case INT_VAR_MIN_MAX:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::ByMinMax>(home,xv,vals); break;
+    case INT_VAR_MAX_MIN:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::ByMaxMin>(home,xv,vals); break;
+    case INT_VAR_MAX_MAX:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::ByMaxMax>(home,xv,vals); break;
+    case INT_VAR_SIZE_MIN:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::BySizeMin>(home,xv,vals); break;
+    case INT_VAR_SIZE_MAX:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::BySizeMax>(home,xv,vals); break;
+    case INT_VAR_DEGREE_MIN:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::ByDegreeMin>(home,xv,vals); break;
+    case INT_VAR_DEGREE_MAX:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::ByDegreeMax>(home,xv,vals); break;
+    case INT_VAR_SIZE_DEGREE_MIN:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::BySizeDegreeMin>(home,xv,vals); break;
+    case INT_VAR_SIZE_DEGREE_MAX:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::BySizeDegreeMax>(home,xv,vals); break;
+    case INT_VAR_REGRET_MIN_MIN:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::ByRegretMinMin>(home,xv,vals); break;
+    case INT_VAR_REGRET_MIN_MAX:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::ByRegretMinMax>(home,xv,vals); break;
+    case INT_VAR_REGRET_MAX_MIN:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::ByRegretMaxMin>(home,xv,vals); break;
+    case INT_VAR_REGRET_MAX_MAX:
+      if (home->failed()) return;
+      Branch::create<B,IntView,Branch::ByRegretMaxMax>(home,xv,vals); break;
+    default:
+      throw UnknownBranching("Int::branch");
+    }
+  }
+  
+  template <template <class,class,class,class> class B>
+  void
+  createBranch(Space* home, const BoolVarArgs& x, 
+               IntVarBranch vars, IntValBranch vals) {
+    ViewArray<BoolView> xv(home,x);
+    switch (vars) {
+    case INT_VAR_NONE:
+    case INT_VAR_MIN_MIN:
+    case INT_VAR_MIN_MAX:
+    case INT_VAR_MAX_MIN:
+    case INT_VAR_MAX_MAX:
+    case INT_VAR_SIZE_MIN:
+    case INT_VAR_SIZE_MAX:
+    case INT_VAR_REGRET_MIN_MIN:
+    case INT_VAR_REGRET_MIN_MAX:
+    case INT_VAR_REGRET_MAX_MIN:
+    case INT_VAR_REGRET_MAX_MAX:
+      switch (vals) {
+      case INT_VAL_MIN:
+      case INT_VAL_MED:
+      case INT_VAL_SPLIT_MIN:
+        if (home->failed()) return;
+        (void) new (home) 
+          B<BoolView,Branch::NoValue,
+            Branch::ByNone<BoolView>,
+            Branch::ValZeroOne<BoolView> >(home,xv);
+        break;
+      case INT_VAL_MAX:
+      case INT_VAL_SPLIT_MAX:
+        if (home->failed()) return;
+        (void) new (home) 
+          B<BoolView,Branch::NoValue,
+            Branch::ByNone<BoolView>,
+            Branch::ValOneZero<BoolView> >(home,xv);
+        break;
+      default:
+        throw UnknownBranching("Int::branch");
+      }
+      break;
+    case INT_VAR_DEGREE_MIN:
+    case INT_VAR_SIZE_DEGREE_MAX:
+      switch (vals) {
+      case INT_VAL_MIN:
+      case INT_VAL_MED:
+      case INT_VAL_SPLIT_MIN:
+        if (home->failed()) return;
+        (void) new (home) 
+          B<BoolView,Branch::NoValue,
+            Branch::ByDegreeMinNoTies<BoolView>,
+            Branch::ValZeroOne<BoolView> >(home,xv);
+        break;
+      case INT_VAL_MAX:
+      case INT_VAL_SPLIT_MAX:
+        if (home->failed()) return;
+        (void) new (home) 
+          B<BoolView,Branch::NoValue,
+            Branch::ByDegreeMinNoTies<BoolView>,
+            Branch::ValOneZero<BoolView> >(home,xv);
+        break;
+      default:
+        throw UnknownBranching("Int::branch");
+      }
+      break;
+    case INT_VAR_DEGREE_MAX:
+    case INT_VAR_SIZE_DEGREE_MIN:
+      switch (vals) {
+      case INT_VAL_MIN:
+      case INT_VAL_MED:
+      case INT_VAL_SPLIT_MIN:
+        if (home->failed()) return;
+        (void) new (home) 
+          B<BoolView,Branch::NoValue,
+            Branch::ByDegreeMaxNoTies<BoolView>,
+            Branch::ValZeroOne<BoolView> >(home,xv);
+        break;
+      case INT_VAL_MAX:
+      case INT_VAL_SPLIT_MAX:
+        if (home->failed()) return;
+        (void) new (home) 
+          B<BoolView,Branch::NoValue,
+            Branch::ByDegreeMaxNoTies<BoolView>,
+            Branch::ValOneZero<BoolView> >(home,xv);
+        break;
+      default:
+        throw UnknownBranching("Int::branch");
+      }
+      break;
+    default:
+      throw UnknownBranching("Int::branch");
+    }
+  }
+      
+}}}
+
+// STATISTICS: int-post

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

@@ -0,0 +1,340 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:39:08 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7297 $
+ *
+ *  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 Int { namespace Branch {
+
+  template<class View>
+  forceinline int
+  ValMin<View>::val(const Space*, View x) const {
+    return x.min();
+  }
+  template<class View>
+  forceinline ModEvent
+  ValMin<View>::tell(Space* home, unsigned int a, View x, int n) {
+    return (a == 0) ? x.eq(home,n) : x.gr(home,n);
+  }
+  template<class View>
+  inline Support::Symbol
+  ValMin<View>::type(void) {
+    return Support::Symbol("Gecode::Int::Branch::ValMin");
+  }
+  template <class View>
+  forceinline void
+  ValMin<View>::branchingSpec(const Space* home,
+                              Reflection::VarMap& m,
+                              Reflection::BranchingSpec& bs,
+                              int alt, View x, int n) const {
+    assert(alt <= 2);
+    Reflection::ArrayArg* a0 = Reflection::Arg::newArray(2);
+    std::stringstream s;
+    s << n;
+    (*a0)[0] = x.spec(home, m);
+    (*a0)[1] = Reflection::Arg::newString((std::string("=")+s.str()).c_str());
+    bs[0] = a0;
+    if (alt == 2) {
+      Reflection::ArrayArg* a1 = Reflection::Arg::newArray(2);
+      (*a1)[0] = x.spec(home, m);
+      (*a1)[1] = 
+        Reflection::Arg::newString((std::string(">")+s.str()).c_str());
+      bs[1] = a1;
+    }
+  }
+
+  template<class View>
+  forceinline int
+  ValMed<View>::val(const Space*, View x) const {
+    return x.med();
+  }
+  template<class View>
+  forceinline ModEvent
+  ValMed<View>::tell(Space* home, unsigned int a, View x, int n) {
+    return (a == 0) ? x.eq(home,n) : x.nq(home,n);
+  }
+  template<class View>
+  inline Support::Symbol
+  ValMed<View>::type(void) {
+    return Support::Symbol("Gecode::Int::Branch::ValMed");
+  }
+  template <class View>
+  forceinline void
+  ValMed<View>::branchingSpec(const Space* home,
+                              Reflection::VarMap& m,
+                              Reflection::BranchingSpec& bs,
+                              int alt, View x, int n) const {
+    assert(alt <= 2);
+    Reflection::ArrayArg* a0 = Reflection::Arg::newArray(2);
+    std::stringstream s;
+    s << n;
+    (*a0)[0] = x.spec(home, m);
+    (*a0)[1] = Reflection::Arg::newString((std::string("=")+s.str()).c_str());
+    bs[0] = a0;
+    if (alt == 2) {
+      Reflection::ArrayArg* a1 = Reflection::Arg::newArray(2);
+      (*a1)[0] = x.spec(home, m);
+      (*a1)[1] = 
+        Reflection::Arg::newString((std::string("!=")+s.str()).c_str());
+      bs[1] = a1;
+    }
+  }
+
+
+  template<class View>
+  forceinline int
+  ValMax<View>::val(const Space*, View x) const {
+    return x.max();
+  }
+  template<class View>
+  forceinline ModEvent
+  ValMax<View>::tell(Space* home, unsigned int a, View x, int n) {
+    return (a == 0) ? x.eq(home,n) : x.le(home,n);
+  }
+  template<class View>
+  inline Support::Symbol
+  ValMax<View>::type(void) {
+    return Support::Symbol("Gecode::Int::Branch::ValMax");
+  }
+  template <class View>
+  forceinline void
+  ValMax<View>::branchingSpec(const Space* home,
+                              Reflection::VarMap& m,
+                              Reflection::BranchingSpec& bs,
+                              int alt, View x, int n) const {
+    assert(alt <= 2);
+    Reflection::ArrayArg* a0 = Reflection::Arg::newArray(2);
+    std::stringstream s;
+    s << n;
+    (*a0)[0] = x.spec(home, m);
+    (*a0)[1] = Reflection::Arg::newString((std::string("=")+s.str()).c_str());
+    bs[0] = a0;
+    if (alt == 2) {
+      Reflection::ArrayArg* a1 = Reflection::Arg::newArray(2);
+      (*a1)[0] = x.spec(home, m);
+      (*a1)[1] = 
+        Reflection::Arg::newString((std::string("<")+s.str()).c_str());
+      bs[1] = a1;
+    }
+  }
+
+
+  template<class View>
+  forceinline int
+  ValSplitMin<View>::val(const Space*, View x) const {
+    return (x.width() == 2) ? x.min() : ((x.min()+x.max()) / 2);
+  }
+  template<class View>
+  forceinline ModEvent
+  ValSplitMin<View>::tell(Space* home, unsigned int a, View x, int n) {
+    return (a == 0) ? x.lq(home,n) : x.gr(home,n);
+  }
+  template<class View>
+  inline Support::Symbol
+  ValSplitMin<View>::type(void) {
+    return Support::Symbol("Gecode::Int::Branch::ValSplitMin");
+  }
+  template <class View>
+  forceinline void
+  ValSplitMin<View>::branchingSpec(const Space* home,
+                                   Reflection::VarMap& m,
+                                   Reflection::BranchingSpec& bs,
+                                   int alt, View x, int n) const {
+    assert(alt <= 2);
+    Reflection::ArrayArg* a0 = Reflection::Arg::newArray(2);
+    std::stringstream s;
+    s << n;
+    (*a0)[0] = x.spec(home, m);
+    (*a0)[1] = 
+      Reflection::Arg::newString((std::string("<=")+s.str()).c_str());
+    bs[0] = a0;
+    if (alt == 2) {
+      Reflection::ArrayArg* a1 = Reflection::Arg::newArray(2);
+      (*a1)[0] = x.spec(home, m);
+      (*a1)[1] = 
+        Reflection::Arg::newString((std::string(">")+s.str()).c_str());
+      bs[1] = a1;
+    }
+  }
+
+
+  template<class View>
+  forceinline int
+  ValSplitMax<View>::val(const Space*, View x) const {
+    return (x.width() == 2) ? x.min() : ((x.min()+x.max()) / 2);
+  }
+  template<class View>
+  forceinline ModEvent
+  ValSplitMax<View>::tell(Space* home, unsigned int a, View x, int n) {
+    return (a == 0) ? x.gr(home,n) : x.lq(home,n);
+  }
+  template<class View>
+  inline Support::Symbol
+  ValSplitMax<View>::type(void) {
+    return Support::Symbol("Gecode::Int::Branch::ValSplitMax");
+  }
+  template <class View>
+  forceinline void
+  ValSplitMax<View>::branchingSpec(const Space* home,
+                                   Reflection::VarMap& m,
+                                   Reflection::BranchingSpec& bs,
+                                   int alt, View x, int n) const {
+    assert(alt <= 2);
+    Reflection::ArrayArg* a0 = Reflection::Arg::newArray(2);
+    std::stringstream s;
+    s << n;
+    (*a0)[0] = x.spec(home, m);
+    (*a0)[1] = Reflection::Arg::newString((std::string(">")+s.str()).c_str());
+    bs[0] = a0;
+    if (alt == 2) {
+      Reflection::ArrayArg* a1 = Reflection::Arg::newArray(2);
+      (*a1)[0] = x.spec(home, m);
+      (*a1)[1] = 
+        Reflection::Arg::newString((std::string("<=")+s.str()).c_str());
+      bs[1] = a1;
+    }
+  }
+
+
+  template<template <class,class,class,class> class B, class View,
+           template <class> class SelView>
+  void
+  create(Space* home, ViewArray<View>& x, IntValBranch vals) {
+    switch (vals) {
+    case INT_VAL_MIN:
+      (void) new (home) 
+        B<View,int,SelView<View>,ValMin<View> >(home,x);
+      break;
+    case INT_VAL_MED:
+      (void) new (home) 
+        B<View,int,SelView<View>,ValMed<View> >(home,x);
+      break;
+    case INT_VAL_MAX:
+      (void) new (home) 
+        B<View,int,SelView<View>,ValMax<View> >(home,x);
+      break;
+    case INT_VAL_SPLIT_MIN:
+      (void) new (home)
+        B<View,int,SelView<View>,ValSplitMin<View> >(home,x);
+      break;
+    case INT_VAL_SPLIT_MAX:
+      (void) new (home)
+        B<View,int,SelView<View>,ValSplitMax<View> >(home,x);
+      break;
+    default:
+      throw UnknownBranching("Int::branch");
+    }
+  }
+
+  inline Support::Symbol
+  NoValue::type(void) {
+    return Support::Symbol("Gecode::Int::Branch::NoValue");
+  }
+
+  template<class View>
+  forceinline NoValue
+  ValZeroOne<View>::val(const Space*, View) const {
+    NoValue n; return n;
+  }
+  template<class View>
+  forceinline ModEvent
+  ValZeroOne<View>::tell(Space* home, unsigned int a, View x, NoValue) {
+    return (a == 0) ? x.zero(home) : x.one(home);
+  }
+  template<class View>
+  inline Support::Symbol
+  ValZeroOne<View>::type(void) {
+    return Support::Symbol("Gecode::Int::Branch::ValZeroOne");
+  }
+  template <class View>
+  forceinline void
+  ValZeroOne<View>::branchingSpec(const Space* home,
+                                  Reflection::VarMap& m,
+                                  Reflection::BranchingSpec& bs,
+                                  int alt, View x, NoValue) const {
+    assert(alt <= 2);
+    Reflection::ArrayArg* a0 = Reflection::Arg::newArray(2);
+    (*a0)[0] = x.spec(home, m);
+    (*a0)[1] = Reflection::Arg::newString("= 0");
+    bs[0] = a0;
+    if (alt == 2) {
+      Reflection::ArrayArg* a1 = Reflection::Arg::newArray(2);
+      (*a1)[0] = x.spec(home, m);
+      (*a1)[1] = Reflection::Arg::newString("= 1");
+      bs[1] = a1;
+    }
+  }
+
+
+
+  template<class View>
+  forceinline NoValue
+  ValOneZero<View>::val(const Space*, View) const {
+    NoValue n; return n;
+  }
+  template<class View>
+  forceinline ModEvent
+  ValOneZero<View>::tell(Space* home, unsigned int a, View x, NoValue) {
+    return (a == 0) ? x.one(home) : x.zero(home);
+  }
+  template<class View>
+  inline Support::Symbol
+  ValOneZero<View>::type(void) {
+    return Support::Symbol("Gecode::Int::Branch::ValOneZero");
+  }
+  template <class View>
+  forceinline void
+  ValOneZero<View>::branchingSpec(const Space* home,
+                                  Reflection::VarMap& m,
+                                  Reflection::BranchingSpec& bs,
+                                  int alt, View x, NoValue) const {
+    assert(alt <= 2);
+    Reflection::ArrayArg* a0 = Reflection::Arg::newArray(2);
+    (*a0)[0] = x.spec(home, m);
+    (*a0)[1] = Reflection::Arg::newString("= 1");
+    bs[0] = a0;
+    if (alt == 2) {
+      Reflection::ArrayArg* a1 = Reflection::Arg::newArray(2);
+      (*a1)[0] = x.spec(home, m);
+      (*a1)[1] = Reflection::Arg::newString("= 0");
+      bs[1] = a1;
+    }
+  }
+
+
+}}}
+
+
+// STATISTICS: int-branch
+