@Override
public String visit(ISymbol e) throws IVisitor.VisitorException {
// Symbols do not necessarily have sorts - e.g. if they are function names
ISort sort = typemap.get(e);
if (!isFormula && sort != null && sort.isBool()) {
throw new VisitorException(
"Use of boolean in a term position is not yet implemented in the Simplify adapter",
e.pos()); // FIXME - booleans as terms
}
// Simplify does not allow tab, newline, cr in identifiers;
// these are allowed by SMTLIB.
// Note that neither simplify nor SMTLIB allows \ or |
// All other printable characters are allowed in both.
String oldName = e.value();
String newName = fcnNames.get(oldName);
if (newName != null) {
// There is a direct translation of a pre-defined SMT-LIB name
// into a simplify equivalent - use it.
} else {
// Use the ? character as an escape
newName =
oldName.replace("?", "??").replace("\n", "?n").replace("\r", "?r").replace("\t", "?t");
if (reservedWords.contains(newName)) {
newName = newName + "?!";
}
newName = "|" + newName + "|";
}
return newName;
}
public static void main(String[] args) {
init();
// print(arrays);
ISort sort = SortFactory.createSort(SortType.QUICK);
long start = System.currentTimeMillis();
sort.sort(arrays);
long end = System.currentTimeMillis();
System.out.println("waste time: " + (end - start) + "ms");
// print(arrays);
validate(arrays);
}
@Override
public String visit(ILet e) throws IVisitor.VisitorException {
// Simplify does not have let
// We can create a new temp variable (or function of any quantified parameters)
// and then use that.
for (IBinding b : e.bindings()) {
String r = b.expr().accept(this);
ISort s = typemap.get(b.expr());
// FIXME - don't use toString - also need to map to a unique new temporary
r = (s.isBool() ? "(IFF " : "(EQ ") + b.parameter().accept(this) + " " + r + " )";
conjuncts.add(r);
}
return e.expr().accept(this);
// throw new VisitorException("Use of let is not yet implemented in the Simplify
// adapter",e.pos()); // FIXME - let in Simplify
}
public int[] sort(int[] arr) {
monitor.resetTimer();
monitor.startTimer();
int[] sort = sorting.sort(arr);
monitor.stopTimer();
return sort;
}
public static void doIntRandomSortTest(ISort<Integer> algorithm, int size) {
Integer[] arr = SampleDataForSortGenerator.generateIntArr(size);
Integer[] expected = SampleDataForSortGenerator.sortIntArray(arr);
algorithm.sort(
arr,
new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
});
assertArrayEquals(expected, arr);
}
public void sort(Comparable[] mas) {
sortAlg.sort(mas);
}
@Override
public String visit(IFcnExpr e) throws IVisitor.VisitorException {
boolean resultIsFormula = this.isFormula;
StringBuilder sb = new StringBuilder();
try {
Iterator<IExpr> iter = e.args().iterator();
if (!iter.hasNext())
throw new VisitorException("Did not expect an empty argument list", e.pos());
if (!(e.head() instanceof ISymbol)) {
throw new VisitorException(
"Have not yet implemented parameterized bit-vector functions", e.pos());
}
ISymbol fcn = (ISymbol) e.head();
String newName = fcn.accept(this);
// Determine if the arguments are formulas or terms
if (resultIsFormula) {
if (newName != null && logicNames.contains(newName)) {
// Propositional boolean item
this.isFormula = true;
} else if (e.args().size() <= 1) {
this.isFormula = false;
} else {
IExpr arg = e.args().get(1); // Use argument 1 for ite's sake
ISort sort = typemap.get(arg);
if (sort == null) {
throw new VisitorException(
"INTERNAL ERROR: Encountered an un-sorted expression node: "
+ smtConfig.defaultPrinter.toString(arg),
arg.pos());
}
if (sort.isBool()) {
// Some functions can take both bool and non-bool arguments:
// EQ NEQ DISTINCT ite
this.isFormula = resultIsFormula;
if ("EQ".equals(newName)) newName = "IFF";
} else {
// Arguments must be terms
this.isFormula = false;
}
}
} else {
this.isFormula = false;
}
ISort s = typemap.get(e);
if (s == null) {
throw new VisitorException(
"INTERNAL ERROR: Encountered an un-sorted expression node: "
+ smtConfig.defaultPrinter.toString(e),
e.pos());
}
if (s.isBool() && !resultIsFormula) {
throw new VisitorException(
"Use of boolean in a term position is not yet implemented in the Simplify adapter",
e.pos()); // FIXME - booleans as terms
}
if (isFormula && newName.equals("NEQ")) {
// for formulas, NEQ is (NOT (IFF p q ...))
// In simplify, IFF is not implicitly chainable
int length = e.args().size();
if ((length & 1) == 0) sb.append("(NOT ");
sb.append(leftassoc("IFF", length, iter));
if ((length & 1) == 0) sb.append(")");
} else if (newName.equals("IMPLIES")) {
// right-associative operators that need grouping
if (!iter.hasNext()) {
throw new VisitorException("implies (=>) operation without arguments", e.pos());
}
sb.append(rightassoc(newName, iter));
} else if (newName.equals("DISTINCT")) {
// in simplify, DISTINCT is just for term arguments but the result is a formula
if (isFormula) {
// arguments are formulas, result is formula
if (e.args().size() > 2) {
// More than two distinct boolean values?
sb.append("FALSE");
} else {
sb.append("(NOT (IFF");
while (iter.hasNext()) {
sb.append(" ");
sb.append(iter.next().accept(this));
}
sb.append(" ))");
}
} else if (resultIsFormula) {
// arguments are terms, result is formula - standard use in Simplify
sb.append("(DISTINCT");
while (iter.hasNext()) {
sb.append(" ");
sb.append(iter.next().accept(this));
}
sb.append(")");
} else {
// used in a term position
throw new VisitorException(
"Use of DISTINCT in a term position is not yet implemented in the Simplify adapter",
e.pos()); // FIXME - distinact as a term
}
} else if (ite_term.equals(newName)) {
if (isFormula) {
sb.append("(AND (IMPLIES ");
sb.append(e.args().get(0).accept(this));
sb.append(" ");
sb.append(e.args().get(1).accept(this));
sb.append(")");
sb.append("(IMPLIES (NOT ");
sb.append(e.args().get(0).accept(this));
sb.append(") ");
sb.append(e.args().get(2).accept(this));
sb.append("))");
}
}
if (e.args().size() > 2 && nonchainables.contains(newName)) {
Iterator<IExpr> iter2 = e.args().iterator();
sb.append("(AND ");
IExpr left = iter2.next();
while (iter2.hasNext()) {
IExpr right = iter2.next();
sb.append("(" + newName + " ");
sb.append(left.accept(this));
sb.append(" ");
sb.append(right.accept(this));
sb.append(")");
left = right;
}
sb.append(")");
}
if (e.args().size() > 2 && (newName.equals("-") || newName.equals("/"))) {
Iterator<IExpr> iter2 = e.args().iterator();
sb.append(leftassoc(newName, e.args().size(), iter2));
}
if (sb.length() == 0) {
sb.append("( ");
sb.append(newName);
while (iter.hasNext()) {
sb.append(" ");
sb.append(iter.next().accept(this));
}
sb.append(" )");
}
} finally {
this.isFormula = resultIsFormula;
}
return sb.toString();
}