gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/gecode/int/var-imp/bool.cc

@@ -0,0 +1,104 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-01-25 13:35:29 +0100 (Fri, 25 Jan 2008) $ by $Author: tack $
+ *     $Revision: 5983 $
+ *
+ *  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 { namespace Int {
+
+  BoolVarImp BoolVarImp::s_one(1);
+  BoolVarImp BoolVarImp::s_zero(0);
+
+  ModEvent
+  BoolVarImp::one_none(Space* home) {
+    assert(none());
+    bits() ^= (NONE ^ ONE);
+    assert(one());
+    IntDelta d(false);
+    return notify(home,ME_BOOL_VAL,&d);
+  }
+
+  ModEvent
+  BoolVarImp::zero_none(Space* home) {
+    assert(none());
+    bits() ^= (NONE ^ ZERO);
+    assert(zero());
+    IntDelta d(false);
+    return notify(home,ME_BOOL_VAL,&d);
+  }
+
+
+  Reflection::Arg*
+  BoolVarImp::spec(const Space*, Reflection::VarMap& m) const {
+    int specIndex = m.index(this);
+    if (specIndex != -1)
+      return Reflection::Arg::newVar(specIndex);
+    Reflection::VarSpec* spec =
+      new Reflection::VarSpec(vti, Reflection::Arg::newInt(status()));
+    return (Reflection::Arg::newVar(m.put(this, spec)));
+  }
+
+
+  VarImpBase*
+  BoolVarImp::create(Space* home, Reflection::VarSpec& spec) {
+    unsigned int dom = spec.dom()->toInt();
+    int min = 0;
+    int max = 1;
+    if (dom == Int::BoolVarImp::ZERO)
+      max = 0;
+    else if (dom == Int::BoolVarImp::ONE)
+      min = 1;
+    return new (home) BoolVarImp(home, min, max);
+  }
+
+  void
+  BoolVarImp::constrain(Space* home, VarImpBase* v,
+                        Reflection::VarSpec& spec) {
+    unsigned int d = spec.dom()->toInt();
+    if (d == Int::BoolVarImp::ZERO) {
+      GECODE_ME_FAIL(home, static_cast<Int::BoolVarImp*>(v)->zero(home));
+    } else if (d == Int::BoolVarImp::ONE) {
+      GECODE_ME_FAIL(home, static_cast<Int::BoolVarImp*>(v)->one(home));
+    }
+  }
+
+  namespace {
+    Reflection::VarImpRegistrar<BoolVarImp> registerBoolVarImp;
+  }
+
+}}
+
+// STATISTICS: int-var

data/ext/gecode-2.1.1/gecode/int/var-imp/bool.icc

