@Override
 public ESat isEntailed() {
   if (G.instantiated()) {
     int nr = 0;
     for (int i = 0; i < n_R.get(); i++) {
       nr += G_R.getSuccessorsOf(i).neighborhoodSize();
     }
     if (nr == n_R.get() - 1) {
       return ESat.TRUE;
     }
     return ESat.FALSE;
   }
   return ESat.UNDEFINED;
 }
示例#2
0
 public int nextValue(int aValue) {
   aValue -= OFFSET;
   int lb = LB.get();
   if (aValue < 0 || aValue < lb) return lb + OFFSET;
   aValue = VALUES.nextSetBit(aValue + 1);
   if (aValue > -1) return aValue + OFFSET;
   return Integer.MAX_VALUE;
 }
示例#3
0
 /**
  * Returns <tt>true</tt> if the iteration has more elements. (In other words, returns
  * <tt>true</tt> if <tt>next</tt> would return an element rather than throwing an exception.)
  *
  * @return <tt>true</tt> if the iterator has more elements.
  */
 @Override
 public boolean hasNext() {
   i++;
   while (i < nlast && elements[i].isInstantiated()) {
     storedBipartiteVarSet.swap(i);
     nlast = last.get();
   }
   return i < nlast;
 }
示例#4
0
 @Override
 public int previousValue(int aValue) {
   aValue -= OFFSET;
   int ub = UB.get();
   if (aValue > ub) return ub + OFFSET;
   aValue = VALUES.prevSetBit(aValue - 1);
   if (aValue > -1) return aValue + OFFSET;
   return Integer.MIN_VALUE;
 }
示例#5
0
  /**
   * Updates the lower bound of the domain of <code>this</code> to <code>value</code>. The
   * instruction comes from <code>propagator</code>.
   *
   * <ul>
   *   <li>If <code>value</code> is smaller than the lower bound of the domain, nothing is done and
   *       the return value is <code>false</code>,
   *   <li>if updating the lower bound to <code>value</code> leads to a dead-end (domain wipe-out),
   *       a <code>ContradictionException</code> is thrown,
   *   <li>otherwise, if updating the lower bound to <code>value</code> can be done safely, the
   *       event type is created (the original event can be promoted) and observers are notified and
   *       the return value is <code>true</code>
   * </ul>
   *
   * @param value new lower bound (included)
   * @param cause updating releaser
   * @param informCause
   * @return true if the lower bound has been updated, false otherwise
   * @throws solver.exception.ContradictionException if the domain become empty due to this action
   */
  public boolean updateLowerBound(int value, ICause cause, boolean informCause)
      throws ContradictionException {
    boolean change;
    ICause antipromo = cause;
    if (informCause) {
      cause = Cause.Null;
    }
    int old = this.getLB();
    if (old < value) {
      if (this.getUB() < value) {
        solver.getExplainer().updateLowerBound(this, old, value, antipromo);
        this.contradiction(cause, MSG_LOW);
      } else {
        EventType e = EventType.INCLOW;

        int aValue = value - OFFSET;
        if (reactOnRemoval) {
          // BEWARE: this loop significantly decreases performances
          for (int i = old - OFFSET; i < aValue; i = VALUES.nextSetBit(i + 1)) {
            delta.add(i + OFFSET);
          }
        }
        VALUES.clear(old - OFFSET, aValue);
        LB.set(VALUES.nextSetBit(aValue));
        int _size = SIZE.get();
        int card = VALUES.cardinality();
        SIZE.set(card);
        change = _size - card > 0;

        if (instantiated()) {
          e = EventType.INSTANTIATE;
          if (cause.reactOnPromotion()) {
            cause = Cause.Null;
          }
        }
        assert (change);
        this.notifyPropagators(e, cause);
        solver.getExplainer().updateLowerBound(this, old, value, antipromo);
        return change;
      }
    }
    return false;
  }
示例#6
0
 /** Freeze the iterator, cannot be reused. */
 public void init(
     final StoredBipartiteVarSet aStoredBipartiteVarSet,
     final E[] someElements,
     final IStateInt aLast) {
   super.init();
   this.storedBipartiteVarSet = aStoredBipartiteVarSet;
   this.elements = someElements;
   this.last = aLast;
   this.nlast = aLast.get();
   i = -1;
 }
