コード例 #1
0
ファイル: order.hpp プロジェクト: celikpence/gecode
  inline bool
  normalize(Space& home,
            ViewArray<View>& y,
            ViewArray<View>& x,
            bool& nofix) {

    int ys = y.size();
    for (int i = 1; i < ys; i++) {
      ModEvent me_lb = y[i].gq(home, y[i - 1].min());
      if (me_failed(me_lb))
        return false;
      nofix |= (me_modified(me_lb) && y[i - 1].min() != y[i].min());
    }

    for (int i = ys - 1; i--; ) {
      ModEvent me_ub = y[i].lq(home, y[i + 1].max());
      if (me_failed(me_ub))
        return false;
      nofix |= (me_modified(me_ub) && y[i + 1].max() != y[i].max());
    }

    int xs = x.size();
    for (int i = xs; i--; ) {
      ModEvent me = x[i].gq(home, y[0].min());
      if (me_failed(me))
        return false;
      nofix |= (me_modified(me) && x[i].min() != y[0].min());

      me = x[i].lq(home, y[xs - 1].max());
      if (me_failed(me))
        return false;
      nofix |= (me_modified(me) && x[i].max() != y[xs - 1].max());
    }
    return true;
  }
コード例 #2
0
ファイル: val.hpp プロジェクト: kenhys/gecode
ExecStatus
doprop_val(Space& home, int n, Info* x, Offset& ox,
           Info* y, Offset& oy,
           int& n_na, ProcessStack& xa, ProcessStack& ya) {
    do {
        int i = xa.pop();
        int j = ox(x[i].view).val();
        // Assign the y variable to i (or test if already assigned!)
        {
            ModEvent me = oy(y[j].view).eq(home,i);
            if (me_failed(me)) {
                return ES_FAILED;
            }
            // Record that y[j] has been assigned and must be propagated
            if (me_modified(me))
                ya.push(j);
        }
        // Prune the value j from all x variables
        for (int k=i; k--; ) {
            ModEvent me = ox(x[k].view).nq(home,j);
            if (me_failed(me)) {
                return ES_FAILED;
            }
            if (me_modified(me)) {
                if (me == ME_INT_VAL) {
                    // Record that x[k] has been assigned and must be propagated
                    xa.push(k);
                } else {
                    // One value has been removed and this removal does not need
                    // to be propagated again: after all y[j] = i, so it holds
                    // that y[j] != k.
                    x[k].removed(j);
                }
            }
        }
        // The same for the other views
        for (int k=i+1; k<n; k++) {
            ModEvent me = ox(x[k].view).nq(home,j);
            if (me_failed(me)) {
                return ES_FAILED;
            }
            if (me_modified(me)) {
                if (me == ME_INT_VAL) {
                    // Record that x[k] has been assigned and must be propagated
                    xa.push(k);
                } else {
                    // One value has been removed and this removal does not need
                    // to be propagated again: after all y[j] = i, so it holds
                    // that y[j] != k.
                    x[k].removed(j);
                }
            }
        }
        x[i].assigned();
        n_na--;
    } while (!xa.empty());
    return ES_OK;
}
コード例 #3
0
ファイル: view-values.hpp プロジェクト: MGKhKhD/easy-IP
 ExecStatus
 ViewValuesBrancher<n,min>::commit(Space& home, const Choice& c, 
                                   unsigned int a) {
   const PosValuesChoice& pvc
     = static_cast<const PosValuesChoice&>(c);
   IntView x(ViewBrancher<IntView,n>::view(pvc.pos()));
   unsigned int b = min ? a : (pvc.alternatives() - 1 - a);
   return me_failed(x.eq(home,pvc.val(b))) ? ES_FAILED : ES_OK;
 }
コード例 #4
0
 ExecStatus
 ViewValuesBrancher<ViewSel,View>
 ::commit(Space& home, const Choice& c, unsigned int a) {
   const PosValuesChoice<ViewSel,View>& pvc
     = static_cast<const PosValuesChoice<ViewSel,View>&>(c);
   View v(ViewBrancher<ViewSel>::view(pvc.pos()).varimp());
   viewsel.commit(home, pvc.viewchoice(), a);
   return me_failed(v.eq(home,pvc.val(a))) ? ES_FAILED : ES_OK;
 }
コード例 #5
0
ファイル: task.hpp プロジェクト: celikpence/gecode
 forceinline ModEvent
 ManFlexTask::norun(Space& home, int e, int l) {
   if (e <= l) {
     Iter::Ranges::Singleton sr(e-_p.min()+1,l);
     if (me_failed(_s.minus_r(home,sr,false)))
       return Int::ME_INT_FAILED;
     Iter::Ranges::Singleton er(e+1,_p.min()+l);
     return _e.minus_r(home,er,false);
   } else {
     return Int::ME_INT_NONE;
   }
 }
