Examples with IfThenElseExpr jkind.lustre.IfThenElseExpr used on opensource projects

Example 11 with IfThenElseExpr

use of jkind.lustre.IfThenElseExpr in project AGREE by loonwerks.

the class LustreCondactNodeVisitor method translate.

public static Node translate(AgreeProgram agreeProgram, AgreeNode agreeNode, Node node) {
    if (node.outputs.size() != 1) {
        throw new AgreeException("We expect that this node only has a single output representing " + "all constraints for the contract");
    }
    LustreCondactNodeVisitor visitor = new LustreCondactNodeVisitor(agreeProgram, node);
    NodeBuilder builder = new NodeBuilder(node);
    builder.clearEquations();
    builder.addInput(new AgreeVar(clockVarName, NamedType.BOOL, null));
    addTickedEq(builder);
    addInitEq(builder);
    Expr holdExpr = new BoolExpr(true);
    // make clock hold exprs
    for (AgreeVar var : agreeNode.outputs) {
        Expr varId = new IdExpr(var.id);
        Expr preVar = new UnaryExpr(UnaryOp.PRE, varId);
        holdExpr = new BinaryExpr(holdExpr, BinaryOp.AND, new BinaryExpr(varId, BinaryOp.EQUAL, preVar));
    }
    holdExpr = new BinaryExpr(new BoolExpr(true), BinaryOp.ARROW, holdExpr);
    for (int i = 0; i < agreeNode.assumptions.size(); i++) {
        Expr varId = new IdExpr(LustreAstBuilder.assumeSuffix + i);
        Expr preVar = new UnaryExpr(UnaryOp.PRE, varId);
        preVar = new BinaryExpr(new BoolExpr(true), BinaryOp.ARROW, preVar);
        holdExpr = new BinaryExpr(holdExpr, BinaryOp.AND, new BinaryExpr(varId, BinaryOp.EQUAL, preVar));
    }
    holdExpr = expr("(not clk => holdExpr)", to("clk", clockVarName), to("holdExpr", holdExpr));
    // make the constraint for the initial outputs
    Expr initConstr = expr("not ticked => initExpr", to("ticked", tickedVarName), to("initExpr", agreeNode.initialConstraint));
    // re-write the old expression using the visitor
    for (Equation eq : node.equations) {
        if (eq.lhs.size() != 1) {
            throw new AgreeException("we expect that all eqs have a single lhs now");
        }
        IdExpr var = eq.lhs.get(0);
        boolean isLocal = false;
        for (VarDecl local : node.locals) {
            if (local.id.equals(var.id)) {
                isLocal = true;
                break;
            }
        }
        if (isLocal) {
            Expr newExpr = eq.expr.accept(visitor);
            newExpr = new IfThenElseExpr(new IdExpr(clockVarName), newExpr, new UnaryExpr(UnaryOp.PRE, var));
            builder.addEquation(new Equation(eq.lhs, newExpr));
        } else {
            // this is the only output
            Expr newExpr = eq.expr.accept(visitor);
            newExpr = new BinaryExpr(new IdExpr(clockVarName), BinaryOp.IMPLIES, newExpr);
            builder.addEquation(new Equation(eq.lhs, new BinaryExpr(initConstr, BinaryOp.AND, new BinaryExpr(holdExpr, BinaryOp.AND, newExpr))));
        }
    }
    // this var equations should be populated by the visitor call above
    builder.addEquations(visitor.stateVarEqs);
    builder.addLocals(visitor.stateVars);
    return builder.build();
}

Example 12 with IfThenElseExpr

use of jkind.lustre.IfThenElseExpr in project AGREE by loonwerks.

the class AgreePatternTranslator method translatePatternEventProperty.

