Method propagate

gecode/set/element/inter.hpp:111–306

  template<class View, class View0, class View1>
  ExecStatus
  ElementIntersection<View,View0,View1>::propagate(Space& home,
                                                   const ModEventDelta&) {
    Region r;
    int n = iv.size();

    bool loopVar;
    do {
      loopVar = false;

      // Cache the upper bound iterator, as we have to
      // modify the upper bound while iterating
      LubRanges<View0> x0ub(x0);
      Iter::Ranges::Cache x0ubc(r,x0ub);
      Iter::Ranges::ToValues<Iter::Ranges::Cache> vx0ub(x0ubc);

      GlbRanges<View0> x0lb(x0);
      Iter::Ranges::Cache x0lbc(r,x0lb);
      Iter::Ranges::ToValues<Iter::Ranges::Cache> vx0(x0lbc);

      // In the first iteration, compute in before[i] the intersection
      // of all the lower bounds of the x_i. At the same time,
      // exclude inconsistent x_i from x0 and remove them from
      // the list, cancel their dependencies.

      LUBndSet sofarBefore(home,universe);
      LUBndSet* before = r.alloc<LUBndSet>(n);

      int j = 0;
      int i = 0;
      while ( vx0ub() ) {

        // Remove vars at indices not in the upper bound
        if (iv[i].idx < vx0ub.val()) {
          iv[i].view.cancel(home,*this, PC_SET_ANY);
          ++i;
          continue;
        }
        assert(iv[i].idx == vx0ub.val());
        iv[j] = iv[i];

        View candidate = iv[j].view;
        int candidateInd = iv[j].idx;

        // inter = glb(x1) & complement(lub(candidate))
        GlbRanges<View1> x1lb(x1);
        LubRanges<View> candub(candidate);
        Iter::Ranges::Diff<GlbRanges<View1>,LubRanges<View> >
          inter(x1lb, candub);

        // exclude inconsistent x_i
        // an x_i is inconsistent if
        //  * its max cardinality is less than minCard of x1
        //  * inter is not empty (there are elements in x_0
        //    that can't be in x_i)
        if (candidate.cardMax() < x1.cardMin() ||
            inter()) {
          ModEvent me = (x0.exclude(home,candidateInd));