Java ConstantTerm類代碼示例

import ap.terfor.ConstantTerm; //導入依賴的package包/類
public ProverExpr[] freeVariables(ProverExpr expr) {
  final ArrayList<ProverExpr> res = new ArrayList<ProverExpr> ();
  
  final scala.Tuple3<scala.collection.Set<IVariable>,
                      scala.collection.Set<ConstantTerm>,
                      scala.collection.Set<Predicate>> symTriple;
  if (expr instanceof TermExpr)
    symTriple = SymbolCollector$.MODULE$.varsConstsPreds(((TermExpr)expr).term);
  else
    symTriple = SymbolCollector$.MODULE$.varsConstsPreds(((FormulaExpr)expr).formula);
  
  final Iterator<IVariable> it1 = symTriple._1().iterator();
  while (it1.hasNext())
    res.add(new TermExpr(it1.next(), getIntType()));
  
  final Iterator<ConstantTerm> it2 = symTriple._2().iterator();
  while (it2.hasNext())
    res.add(new TermExpr(IConstant$.MODULE$.apply(it2.next()), getIntType()));
  
  final Iterator<Predicate> it3 = symTriple._3().iterator();
  final List<ITerm> emptyArgs = (new ArrayBuffer<ITerm>()).toList();
  while (it3.hasNext())
    res.add(new FormulaExpr(IAtom$.MODULE$.apply(it3.next(), emptyArgs)));
  
  return res.toArray(new ProverExpr[0]);
}
 

import ap.terfor.ConstantTerm; //導入依賴的package包/類
/**
 * Simultaneously substitute <code>from</code> with <code>to</code>
 * in <code>target</code>. <code>from</code> has to be an array of
 * free or bound variables.
 */
public ProverExpr substitute(ProverExpr target,
                              ProverExpr[] from, ProverExpr[] to) {
  assert(from.length == to.length);
  
     final scala.collection.mutable.HashMap<ConstantTerm, ITerm> constantSubst =
         new scala.collection.mutable.HashMap<ConstantTerm, ITerm>();
     final scala.collection.mutable.HashMap<Predicate, IFormula> predicateSubst =
         new scala.collection.mutable.HashMap<Predicate, IFormula>();

     for (int i = 0; i < from.length; ++i) {
       if (from[i] instanceof TermExpr) {
         final ConstantTerm c = ((IConstant)((TermExpr)from[i]).term).c();
         final ITerm t = ((TermExpr)to[i]).term;
         constantSubst.put(c, t);
       } else {
         final Predicate p = ((IAtom)((FormulaExpr)from[i]).formula).pred();
         assert(p.arity() == 0);
         final IFormula f = ((FormulaExpr)to[i]).formula;
         predicateSubst.put(p, f);
       }
     }
     
     // We currently just assume that there are no clashes between substituted
     // terms and predicates/formulae, and that the substitutions can be
     // carried out in sequence
     
     if (target instanceof TermExpr) {
       final ITerm t1 = ((TermExpr)target).term;
       final ITerm t2 = ConstantSubstVisitor$.MODULE$.apply(t1, constantSubst);
       final ITerm t3 = PredicateSubstVisitor$.MODULE$.apply(t2, predicateSubst);
       return new TermExpr(t3, target.getType());
     } else {
       final IFormula f1 = ((FormulaExpr)target).formula;
       final IFormula f2 = ConstantSubstVisitor$.MODULE$.apply(f1, constantSubst);
       final IFormula f3 = PredicateSubstVisitor$.MODULE$.apply(f2, predicateSubst);
       return new FormulaExpr(f3);
     }
}
 

import ap.terfor.ConstantTerm; //導入依賴的package包/類
public List<? extends IExpression> parseStringToTerms(String s, PrincessFormulaCreator creator) {

    Tuple3<
            Seq<IFormula>, scala.collection.immutable.Map<IFunction, SMTFunctionType>,
            scala.collection.immutable.Map<ConstantTerm, SMTType>>
        triple = api.extractSMTLIBAssertionsSymbols(new StringReader(s));

    List<? extends IExpression> formula = seqAsJavaList(triple._1());
    Map<IFunction, SMTFunctionType> functionTypes = mapAsJavaMap(triple._2());
    Map<ConstantTerm, SMTType> constantTypes = mapAsJavaMap(triple._3());

    ImmutableSet.Builder<IExpression> declaredFunctions = ImmutableSet.builder();
    for (IExpression f : formula) {
      declaredFunctions.addAll(creator.extractVariablesAndUFs(f, true).values());
    }
    for (IExpression var : declaredFunctions.build()) {
      if (var instanceof IConstant) {
        SMTType type = constantTypes.get(((IConstant) var).c());
        if (type instanceof SMTParser2InputAbsy.SMTArray) {
          arrayVariablesCache.put(var.toString(), (ITerm) var);
        } else {
          intVariablesCache.put(var.toString(), (ITerm) var);
        }
        addSymbol((IConstant) var);
      } else if (var instanceof IAtom) {
        boolVariablesCache.put(((IAtom) var).pred().name(), (IFormula) var);
        addSymbol((IAtom) var);
      } else if (var instanceof IFunApp) {
        IFunction fun = ((IFunApp) var).fun();
        functionsCache.put(fun.name(), fun);
        functionsReturnTypes.put(fun, convertToTermType(functionTypes.get(fun)));
        addFunction(fun);
      }
    }
    return formula;
  }
 

import ap.terfor.ConstantTerm; //導入依賴的package包/類
private List<ConstantTerm> toConstantTerm(List<IExpression> lst) {
  List<ConstantTerm> retVal = new ArrayList<>(lst.size());
  for (IExpression f : lst) {
    retVal.add(((IConstant) f).c());
  }
  return retVal;
}