private Expr translatePatternEventProperty(AgreeCauseEffectPattern pattern, AgreeNodeBuilder builder, IdExpr causeId, IdExpr effectId) {
    EObject varReference = pattern.reference;
    AgreeVar timerVar = new AgreeVar(TIMER_PREFIX + patternIndex, NamedType.REAL, varReference);
    AgreeVar runVar = new AgreeVar(RUNNING_PREFIX + patternIndex, NamedType.BOOL, varReference);
    AgreeVar recordVar = new AgreeVar(RECORD_PREFIX + patternIndex, NamedType.BOOL, varReference);
    builder.addLocal(timerVar);
    builder.addLocal(runVar);
    builder.addInput(recordVar);
    IdExpr timerId = new IdExpr(timerVar.id);
    IdExpr runId = new IdExpr(runVar.id);
    IdExpr recordId = new IdExpr(recordVar.id);
    // run = record -> if pre(run) and e and l <= timer <= h then
    // false
    // else
    // if record then
    // true
    // else
    // pre(run)
    Expr preRun = new UnaryExpr(UnaryOp.PRE, runId);
    {
        Expr if2 = new IfThenElseExpr(recordId, new BoolExpr(true), preRun);
        BinaryOp left = getIntervalLeftOp(pattern.effectInterval);
        BinaryOp right = getIntervalRightOp(pattern.effectInterval);
        Expr timerLow = new BinaryExpr(pattern.effectInterval.low, left, timerId);
        Expr timerHigh = new BinaryExpr(timerId, right, pattern.effectInterval.high);
        Expr cond1 = new BinaryExpr(preRun, BinaryOp.AND, effectId);
        cond1 = new BinaryExpr(cond1, BinaryOp.AND, timerLow);
        cond1 = new BinaryExpr(cond1, BinaryOp.AND, timerHigh);
        Expr if1 = new IfThenElseExpr(cond1, new BoolExpr(false), if2);
        Expr runExpr = new BinaryExpr(recordId, BinaryOp.ARROW, if1);
        builder.addLocalEquation(new AgreeEquation(runId, runExpr, varReference));
    }
    // timer = (0 -> if pre(run) then pre(timer) + (t - pre(t)) else 0)
    {
        Expr preTimer = new UnaryExpr(UnaryOp.PRE, timerId);
        Expr preT = new UnaryExpr(UnaryOp.PRE, timeExpr);
        Expr elapsed = new BinaryExpr(timeExpr, BinaryOp.MINUS, preT);
        Expr total = new BinaryExpr(preTimer, BinaryOp.PLUS, elapsed);
        Expr timerExpr = new IfThenElseExpr(preRun, total, new RealExpr(BigDecimal.ZERO));
        timerExpr = new BinaryExpr(new RealExpr(BigDecimal.ZERO), BinaryOp.ARROW, timerExpr);
        builder.addLocalEquation(new AgreeEquation(timerId, timerExpr, varReference));
    }
    // property that should be true for timer to help induction
    {
        Expr expr = new BinaryExpr(timerId, BinaryOp.GREATEREQUAL, new RealExpr(BigDecimal.ZERO));
        builder.addAssertion(new AgreeStatement(null, expr, varReference));
    }
    // record => cause and not (e and (l = 0))
    {
        Expr causeExpr;
        if (pattern.effectInterval.type == IntervalType.OPEN_LEFT || pattern.effectInterval.type == IntervalType.OPEN) {
            causeExpr = causeId;
        } else {
            Expr eAndLZero = new BinaryExpr(pattern.effectInterval.low, BinaryOp.EQUAL, new RealExpr(BigDecimal.ZERO));
            eAndLZero = new BinaryExpr(effectId, BinaryOp.AND, eAndLZero);
            Expr notEAndLZero = new UnaryExpr(UnaryOp.NOT, eAndLZero);
            causeExpr = new BinaryExpr(causeId, BinaryOp.AND, notEAndLZero);
        }
        Expr recordExpr = new BinaryExpr(recordId, BinaryOp.IMPLIES, causeExpr);
        AgreeStatement statement = new AgreeStatement(null, recordExpr, varReference);
        builder.addAssertion(statement);
    }
    // lemma to help induction
    AgreeVar timeOfCause = getTimeOf(causeId.id, builder, pattern);
    AgreeVar timeOfEffect = getTimeOf(effectId.id, builder, pattern);
    // Expr expr = expr("(timer > 0.0 => timeOfCause > 0.0) and "
    // + "(timeOfEffect < timeOfCause => timer <= time - timeOfCause) and "
    // + "(cause => timeOfCause = time) and"
    // + "(true -> ((pre (timeOfEffect - low > timeOfCause)) => timer =
    // 0.0))",
    // to("timer", timerVar),
    // to("timeOfCause", timeOfCause),
    // to("time", timeExpr),
    // to("cause", causeId),
    // to("timeOfEffect", timeOfEffect),
    // to("low", pattern.effectInterval.low));
    Expr expr = expr("(timer > 0.0 => timeOfCause >= 0.0) and " + "(timer <= time) and" + "(timeOfEffect >= timeOfCause and timer <= high and timeOfEffect >= time - timer + low => not run) and" + "(true -> (pre(timeOfEffect >= timeOfCause + low and timeOfEffect <= timeOfCause + high and timer <= high) => timer = 0.0)) and" + "(timer = 0.0 or timer >= time - timeOfCause)", to("timer", timerVar), to("timeOfCause", timeOfCause), to("timeOfEffect", timeOfEffect), to("time", timeExpr), to("low", pattern.effectInterval.low), to("high", pattern.effectInterval.high), to("run", runVar));
    builder.addPatternProp(new AgreeStatement("Timer Lemma for Pattern " + patternIndex, expr, pattern));
    // timer <= h
    BinaryOp right = getIntervalRightOp(pattern.effectInterval);
    return new BinaryExpr(timerId, right, pattern.effectInterval.high);
}