コード例 #6
0
inline bool
narrow_domy(Space& home,
            ViewArray<View>& x, ViewArray<View>& y,
            int phi[], int phiprime[], bool& nofix) {
    for (int i=x.size(); i--; ) {
        ModEvent me_lb = y[i].gq(home, x[phiprime[i]].min());
        if (me_failed(me_lb)) {
            return false;
        }
        nofix |= (me_modified(me_lb) &&
                  x[phiprime[i]].min() != y[i].min());

        ModEvent me_ub = y[i].lq(home, x[phi[i]].max());
        if (me_failed(me_ub)) {
            return false;
        }
        nofix |= (me_modified(me_ub) &&
                  x[phi[i]].max() != y[i].max());
    }
    return true;
}
コード例 #7
0
ファイル: mult.hpp プロジェクト: Wushaowei001/gecode-clone
 forceinline ExecStatus
 prop_mult_plus_bnd(Space& home, Propagator& p, VA x0, VB x1, VC x2) {
   assert(pos(x0) && pos(x1) && pos(x2));
   bool mod;
   do {
     mod = false;
     {
       ModEvent me = x2.lq(home,mll(x0.max(),x1.max()));
       if (me_failed(me)) return ES_FAILED;
       mod |= me_modified(me);
     }
     {
       ModEvent me = x2.gq(home,mll(x0.min(),x1.min()));
       if (me_failed(me)) return ES_FAILED;
       mod |= me_modified(me);
     }
     {
       ModEvent me = x0.lq(home,floor_div_pp(x2.max(),x1.min()));
       if (me_failed(me)) return ES_FAILED;
       mod |= me_modified(me);
     }
     {
       ModEvent me = x0.gq(home,ceil_div_pp(x2.min(),x1.max()));
       if (me_failed(me)) return ES_FAILED;
       mod |= me_modified(me);
     }
     {
       ModEvent me = x1.lq(home,floor_div_pp(x2.max(),x0.min()));
       if (me_failed(me)) return ES_FAILED;
       mod |= me_modified(me);
     }
     {
       ModEvent me = x1.gq(home,ceil_div_pp(x2.min(),x0.max()));
       if (me_failed(me)) return ES_FAILED;
       mod |= me_modified(me);
     }
   } while (mod);
   return x0.assigned() && x1.assigned() ?
     home.ES_SUBSUMED(p) : ES_FIX;
 }
コード例 #8
0
ファイル: ngl.cpp プロジェクト: MGKhKhD/easy-IP
 ExecStatus
 ExcNGL::prune(Space& home) {
   return me_failed(x.include(home,n)) ? ES_FAILED : ES_OK;
 }
コード例 #9
0
ファイル: ngl.hpp プロジェクト: Wushaowei001/gecode-profiling
 ExecStatus
 NqNGL<View>::prune(Space& home) {
   return me_failed(x.eq(home,n)) ? ES_FAILED : ES_OK;
 }
