import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
public IConstr addClause(IVecInt literals) throws ContradictionException {
	if (firstConstr) {
		if (!fixedNbClauses) {
			firstCharPos = 7 + Integer.toString(nbvars).length();
			out.append("                    ");
			out.append("\n");
			nbclauses = 0;
		}
		firstConstr = false;
	}
	if (!fixedNbClauses) {
		nbclauses++;
	}
	for (IteratorInt iterator = literals.iterator(); iterator.hasNext();) {
		out.append(iterator.next()).append(" ");
	}
	out.append("0\n");
	return null;
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
public List<Literal> knownValues() {
	LinkedList<Literal> list = new LinkedList<Literal>();
	try {
		IVecInt bone = RemiUtils.backbone(solver);
		IteratorInt iter = bone.iterator();
		while (iter.hasNext()) {
			int value = iter.next();
			Object var = intToVar.get(Math.abs(value));
			Literal literal = new Literal(var, value > 0);
			list.add(literal);
		}
	} catch (TimeoutException e) {
		e.printStackTrace();
	} 
	return list;
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
public IVecInt compute(ISolver solver, int[] implicant,
        IVecInt assumptions, IVecInt filter) throws TimeoutException {
    nbSatTests = 0;
    BitSet assumptionsSet = new BitSet(solver.nVars());
    for (IteratorInt it = assumptions.iterator(); it.hasNext();) {
        assumptionsSet.set(Math.abs(it.next()));
    }
    BitSet filterSet = new BitSet();
    for (IteratorInt it = filter.iterator(); it.hasNext();) {
        filterSet.set(Math.abs(it.next()));
    }
    IVecInt litsToTest = new VecInt();
    for (int p : implicant) {
        if (!assumptionsSet.get(Math.abs(p))
                && filterSet.get(Math.abs(p))) {
            litsToTest.push(-p);
        }
    }
    return compute(solver, assumptions, litsToTest);
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
public IConstr addClause(IVecInt literals) throws ContradictionException {
    if (this.firstConstr) {
        if (!this.fixedNbClauses) {
            this.firstCharPos = 0;
            this.out.append("                    ");
            this.out.append("\n");
            this.nbclauses = 0;
        }
        this.firstConstr = false;
    }
    if (!this.fixedNbClauses) {
        this.nbclauses++;
    }
    for (IteratorInt iterator = literals.iterator(); iterator.hasNext();) {
        this.out.append(iterator.next()).append(" ");
    }
    this.out.append("0\n");
    return null;
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
@Override
public IVecInt unsatExplanation() {
    IVecInt internal = super.unsatExplanation();
    IVecInt external = new VecInt(internal.size());
    int p;
    Integer group;
    for (IteratorInt it = internal.iterator(); it.hasNext();) {
        p = it.next();
        if (p > 0) {
            group = varToHighLevel.get(p);
        } else {
            Integer negGroup = varToHighLevel.get(-p);
            group = (negGroup == null) ? (null) : (-negGroup);
        }
        if (group != null) {
            external.push(group);
        }
    }
    return external;
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
public IteratorInt iterator() {
    return new IteratorInt() {
        private int i = 0;

        public boolean hasNext() {
            return this.i < VecInt.this.nbelem;
        }

        public int next() {
            if (this.i == VecInt.this.nbelem) {
                throw new NoSuchElementException();
            }
            return VecInt.this.myarray[this.i++];
        }
    };
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
private void createSumAndLexObjs() {
    IVecInt auxObjsVars = new VecInt();
    IVec<BigInteger> sumObjCoeffs = new Vec<BigInteger>();
    IVec<BigInteger> lexObjCoeffs = new Vec<BigInteger>();
    BigInteger lexFactor = BigInteger.ONE;
    for (Iterator<IntegerVariable> intVarIt = objBoundVariables.iterator(); intVarIt
            .hasNext();) {
        BigInteger sumFactor = BigInteger.ONE;
        IntegerVariable nextBoundVar = intVarIt.next();
        for (IteratorInt nextBoundVarLitsIt = nextBoundVar.getVars()
                .iterator(); nextBoundVarLitsIt.hasNext();) {
            auxObjsVars.push(nextBoundVarLitsIt.next());
            sumObjCoeffs.push(sumFactor);
            sumFactor = sumFactor.shiftLeft(1);
            lexObjCoeffs.push(lexFactor);
            lexFactor = lexFactor.shiftLeft(1);
        }
    }
    this.sumObj = new ObjectiveFunction(auxObjsVars, sumObjCoeffs);
    this.lexObj = new ObjectiveFunction(auxObjsVars, lexObjCoeffs);
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
public IConstr addAtLeast(IVecInt literals, IVecInt coeffs, int degree,
        int groupId) throws ContradictionException {
    int newvar = getGroupVar(literals, groupId);
    literals.push(newvar);
    if (degree >= 0) {
        coeffs.push(degree);
    } else {
        int sum = 0;
        for (IteratorInt ite = coeffs.iterator(); ite.hasNext();) {
            sum = sum + ite.next();
        }
        sum = sum - degree;
        coeffs.push(-sum);
    }
    return decorated().addAtLeast(literals, coeffs, degree);
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
@Override
public IConstr addClause(IVecInt literals) throws ContradictionException {
    StringBuffer out = getOut();
    this.nbOfConstraints++;
    int negationweight = 0;
    int lit;
    for (IteratorInt iterator = literals.iterator(); iterator.hasNext();) {
        lit = iterator.next();
        if (lit > 0) {
            out.append("+1 x" + lit + " ");
        } else {
            out.append("-1 x" + -lit + " ");
            negationweight++;
        }
    }
    out.append(">= " + (1 - negationweight) + " ;\n");
    return FAKE_CONSTR;
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
public void init() {
    if (getObjectiveFunction() != null) {
        this.objWeightsMap = new HashMap<Integer, BigInteger>();
        IteratorInt litsIt = getObjectiveFunction().getVars().iterator();
        Iterator<BigInteger> weightsIt = getObjectiveFunction().getCoeffs()
                .iterator();
        for (; litsIt.hasNext();)
            this.objWeightsMap.put(litsIt.next(), weightsIt.next());
    }
    if (this.preprocessing) {
        sat4jPreprocessing();
    } else if (this.rissLocation != null) {
        rissPreprocessing();
    } else {
        noPreprocessing();
    }
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
private void updateObjMinBound(AtLeastCard card) {
    AtMostCard atMost = card.toAtMost();
    if (this.objWeightsMap == null)
        return;
    List<BigInteger> weights = new ArrayList<BigInteger>();
    for (IteratorInt it = atMost.getLits().iterator(); it.hasNext();) {
        BigInteger weight = this.objWeightsMap.get(-it.next());
        if (weight != null)
            weights.add(weight);
    }
    Collections.sort(weights);
    BigInteger newMinBound = BigInteger.ZERO;
    for (int i = 0; i < weights.size() - atMost.getDegree(); ++i) {
        newMinBound = newMinBound.add(weights.get(i));
    }
    if (this.objMinBound == null
            || this.objMinBound.compareTo(newMinBound) == -1)
        this.objMinBound = newMinBound;
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
private IConstr addPseudoBoolean(IVecInt lits, IVecInt coeffs,
        boolean moreThan, int d) throws ContradictionException {
    int newvar = createNewVar(lits);
    lits.push(newvar);
    if (moreThan && d >= 0) {
        coeffs.push(d);
    } else {
        int sum = 0;
        for (IteratorInt ite = coeffs.iterator(); ite.hasNext();) {
            sum += ite.next();
        }
        sum = sum - d;
        coeffs.push(-sum);
    }
    IConstr constr = moreThan ? decorated().addAtLeast(lits, coeffs, d)
            : decorated().addAtMost(lits, coeffs, d);
    if (constr == null) {
        // constraint trivially satisfied
        discardLastestVar();
        // System.err.println(lits.toString()+"/"+coeffs+"/"+(moreThan?">=":"<=")+d);
    } else {
        getConstrs().put(newvar, constr);
    }
    return constr;
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
public IConstr addAtLeast(IVecInt literals, IVecInt coeffs, int degree)
        throws ContradictionException {
    assertConstraintIsCard(coeffs);
    Set<Integer> negLitsSet = new HashSet<Integer>(literals.size());
    for (IteratorInt it = literals.iterator(); it.hasNext();)
        negLitsSet.add(-it.next());
    int clausesDegree = literals.size() - degree + 1;
    ConstrGroup group = new ConstrGroup(false);
    CombinationIterator combIt = new CombinationIterator(literals.size()
            - degree, negLitsSet);
    for (Set<Integer> comb : combIt) {
        for (IteratorInt it = literals.iterator(); it.hasNext();) {
            int lit = it.next();
            if (!comb.contains(-lit)) {
                IVecInt clause = new VecInt(clausesDegree);
                clause.push(lit);
                for (Integer negLit : comb) {
                    clause.push(-negLit);
                }
                group.add(addClause(clause));
            }
        }
    }
    return group;
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    AtLeastCard other = (AtLeastCard) obj;
    if (degree != other.degree)
        return false;
    if (lits == null) {
        if (other.lits != null)
            return false;
    }
    Set<Integer> litsSet1 = new HashSet<Integer>();
    for (IteratorInt it = lits.iterator(); it.hasNext();)
        litsSet1.add(it.next());
    Set<Integer> litsSet2 = new HashSet<Integer>();
    for (IteratorInt it = other.lits.iterator(); it.hasNext();)
        litsSet2.add(it.next());
    if (!litsSet1.equals(litsSet2))
        return false;
    return true;
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
/**
 * Compute the objects implied by the assumptions.
 * 
 * @param assumptions
 *            already satisfied objects (e.g. user choices)
 * @param satisfied
 *            the objects that are always satisfied under assumptions
 *            (includes the objects from assumptions)
 * @param falsified
 *            the objects that are always falsified under assumptions.
 * @return the set of objects fixed
 * @throws TimeoutException
 * @since 2.3.3
 */
public void impliedBy(Collection<T> assumptions, Collection<T> satisfied,
        Collection<T> falsified) throws TimeoutException {
    IVecInt assump = new VecInt(assumptions.size());
    for (T thing : assumptions) {
        assump.push(getIntValue(thing));
    }
    IVecInt implied = Backbone.instance().compute(solver, assump);
    int p;
    for (IteratorInt it = implied.iterator(); it.hasNext();) {
        p = it.next();
        if (p > 0) {
            satisfied.add(mapToDomain.get(p));
        } else {
            falsified.add(mapToDomain.get(-p));
        }
    }
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
public ImplicationNamer<T, C> implies(T... things)
        throws ContradictionException {
    IVecInt clause = new VecInt();
    for (T t : things) {
        clause.push(this.helper.getIntValue(t));
    }
    int p;
    IConstr constr;
    for (IteratorInt it = this.literals.iterator(); it.hasNext();) {
        p = it.next();
        clause.push(p);
        constr = this.helper.solver.addClause(clause);
        if (constr == null) {
            throw new IllegalStateException(
                    "Constraints are not supposed to be null when using the helper");
        }
        this.toName.push(constr);
        clause.remove(p);
    }
    return new ImplicationNamer<T, C>(this.helper, this.toName);
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
private void pushIntegerVariables(IVecInt literals,
        IVec<BigInteger> coeffs, IVec<IntegerVariable> integerVars,
        IVec<BigInteger> integerVarsCoeffs) {
    if (integerVars.size() != integerVarsCoeffs.size()) {
        throw new IllegalArgumentException(
                "different number of integer variables and integer variables coeffs");
    }
    Iterator<IntegerVariable> intVarsIt = integerVars.iterator();
    Iterator<BigInteger> intVarsCoeffsIt = integerVarsCoeffs.iterator();
    while (intVarsIt.hasNext()) {
        BigInteger factor = intVarsCoeffsIt.next();
        IteratorInt intVarLitsIt = intVarsIt.next().getVars().iterator();
        while (intVarLitsIt.hasNext()) {
            literals.push(intVarLitsIt.next());
            coeffs.push(factor);
            factor = factor.shiftLeft(1);
        }
    }
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
public IteratorInt iterator() {
	return new IteratorInt() {
		int cursor = 0;

		public boolean hasNext() {
			return cursor < vec.length;
		}

		public int next() {
			if (!hasNext())
				throw new NoSuchElementException();
			return vec[cursor++];
		}
	};
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
public IteratorInt iterator() {
	return new IteratorInt() {
		int cursor = 0;
		public boolean hasNext() {
			return cursor < vec.length;
		}
		public int next() {
			if (!hasNext()) 
				throw new NoSuchElementException();
			return vec[cursor++];
		}
	};
}
 

import org.sat4j.specs.IteratorInt; //导入依赖的package包/类
public IConstr addAtMost(IVecInt literals, int degree)
		throws ContradictionException {
	int n = literals.size();
	IVecInt opliterals = new VecInt(n);
	for (IteratorInt iterator = literals.iterator(); iterator.hasNext();) {
		opliterals.push(-iterator.next());
	}
	return addAtLeast(opliterals, n - degree);
}