Example 13 with IfThenElseExpr

use of jkind.lustre.IfThenElseExpr in project AGREE by loonwerks.

the class AgreeRealtimeCalendarBuilder method getMinPosNode.

private static Node getMinPosNode() {
    NodeBuilder builder = new NodeBuilder(MIN_POS_NODE_NAME);
    IdExpr a = new IdExpr("a");
    IdExpr b = new IdExpr("b");
    IdExpr ret = new IdExpr("ret");
    builder.addInput(new VarDecl(a.id, NamedType.REAL));
    builder.addInput(new VarDecl(b.id, NamedType.REAL));
    builder.addOutput(new VarDecl(ret.id, NamedType.REAL));
    Expr aLessB = new BinaryExpr(a, BinaryOp.LESSEQUAL, b);
    Expr bNeg = new BinaryExpr(b, BinaryOp.LESSEQUAL, new RealExpr(BigDecimal.ZERO));
    Expr aNeg = new BinaryExpr(a, BinaryOp.LESSEQUAL, new RealExpr(BigDecimal.ZERO));
    Expr ifALessB = new IfThenElseExpr(aLessB, a, b);
    Expr ifBNeg = new IfThenElseExpr(bNeg, a, ifALessB);
    Expr ifANeg = new IfThenElseExpr(aNeg, b, ifBNeg);
    builder.addEquation(new Equation(ret, ifANeg));
    return builder.build();
}

Example 14 with IfThenElseExpr

use of jkind.lustre.IfThenElseExpr in project AGREE by loonwerks.

the class ReplaceFollowedByOperator method visit.

@Override
public Expr visit(final BinaryExpr e) {
    // Convert any usage of the followed by/arrow operator when an if then else expression involving the step variable
    if (e.op == BinaryOp.ARROW) {
        final Expr ifExpression = new BinaryExpr(new IdExpr(stepVariableId), BinaryOp.EQUAL, new IntExpr(firstStepValue));
        final Expr newExpression = new IfThenElseExpr(ifExpression, e.left.accept(this), e.right.accept(this));
        return newExpression;
    }
    return super.visit(e);
}

Example 15 with IfThenElseExpr

use of jkind.lustre.IfThenElseExpr in project AGREE by loonwerks.

the class AgreeCalendarUtils method queueNode.

