Java Code Examples for kodkod.ast.Expression#compose()

/**
 * Calls lookup(expr) and returns the cached value, if any. If a replacement has
 * not been cached, visits the expr's children. If nothing changes, the argument
 * is cached and returned, otherwise a replacement expr is cached and returned.
 *
 * @return { e: Expression | e.op = expr.op && #e.children = #expr.children &&
 *         all i: [0..expr.children) | e.child(i) =
 *         expr.child(i).accept(delegate) }
 */
@Override
public Expression visit(NaryExpression expr) {
    Expression ret = lookup(expr);
    if (ret != null)
        return ret;

    final Expression[] visited = new Expression[expr.size()];
    boolean allSame = true;
    for (int i = 0; i < visited.length; i++) {
        final Expression child = expr.child(i);
        visited[i] = child.accept(delegate);
        allSame = allSame && visited[i] == child;
    }

    ret = allSame ? expr : Expression.compose(expr.op(), visited);
    return cache(expr, ret);
}
 

private final void testNary(ExprOperator op) {
    bounds.bound(r1[0], factory.range(factory.tuple(1, 0), factory.tuple(1, 3)));
    bounds.bound(r1[1], factory.range(factory.tuple(1, 2), factory.tuple(1, 5)));
    bounds.bound(r1[3], factory.range(factory.tuple(1, 3), factory.tuple(1, 6)));

    for (int i = 2; i <= 5; i++) {
        final Expression[] exprs = new Expression[i];
        exprs[0] = r1[0];
        Expression binExpr = r1[0];
        for (int j = 1; j < i; j++) {
            binExpr = binExpr.compose(op, r1[j % 4]);
            exprs[j] = r1[j % 4];
        }
        Expression nExpr = Expression.compose(op, exprs);
        final Solution sol = solver.solve(binExpr.eq(nExpr).not(), bounds);
        assertNull(sol.instance());
    }

}
 

private final void testNary(ExprOperator op) {
    bounds.bound(r1[0], factory.range(factory.tuple(1, 0), factory.tuple(1, 3)));
    bounds.bound(r1[1], factory.range(factory.tuple(1, 2), factory.tuple(1, 5)));
    bounds.bound(r1[3], factory.range(factory.tuple(1, 3), factory.tuple(1, 6)));

    for (int i = 2; i <= 5; i++) {
        final Expression[] exprs = new Expression[i];
        exprs[0] = r1[0];
        Expression binExpr = r1[0];
        for (int j = 1; j < i; j++) {
            binExpr = binExpr.compose(op, r1[j % 4]);
            exprs[j] = r1[j % 4];
        }
        Expression nExpr = Expression.compose(op, exprs);
        final Solution sol = solver.solve(binExpr.eq(nExpr).not(), bounds);
        assertNull(sol.instance());
    }

}
 

/** 
 * Calls lookup(expr) and returns the cached value, if any.  
 * If a replacement has not been cached, visits the expr's 
 * children.  If nothing changes, the argument is cached and
 * returned, otherwise a replacement expr is cached and returned.
 * @return { e: Expression | e.op = expr.op && #e.children = #expr.children && all i: [0..expr.children) | e.child(i) = expr.child(i).accept(this) }
 */
public Expression visit(NaryExpression expr) {
	Expression ret = lookup(expr);
	if (ret!=null) return ret;
	
	final Expression[] visited = new Expression[expr.size()];
	boolean allSame = true;
	for(int i = 0 ; i < visited.length; i++) { 
		final Expression child = expr.child(i);
		visited[i] = child.accept(this);
		allSame = allSame && visited[i]==child;
	}
	
	ret = allSame ? expr : Expression.compose(expr.op(), visited);
	return cache(expr,ret);
}
 

private final void testNary(ExprOperator op) { 
	bounds.bound(r1[0], factory.range(factory.tuple(1, 0), factory.tuple(1, 3)));
	bounds.bound(r1[1], factory.range(factory.tuple(1, 2), factory.tuple(1, 5)));
	bounds.bound(r1[3], factory.range(factory.tuple(1, 3), factory.tuple(1, 6)));
	

	for(int i = 2; i <= 5; i++) { 
		final Expression[] exprs = new Expression[i];
		exprs[0] = r1[0];
		Expression binExpr = r1[0];
		for(int j = 1; j < i; j++) { 
			binExpr = binExpr.compose(op, r1[j%4]);
			exprs[j] = r1[j%4];
		}
		Expression nExpr = Expression.compose(op, exprs);
		final Solution sol = solver.solve(binExpr.eq(nExpr).not(), bounds);
		assertNull(sol.instance());	
	}
	
	
}
 

