gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/gecode/cpltset/branch.cc

@@ -0,0 +1,68 @@
+/* -*- 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-08-21 12:23:30 +0200 (Tue, 21 Aug 2007) $ by $Author: schulte $
+ *     $Revision: 4892 $
+ *
+ *  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/branch.hh"
+
+namespace Gecode {
+
+  using namespace CpltSet;
+
+  void
+  branch(Space* home, const CpltSetVarArgs& xa,
+         CpltSetVarBranch vars, CpltSetValBranch vals) {
+    if (home->failed()) 
+      return;
+    ViewArray<CpltSetView> x(home,xa);
+    switch (vars) {
+    case CPLTSET_VAR_NONE:
+      Branch::create<Branch::ByNone>(home,x,vals); break;
+    case CPLTSET_VAR_MIN_CARD:
+      Branch::create<Branch::ByMinCard>(home,x,vals); break;
+    case CPLTSET_VAR_MAX_CARD:
+      Branch::create<Branch::ByMaxCard>(home,x,vals); break;
+    case CPLTSET_VAR_MIN_UNKNOWN_ELEM:
+      Branch::create<Branch::ByMinUnknown>(home,x,vals); break;
+    case CPLTSET_VAR_MAX_UNKNOWN_ELEM:
+      Branch::create<Branch::ByMaxUnknown>(home,x,vals); break;
+    default:
+      throw CpltSet::UnknownBranching("CpltSet::branch");
+    }
+  }
+
+}
+
+// STATISTICS: cpltset-post

data/ext/gecode-2.1.1/gecode/cpltset/branch.hh

@@ -0,0 +1,208 @@
+/* -*- 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-02-16 10:42:26 +0100 (Sat, 16 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6185 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_CPLTSET_BRANCH_HH__
+#define __GECODE_CPLTSET_BRANCH_HH__
+
+#include "gecode/cpltset.hh"
+
+/**
+ * \namespace Gecode::CpltSet::Branch
+ * \brief %CpltSet branchings
+ */
+
+namespace Gecode { namespace CpltSet { namespace Branch {
+
+  /*
+   * Value selection classes
+   *
+   */
+
+  /**
+   * \brief Class for selecting minimum value of unknown ranges
+   *
+   * All value selection classes require 
+   * \code #include "gecode/set/branch.hh" \endcode
+   * \ingroup FuncCpltSetSelVal
+   */
+  template <bool exclude>
+  class ValMinUnknown {
+  public:
+    /// Return minimum value of view \a x
+    int val(const Space*, CpltSetView x) const;
+    /// Tell \f$v\in x\f$ (\a a = 0) or \f$v\notin x\f$ (\a a = 1)
+    ModEvent tell(Space* home, unsigned int a, CpltSetView x, int v);
+    /// Type of this value selection (for reflection)
+    static Support::Symbol type(void);
+    /// Specification of a branch (for reflection)
+    void branchingSpec(const Space* home,
+                       Reflection::VarMap& m, Reflection::BranchingSpec& bs,
+                       int alt, CpltSetView x, int n) const;
+  };
+
+  /**
+   * \brief Class for selecting maximum value of unknown ranges
+   *
+   * All value selection classes require 
+   * \code #include "gecode/set/branch.hh" \endcode
+   * \ingroup FuncCpltSetSelVal
+   */
+  template <bool exclude>
+  class ValMaxUnknown {
+  public:
+    /// Return minimum value of view \a x
+    int val(const Space*, CpltSetView x) const;
+    /// Tell \f$v\in x\f$ (\a a = 0) or \f$v\notin x\f$ (\a a = 1)
+    ModEvent tell(Space* home, unsigned int a, CpltSetView x, int v);
+    /// Type of this value selection (for reflection)
+    static Support::Symbol type(void);
+    /// Specification of a branch (for reflection)
+    void branchingSpec(const Space* home,
+                       Reflection::VarMap& m, Reflection::BranchingSpec& bs,
+                       int alt, CpltSetView x, int n) const;
+  };
+
+  /// Create branchings for a given view selection strategy \a ViewSel
+  template <class SelView>
+  static void
+  create(Space* home, ViewArray<CpltSetView>&, CpltSetValBranch);
+
+  /*
+   * View selection classes
+   *
+   */
+
+  /**
+   * \brief View selection class for first view
+   *
+   * Requires \code #include "gecode/set/branch.hh" \endcode
+   * \ingroup FuncCpltSetSelView
+   */
+  class ByNone {
+  public:
+    /// Intialize with view \a x
+    ViewSelStatus init(const Space*, CpltSetView);
+    /// Possibly select better view \a x
+    ViewSelStatus select(const Space*, CpltSetView);
+    /// Type of this view selection (for reflection)
+    static Support::Symbol type(void);
+  };
+
+  /**
+   * \brief View selection class for view with smallest cardinality of lub-glb
+   *
+   * Requires \code #include "gecode/set/branch.hh" \endcode
+   * \ingroup FuncCpltSetSelView
+   */
+  class ByMinCard {
+  private:
+    /// So-far smallest cardinality
+    unsigned int minCard;
+  public:
+    /// Intialize with view \a x
+    ViewSelStatus init(const Space*, CpltSetView x);
+    /// Possibly select better view \a x
+    ViewSelStatus select(const Space*, CpltSetView x);
+    /// Type of this view selection (for reflection)
+    static Support::Symbol type(void);
+  };
+
+  /**
+   * \brief View selection class for view with greatest cardinality of lub-glb
+   *
+   * Requires \code #include "gecode/set/branch.hh" \endcode
+   * \ingroup FuncCpltSetSelView
+   */
+  class ByMaxCard {
+  private:
+    /// So-far greatest cardinality
+    unsigned int maxCard;
+  public:
+    /// Intialize with view \a x
+    ViewSelStatus init(const Space*, CpltSetView x);
+    /// Possibly select better view \a x
+    ViewSelStatus select(const Space*, CpltSetView x);
+    /// Type of this view selection (for reflection)
+    static Support::Symbol type(void);
+  };
+
+  /**
+   * \brief View selection class for view with smallest element in lub-glb
+   *
+   * Requires \code #include "gecode/cpltset/branch.hh" \endcode
+   * \ingroup FuncCpltSetSelView
+   */
+  class ByMinUnknown {
+  private:
+    /// So-far smallest element
+    int minUnknown;
+  public:
+    /// Intialize with view \a x
+    ViewSelStatus init(const Space*, CpltSetView x);
+    /// Possibly select better view \a x
+    ViewSelStatus select(const Space*, CpltSetView x);
+    /// Type of this view selection (for reflection)
+    static Support::Symbol type(void);
+  };
+
+  /**
+   * \brief View selection class for view with greatest element in lub-glb
+   *
+   * Requires \code #include "gecode/set/branch.hh" \endcode
+   * \ingroup FuncCpltSetSelView
+   */
+  class ByMaxUnknown {
+  private:
+    /// So-far greatest element
+    int maxUnknown;
+  public:
+    /// Intialize with view \a x
+    ViewSelStatus init(const Space*, CpltSetView x);
+    /// Possibly select better view \a x
+    ViewSelStatus select(const Space*, CpltSetView x);
+    /// Type of this view selection (for reflection)
+    static Support::Symbol type(void);
+  };
+
+}}}
+
+#include "gecode/cpltset/branch/select-val.icc"
+#include "gecode/cpltset/branch/select-view.icc"
+
+#endif
+
+// STATISTICS: cpltset-branch

