コード例 #1
0
  private Template loopVarsAndHeadFreeCombMethod(InfixReln relation) {
    Template choice = null;
    // Get all loop head and loop tail variables.
    Set<TemplateTerm> headVars = getUnindexedVarsAsTerms(loopFormulaHead);
    Set<TemplateTerm> tailVars = getUnindexedVarsAsTerms(loopFormulaTail);

    // Declare a list of terms for each conjunct.
    List<TemplateTerm> headTerms = new Vector<>();
    List<TemplateTerm> tailTerms = new Vector<>();

    // Add the loop vars.
    headTerms.addAll(headVars);
    tailTerms.addAll(tailVars);

    // Create a fresh parameter linear combination of the terms for each conjunct.
    TemplateSum headLHS = TemplateSum.freshParamLinComb(type, headTerms);
    TemplateSum tailLHS = TemplateSum.freshParamLinComb(type, tailTerms);

    // Make RHS parameters.
    TemplateVariable param = TemplateTerm.getNextFreshParameter(type);
    TemplateTerm headRHS = new TemplateTerm(type);
    headRHS.setParameter(param);
    param = TemplateTerm.getNextFreshParameter(type);
    TemplateTerm tailRHS = new TemplateTerm(type);
    tailRHS.setParameter(param);

    // Build the conjuncts as constraints.
    TemplateFormula headFormula = new TemplateConstraint(headLHS, InfixReln.LEQ, headRHS);
    TemplateFormula tailFormula = new TemplateConstraint(tailLHS, InfixReln.EQUAL, tailRHS);

    // Form the conjunction.
    TemplateFormula formula =
        TemplateConjunction.conjoin((TemplateBoolean) headFormula, (TemplateBoolean) tailFormula);

    // Make nonzero parameter clause.
    // Namely, we simply ask that not all of the top-level parameters on
    // the LHS be zero.
    Set<TemplateVariable> topLevelLHSparams = headLHS.getTopLevelParameters();
    topLevelLHSparams.addAll(tailLHS.getTopLevelParameters());
    TemplateFormula nzpc = makeBasicParamClause(topLevelLHSparams);

    choice = new Template(formula, nzpc);
    return choice;
  }
コード例 #2
0
  private Template loopVarsFreeCombMethod(InfixReln relation) {
    Template choice = null;
    // Get all loop variables.
    Set<TemplateTerm> loopVars = getUnindexedVarsAsTerms(loopFormula);

    // Get all distinct UIF names occurring at the top level in the loop formula,
    // and their arities.
    Map<String, Integer> uifNA = getTopLevelUIFnamesAndArities(loopFormula);

    // Declare the list of terms for the template.
    List<TemplateTerm> templateTerms = new Vector<>();

    // First add one term for each UIF name.
    int arity;
    TemplateUIF uif;
    for (String name : uifNA.keySet()) {
      arity = uifNA.get(name).intValue();
      TemplateSum[] args = new TemplateSum[arity];
      // each arg is a fresh parameter linear combination over loopVars
      for (int i = 0; i < arity; i++) {
        args[i] = TemplateSum.freshParamLinComb(type, loopVars);
      }
      // create the uif
      uif = new TemplateUIF(name, type, new TemplateSumList(args));
      // put it in a term
      templateTerms.add(new TemplateTerm(uif));
    }

    // Now add the loop vars themselves.
    templateTerms.addAll(loopVars);

    // Finally create a fresh parameter linear combination of all the terms.
    TemplateSum LHS = TemplateSum.freshParamLinComb(type, templateTerms);

    // Make RHS parameter.
    TemplateVariable param = TemplateTerm.getNextFreshParameter(type);
    TemplateTerm RHS = new TemplateTerm(type);
    RHS.setParameter(param);

    // Build template formula as constraint.
    TemplateFormula formula = new TemplateConstraint(LHS, relation, RHS);

    // Make nonzero parameter clause.
    // Namely, we simply ask that not all of the top-level parameters on
    // the LHS be zero.
    Set<TemplateVariable> topLevelLHSparams = LHS.getTopLevelParameters();
    TemplateFormula nzpc = makeBasicParamClause(topLevelLHSparams);

    choice = new Template(formula, nzpc);
    return choice;
  }
コード例 #3
0
 private TemplateTerm makeRHSParameter() {
   TemplateVariable param = TemplateTerm.getNextFreshParameter(type);
   TemplateTerm RHS = new TemplateTerm(type);
   RHS.setParameter(param);
   return RHS;
 }