コード例 #10
0
ファイル: propagate.cpp プロジェクト: Wushaowei001/omnibus
  /*
   * Propagation proper
   *
   */
  ExecStatus 
  Pack::propagate(Space& home, const ModEventDelta& med) {
    // Number of items
    int n = bs.size();
    // Number of bins
    int m = l.size();

    {
      Region region(home);

      // Possible sizes for bins
      int* s = region.alloc<int>(m);

      for (int j=m; j--; )
        s[j] = 0;

      // Compute sizes for bins
      if (OffsetView::me(med) == ME_INT_VAL) {
        // Also eliminate assigned items
        int k=0;
        for (int i=0; i<n; i++)
          if (bs[i].assigned()) {
            int j = bs[i].bin().val();
            l[j].offset(l[j].offset() - bs[i].size());
            t -= bs[i].size();
          } else {
            for (ViewValues<IntView> j(bs[i].bin()); j(); ++j)
              s[j.val()] += bs[i].size();
            bs[k++] = bs[i];
          }
        n=k; bs.size(n);
      } else {
        for (int i=n; i--; ) {
          assert(!bs[i].assigned());
          for (ViewValues<IntView> j(bs[i].bin()); j(); ++j)
            s[j.val()] += bs[i].size();
        }
      }

      // Propagate bin loads and compute lower and upper bound
      int min = t, max = t;
      for (int j=m; j--; ) {
        GECODE_ME_CHECK(l[j].gq(home,0));
        GECODE_ME_CHECK(l[j].lq(home,s[j]));
        min -= l[j].max(); max -= l[j].min();
      }

      // Propagate that load must be equal to total size
      for (bool mod = true; mod; ) {
        mod = false; ModEvent me;
        for (int j=m; j--; ) {
          int lj_min = l[j].min();
          me = l[j].gq(home, min + l[j].max());
          if (me_failed(me))
            return ES_FAILED;
          if (me_modified(me)) {
            max += lj_min - l[j].min(); mod = true;
          }
          int lj_max = l[j].max();
          me = l[j].lq(home, max + l[j].min());
          if (me_failed(me))
            return ES_FAILED;
          if (me_modified(me)) {
            min += lj_max - l[j].max(); mod = true;
          }
        }
      }

      if (n == 0) {
        assert(l.assigned());
        return home.ES_SUBSUMED(*this);
      }

    
      {
        TellCache tc(region,m);

        int k=0;
        for (int i=0; i<n; i++) {
          for (ViewValues<IntView> j(bs[i].bin()); j(); ++j) {
            if (bs[i].size() > l[j.val()].max())
              tc.nq(j.val());
            if (s[j.val()] - bs[i].size() < l[j.val()].min()) 
              tc.eq(j.val());
          }
          GECODE_ES_CHECK(tc.tell(home,bs[i].bin()));
          // Eliminate assigned bin
          if (bs[i].assigned()) {
            int j = bs[i].bin().val();
            l[j].offset(l[j].offset() - bs[i].size());
            t -= bs[i].size();
          } else {
            bs[k++] = bs[i];
          }
        }
        n=k; bs.size(n);
      }

    }

    // Only if the propagator is at fixpoint here, continue with the more
    // expensive stage for propagation.
    if (IntView::me(modeventdelta()) != ME_INT_NONE)
      return ES_NOFIX;

    // Now the invariant holds that no more assigned bins exist!
    {
      Region region(home);

      // Size of items
      SizeSetMinusOne* s = region.alloc<SizeSetMinusOne>(m);

      for (int j=m; j--; )
        s[j] = SizeSetMinusOne(region,n);

      // Set up size information
      for (int i=0; i<n; i++) {
        assert(!bs[i].assigned());
        for (ViewValues<IntView> j(bs[i].bin()); j(); ++j) 
          s[j.val()].add(bs[i].size());
      }

      for (int j=m; j--; ) {
        // Can items still be packed into bin?
        if (nosum(static_cast<SizeSet&>(s[j]), l[j].min(), l[j].max()))
          return ES_FAILED;
        int ap, bp;
        // Must there be packed more items into bin?
        if (nosum(static_cast<SizeSet&>(s[j]), l[j].min(), l[j].min(), 
                  ap, bp))
          GECODE_ME_CHECK(l[j].gq(home,bp));
        // Must there be packed less items into bin?
        if (nosum(static_cast<SizeSet&>(s[j]), l[j].max(), l[j].max(), 
                  ap, bp))
          GECODE_ME_CHECK(l[j].lq(home,ap));
      }

      TellCache tc(region,m);

      int k=0;
      for (int i=0; i<n; i++) {
        assert(!bs[i].assigned());
        for (ViewValues<IntView> j(bs[i].bin()); j(); ++j) {
          // Items must be removed in decreasing size!
          s[j.val()].minus(bs[i].size());
          // Can item i still be packed into bin j?
          if (nosum(s[j.val()], 
                    l[j.val()].min() - bs[i].size(),
                    l[j.val()].max() - bs[i].size()))
            tc.nq(j.val());
          // Must item i be packed into bin j?
          if (nosum(s[j.val()], l[j.val()].min(), l[j.val()].max()))
            tc.eq(j.val());
        }
        GECODE_ES_CHECK(tc.tell(home,bs[i].bin()));
        if (bs[i].assigned()) {
          int j = bs[i].bin().val();
          l[j].offset(l[j].offset() - bs[i].size());
          t -= bs[i].size();
        } else {
          bs[k++] = bs[i];
        }
      }
      n=k; bs.size(n);
    }

    // Perform lower bound checking
    if (n > 0) {
      Region region(home);

      // Find capacity estimate (we start from bs[0] as it might be
      // not packable, actually (will be detected later anyway)!
      int c = bs[0].size();
      for (int j=m; j--; )
        c = std::max(c,l[j].max());

      // Count how many items have a certain size (bucket sort)
      int* n_s = region.alloc<int>(c+1);

      for (int i=c+1; i--; )
        n_s[i] = 0;

      // Count unpacked items
      for (int i=n; i--; )
        n_s[bs[i].size()]++;

      // Number of items and remaining bin load
      int nm = n;

      // Only count positive remaining bin loads
      for (int j=m; j--; ) 
        if (l[j].max() < 0) {
          return ES_FAILED;
        } else if (c > l[j].max()) {
          n_s[c - l[j].max()]++; nm++;
        }

      // Sizes of items and remaining bin loads
      int* s = region.alloc<int>(nm);

      // Setup sorted sizes
      {
        int k=0;
        for (int i=c+1; i--; )
          for (int n=n_s[i]; n--; )
            s[k++]=i;
        assert(k == nm);
      }

      // Items in N1 are from 0 ... n1 - 1
      int n1 = 0;
      // Items in N2 are from n1 ... n12 - 1, we count elements in N1 and N2
      int n12 = 0;
      // Items in N3 are from n12 ... n3 - 1 
      int n3 = 0;
      // Free space in N2
      int f2 = 0;
      // Total size of items in N3
      int s3 = 0;

      // Initialize n12 and f2
      for (; (n12 < nm) && (s[n12] > c/2); n12++)
        f2 += c - s[n12];

      // Initialize n3 and s3
      for (n3 = n12; n3 < nm; n3++)
        s3 += s[n3];
        
      // Compute lower bounds
      for (int k=0; k<=c/2; k++) {
        // Make N1 larger by adding elements and N2 smaller
        for (; (n1 < nm) && (s[n1] > c-k); n1++)
          f2 -= c - s[n1];
        assert(n1 <= n12);
        // Make N3 smaller by removing elements
        for (; (s[n3-1] < k) && (n3 > n12); n3--)
          s3 -= s[n3-1];
        // Overspill
        int o = (s3 > f2) ? ((s3 - f2 + c - 1) / c) : 0;
        if (n12 + o > m)
          return ES_FAILED;
      }
    }

    return ES_NOFIX;
  }
