Java IVecInt.get方法代码示例

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
protected IVecInt dimacs2internal(IVecInt in) {
	__dimacs_out.clear();
	__dimacs_out.ensure(in.size());
	int p;
	for (int i = 0; i < in.size(); i++) {
		p = in.get(i);
		if (p == 0) {
			throw new IllegalArgumentException(
					"0 is not a valid variable identifier");
		}
		__dimacs_out.unsafePush(voc.getFromPool(p));
	}
	return __dimacs_out;
}
 

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包/类
private int readOutput(int nboutputs, EfficientScanner scanner)
		throws IOException, ParseFormatException {
	IVecInt outputs = new VecInt(nboutputs);
	for (int i = 0; i < nboutputs; i++) {
		outputs.push(scanner.nextInt());
	}
	return outputs.get(0);
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
/**
 * Constructeur de base cr?ant des contraintes vides
 * 
 * @param size
 *            nombre de litt?raux de la contrainte
 * @param learnt
 *            indique si la contrainte est apprise
 */
private MaxWatchCard(ILits voc, IVecInt ps, boolean moreThan, int degree) {

	// On met en place les valeurs
	this.voc = voc;
	this.degree = degree;
	this.moreThan = moreThan;

	// On simplifie ps
	int[] index = new int[voc.nVars() * 2 + 2];
	for (int i = 0; i < index.length; i++)
		index[i] = 0;
	// On repertorie les litt?raux utiles
	for (int i = 0; i < ps.size(); i++) {
		if (index[ps.get(i) ^ 1] == 0) {
			index[ps.get(i)]++;
		} else {
			index[ps.get(i) ^ 1]--;
		}
	}
	// On supprime les litt?raux inutiles
	int ind = 0;
	while (ind < ps.size()) {
		if (index[ps.get(ind)] > 0) {
			index[ps.get(ind)]--;
			ind++;
		} else {
			if ((ps.get(ind) & 1) != 0)
				this.degree--;
			ps.set(ind, ps.last());
			ps.pop();
		}
	}

	// On copie les litt?raux de la contrainte
	lits = new int[ps.size()];
	ps.moveTo(lits);

	// On normalise la contrainte au sens de Barth
	normalize();

	// Mise en place de l'observation maximale
	watchCumul = 0;

	// On observe les litt?raux non falsifi?
	for (int i = 0; i < lits.length; i++) {
		// Rappel: les ?l?ments falsifi?s ne seront jamais d?pil?s
		if (!voc.isFalsified(lits[i])) {
			watchCumul++;
			voc.watch(lits[i] ^ 1, this);
		}
	}
}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
/**
 * Constructs and normalizes a cardinality constraint. used by
 * minWatchCardNew in the non-normalized case.
 * 
 * @param voc
 *            vocabulary used by the constraint
 * @param ps
 *            literals involved in the constraint
 * @param moreThan
 *            should be ATLEAST or ATMOST;
 * @param degree
 *            degree of the constraint
 */
public MinWatchCard(ILits voc, IVecInt ps, boolean moreThan, int degree) {
	// On met en place les valeurs
	this.voc = voc;
	this.degree = degree;
	this.moreThan = moreThan;

	// On simplifie ps
	int[] index = new int[voc.nVars() * 2 + 2];
	// Fresh array should have all elements set to 0

	// On repertorie les litt?raux utiles
	for (int i = 0; i < ps.size(); i++) {
		int p = ps.get(i);
		if (index[p ^ 1] == 0) {
			index[p]++;
		} else {
			index[p ^ 1]--;
		}
	}
	// On supprime les litt?raux inutiles
	int ind = 0;
	while (ind < ps.size()) {
		if (index[ps.get(ind)] > 0) {
			index[ps.get(ind)]--;
			ind++;
		} else {
			// ??
			if ((ps.get(ind) & 1) != 0)
				this.degree--;
			ps.delete(ind);
		}
	}

	// On copie les litt?raux de la contrainte
	lits = new int[ps.size()];
	ps.moveTo(lits);

	// On normalise la contrainte au sens de Barth
	normalize();

}
 

import org.sat4j.specs.IVecInt; //导入方法依赖的package包/类
/**
 * Perform some sanity check before constructing a clause a) if a literal is
 * assigned true, return null (the clause is satisfied) b) if a literal is
 * assigned false, remove it c) if a clause contains a literal and its
 * opposite (tautology) return null d) remove duplicate literals e) if the
 * clause is empty, return null f) if the clause if unit, transmit it to the
 * object responsible for unit propagation
 * 
 * @param ps
 *            the list of literals
 * @param voc
 *            the vocabulary used
 * @param s
 *            the object responsible for unit propagation
 * @return null if the clause should be ignored, the (possibly modified)
 *         list of literals otherwise
 * @throws ContradictionException
 *             if discovered by unit propagation
 */
public static IVecInt sanityCheck(IVecInt ps, ILits voc,
		UnitPropagationListener s) throws ContradictionException {
	// si un litt???ral de ps est vrai, retourner vrai
	// enlever les litt???raux falsifi???s de ps
	for (int i = 0; i < ps.size();) {
		// on verifie si le litteral est affecte
		if (voc.isUnassigned(ps.get(i))) {
			// on passe au literal suivant
			i++;
		} else {
			// Si le litteral est satisfait, la clause est
			// satisfaite
			if (voc.isSatisfied(ps.get(i))) {
				// on retourne la clause
				return null;
			}
			// on enleve le ieme litteral
			ps.delete(i);

		}
	}

	// on trie le vecteur ps
	ps.sortUnique();

	// ???limine les clauses tautologiques
	// deux litt???raux de signe oppos???s apparaissent dans la m???me
	// clause
	for (int i = 0; i < ps.size() - 1; i++) {
		if (ps.get(i) == (ps.get(i + 1) ^ 1)) {
			// la clause est tautologique
			return null;
		}
	}

	if (propagationCheck(ps, s))
		return null;

	return ps;
}