kodkod.ast.SumExpression Java Examples

/** 
 * Calls lookup(intExpr) and returns the cached value, if any.  
 * If a translation has not been cached, translates the expression,
 * calls cache(...) on it and returns it.
 * @return let t = lookup(intExpr) | some t => t, 
 * 	cache(intExpr, translate(intExpr))
 */
public final Int visit(SumExpression intExpr) {
	final Int ret = lookup(intExpr);
	if (ret!=null) return ret;
	final List<Int> values = new ArrayList<Int>();
	sum(intExpr.decls(), intExpr.intExpr(), 0, BooleanConstant.TRUE, values);
	for(int sums = values.size(); sums > 1; sums -= sums/2) { 
		final int max = sums-1;
		for(int i = 0; i < max; i += 2) { 
			values.set(i/2, values.get(i).plus(values.get(i+1)));
		}
		if (max%2==0) { // even max => odd number of entries
			values.set(max/2, values.get(max));
		}
	}
	return cache(intExpr, values.isEmpty() ? interpreter.factory().integer(0) : values.get(0));
}
 

/**
 * @see kodkod.ast.visitor.AbstractReplacer#visit(kodkod.ast.SumExpression)
 */
@Override
public final IntExpression visit(SumExpression intExpr) {
    IntExpression ret = lookup(intExpr);
    if (ret != null)
        return ret;
    final Environment<Expression,Expression> oldRepEnv = repEnv; // skolemDepth
                                                                // < 0
                                                                // at
                                                                // this
                                                                // point
    final Decls decls = visit(intExpr.decls());
    final IntExpression expr = intExpr.intExpr().accept(this);
    ret = (decls == intExpr.decls() && expr == intExpr.intExpr()) ? intExpr : expr.sum(decls);
    repEnv = oldRepEnv;
    return cache(intExpr, ret);
}
 

/**
 * Calls lookup(intExpr) and returns the cached value, if any. If a translation
 * has not been cached, translates the expression, calls cache(...) on it and
 * returns it.
 *
 * @return let t = lookup(intExpr) | some t => t, cache(intExpr,
 *         translate(intExpr))
 */
@Override
public final Int visit(SumExpression intExpr) {
    final Int ret = lookup(intExpr);
    if (ret != null)
        return ret;
    final List<Int> values = new ArrayList<Int>();
    sum(intExpr.decls(), intExpr.intExpr(), 0, BooleanConstant.TRUE, values);
    for (int sums = values.size(); sums > 1; sums -= sums / 2) {
        final int max = sums - 1;
        for (int i = 0; i < max; i += 2) {
            values.set(i / 2, values.get(i).plus(values.get(i + 1)));
        }
        if (max % 2 == 0) { // even max => odd number of entries
            values.set(max / 2, values.get(max));
        }
    }
    if (values.isEmpty()) {
        return cache(intExpr, interpreter.factory().integer(0));
    } else {
        Int sumValue = values.get(0);
        return cache(intExpr, sumValue);
    }
}
 

/** {@inheritDoc} */
@Override
public void visit(SumExpression x) {
    String newname = makename(x);
    if (newname == null)
        return;
    String d = make(x.decls());
    String f = make(x.intExpr());
    file.printf("IntExpression %s=%s.sum(%s);%n", newname, f, d);
}
 

/** @effects this.tokens' = concat[ this.tokens,  "sum",
 *   tokenize[node.decls], "|", tokenize[ node.intExpr ],  ]*/
public void visit(SumExpression node) {
	if (displayed(node)) return;
	final boolean oldTop = notTop();
	keyword("sum");
	node.decls().accept(this);
	infix("|");
	node.intExpr().accept(this);
	top = oldTop;
}
 

/** @return true if the given int expression needs to be parenthesized if a 
 * child of a binary int expression with the given operator */
private boolean parenthesize(IntOperator op, IntExpression child) { 
	return child instanceof SumExpression ||
		   child instanceof IfIntExpression || 
		   child instanceof NaryIntExpression ||
	       (child instanceof BinaryIntExpression && 
	        (!associative(op) || ((BinaryIntExpression)child).op()!=op));
}
 

/** @ensures this.tokens' = concat[ this.tokens,  "sum",
 *   tokenize[node.decls], "|", tokenize[ node.intExpr ],  ]*/
public void visit(SumExpression node) {
	keyword("sum");
	node.decls().accept(this);
	infix("|");
	node.intExpr().accept(this);
}
 

/** @return true if the given int expression needs to be parenthesized if a 
 * child of a binary int expression with the given operator */