data/ext/gecode-2.1.1/gecode/cpltset/branch/select-val.icc

@@ -0,0 +1,167 @@
+/* -*- 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-02-16 10:42:26 +0100 (Sat, 16 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6185 $
+ *
+ *  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 { namespace Branch {
+
+  template <bool exclude>
+  forceinline int
+  ValMinUnknown<exclude>::val(const Space*, CpltSetView x) const {
+    UnknownValues<CpltSetView> unknown(x);
+    int v = unknown.val();
+    return v;
+  }
+
+  template <bool exclude>
+  forceinline ModEvent
+  ValMinUnknown<exclude>::tell(Space* home, unsigned int a,
+                               CpltSetView x, int v) {
+    return (a == (int) exclude) ? x.include(home,v) : x.exclude(home,v);
+  }
+
+  template<bool exclude>
+  inline Support::Symbol
+  ValMinUnknown<exclude>::type(void) {
+    return Support::Symbol("CpltSet::Branch::ValMinUnknown");
+  }
+
+  template<bool exclude>
+  forceinline void
+  ValMinUnknown<exclude>::branchingSpec(const Space* home,
+                                        Reflection::VarMap& m,
+                                        Reflection::BranchingSpec& bs,
+                                        int alt, CpltSetView x, int n) const {
+    assert(alt <= 2);
+    Reflection::ArrayArg* a0 = Reflection::Arg::newArray(2);
+    std::stringstream s;
+    s << n;
+    if (exclude) {
+      (*a0)[0] = Reflection::Arg::newString((s.str()+" not in ").c_str());
+    } else {
+      (*a0)[0] = Reflection::Arg::newString((s.str()+" in ").c_str());      
+    }
+    (*a0)[1] = x.spec(home, m);
+    bs[0] = a0;
+    if (alt == 2) {
+      Reflection::ArrayArg* a1 = Reflection::Arg::newArray(2);
+      if (exclude) {
+        (*a1)[0] = Reflection::Arg::newString((s.str()+" in ").c_str());
+      } else {
+        (*a1)[0] = Reflection::Arg::newString((s.str()+" not in ").c_str());      
+      }
+      (*a1)[1] = x.spec(home, m);
+      bs[1] = a1;
+    }
+  }
+
+  template <bool exclude>
+  forceinline int
+  ValMaxUnknown<exclude>::val(const Space*, CpltSetView x) const {
+    int maxElem = 0;
+    Set::UnknownRanges<CpltSetView> unknown(x);
+    while (unknown()) {
+      maxElem = unknown.max();
+      ++unknown;
+    }
+    return maxElem;
+  }
+
+  template <bool exclude>
+  forceinline ModEvent
+  ValMaxUnknown<exclude>::tell(Space* home, unsigned int a,
+                               CpltSetView x, int v) {
+    return (a == (int) exclude) ? x.include(home,v) : x.exclude(home,v);
+  }
+
+  template<bool exclude>
+  inline Support::Symbol
+  ValMaxUnknown<exclude>::type(void) {
+    return Support::Symbol("CpltSet::Branch::ValMaxUnknown");
+  }
+
+  template<bool exclude>
+  forceinline void
+  ValMaxUnknown<exclude>::branchingSpec(const Space* home,
+                                        Reflection::VarMap& m,
+                                        Reflection::BranchingSpec& bs,
+                                        int alt, CpltSetView x, int n) const {
+    assert(alt <= 2);
+    Reflection::ArrayArg* a0 = Reflection::Arg::newArray(2);
+    std::stringstream s;
+    s << n;
+    if (exclude) {
+      (*a0)[0] = Reflection::Arg::newString((s.str()+" not in ").c_str());
+    } else {
+      (*a0)[0] = Reflection::Arg::newString((s.str()+" in ").c_str());      
+    }
+    (*a0)[1] = x.spec(home, m);
+    bs[0] = a0;
+    if (alt == 2) {
+      Reflection::ArrayArg* a1 = Reflection::Arg::newArray(2);
+      if (exclude) {
+        (*a1)[0] = Reflection::Arg::newString((s.str()+" in ").c_str());
+      } else {
+        (*a1)[0] = Reflection::Arg::newString((s.str()+" not in ").c_str());      
+      }
+      (*a1)[1] = x.spec(home, m);
+      bs[1] = a1;
+    }
+  }
+
+  template <class SelView>
+  static void
+  create(Space* home, ViewArray<CpltSetView>& x, CpltSetValBranch vals) {
+    switch (vals) {
+    case CPLTSET_VAL_MIN_UNKNOWN:
+      (void) new (home) ViewValBranching<CpltSetView,int,SelView,ValMinUnknown<false> >(home,x);
+      break;
+    case CPLTSET_VAL_MIN_UNKNOWN_EX_FIRST:
+      (void) new (home) ViewValBranching<CpltSetView,int,SelView,ValMinUnknown<true> >(home,x);
+      break;
+    case CPLTSET_VAL_MAX_UNKNOWN:
+      (void) new (home) ViewValBranching<CpltSetView,int,SelView,ValMaxUnknown<false> >(home,x);
+      break;
+    case CPLTSET_VAL_MAX_UNKNOWN_EX_FIRST:
+      (void) new (home) ViewValBranching<CpltSetView,int,SelView,ValMaxUnknown<true> >(home,x);
+      break;
+    default:
+      throw UnknownBranching("CpltSet::branch");
+    }
+  }
+
+}}}
+
+// STATISTICS: cpltset-branch

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

@@ -0,0 +1,143 @@
+/* -*- 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-13 17:49:17 +0100 (Sun, 13 Jan 2008) $ by $Author: tack $
+ *     $Revision: 5864 $
+ *
+ *  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 { namespace Branch {
+
+  forceinline ViewSelStatus
+  ByNone::init(const Space*, CpltSetView) {
+    return VSS_COMMIT;
+  }
+
+  forceinline ViewSelStatus
+  ByNone::select(const Space*, CpltSetView) {
+    GECODE_NEVER;
+    return VSS_NONE;
+  }
+
+  inline Support::Symbol
+  ByNone::type(void) {
+    return Support::Symbol("CpltSet::Branch::ByNone");
+  }
+
+  forceinline ViewSelStatus
+  ByMinCard::init(const Space*, CpltSetView x) { 
+    minCard = x.unknownSize();
+    return (minCard == 1) ? VSS_COMMIT : VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByMinCard::select(const Space*, CpltSetView x) {
+    unsigned int us = x.unknownSize();
+    if (us < minCard) {
+      minCard = us;
+      return (minCard == 1) ? VSS_COMMIT : VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+  inline Support::Symbol
+  ByMinCard::type(void) {
+    return Support::Symbol("CpltSet::Branch::ByMinCard");
+  }
+
+  forceinline ViewSelStatus
+  ByMaxCard::init(const Space*, CpltSetView x) { 
+    maxCard = x.unknownSize();
+    return VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByMaxCard::select(const Space*, CpltSetView x) {
+    unsigned int us = x.unknownSize();
+    if (us > maxCard) {
+      maxCard = us; return VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+  inline Support::Symbol
+  ByMaxCard::type(void) {
+    return Support::Symbol("CpltSet::Branch::ByMaxCard");
+  }
+
+  forceinline ViewSelStatus
+  ByMinUnknown::init(const Space*, CpltSetView x) {
+    Set::UnknownRanges<CpltSetView> unknown(x);
+    minUnknown = unknown.min();
+    return VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByMinUnknown::select(const Space*, CpltSetView x) {
+    Set::UnknownRanges<CpltSetView> unknown(x);
+    int um = unknown.min();
+    if (um < minUnknown) {
+      minUnknown = um; return VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+  inline Support::Symbol
+  ByMinUnknown::type(void) {
+    return Support::Symbol("CpltSet::Branch::ByMinUnknown");
+  }
+
+  forceinline ViewSelStatus
+  ByMaxUnknown::init (const Space*, CpltSetView x) {
+    Set::UnknownRanges<CpltSetView> unknown(x);
+    do {
+      maxUnknown = unknown.max();
+      ++unknown;
+    } while(unknown());
+    return VSS_SELECT;
+  }
+  forceinline ViewSelStatus
+  ByMaxUnknown::select(const Space*, CpltSetView x) {
+    Set::UnknownRanges<CpltSetView> unknown(x);
+    int um = 0;
+    assert(unknown());
+    do {
+      um = unknown.max();
+      ++unknown;
+    } while(unknown());
+    if (um > maxUnknown) {
+      maxUnknown = um; return VSS_SELECT;
+    }
+    return VSS_NONE;
+  }
+  inline Support::Symbol
+  ByMaxUnknown::type(void) {
+    return Support::Symbol("CpltSet::Branch::ByMaxUnknown");
+  }
+
+}}}
+
+// STATISTICS: cpltset-branch