@@ -0,0 +1,423 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-02-18 01:59:54 +0100 (Mon, 18 Feb 2008) $ by $Author: schulte $
+ *     $Revision: 6192 $
+ *
+ *  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 {
+
+  /*
+   * Creation of new variable implementations
+   *
+   */
+  forceinline
+  BoolVarImp::BoolVarImp(int n) {
+    assert(bits() == 0);
+    bits() |= (n << 1) | n;
+  }
+  forceinline
+  BoolVarImp::BoolVarImp(Space* home, int min, int max)
+    : BoolVarImpBase(home) {
+    assert(bits() == 0);
+    bits() |= (max << 1) | min;
+  }
+
+
+  /*
+   * Operations on integer variable implementations
+   *
+   */
+  forceinline BoolStatus
+  BoolVarImp::status(void) const {
+    return bits() & 3;
+  }
+  forceinline int
+  BoolVarImp::min(void) const {
+    return bits() & 1;
+  }
+  forceinline int
+  BoolVarImp::max(void) const {
+    return (bits() & 2) >> 1;
+  }
+  forceinline int
+  BoolVarImp::med(void) const {
+    return min();
+  }
+
+  forceinline int
+  BoolVarImp::val(void) const {
+    assert(status() != NONE);    
+    return min();
+  }
+
+  forceinline bool
+  BoolVarImp::range(void) const {
+    return true;
+  }
+  forceinline bool
+  BoolVarImp::assigned(void) const {
+    return status() != NONE;
+  }
+
+
+  forceinline unsigned int
+  BoolVarImp::width(void) const {
+    return assigned() ? 1U : 2U;
+  }
+
+  forceinline unsigned int
+  BoolVarImp::size(void) const {
+    return assigned() ? 1U : 2U;
+  }
+
+  forceinline unsigned int
+  BoolVarImp::regret_min(void) const {
+    return assigned() ? 1U : 0U;
+  }
+  forceinline unsigned int
+  BoolVarImp::regret_max(void) const {
+    return assigned() ? 1U : 0U;
+  }
+
+
+
+  /*
+   * Tests
+   *
+   */
+
+  forceinline bool
+  BoolVarImp::in(int n) const {
+    return (n >= min()) && (n <= max());
+  }
+  forceinline bool
+  BoolVarImp::in(double n) const {
+    return (n >= min()) && (n <= max());
+  }
+
+
+  /*
+   * Boolean domain tests
+   *
+   */
+  forceinline bool
+  BoolVarImp::zero(void) const {
+    return status() < NONE;
+  }
+  forceinline bool
+  BoolVarImp::one(void) const {
+    return status() > NONE;
+  }
+  forceinline bool
+  BoolVarImp::none(void) const {
+    return status() == NONE;
+  }
+
+  
+  /*
+   * Support for delta information
+   *
+   */
+  forceinline ModEvent
+  BoolVarImp::modevent(const Delta*) {
+    return ME_BOOL_VAL;
+  }
+  forceinline int 
+  BoolVarImp::min(const Delta*) const {
+    return 1-val();
+  }
+  forceinline int 
+  BoolVarImp::max(const Delta*) const {
+    return 1-val();
+  }
+  forceinline bool 
+  BoolVarImp::any(const Delta*) const {
+    return false;
+  }
+
+
+  /*
+   * Boolean tell operations
+   *
+   */
+  forceinline ModEvent
+  BoolVarImp::zero(Space* home) {
+    if (one())  return ME_BOOL_FAILED;
+    if (zero()) return ME_BOOL_NONE;
+    return zero_none(home);
+  }
+  forceinline ModEvent
+  BoolVarImp::one(Space* home) {
+    if (one())  return ME_BOOL_NONE;
+    if (zero()) return ME_BOOL_FAILED;
+    return one_none(home);
+  }
+
+
+  /*
+   * Tell operations
+   *
+   */
+  forceinline ModEvent
+  BoolVarImp::gq(Space* home, int n) {
+    if (n <= 0) return ME_INT_NONE;
+    if (n > 1)  return ME_INT_FAILED;
+    return one(home);
+  }
+  forceinline ModEvent
+  BoolVarImp::gq(Space* home, double n) {
+    if (n <= 0) return ME_INT_NONE;
+    if (n > 1)  return ME_INT_FAILED;
+    return one(home);
+  }
+
+
+  forceinline ModEvent
+  BoolVarImp::lq(Space* home, int n) {
+    if (n < 0)  return ME_INT_FAILED;
+    if (n >= 1) return ME_INT_NONE;
+    return zero(home);
+  }
+  forceinline ModEvent
+  BoolVarImp::lq(Space* home, double n) {
+    if (n < 0)  return ME_INT_FAILED;
+    if (n >= 1) return ME_INT_NONE;
+    return zero(home);
+  }
+
+
+  forceinline ModEvent
+  BoolVarImp::eq(Space* home, int n) {
+    if ((n < 0) || (n > 1)) return ME_INT_FAILED;
+    return (n == 0) ? zero(home): one(home);
+  }
+  forceinline ModEvent
+  BoolVarImp::eq(Space* home, double n) {
+    if ((n < 0) || (n > 1)) return ME_INT_FAILED;
+    return (n == 0) ? zero(home): one(home);
+  }
+
+
+  forceinline ModEvent
+  BoolVarImp::nq(Space* home, int n) {
+    if ((n < 0) || (n > 1)) return ME_INT_NONE;
+    return (n == 0) ? one(home): zero(home);
+  }
+  forceinline ModEvent
+  BoolVarImp::nq(Space* home, double n) {
+    if ((n < 0) || (n > 1)) return ME_INT_NONE;
+    return (n == 0) ? one(home): zero(home);
+  }
+
+
+  /*
+   * Copying a variable
+   *
+   */
+
+  forceinline
+  BoolVarImp::BoolVarImp(Space* home, bool share, BoolVarImp& x)
+    : BoolVarImpBase(home,share,x) {}
+  forceinline BoolVarImp*
+  BoolVarImp::copy(Space* home, bool share) {
+    if (copied())
+      return static_cast<BoolVarImp*>(forward());
+    else if (zero())
+      return &s_zero;
+    else if (one())
+      return &s_one;
+    else
+      return new (home) BoolVarImp(home,share,*this);
+  }
+
+
+  /*
+   * Iterator-based domain operations
+   *
+   */
+  template <class I>
+  forceinline ModEvent
+  BoolVarImp::narrow_r(Space* home, I& i, bool) {
+    // Is new domain empty?
+    if (!i())
+      return ME_INT_FAILED;
+    assert((i.min() == 0) || (i.min() == 1)); 
+    assert((i.max() == 0) || (i.max() == 1)); 
+    if (i.max() == 0) {
+      assert(!one());
+      // Assign domain to be zero (domain cannot be one)
+      return zero(home);
+    }
+    if (i.min() == 1) {
+      // Assign domain to be one (domain cannot be zero)
+      assert(!zero());
+      return one(home);
+    }
+    assert(none());
+    return ME_INT_NONE;
+  }
+  template <class I>
+  forceinline ModEvent
+  BoolVarImp::inter_r(Space* home, I& i, bool) {
+    // Skip all ranges that are too small
+    while (i() && (i.max() < 0))
+      ++i;
+    // Is new domain empty?
+    if (!i() || (i.min() > 1))
+      return ME_INT_FAILED;
+    assert(i.min() <= 1);
+    if (i.min() == 1)
+      return one(home);
+    if (i.max() == 0)
+      return zero(home);
+    assert((i.min() <= 0) && (i.max() >= 1));
+    return ME_INT_NONE;
+  }
+  template <class I>
+  forceinline ModEvent
+  BoolVarImp::minus_r(Space* home, I& i, bool) {
+    // Skip all ranges that are too small
+    while (i() && (i.max() < 0))
+      ++i;
+    // Is new domain empty?
+    if (!i() || (i.min() > 1))
+      return ME_INT_NONE;
+    assert(i.min() <= 1);
+    if (i.min() == 1)
+      return zero(home);
+    if (i.max() == 0)
+      return one(home);
+    assert((i.min() <= 0) && (i.max() >= 1));
+    return ME_INT_FAILED;
+  }
+
+  template <class I>
+  forceinline ModEvent
+  BoolVarImp::narrow_v(Space* home, I& i, bool) {
+    if (!i())
+      return ME_INT_FAILED;
+    if (!none())
+      return ME_INT_NONE;
+    if (i.val() == 0) {
+      do {
+        ++i;
+      } while (i() && (i.val() == 0));
+      if (!i())
+        return zero_none(home);
+      return ME_INT_NONE;
+    } else {
+      assert(i.val() == 1);
+      return one_none(home);
+    }
+  }
+  template <class I>
+  forceinline ModEvent
+  BoolVarImp::inter_v(Space* home, I& i, bool) {
+    while (i() && (i.val() < 0)) 
+      ++i;
+    if (!i() || (i.val() > 1))
+      return ME_INT_FAILED;
+    if (i.val() == 0) {
+      do {
+        ++i;
+      } while (i() && (i.val() == 0));
+      if (!i() || (i.val() > 1))
+        return zero(home);
+      return ME_INT_NONE;
+    } else {
+      assert(i.val() == 1);
+      return one(home);
+    }
+  }
+  template <class I>
+  forceinline ModEvent
+  BoolVarImp::minus_v(Space* home, I& i, bool) {
+    while (i() && (i.val() < 0)) 
+      ++i;
+    if (!i() || (i.val() > 1))
+      return ME_INT_NONE;
+    if (i.val() == 0) {
+      do {
+        ++i;
+      } while (i() && (i.val() == 0));
+      if (!i() || (i.val() > 1))
+        return one(home);
+      return ME_INT_FAILED;
+    } else {
+      assert(i.val() == 1);
+      return zero(home);
+    }
+  }
+
+
+
+  /*
+   * Dependencies
+   *
+   */
+  forceinline void
+  BoolVarImp::subscribe(Space* home, Propagator* p, PropCond, 
+                        bool process) {
+    // Subscription can be used with integer propagation conditions,
+    // which must be remapped to the single Boolean propagation condition.
+    BoolVarImpBase::subscribe(home,p,PC_BOOL_VAL,assigned(),process);
+  }
+  forceinline void
+  BoolVarImp::cancel(Space* home, Propagator* p, PropCond) {
+    BoolVarImpBase::cancel(home,p,PC_BOOL_VAL,assigned());
+  }
+
+  forceinline void
+  BoolVarImp::subscribe(Space* home, Advisor* a) {
+    BoolVarImpBase::subscribe(home,a,assigned());
+  }
+  forceinline void
+  BoolVarImp::cancel(Space* home, Advisor* a) {
+    BoolVarImpBase::cancel(home,a,assigned());
+  }
+
+  forceinline void
+  BoolVarImp::schedule(Space* home, Propagator* p, ModEvent me) {
+    if (me == ME_GEN_ASSIGNED)
+      BoolVarImpBase::schedule(home,p,me);
+  }
+
+  forceinline ModEventDelta
+  BoolVarImp::med(ModEvent me) {
+    return BoolVarImpBase::med(me);
+  }
+
+}}
+
+// STATISTICS: int-var