示例#7
0
 private void updateBeta() throws ContradictionException {
   do {
     beta.add(1);
   } while (beta.get() < n && checkKerEnv(vars[beta.get()]));
   if (beta.get() > gamma.get()) {
     vars[alpha.get()].remFromEnveloppe(t, this, true);
     vars[alpha.get()].addToKernel(s, this, true);
   }
 }
示例#8
0
 private void checkGamma(int idx) throws ContradictionException {
   if (beta.get() < gamma.get()
       && idx < gamma.get()
       && !vars[idx].isInDomainEnveloppe(s)
       && vars[idx].isInDomainKernel(t)) {
     gamma.set(idx);
     if (beta.get() > idx) {
       vars[alpha.get()].remFromEnveloppe(t, this, true);
       vars[alpha.get()].addToKernel(s, this, true);
     }
   }
 }
示例#9
0
 public String toString() {
   StringBuilder s = new StringBuilder(20);
   s.append(name).append(" = ");
   if (SIZE.get() == 1) {
     s.append(this.getLB());
   } else {
     s.append('{').append(getLB());
     int nb = 5;
     for (int i = nextValue(getLB()); i < Integer.MAX_VALUE && nb > 0; i = nextValue(i)) {
       s.append(',').append(i);
       nb--;
     }
     if (nb == 0) {
       s.append("...,").append(this.getUB());
     }
     s.append('}');
   }
   return s.toString();
 }
示例#10
0
  private void propagate(int idx) throws ContradictionException {

    if (beta.get() <= gamma.get()) {
      SetVar var = vars[idx];
      if ((idx == alpha.get()) && checkKerEnv(var)) {
        updateVar(var);
        alpha.add(1);

        while (alpha.get() < beta.get()) {
          updateVar(vars[alpha.get()]);
          alpha.add(1);
        }
        while (alpha.get() < n && checkKerEnv(vars[alpha.get()])) {
          updateVar(vars[alpha.get()]);
          alpha.add(1);
        }
        beta.set(alpha.get());
        if (alpha.get() < n) updateBeta();
      } else if (idx == beta.get() && checkKerEnv(var)) {
        updateBeta();
      }
      checkGamma(idx);
    }
  }
 /** Returns the current size of the domain. */
 public int getSize() {
   return size.get();
 }
示例#12
0
 public int getDomainSize() {
   return SIZE.get();
 }
示例#13
0
 @Override
 public void propagate(int evtmask) throws ContradictionException {
   for (int i = 0; i < n; i++) {
     sccFirst[i].set(-1);
     sccNext[i].set(-1);
     mates[i].clear();
     G_R.getActiveNodes().desactivate(i);
   }
   ArrayList<TIntArrayList> allSCC = StrongConnectivityFinder.findAllSCCOf(G.getEnvelopGraph());
   int s = allSCC.size();
   n_R.set(s);
   int elem;
   TIntArrayList list;
   for (int i = 0; i < s; i++) {
     list = allSCC.get(i);
     G_R.getActiveNodes().activate(i);
     for (int j = list.size() - 1; j >= 0; j--) {
       elem = list.get(j);
       sccOf[elem].set(i);
       addNode(i, elem);
     }
   }
   INeighbors succs;
   int x;
   for (int i = 0; i < n; i++) {
     x = sccOf[i].get();
     succs = G.getEnvelopGraph().getSuccessorsOf(i);
     for (int j = succs.getFirstElement(); j >= 0; j = succs.getNextElement()) {
       if (x != sccOf[j].get()) {
         G_R.addArc(x, sccOf[j].get());
         mates[x].add((i + 1) * n + j);
       }
     }
   }
   int first = -1;
   int last = -1;
   for (int i = 0; i < s; i++) {
     if (G_R.getPredecessorsOf(i).isEmpty()) {
       first = i;
     }
     if (G_R.getSuccessorsOf(i).isEmpty()) {
       last = i;
     }
   }
   if (first == -1 || last == -1 || first == last) {
     contradiction(G, "");
   }
   if (visit(first, last) != n_R.get()) {
     contradiction(G, "");
   }
   int to, arc;
   for (int i = 0; i < n; i++) {
     to = G.getKernelGraph().getSuccessorsOf(i).getFirstElement();
     x = sccOf[i].get();
     if (to != -1 && sccOf[to].get() != x && mates[x].neighborhoodSize() > 1) {
       arc = (i + 1) * n + to;
       for (int a = mates[x].getFirstElement(); a >= 0; a = mates[x].getNextElement()) {
         if (a != arc) {
           G.removeArc(a / n - 1, a % n, this);
         }
       }
       mates[x].clear();
       mates[x].add(arc);
     }
   }
 }
 /** Returns the minimal present value. */
 public int getFirstVal() {
   if (size.get() > 0) return contents.nextSetBit(0) + offset;
   else return -1;
 }
