kodkod.ast.operator.IntCompOperator Java Examples

public Formula visit(IntComparisonFormula formula) { 
	Formula ret = lookup(formula);
	if (ret!=null) return ret;
	
	final IntCompOperator op = formula.op();
	final IntExpression left = formula.left().accept(this);
	final IntExpression right = formula.right().accept(this);
	
	if (left==right) return cache(formula,Formula.TRUE);
	
	final int hash = hash(op, left, right);
	for(Iterator<PartialCannonicalizer.Holder<Formula>> itr = formulas.get(hash); itr.hasNext(); ) {
		final Formula next = itr.next().obj;
		if (next instanceof IntComparisonFormula) { 
			final IntComparisonFormula hit = (IntComparisonFormula) next;
			if (hit.op()==op && hit.left()==left && hit.right()==right) { 
				return cache(formula, hit);
			}
		}
	}

	ret = left==formula.left()&&right==formula.right() ? formula : left.compare(op, right);
	formulas.add(new PartialCannonicalizer.Holder<Formula>(ret, hash));
	return cache(formula,ret);
}
 

public static Formula numeric_test(Expression l, Expression r, IntCompOperator op, boolean negated) {
	Formula test = intValue(l).compare(op, intValue(r));
	if (negated) {
		test = test.not();
	}
	return isNumeric(l).and(isNumeric(r)).and(test);
}
 

public Formula visit(IntComparisonFormula formula) { 
	Formula ret = lookup(formula);
	if (ret!=null) return ret;
	
	final IntCompOperator op = formula.op();
	final IntExpression left = formula.left().accept(this);
	final IntExpression right = formula.right().accept(this);
	
	if (left==right) return cache(formula,Formula.TRUE);
	
	ret = left==formula.left()&&right==formula.right() ? formula : left.compare(op, right);
	return cache(formula,ret);
}
 

public static Formula not_equal_test(Expression l, Expression r) {
	return string_equal(l, r, true)
			.or(numeric_test(l, r, IntCompOperator.EQ, true))
			.or(language_equal(l, r, true))
			.or(unknown_equal(l, r, true))
			.or(isLiteral(l).not().and(isLiteral(r).not()).and(l.eq(r).not()));
}
 

public static Formula equal_test(Expression l, Expression r) {
	return string_equal(l, r, false)
			.or(numeric_test(l, r, IntCompOperator.EQ, false))
			.or(language_equal(l, r, false))
			.or(unknown_equal(l, r, false))
			.or(isLiteral(l).not().and(isLiteral(r).not()).and(l.eq(r)));
}
 

public static Formula numeric_test(Pair<Expression,IntExpression> l, Pair<Expression,IntExpression> r, IntCompOperator op, boolean negated) {
	Formula test = intValue(l).compare(op, intValue(r));
	if (negated) {
		test = test.not();
	}
	return isNumeric(l).and(isNumeric(r)).and(test);
}
 

private final void testCompOp(IntCompOperator op, IntExpression ei, IntExpression ej, int i, int j, boolean result) {
	final Formula e = ei.compare(op, ej);
	final Formula f = ei.eq(constant(i)).and(ej.eq(constant(j))).and(result ? e : e.not());
	final Solution s = solve(f);
	assertNotNull(s.instance());
	final Evaluator eval = new Evaluator(s.instance(), solver.options());
	assertFalse(result ^ eval.evaluate(e));
	
}
 

private final void testCompOp(IntCompOperator op, IntExpression ei, IntExpression ej, int i, int j, boolean result) {
    final Formula e = ei.compare(op, ej);
    final Formula f = ei.eq(constant(i)).and(ej.eq(constant(j))).and(result ? e : e.not());
    final Solution s = solve(f);
    if (overflows(ei, i, 0) || overflows(ej, j, 0)) {
        assertNull(f.toString(), s.instance());
    } else {
        assertNotNull(f.toString(), s.instance());
        final Evaluator eval = new Evaluator(s.instance(), solver.options());
        assertFalse(result ^ eval.evaluate(e));
    }
}
 

/**
 * Returns a formula comparing this and the given integer expression using the
 * specified operator.
 * @return {f: Formula | f.left = this and f.right = intExpr and f.op = op }
 */
public Formula compare(IntCompOperator op, IntExpression intExpr) {
	if (op==null || intExpr==null)
		throw new NullPointerException();
	return new IntComparisonFormula(this, op, intExpr);	
}
 

public static Formula less_test(Expression l, Expression r) {
	return numeric_test(l, r, IntCompOperator.LT, false).or(string_less(l, r));
}
 

public static Formula greater_test(Expression l, Expression r) {
	return numeric_test(l, r, IntCompOperator.GT, false).or(string_greater(l, r));
}
 

public static Formula less_test(Pair<Expression,IntExpression> l, Pair<Expression,IntExpression> r) {
	return numeric_test(l, r, IntCompOperator.LT, false).or(string_less(l.fst, r.fst));
}
 

public static Formula greater_test(Pair<Expression,IntExpression> l, Pair<Expression,IntExpression> r) {
	return numeric_test(l, r, IntCompOperator.GT, false).or(string_greater(l.fst, r.fst));
}
 

/**
 * Returns the operator of this.
 * @return this.op
 */
public IntCompOperator op() {return op;}
 

/**
 * Constructs a new int comparison formula: left op right
 *
 * @ensures this.left' = left && this.right' = right && this.op' = op
 * @throws NullPointerException left = null || right = null || op = null
 */
IntComparisonFormula(final IntExpression left, final IntCompOperator op, final IntExpression right) {
    this.left = left;
    this.right = right;
    this.op = op;
}
 

/**  
 * Constructs a new int comparison formula: left op right
 * 
 * @ensures this.left' = left && this.right' = right && this.op' = op
 * @throws NullPointerException  left = null || right = null || op = null
 */
IntComparisonFormula(final IntExpression left, final IntCompOperator op, final IntExpression right) {
	this.left = left;
	this.right = right;
	this.op = op;
}
 

/**
 * Returns a formula comparing this and the given integer expression using the
 * specified operator.
 *
 * @return {f: Formula | f.left = this and f.right = intExpr and f.op = op }
 */
public Formula compare(IntCompOperator op, IntExpression intExpr) {
    if (op == null || intExpr == null)
        throw new NullPointerException();
    return new IntComparisonFormula(this, op, intExpr);
}
 

/**
 * Returns the operator of this.
 *
 * @return this.op
 */
public IntCompOperator op() {
    return op;
}