private boolean parenthesize(IntOperator op, IntExpression child) { 
	return child instanceof SumExpression ||
		   child instanceof IfIntExpression || 
		   child instanceof NaryIntExpression ||
	       (child instanceof BinaryIntExpression && 
	        (!associative(op) || ((BinaryIntExpression)child).op()!=op));
}
 

/**
 * @see kodkod.ast.visitor.AbstractReplacer#visit(kodkod.ast.SumExpression)
 */
@Override
public final IntExpression visit(SumExpression intExpr) {
	IntExpression ret = lookup(intExpr);
	if (ret!=null) return ret;	
	final Environment<Expression> oldRepEnv = repEnv; // skolemDepth < 0 at this point
	final Decls decls  = visit((Decls)intExpr.decls());
	final IntExpression expr = intExpr.intExpr().accept(this);
	ret =  (decls==intExpr.decls() && expr==intExpr.intExpr()) ? intExpr : expr.sum(decls);
	repEnv = oldRepEnv;
	return cache(intExpr,ret);
}
 

/** 
 * Calls lookup(intExpr) and returns the cached value, if any.  
 * If no cached value exists, visits each child, caches the
 * union of the children's return values and returns it. 
 * @return let x = lookup(intExpr) | 
 *          x != null => x,  
 *          cache(intExpr, intExpr.decls.accept(this) + intExpr.intExpr.accept(this)) 
 */
public Set<T> visit(SumExpression intExpr) {
	Set<T> ret = lookup(intExpr);
	if (ret!=null) return ret;		
	ret = newSet();
	ret.addAll(intExpr.decls().accept(this));
	ret.addAll(intExpr.intExpr().accept(this));
	return cache(intExpr, ret);
}
 

/** 
* Calls lookup(intExpr) 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 { c: IntExpression | [[c]] = sum intExpr.decls.accept(this) | intExpr.intExpr.accept(this) }
*/
  public IntExpression visit(SumExpression intExpr) {
IntExpression ret = lookup(intExpr);
if (ret!=null) return ret;
	
final Decls decls  = intExpr.decls().accept(this);
final IntExpression expr = intExpr.intExpr().accept(this);
ret =  (decls==intExpr.decls() && expr==intExpr.intExpr()) ? 
		intExpr : expr.sum(decls);
return cache(intExpr,ret);
  }
 

/**
 * @ensures this.tokens' = concat[ this.tokens, "sum", tokenize[node.decls],
 *          "|", tokenize[ node.intExpr ], ]
 */
@Override
public void visit(SumExpression node) {
    keyword("sum");
    node.decls().accept(this);
    infix("|");
    node.intExpr().accept(this);
}
 

/**
 * Calls lookup(intExpr) 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 { c: IntExpression | [[c]] = sum intExpr.decls.accept(delegate) |
 *         intExpr.intExpr.accept(delegate) }
 */
@Override
public IntExpression visit(SumExpression intExpr) {
    IntExpression ret = lookup(intExpr);
    if (ret != null)
        return ret;

    final Decls decls = intExpr.decls().accept(delegate);
    final IntExpression expr = intExpr.intExpr().accept(delegate);
    ret = (decls == intExpr.decls() && expr == intExpr.intExpr()) ? intExpr : expr.sum(decls);
    return cache(intExpr, ret);
}
 

/**
 * Visits the children of the given sum expression if this.visited(intExpr)
 * returns false. Otherwise does nothing.
 *
 * @ensures intExpr.decls.accept(this) && intExpr.intExpr.accept(this)
 */
@Override
public void visit(SumExpression intExpr) {
    if (visited(intExpr))
        return;
    intExpr.decls().accept(this);
    intExpr.intExpr().accept(this);
}
 

/**
 * Calls lookup(intExpr) and returns the cached value, if any. If no cached
 * value exists, visits each child, caches the union of the children's return
 * values and returns it.
 *
 * @return let x = lookup(intExpr) | x != null => x, cache(intExpr,
 *         intExpr.decls.accept(this) + intExpr.intExpr.accept(this))
 */
@Override
public Set<T> visit(SumExpression intExpr) {
    Set<T> ret = lookup(intExpr);
    if (ret != null)
        return ret;
    ret = newSet();
    ret.addAll(intExpr.decls().accept(this));
    ret.addAll(intExpr.intExpr().accept(this));
    return cache(intExpr, ret);
}
 

@Override
public void visit(SumExpression intExpr) {
    visit(intExpr, "sum", intExpr.decls(), intExpr.intExpr());
}
 