示例#15
0
 public boolean instantiated() {
   return SIZE.get() == 1;
 }
示例#16
0
  /**
   * Removes <code>value</code>from the domain of <code>this</code>. The instruction comes from
   * <code>propagator</code>.
   *
   * <ul>
   *   <li>If <code>value</code> is out of the domain, nothing is done and the return value is
   *       <code>false</code>,
   *   <li>if removing <code>value</code> leads to a dead-end (domain wipe-out), a <code>
   *       ContradictionException</code> is thrown,
   *   <li>otherwise, if removing <code>value</code> from the domain can be done safely, the event
   *       type is created (the original event can be promoted) and observers are notified and the
   *       return value is <code>true</code>
   * </ul>
   *
   * @param value value to remove from the domain (int)
   * @param cause removal releaser
   * @param informCause
   * @return true if the value has been removed, false otherwise
   * @throws solver.exception.ContradictionException if the domain become empty due to this action
   */
  public boolean removeValue(int value, ICause cause, boolean informCause)
      throws ContradictionException {
    // BEWARE: THIS CODE SHOULD NOT BE MOVED TO THE DOMAIN TO NOT DECREASE PERFORMANCES!
    boolean change = false;
    ICause antipromo = cause;
    if (informCause) {
      cause = Cause.Null;
    }
    int inf = getLB();
    int sup = getUB();
    if (value == inf && value == sup) {
      solver.getExplainer().removeValue(this, value, antipromo);
      this.contradiction(cause, MSG_REMOVE);
    } else {
      if (inf <= value && value <= sup) {
        EventType e = EventType.REMOVE;

        int aValue = value - OFFSET;
        change = VALUES.get(aValue);
        this.VALUES.set(aValue, false);
        if (change) {
          this.SIZE.add(-1);
          if (reactOnRemoval) {
            delta.add(aValue + OFFSET);
          }
        }

        if (value == inf) {
          LB.set(VALUES.nextSetBit(aValue));
          e = EventType.INCLOW;
          if (cause.reactOnPromotion()) {
            cause = Cause.Null;
          }
        } else if (value == sup) {
          UB.set(VALUES.prevSetBit(aValue));
          e = EventType.DECUPP;
          if (cause.reactOnPromotion()) {
            cause = Cause.Null;
          }
        }
        if (change && !VALUES.isEmpty()) {
          if (this.instantiated()) {
            e = EventType.INSTANTIATE;
            if (cause.reactOnPromotion()) {
              cause = Cause.Null;
            }
          }
          this.notifyPropagators(e, cause);
        } else {
          if (VALUES.isEmpty()) {
            solver.getExplainer().removeValue(this, value, antipromo);
            this.contradiction(cause, MSG_EMPTY);
          }
        }
      }
    }
    if (change) {
      solver.getExplainer().removeValue(this, value, antipromo);
    }
    return change;
  }
 /** Returns the maximal present value. */
 public int getLastVal() {
   if (size.get() > 0) return contents.prevSetBit(capacity - 1) + offset;
   else return -1;
 }
 private void removeIndex(int i) {
   contents.clear(i);
   delatDom.remove(i + offset);
   if (contents.get(i)) LOGGER.severe("etrange etrange");
   size.add(-1);
 }
示例#19
0
  private void initialize() throws ContradictionException {
    alpha = environment.makeInt(0);

    while ((alpha.get() < n) && checkKerEnv(vars[alpha.get()])) {
      updateVar(vars[alpha.get()]);
      alpha.add(1);
    }

    beta = environment.makeInt(alpha.get());
    gamma = environment.makeInt(alpha.get());

    if (alpha.get() < n) {
      do {
        gamma.add(1);
      } while ((gamma.get()) < n
          && (vars[gamma.get()].isInDomainEnveloppe(s) || !vars[gamma.get()].isInDomainKernel(t)));
      updateBeta();
    }
  }
 private void addIndex(int i) {
   contents.set(i);
   delatDom.remove(i + offset);
   if (!contents.get(i)) LOGGER.severe("etrange etrange");
   size.add(1);
 }