private final void testNary(ExprOperator op) { 
	bounds.bound(r1[0], factory.range(factory.tuple(1, 0), factory.tuple(1, 3)));
	bounds.bound(r1[1], factory.range(factory.tuple(1, 2), factory.tuple(1, 5)));
	bounds.bound(r1[3], factory.range(factory.tuple(1, 3), factory.tuple(1, 6)));
	

	for(int i = 2; i <= 5; i++) { 
		final Expression[] exprs = new Expression[i];
		exprs[0] = r1[0];
		Expression binExpr = r1[0];
		for(int j = 1; j < i; j++) { 
			binExpr = binExpr.compose(op, r1[j%4]);
			exprs[j] = r1[j%4];
		}
		Expression nExpr = Expression.compose(op, exprs);
		final Solution sol = solver.solve(binExpr.eq(nExpr).not(), bounds);
		assertNull(sol.instance());	
	}
	
	
}
 

public Expression visit(NaryExpression expr) { 
	Expression ret = lookup(expr);
	if (ret!=null) return ret;
	
	final ExprOperator op = expr.op();
	
	final List<Expression> children = simplify(op, visitAll(expr));
	final int size = children.size();
	switch(size) { 
	case 0 : return cache(expr, empty(expr.arity()));
	case 1 : return cache(expr, children.get(0));
	default :
		ret = expr.size()==size && allSame(expr,children) ? expr : Expression.compose(op, children);
		return cache(expr,ret);
	}	
}
 

/**
 * Calls lookup(binExpr) and returns the cached value, if any. If a replacement
 * has not been cached, visits the expression's children. If nothing changes,
 * the argument is cached and returned, otherwise a replacement expression is
 * cached and returned.
 *
 * @return { b: BinaryExpression | b.left = binExpr.left.accept(delegate) &&
 *         b.right = binExpr.right.accept(delegate) && b.op = binExpr.op }
 */
@Override
public Expression visit(BinaryExpression binExpr) {
    Expression ret = lookup(binExpr);
    if (ret != null)
        return ret;

    final Expression left = binExpr.left().accept(delegate);
    final Expression right = binExpr.right().accept(delegate);
    ret = (left == binExpr.left() && right == binExpr.right()) ? binExpr : left.compose(binExpr.op(), right);
    return cache(binExpr, ret);
}
 

/** 
 * Calls lookup(binExpr) and returns the cached value, if any.  
 * If a replacement has not been cached, visits the expression's 
 * children.  If nothing changes, the argument is cached and
 * returned, otherwise a replacement expression is cached and returned.
 * @return { b: BinaryExpression | b.left = binExpr.left.accept(this) &&
 *                                 b.right = binExpr.right.accept(this) && b.op = binExpr.op }
 */
public Expression visit(BinaryExpression binExpr) {
	Expression ret = lookup(binExpr);
	if (ret!=null) return ret;
	
	final Expression left  = binExpr.left().accept(this);
	final Expression right = binExpr.right().accept(this);
	ret = (left==binExpr.left() && right==binExpr.right()) ?
		  binExpr : left.compose(binExpr.op(), right);
	return cache(binExpr,ret);
}
 

public Expression visit(BinaryExpression expr) { 
	Expression ret = lookup(expr);
	if (ret!=null) return ret;
	final ExprOperator op = expr.op();
	final Expression left = expr.left().accept(this);
	final Expression right = expr.right().accept(this);
	
	ret = simplify(op, left, right);
	
	if (ret==null) {
	
		final int hash = hash(op, left, right);
		for(Iterator<PartialCannonicalizer.Holder<Expression>> itr = exprs.get(hash); itr.hasNext(); ) {
			final Expression next = itr.next().obj;
			if (next instanceof BinaryExpression) { 
				final BinaryExpression hit = (BinaryExpression) next;
				if (hit.op()==op && hit.left()==left && hit.right()==right) { 
					return cache(expr, hit);
				}
			}
		}

		ret = left==expr.left()&&right==expr.right() ? expr : left.compose(op, right);
		exprs.add(new PartialCannonicalizer.Holder<Expression>(ret, hash));
	}
	
	return cache(expr,ret);
}
 

public Expression visit(BinaryExpression expr) { 
	Expression ret = lookup(expr);
	if (ret!=null) return ret;
	final ExprOperator op = expr.op();
	final Expression left = expr.left().accept(this);
	final Expression right = expr.right().accept(this);
	
	ret = simplify(op, left, right);
	
	if (ret==null) {
		ret = left==expr.left()&&right==expr.right() ? expr : left.compose(op, right);
	}
	
	return cache(expr,ret);
}