コード例 #11
0
ファイル: order.hpp プロジェクト: celikpence/gecode
  inline bool
  perm_bc(Space& home, int tau[],
          SccComponent sinfo[],
          int scclist[],
          ViewArray<View>& x,
          ViewArray<View>& z,
          bool& crossingedge,
          bool& nofix) {

    int ps = x.size();

    for (int i = 1; i < ps; i++) {
      // if there are "crossed edges"
      if (x[i - 1].min() < x[i].min()) {
        if (z[i - 1].min() > z[i].min()) {
          if (z[i].min() != sinfo[scclist[i]].leftmost) {
            // edge does not take part in solution
            if (z[i].assigned()) { // vital edge do not remove it
              if (x[i - 1].max() < x[i].min()) {
                // invalid permutation
                // the upper bound sorting cannot fix this
                return false;
              }
            } else {
              crossingedge = true;
              // and the permutation can still be changed
              // fix the permutation, i.e. modify z
              ModEvent me_z = z[i].gq(home, z[i - 1].min());
              if (me_failed(me_z)) {
                return false;
              }
              nofix |= ( me_modified(me_z) &&
                         z[i - 1].min() != z[i].min());
            }
          }
        }
      }
    }

    // the same check as above for the upper bounds
    for (int i = ps - 1; i--; ) {
      if (x[tau[i]].max() < x[tau[i + 1]].max()) {
        if (z[tau[i]].max() > z[tau[i + 1]].max()) {
          if (z[tau[i]].max() != sinfo[scclist[tau[i]]].rightmost) {
            // edge does not take part in solution
            if (z[tau[i]].assigned()) {
              if (x[tau[i + 1]].min() > x[tau[i]].max()) {
                // invalid permutation
                return false;
              }
            } else {
              crossingedge = true;
              ModEvent me_z = z[tau[i]].lq(home, z[tau[i + 1]].max());
              if (me_failed(me_z)) {
                return false;
              }
              nofix |= (me_modified(me_z) &&
                        z[tau[i + 1]].max() != z[tau[i]].max());
            }
          }
        }
      }
    }

    return true;
  }