public static Node queueNode(String nodeName, Type type, int queueSize) {
    List<VarDecl> inputs = new ArrayList<>();
    List<VarDecl> outputs = new ArrayList<>();
    List<VarDecl> locals = new ArrayList<>();
    List<IdExpr> els = new ArrayList<>();
    List<Equation> eqs = new ArrayList<>();
    String elBase = "el";
    IdExpr elemIn = new IdExpr("el_in");
    IdExpr elemOut = new IdExpr("el_out");
    IdExpr insert = new IdExpr("insert");
    IdExpr output = new IdExpr("output");
    IdExpr input = new IdExpr("input");
    IdExpr numEls = new IdExpr("num_els");
    inputs.add(new VarDecl(input.id, type));
    inputs.add(new VarDecl(elemIn.id, NamedType.BOOL));
    inputs.add(new VarDecl(elemOut.id, NamedType.BOOL));
    outputs.add(new VarDecl(numEls.id, NamedType.INT));
    outputs.add(new VarDecl(output.id, type));
    locals.add(new VarDecl(insert.id, NamedType.INT));
    // add an extra "dummy element" for handling too many inserts
    for (int i = 0; i < queueSize + 1; i++) {
        IdExpr el = new IdExpr(elBase + i);
        els.add(el);
        locals.add(new VarDecl(el.id, type));
    }
    // equation for insert
    Expr preElemIn = new UnaryExpr(UnaryOp.PRE, elemIn);
    Expr preElemOut = new UnaryExpr(UnaryOp.PRE, elemOut);
    Expr preInsert = new UnaryExpr(UnaryOp.PRE, insert);
    Expr preInsertMore = new BinaryExpr(preInsert, BinaryOp.PLUS, new IntExpr(BigInteger.ONE));
    Expr preInsertLess = new BinaryExpr(preInsert, BinaryOp.MINUS, new IntExpr(BigInteger.ONE));
    Expr insertIf0 = new IfThenElseExpr(preElemIn, preInsertMore, preInsert);
    Expr insertIf1 = new IfThenElseExpr(preElemOut, preInsertLess, insertIf0);
    Expr insertExpr = new BinaryExpr(new IntExpr(BigInteger.ZERO), BinaryOp.ARROW, insertIf1);
    Equation insertEq = new Equation(insert, insertExpr);
    eqs.add(insertEq);
    // equation for numEls
    Expr preNumEls = new UnaryExpr(UnaryOp.PRE, numEls);
    Expr preNumElsMore = new BinaryExpr(preNumEls, BinaryOp.PLUS, new IntExpr(BigInteger.ONE));
    Expr preNumElsLessExpr = new BinaryExpr(preNumEls, BinaryOp.MINUS, new IntExpr(BigInteger.ONE));
    Expr numElsIf0 = new IfThenElseExpr(preElemIn, preNumElsMore, preNumEls);
    Expr numElsExpr = new IfThenElseExpr(preElemOut, preNumElsLessExpr, numElsIf0);
    numElsExpr = new BinaryExpr(new IntExpr(BigInteger.ZERO), BinaryOp.ARROW, numElsExpr);
    Equation numElsEq = new Equation(numEls, numElsExpr);
    eqs.add(numElsEq);
    // equation for the output
    Equation outputEq = new Equation(output, new IdExpr(elBase + 0));
    eqs.add(outputEq);
    // equations for each queue element
    Expr preInput = new UnaryExpr(UnaryOp.PRE, input);
    for (int i = 0; i < queueSize; i++) {
        Expr preEl = new UnaryExpr(UnaryOp.PRE, els.get(i));
        Expr cond = new UnaryExpr(UnaryOp.PRE, insert);
        cond = new BinaryExpr(cond, BinaryOp.EQUAL, new IntExpr(BigInteger.valueOf(i)));
        cond = new BinaryExpr(preElemIn, BinaryOp.AND, cond);
        Expr elemIf0 = new IfThenElseExpr(cond, preInput, preEl);
        Expr elemIf1 = new IfThenElseExpr(preElemOut, els.get(i + 1), elemIf0);
        Expr elExpr = new BinaryExpr(input, BinaryOp.ARROW, elemIf1);
        Equation elEq = new Equation(els.get(i), elExpr);
        eqs.add(elEq);
    }
    // special case for the dummy element
    Equation elEq = new Equation(els.get(queueSize), input);
    eqs.add(elEq);
    // queue properties:
    List<String> props = new ArrayList<>();
    // don't remove more than are present:
    // Expr propExpr0 = new BinaryExpr(preRemove, BinaryOp.EQUAL,
    // preInsert);
    // Expr propExpr1 = new BinaryExpr(remove, BinaryOp.EQUAL, preRemove);
    // Expr propImpl = new BinaryExpr(propExpr0, BinaryOp.IMPLIES,
    // propExpr1);
    // Expr propArrow = new BinaryExpr(remove, BinaryOp.LESSEQUAL, insert);
    // propArrow = new BinaryExpr(propArrow, BinaryOp.ARROW, propImpl);
    Expr propExpr = new BinaryExpr(numEls, BinaryOp.GREATEREQUAL, new IntExpr(BigInteger.ZERO));
    IdExpr propId0 = new IdExpr("__REMOVE_LTE_INSERT_" + nodeName);
    locals.add(new VarDecl(propId0.id, NamedType.BOOL));
    Equation propEq0 = new Equation(propId0, propExpr);
    eqs.add(propEq0);
    props.add(propId0.id);
    NodeBuilder builder = new NodeBuilder(nodeName);
    builder.addInputs(inputs);
    builder.addOutputs(outputs);
    builder.addLocals(locals);
    builder.addEquations(eqs);
    builder.addProperties(props);
    return builder.build();
}