@Override
public Boolean visit(SumExpression intExpr) {
    return visit(intExpr, intExpr.decls(), intExpr.intExpr());
}
 

@Override
public Boolean visit(SumExpression e) {
    return checkVisitedThenAccumA(e, Boolean.FALSE, e.decls(), e.intExpr());
}
 

@Override
public I visit(SumExpression intExpr) {
    start(intExpr);
    return end(intExpr, visitor.visit(intExpr));
}
 

@Override
public IntExpression visit(SumExpression intExpr) {
    return intExpr;
}
 

/**
 * Visits the children of the given sum expression  if
 * this.visited(intExpr) returns false.  Otherwise does nothing.
 * @ensures intExpr.decls.accept(this) && intExpr.intExpr.accept(this)
 */
public void visit(SumExpression intExpr) {
	if (visited(intExpr)) return;
	intExpr.decls().accept(this);
	intExpr.intExpr().accept(this);
}
 

public Boolean visit(SumExpression intExpr) {
	return visit(intExpr, intExpr.decls(), intExpr.intExpr());
}
 

/**
 * Visits the given sum expression.
 */
public void visit(SumExpression intExpr);
 

/**
 * @return true if the given int expression needs to be parenthesized if a child
 *         of a binary int expression with the given operator
 */
private boolean parenthesize(IntOperator op, IntExpression child) {
    return child instanceof SumExpression || child instanceof IfIntExpression || child instanceof NaryIntExpression || (child instanceof BinaryIntExpression && (!associative(op) || ((BinaryIntExpression) child).op() != op));
}
 

/**
 * Visits the given sum expression and returns the result.
 *
 * @return the result of visiting <code>intExpr</code>
 */
public I visit(SumExpression intExpr);
 

/** 
 * Calls lookup(intExpr) and returns the cached value, if any.  
 * If no cached value exists, computes, caches and returns the set
 * of free variables in intExpr.  
 * @return let x = lookup(intExpr), d = intExpr.declarations, e = intExpr.intExpr | 
 *          x != null => x,  
 *          cache(intExpr, 
 *            (e.accept(this) - d.children.variable) + 
 *            {v: Variable | some i: [0..d.size) | 
 *             v in d.declarations[i].accept(this) - d.declarations[0..i).variable } ) 
 */
@Override
public Set<Variable> visit(SumExpression intExpr) {
	return visit(intExpr, intExpr.decls(), intExpr.intExpr());
}
 

/**
 * Calls lookup(intExpr) and returns the cached value, if any. If no cached
 * value exists, visits each child, caches the disjunction of the children's
 * return values and returns it.
 *
 * @return let x = lookup(intExpr) | x != null => x, cache(intExpr,
 *         intExpr.decls.accept(this) || intExpr.intExpr.accept(this))
 */
@Override
public Boolean visit(SumExpression intExpr) {
    final Boolean ret = lookup(intExpr);
    return (ret != null) ? ret : cache(intExpr, intExpr.decls().accept(this) || intExpr.intExpr().accept(this));
}
 

/** 
 * Calls lookup(intExpr) and returns the cached value, if any.  
 * If no cached value exists, visits each child, caches the
 * disjunction of the children's return values and returns it. 
 * @return let x = lookup(intExpr) | 
 *          x != null => x,  
 *          cache(intExpr, intExpr.decls.accept(this) || intExpr.intExpr.accept(this)) 
 */
public Boolean visit(SumExpression intExpr) {
	final Boolean ret = lookup(intExpr);
	return (ret!=null) ? ret : cache(intExpr, intExpr.decls().accept(this) || intExpr.intExpr().accept(this));
}
 

/**
 * Calls lookup(intExpr) and returns the cached value, if any. If no cached
 * value exists, computes, caches and returns the set of free variables in
 * intExpr.
 *
 * @return let x = lookup(intExpr), d = intExpr.declarations, e =
 *         intExpr.intExpr | x != null => x, cache(intExpr, (e.accept(this) -
 *         d.children.variable) + {v: Variable | some i: [0..d.size) | v in
 *         d.declarations[i].accept(this) - d.declarations[0..i).variable } )
 */
@Override
public Set<Variable> visit(SumExpression intExpr) {
    return visit(intExpr, intExpr.decls(), intExpr.intExpr());
}
 

/**
   * Visits the given sum expression and returns the result.
* @return the result of visiting <code>intExpr</code> 
   */
  public I visit(SumExpression intExpr);