Java IVecInt.copyTo方法代码示例

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
/**
 * translate y <=> x1 \/ x2 \/ ... \/ xn into clauses.
 * 
 * @param y
 * @param literals
 * @throws ContradictionException
 * @since 2.1
 */
public IConstr[] or(int y, IVecInt literals) throws ContradictionException {
	// y <=> OR x1 x2 ...xn
	// y => x1 x2 ... xn
	IConstr[] constrs = new IConstr[literals.size() + 1];
	IVecInt clause = new VecInt(literals.size() + 2);
	literals.copyTo(clause);
	clause.push(-y);
	constrs[0] = processClause(clause);
	clause.clear();
	for (int i = 0; i < literals.size(); i++) {
		// xi => y
		clause.clear();
		clause.push(y);
		clause.push(-literals.get(i));
		constrs[i + 1] = processClause(clause);
	}
	return constrs;
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
@Override
public IConstr addClause(IVecInt literals) throws ContradictionException {
	if (literals.equals(lastClause)) {
		// System.err.println("c Duplicated entry: " + literals);
		return null;
	}
	lastClause.clear();
	literals.copyTo(lastClause);
	int newvar = createNewVar(literals);
	literals.push(newvar);
	lastConstr = super.addClause(literals);
	if (lastConstr == null) {
		discardLastestVar();
	} else {
		constrs.put(newvar, lastConstr);
	}
	return lastConstr;
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
private void expensiveSimplification(IVecInt conflictToReduce) {
	// Simplify conflict clause (a lot):
	//
	int i, j;
	// (maintain an abstraction of levels involved in conflict)
	analyzetoclear.clear();
	conflictToReduce.copyTo(analyzetoclear);
	for (i = 1, j = 1; i < conflictToReduce.size(); i++)
		if (voc.getReason(conflictToReduce.get(i)) == null
				|| !analyzeRemovable(conflictToReduce.get(i)))
			conflictToReduce.moveTo(j++, i);
	conflictToReduce.shrink(i - j);
	stats.reducedliterals += (i - j);
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
private void expensiveSimplificationWLOnly(IVecInt conflictToReduce) {
	// Simplify conflict clause (a lot):
	//
	int i, j;
	// (maintain an abstraction of levels involved in conflict)
	analyzetoclear.clear();
	conflictToReduce.copyTo(analyzetoclear);
	for (i = 1, j = 1; i < conflictToReduce.size(); i++)
		if (voc.getReason(conflictToReduce.get(i)) == null
				|| !analyzeRemovableWLOnly(conflictToReduce.get(i)))
			conflictToReduce.moveTo(j++, i);
	conflictToReduce.shrink(i - j);
	stats.reducedliterals += (i - j);
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
public int[] primeImplicant() {
	IVecInt currentD = new VecInt(decisions.size());
	decisions.copyTo(currentD);
	IVecInt assumptions = new VecInt(implied.size() + decisions.size());
	implied.copyTo(assumptions);
	decisions.copyTo(assumptions);
	IVecInt prime = new VecInt(assumptions.size());
	implied.copyTo(prime);
	for (int i = 0; i < currentD.size(); i++) {
		int p = currentD.get(i);
		assumptions.remove(p);
		assumptions.push(-p);
		try {
			if (isSatisfiable(assumptions)) {
				assumptions.pop();
				assumptions.push(-p);
			} else {
				prime.push(p);
				assumptions.pop();
				assumptions.push(p);
			}
		} catch (TimeoutException e) {
			throw new IllegalStateException("Should not timeout here", e);
		}
	}
	int[] implicant = new int[prime.size()];
	prime.copyTo(implicant);
	return implicant;
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
/**
 * translate y <=> x1 xor x2 xor ... xor xn into clauses.
 * 
 * @param y
 * @param literals
 * @throws ContradictionException
 * @since 2.1
 */
public IConstr[] xor(int y, IVecInt literals) throws ContradictionException {
	literals.push(-y);
	int[] f = new int[literals.size()];
	literals.copyTo(f);
	IVec<IConstr> vconstrs = new Vec<IConstr>();
	xor2Clause(f, 0, false, vconstrs);
	IConstr[] constrs = new IConstr[vconstrs.size()];
	vconstrs.copyTo(constrs);
	return constrs;
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
/**
 * translate y <=> (x1 <=> x2 <=> ... <=> xn) into clauses.
 * 
 * @param y
 * @param literals
 * @throws ContradictionException
 * @since 2.1
 */
public IConstr[] iff(int y, IVecInt literals) throws ContradictionException {
	literals.push(y);
	int[] f = new int[literals.size()];
	literals.copyTo(f);
	IVec<IConstr> vconstrs = new Vec<IConstr>();
	iff2Clause(f, 0, false, vconstrs);
	IConstr[] constrs = new IConstr[vconstrs.size()];
	vconstrs.copyTo(constrs);
	return constrs;
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
public IVecInt explain(ISolver solver, Map<Integer, ?> constrs,
		IVecInt assumps) throws TimeoutException {
	computationCanceled = false;
	IVecInt encodingAssumptions = new VecInt(constrs.size()
			+ assumps.size());
	assumps.copyTo(encodingAssumptions);
	IVecInt firstExplanation = solver.unsatExplanation();
	if (solver.isVerbose()) {
		System.out.print(solver.getLogPrefix() + "initial unsat core ");
		firstExplanation.sort();
		for (IteratorInt it = firstExplanation.iterator(); it.hasNext();) {
			System.out.print(constrs.get(-it.next()));
			System.out.print(" ");
		}
		System.out.println();
	}
	Set<Integer> constraintsVariables = constrs.keySet();
	int p;
	for (int i = 0; i < firstExplanation.size(); i++) {
		if (constraintsVariables.contains(p = -firstExplanation.get(i))) {
			encodingAssumptions.push(p);
		}
	}
	IVecInt results = new VecInt(encodingAssumptions.size());
	computeExplanation(solver, encodingAssumptions, assumps.size(),
			encodingAssumptions.size() - 1, results);
	return results;
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
@Override
public int[] findModel(IVecInt assumps) throws TimeoutException {
	assump = assumps;
	IVecInt extraVariables = new VecInt();
	assumps.copyTo(extraVariables);
	for (Integer p : constrs.keySet()) {
		extraVariables.push(-p);
	}
	return super.findModel(extraVariables);
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
@Override
public boolean isSatisfiable(IVecInt assumps) throws TimeoutException {
	assump = assumps;
	IVecInt extraVariables = new VecInt();
	assumps.copyTo(extraVariables);
	for (Integer p : constrs.keySet()) {
		extraVariables.push(-p);
	}
	return super.isSatisfiable(extraVariables);
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
public UnitClauses(IVecInt values) {
	literals = new int[values.size()];
	values.copyTo(literals);
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
public void addCriterion(IVecInt literals) {
	IVecInt copy = new VecInt(literals.size());
	literals.copyTo(copy);
	criteria.add(copy);
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
public IVecInt explain(ISolver solver, Map<Integer, ?> constrs,
		IVecInt assumps) throws TimeoutException {
	computationCanceled = false;
	IVecInt encodingAssumptions = new VecInt(constrs.size()
			+ assumps.size());
	assumps.copyTo(encodingAssumptions);
	IVecInt firstExplanation = solver.unsatExplanation();
	IVecInt results = new VecInt(firstExplanation.size());
	if (firstExplanation.size() == 1) {
		results.push(-firstExplanation.get(0));
		return results;
	}
	if (solver.isVerbose()) {
		System.out.print(solver.getLogPrefix() + "initial unsat core ");
		firstExplanation.sort();
		for (IteratorInt it = firstExplanation.iterator(); it.hasNext();) {
			System.out.print(constrs.get(-it.next()));
			System.out.print(" ");
		}
		System.out.println();
	}
	for (int i = 0; i < firstExplanation.size();) {
		if (assumps.contains(firstExplanation.get(i))) {
			firstExplanation.delete(i);
		} else {
			i++;
		}
	}
	Set<Integer> constraintsVariables = constrs.keySet();
	IVecInt remainingVariables = new VecInt(constraintsVariables.size());
	for (Integer v : constraintsVariables) {
		remainingVariables.push(v);
	}
	int p;
	for (IteratorInt it = firstExplanation.iterator(); it.hasNext();) {
		p = it.next();
		if (p < 0) {
			p = -p;
		}
		remainingVariables.remove(p);
		encodingAssumptions.push(p);
	}
	int unsatcorelimit = encodingAssumptions.size() - 1;

	remainingVariables.copyTo(encodingAssumptions);
	computeExplanation(solver, constrs, encodingAssumptions,
			assumps.size(), unsatcorelimit, results);
	return results;
}