コード例 #12
0
  ExecStatus
  prop_val(Space& home, ViewArray<View>& x) {
    assert(x.size() > 1);
    int n = x.size();

    Region r(home);
    int* stack = r.alloc<int>(n);
    int* c_v = &stack[0];
    // c_n is the current number of values on stack
    int c_n = 0;

    // Collect all assigned variables on stack
    for (int i = n; i--; )
      if (x[i].assigned()) {
        c_v[c_n++]=x[i].val(); x[i]=x[--n];
      }

    // The number of trips
    int t = 0;
    do {
      t++;
      if (!complete && (t > 16)) {
        // Give up after sixteen iterations, but the values must be
        // propagated first
        // Maybe we are lucky in that this iteration does the trick...
        ExecStatus es = ES_FIX;
        while (c_n > 0) {
          int v = c_v[--c_n];
          // Check whether value is on stack only once
          for (int i = c_n; i--; )
            if (c_v[i] == v)
              goto failed;
          // Tell and do not collect new values
          for (int i = n; i--; ) {
            ModEvent me = x[i].nq(home,v);
            if (me_failed(me))
              goto failed;
            if (me == ME_INT_VAL)
              es = ES_NOFIX;
          }
        }
        x.size(n);
        return es;
      }
      if (c_n > 31) {
        // Many values, use full domain operation
        IntSet d(&c_v[0],c_n);
        // If the size s of d is different from the number of values,
        // a value must have appeared multiply: failure
        if (d.size() != static_cast<unsigned int>(c_n))
          goto failed;
        // We do not need the values on the stack any longer, reset
        c_n = 0;
        // Tell and collect new values
        for (int i = n; i--; )
          if ((d.min() <= x[i].max()) && (d.max() >= x[i].min())) {
            IntSetRanges dr(d);
            ModEvent me = x[i].minus_r(home,dr,false);
            if (me_failed(me))
              goto failed;
            if (me == ME_INT_VAL) {
              c_v[c_n++]=x[i].val(); x[i]=x[--n];
            }
          }
      } else {
        // Values for next iteration
        int* n_v = &c_v[c_n];
        // Stack top for the next iteration
        int n_n = 0;
        while (c_n > 0) {
          int v = c_v[--c_n];
          // Check whether value is not on current stack
          for (int i = c_n; i--; )
            if (c_v[i] == v)
              goto failed;
          // Check whether value is not on next stack
          for (int i = n_n; i--; )
            if (n_v[i] == v)
              goto failed;
          // Tell and collect new values
          for (int i = n; i--; ) {
            ModEvent me = x[i].nq(home,v);
            if (me_failed(me))
              goto failed;
            if (me == ME_INT_VAL) {
              n_v[n_n++]=x[i].val(); x[i]=x[--n];
            }
          }
        }
        c_v = n_v; c_n = n_n;
      }
    } while (c_n > 0);
    x.size(n);
    return ES_FIX;
  failed:
    x.size(0);
    return ES_FAILED;
  }
コード例 #13
0
inline bool
narrow_domx(Space& home,
            ViewArray<View>& x,
            ViewArray<View>& y,
            ViewArray<View>& z,
            int tau[],
            int[],
            int scclist[],
            SccComponent sinfo[],
            bool& nofix) {

    int xs = x.size();

    // For every x node
    for (int i = 0; i < xs; i++) {

        int xmin = x[i].min();
        /*
         * take the scc-list for the current x node
         * start from the leftmost reachable y node of the scc
         * and check which Y node in the scc is
         * really the rightmost node intersecting x, i.e.
         * search for the greatest lower bound of x
         */
        int start = sinfo[scclist[i]].leftmost;
        while (y[start].max() < xmin) {
            start = sinfo[start].right;
        }

        if (Perm) {
            // start is the leftmost-position for x_i
            // that denotes the lower bound on p_i

            ModEvent me_plb = z[i].gq(home, start);
            if (me_failed(me_plb)) {
                return false;
            }
            nofix |= (me_modified(me_plb) && start != z[i].min());
        }

        ModEvent me_lb = x[i].gq(home, y[start].min());
        if (me_failed(me_lb)) {
            return false;
        }
        nofix |= (me_modified(me_lb) &&
                  y[start].min() != x[i].min());

        int ptau = tau[xs - 1 - i];
        int xmax = x[ptau].max();
        /*
         * take the scc-list for the current x node
         * start from the rightmost reachable node and check which
         * y node in the scc is
         * really the rightmost node intersecting x, i.e.
         * search for the smallest upper bound of x
         */
        start = sinfo[scclist[ptau]].rightmost;
        while (y[start].min() > xmax) {
            start = sinfo[start].left;
        }

        if (Perm) {
            //start is the rightmost-position for x_i
            //that denotes the upper bound on p_i
            ModEvent me_pub = z[ptau].lq(home, start);
            if (me_failed(me_pub)) {
                return false;
            }
            nofix |= (me_modified(me_pub) && start != z[ptau].max());
        }

        ModEvent me_ub = x[ptau].lq(home, y[start].max());
        if (me_failed(me_ub)) {
            return false;
        }
        nofix |= (me_modified(me_ub) &&
                  y[start].max() != x[ptau].max());
    }
    return true;
}