18package com.microsoft.z3;
20import static com.microsoft.z3.Constructor.of;
22import com.microsoft.z3.enumerations.Z3_ast_print_mode;
35@SuppressWarnings(
"unchecked")
38 static final Object creation_lock =
new Object();
41 synchronized (creation_lock) {
42 m_ctx = Native.mkContextRc(0);
48 synchronized (creation_lock) {
72 public Context(Map<String, String> settings) {
73 synchronized (creation_lock) {
74 long cfg = Native.mkConfig();
76 Native.setParamValue(cfg, kv.getKey(), kv.getValue());
78 m_ctx = Native.mkContextRc(cfg);
79 Native.delConfig(cfg);
86 Native.setInternalErrorHandler(m_ctx);
115 for (
int i = 0; i < names.length; ++i)
116 result[i] = mkSymbol(names[i]);
121 private IntSort m_intSort =
null;
123 private SeqSort<CharSort> m_stringSort =
null;
130 if (m_boolSort ==
null) {
141 if (m_intSort ==
null) {
152 if (m_realSort ==
null) {
180 if (m_stringSort ==
null) {
181 m_stringSort = mkStringSort();
191 checkContextMatch(s);
200 return mkUninterpretedSort(mkSymbol(str));
224 return new BitVecSort(
this, Native.mkBvSort(nCtx(), size));
232 checkContextMatch(domain);
233 checkContextMatch(
range);
241 public <R extends Sort> ArraySort<Sort, R> mkArraySort(Sort[] domains, R
range)
243 checkContextMatch(domains);
244 checkContextMatch(
range);
245 return new ArraySort<>(
this, domains,
range);
253 return new SeqSort<>(
this, Native.mkStringSort(nCtx()));
259 public <R extends Sort>
SeqSort<R> mkSeqSort(R s)
261 return new SeqSort<>(
this, Native.mkSeqSort(nCtx(), s.getNativeObject()));
267 public <R extends Sort> ReSort<R> mkReSort(R s)
269 return new ReSort<>(
this, Native.mkReSort(nCtx(), s.getNativeObject()));
279 checkContextMatch(name);
280 checkContextMatch(fieldNames);
281 checkContextMatch(fieldSorts);
282 return new TupleSort(
this, name, fieldNames.length, fieldNames,
292 checkContextMatch(name);
293 checkContextMatch(enumNames);
300 public <R> EnumSort<R> mkEnumSort(
String name,
String... enumNames)
303 return new EnumSort<>(
this, mkSymbol(name), mkSymbols(enumNames));
309 public <R extends Sort> ListSort<R> mkListSort(Symbol name, R elemSort)
311 checkContextMatch(name);
312 checkContextMatch(elemSort);
313 return new ListSort<>(
this, name, elemSort);
319 public <R extends Sort> ListSort<R> mkListSort(
String name, R elemSort)
321 checkContextMatch(elemSort);
322 return new ListSort<>(
this, mkSymbol(name), elemSort);
328 public <R> FiniteDomainSort<R> mkFiniteDomainSort(Symbol name,
long size)
331 checkContextMatch(name);
332 return new FiniteDomainSort<>(
this, name, size);
338 public <R> FiniteDomainSort<R> mkFiniteDomainSort(
String name,
long size)
341 return new FiniteDomainSort<>(
this, mkSymbol(name), size);
355 public <R> Constructor<R> mkConstructor(Symbol name, Symbol recognizer,
356 Symbol[] fieldNames, Sort[] sorts,
int[] sortRefs)
359 return of(
this, name, recognizer, fieldNames, sorts, sortRefs);
365 public <R> Constructor<R> mkConstructor(
String name,
String recognizer,
366 String[] fieldNames, Sort[] sorts,
int[] sortRefs)
368 return of(
this, mkSymbol(name), mkSymbol(recognizer), mkSymbols(fieldNames), sorts, sortRefs);
374 public <R> DatatypeSort<R> mkDatatypeSort(Symbol name, Constructor<R>[] constructors)
376 checkContextMatch(name);
377 checkContextMatch(constructors);
378 return new DatatypeSort<>(
this, name, constructors);
384 public <R> DatatypeSort<R> mkDatatypeSort(
String name, Constructor<R>[] constructors)
387 checkContextMatch(constructors);
388 return new DatatypeSort<>(
this, mkSymbol(name), constructors);
398 checkContextMatch(names);
399 int n = names.length;
401 long[] n_constr =
new long[n];
402 for (
int i = 0; i < n; i++)
406 checkContextMatch(constructor);
408 n_constr[i] = cla[i].getNativeObject();
410 long[] n_res =
new long[n];
414 for (
int i = 0; i < n; i++)
425 return mkDatatypeSorts(mkSymbols(names), c);
438 Native.datatypeUpdateField
439 (nCtx(), field.getNativeObject(),
440 t.getNativeObject(), v.getNativeObject()));
447 public <R extends Sort> FuncDecl<R> mkFuncDecl(Symbol name, Sort[] domain, R
range)
449 checkContextMatch(name);
450 checkContextMatch(domain);
451 checkContextMatch(
range);
452 return new FuncDecl<>(
this, name, domain,
range);
458 public <R extends Sort> FuncDecl<R> mkFuncDecl(Symbol name, Sort domain, R
range)
461 checkContextMatch(name);
462 checkContextMatch(domain);
463 checkContextMatch(
range);
464 Sort[] q =
new Sort[] { domain };
465 return new FuncDecl<>(
this, name, q,
range);
471 public <R extends Sort> FuncDecl<R> mkFuncDecl(
String name, Sort[] domain, R
range)
474 checkContextMatch(domain);
475 checkContextMatch(
range);
476 return new FuncDecl<>(
this, mkSymbol(name), domain,
range);
482 public <R extends Sort> FuncDecl<R> mkFuncDecl(
String name, Sort domain, R
range)
485 checkContextMatch(domain);
486 checkContextMatch(
range);
487 Sort[] q =
new Sort[] { domain };
488 return new FuncDecl<>(
this, mkSymbol(name), q,
range);
494 public <R extends Sort> FuncDecl<R> mkRecFuncDecl(Symbol name, Sort[] domain, R
range)
496 checkContextMatch(name);
497 checkContextMatch(domain);
498 checkContextMatch(
range);
499 return new FuncDecl<>(
this, name, domain,
range,
true);
509 public <R extends Sort>
void AddRecDef(FuncDecl<R> f, Expr<?>[] args, Expr<R> body)
511 checkContextMatch(f);
512 checkContextMatch(args);
513 checkContextMatch(body);
514 long[] argsNative = AST.arrayToNative(args);
515 Native.addRecDef(nCtx(), f.getNativeObject(), args.length, argsNative, body.getNativeObject());
524 public <R extends Sort> FuncDecl<R> mkFreshFuncDecl(
String prefix, Sort[] domain, R
range)
527 checkContextMatch(domain);
528 checkContextMatch(
range);
529 return new FuncDecl<>(
this, prefix, domain,
range);
535 public <R extends Sort> FuncDecl<R> mkConstDecl(Symbol name, R
range)
537 checkContextMatch(name);
538 checkContextMatch(
range);
539 return new FuncDecl<>(
this, name,
null,
range);
545 public <R extends Sort> FuncDecl<R> mkConstDecl(
String name, R
range)
547 checkContextMatch(
range);
548 return new FuncDecl<>(
this, mkSymbol(name),
null,
range);
557 public <R extends Sort> FuncDecl<R> mkFreshConstDecl(
String prefix, R
range)
560 checkContextMatch(
range);
561 return new FuncDecl<>(
this, prefix,
null,
range);
569 public <R extends Sort> Expr<R> mkBound(
int index, R ty)
571 return (Expr<R>) Expr.create(
this,
572 Native.mkBound(nCtx(), index, ty.getNativeObject()));
581 if (terms.length == 0)
582 throw new Z3Exception(
"Cannot create a pattern from zero terms");
585 return new Pattern(
this, Native.mkPattern(nCtx(), terms.length,
595 checkContextMatch(name);
596 checkContextMatch(
range);
600 Native.mkConst(nCtx(), name.getNativeObject(),
601 range.getNativeObject()));
608 public <R extends Sort> Expr<R> mkConst(
String name, R
range)
610 return mkConst(mkSymbol(name),
range);
617 public <R extends Sort> Expr<R> mkFreshConst(
String prefix, R
range)
619 checkContextMatch(
range);
620 return (Expr<R>) Expr.create(
this,
621 Native.mkFreshConst(nCtx(), prefix,
range.getNativeObject()));
628 public <R extends Sort> Expr<R> mkConst(FuncDecl<R> f)
630 return mkApp(f, (Expr<?>[])
null);
638 return (
BoolExpr) mkConst(name, getBoolSort());
646 return (
BoolExpr) mkConst(mkSymbol(name), getBoolSort());
654 return (
IntExpr) mkConst(name, getIntSort());
662 return (
IntExpr) mkConst(name, getIntSort());
670 return (
RealExpr) mkConst(name, getRealSort());
678 return (
RealExpr) mkConst(name, getRealSort());
686 return (
BitVecExpr) mkConst(name, mkBitVecSort(size));
694 return (
BitVecExpr) mkConst(name, mkBitVecSort(size));
703 checkContextMatch(f);
704 checkContextMatch(args);
705 return Expr.create(
this, f, args);
713 return new BoolExpr(
this, Native.mkTrue(nCtx()));
721 return new BoolExpr(
this, Native.mkFalse(nCtx()));
729 return value ? mkTrue() : mkFalse();
737 checkContextMatch(x);
738 checkContextMatch(y);
739 return new BoolExpr(
this, Native.mkEq(nCtx(), x.getNativeObject(),
740 y.getNativeObject()));
749 checkContextMatch(args);
750 return new BoolExpr(
this, Native.mkDistinct(nCtx(), args.length,
759 checkContextMatch(a);
760 return new BoolExpr(
this, Native.mkNot(nCtx(), a.getNativeObject()));
772 checkContextMatch(t1);
773 checkContextMatch(t2);
774 checkContextMatch(t3);
775 return (
Expr<R>)
Expr.create(
this, Native.mkIte(nCtx(), t1.getNativeObject(),
776 t2.getNativeObject(), t3.getNativeObject()));
784 checkContextMatch(t1);
785 checkContextMatch(t2);
786 return new BoolExpr(
this, Native.mkIff(nCtx(), t1.getNativeObject(),
787 t2.getNativeObject()));
795 checkContextMatch(t1);
796 checkContextMatch(t2);
797 return new BoolExpr(
this, Native.mkImplies(nCtx(),
798 t1.getNativeObject(), t2.getNativeObject()));
806 checkContextMatch(t1);
807 checkContextMatch(t2);
808 return new BoolExpr(
this, Native.mkXor(nCtx(), t1.getNativeObject(),
809 t2.getNativeObject()));
818 checkContextMatch(t);
819 return new BoolExpr(
this, Native.mkAnd(nCtx(), t.length,
829 checkContextMatch(t);
830 return new BoolExpr(
this, Native.mkOr(nCtx(), t.length,
840 checkContextMatch(t);
851 checkContextMatch(t);
862 checkContextMatch(t);
872 checkContextMatch(t);
874 Native.mkUnaryMinus(nCtx(), t.getNativeObject()));
880 public <R extends ArithSort> ArithExpr<R> mkDiv(Expr<? extends R> t1, Expr<? extends R> t2)
882 checkContextMatch(t1);
883 checkContextMatch(t2);
884 return (ArithExpr<R>) Expr.create(
this, Native.mkDiv(nCtx(),
885 t1.getNativeObject(), t2.getNativeObject()));
895 checkContextMatch(t1);
896 checkContextMatch(t2);
897 return new IntExpr(
this, Native.mkMod(nCtx(), t1.getNativeObject(),
898 t2.getNativeObject()));
908 checkContextMatch(t1);
909 checkContextMatch(t2);
910 return new IntExpr(
this, Native.mkRem(nCtx(), t1.getNativeObject(),
911 t2.getNativeObject()));
920 checkContextMatch(t1);
921 checkContextMatch(t2);
924 Native.mkPower(nCtx(), t1.getNativeObject(),
925 t2.getNativeObject()));
933 checkContextMatch(t1);
934 checkContextMatch(t2);
935 return new BoolExpr(
this, Native.mkLt(nCtx(), t1.getNativeObject(),
936 t2.getNativeObject()));
944 checkContextMatch(t1);
945 checkContextMatch(t2);
946 return new BoolExpr(
this, Native.mkLe(nCtx(), t1.getNativeObject(),
947 t2.getNativeObject()));
955 checkContextMatch(t1);
956 checkContextMatch(t2);
957 return new BoolExpr(
this, Native.mkGt(nCtx(), t1.getNativeObject(),
958 t2.getNativeObject()));
966 checkContextMatch(t1);
967 checkContextMatch(t2);
968 return new BoolExpr(
this, Native.mkGe(nCtx(), t1.getNativeObject(),
969 t2.getNativeObject()));
984 checkContextMatch(t);
986 Native.mkInt2real(nCtx(), t.getNativeObject()));
997 checkContextMatch(t);
998 return new IntExpr(
this, Native.mkReal2int(nCtx(), t.getNativeObject()));
1006 checkContextMatch(t);
1007 return new BoolExpr(
this, Native.mkIsInt(nCtx(), t.getNativeObject()));
1017 checkContextMatch(t);
1018 return new BitVecExpr(
this, Native.mkBvnot(nCtx(), t.getNativeObject()));
1028 checkContextMatch(t);
1029 return new BitVecExpr(
this, Native.mkBvredand(nCtx(),
1030 t.getNativeObject()));
1040 checkContextMatch(t);
1041 return new BitVecExpr(
this, Native.mkBvredor(nCtx(),
1042 t.getNativeObject()));
1052 checkContextMatch(t1);
1053 checkContextMatch(t2);
1054 return new BitVecExpr(
this, Native.mkBvand(nCtx(),
1055 t1.getNativeObject(), t2.getNativeObject()));
1065 checkContextMatch(t1);
1066 checkContextMatch(t2);
1067 return new BitVecExpr(
this, Native.mkBvor(nCtx(), t1.getNativeObject(),
1068 t2.getNativeObject()));
1078 checkContextMatch(t1);
1079 checkContextMatch(t2);
1080 return new BitVecExpr(
this, Native.mkBvxor(nCtx(),
1081 t1.getNativeObject(), t2.getNativeObject()));
1091 checkContextMatch(t1);
1092 checkContextMatch(t2);
1093 return new BitVecExpr(
this, Native.mkBvnand(nCtx(),
1094 t1.getNativeObject(), t2.getNativeObject()));
1104 checkContextMatch(t1);
1105 checkContextMatch(t2);
1106 return new BitVecExpr(
this, Native.mkBvnor(nCtx(),
1107 t1.getNativeObject(), t2.getNativeObject()));
1117 checkContextMatch(t1);
1118 checkContextMatch(t2);
1119 return new BitVecExpr(
this, Native.mkBvxnor(nCtx(),
1120 t1.getNativeObject(), t2.getNativeObject()));
1130 checkContextMatch(t);
1131 return new BitVecExpr(
this, Native.mkBvneg(nCtx(), t.getNativeObject()));
1141 checkContextMatch(t1);
1142 checkContextMatch(t2);
1143 return new BitVecExpr(
this, Native.mkBvadd(nCtx(),
1144 t1.getNativeObject(), t2.getNativeObject()));
1154 checkContextMatch(t1);
1155 checkContextMatch(t2);
1156 return new BitVecExpr(
this, Native.mkBvsub(nCtx(),
1157 t1.getNativeObject(), t2.getNativeObject()));
1167 checkContextMatch(t1);
1168 checkContextMatch(t2);
1169 return new BitVecExpr(
this, Native.mkBvmul(nCtx(),
1170 t1.getNativeObject(), t2.getNativeObject()));
1182 checkContextMatch(t1);
1183 checkContextMatch(t2);
1184 return new BitVecExpr(
this, Native.mkBvudiv(nCtx(),
1185 t1.getNativeObject(), t2.getNativeObject()));
1203 checkContextMatch(t1);
1204 checkContextMatch(t2);
1205 return new BitVecExpr(
this, Native.mkBvsdiv(nCtx(),
1206 t1.getNativeObject(), t2.getNativeObject()));
1218 checkContextMatch(t1);
1219 checkContextMatch(t2);
1220 return new BitVecExpr(
this, Native.mkBvurem(nCtx(),
1221 t1.getNativeObject(), t2.getNativeObject()));
1236 checkContextMatch(t1);
1237 checkContextMatch(t2);
1238 return new BitVecExpr(
this, Native.mkBvsrem(nCtx(),
1239 t1.getNativeObject(), t2.getNativeObject()));
1250 checkContextMatch(t1);
1251 checkContextMatch(t2);
1252 return new BitVecExpr(
this, Native.mkBvsmod(nCtx(),
1253 t1.getNativeObject(), t2.getNativeObject()));
1263 checkContextMatch(t1);
1264 checkContextMatch(t2);
1265 return new BoolExpr(
this, Native.mkBvult(nCtx(), t1.getNativeObject(),
1266 t2.getNativeObject()));
1276 checkContextMatch(t1);
1277 checkContextMatch(t2);
1278 return new BoolExpr(
this, Native.mkBvslt(nCtx(), t1.getNativeObject(),
1279 t2.getNativeObject()));
1289 checkContextMatch(t1);
1290 checkContextMatch(t2);
1291 return new BoolExpr(
this, Native.mkBvule(nCtx(), t1.getNativeObject(),
1292 t2.getNativeObject()));
1302 checkContextMatch(t1);
1303 checkContextMatch(t2);
1304 return new BoolExpr(
this, Native.mkBvsle(nCtx(), t1.getNativeObject(),
1305 t2.getNativeObject()));
1315 checkContextMatch(t1);
1316 checkContextMatch(t2);
1317 return new BoolExpr(
this, Native.mkBvuge(nCtx(), t1.getNativeObject(),
1318 t2.getNativeObject()));
1328 checkContextMatch(t1);
1329 checkContextMatch(t2);
1330 return new BoolExpr(
this, Native.mkBvsge(nCtx(), t1.getNativeObject(),
1331 t2.getNativeObject()));
1341 checkContextMatch(t1);
1342 checkContextMatch(t2);
1343 return new BoolExpr(
this, Native.mkBvugt(nCtx(), t1.getNativeObject(),
1344 t2.getNativeObject()));
1354 checkContextMatch(t1);
1355 checkContextMatch(t2);
1356 return new BoolExpr(
this, Native.mkBvsgt(nCtx(), t1.getNativeObject(),
1357 t2.getNativeObject()));
1372 checkContextMatch(t1);
1373 checkContextMatch(t2);
1374 return new BitVecExpr(
this, Native.mkConcat(nCtx(),
1375 t1.getNativeObject(), t2.getNativeObject()));
1389 checkContextMatch(t);
1390 return new BitVecExpr(
this, Native.mkExtract(nCtx(), high, low,
1391 t.getNativeObject()));
1403 checkContextMatch(t);
1404 return new BitVecExpr(
this, Native.mkSignExt(nCtx(), i,
1405 t.getNativeObject()));
1417 checkContextMatch(t);
1418 return new BitVecExpr(
this, Native.mkZeroExt(nCtx(), i,
1419 t.getNativeObject()));
1429 checkContextMatch(t);
1430 return new BitVecExpr(
this, Native.mkRepeat(nCtx(), i,
1431 t.getNativeObject()));
1447 checkContextMatch(t1);
1448 checkContextMatch(t2);
1449 return new BitVecExpr(
this, Native.mkBvshl(nCtx(),
1450 t1.getNativeObject(), t2.getNativeObject()));
1466 checkContextMatch(t1);
1467 checkContextMatch(t2);
1468 return new BitVecExpr(
this, Native.mkBvlshr(nCtx(),
1469 t1.getNativeObject(), t2.getNativeObject()));
1486 checkContextMatch(t1);
1487 checkContextMatch(t2);
1488 return new BitVecExpr(
this, Native.mkBvashr(nCtx(),
1489 t1.getNativeObject(), t2.getNativeObject()));
1499 checkContextMatch(t);
1500 return new BitVecExpr(
this, Native.mkRotateLeft(nCtx(), i,
1501 t.getNativeObject()));
1511 checkContextMatch(t);
1512 return new BitVecExpr(
this, Native.mkRotateRight(nCtx(), i,
1513 t.getNativeObject()));
1525 checkContextMatch(t1);
1526 checkContextMatch(t2);
1527 return new BitVecExpr(
this, Native.mkExtRotateLeft(nCtx(),
1528 t1.getNativeObject(), t2.getNativeObject()));
1540 checkContextMatch(t1);
1541 checkContextMatch(t2);
1542 return new BitVecExpr(
this, Native.mkExtRotateRight(nCtx(),
1543 t1.getNativeObject(), t2.getNativeObject()));
1557 checkContextMatch(t);
1558 return new BitVecExpr(
this, Native.mkInt2bv(nCtx(), n,
1559 t.getNativeObject()));
1578 checkContextMatch(t);
1579 return new IntExpr(
this, Native.mkBv2int(nCtx(), t.getNativeObject(),
1591 checkContextMatch(t1);
1592 checkContextMatch(t2);
1593 return new BoolExpr(
this, Native.mkBvaddNoOverflow(nCtx(), t1
1594 .getNativeObject(), t2.getNativeObject(), (isSigned)));
1605 checkContextMatch(t1);
1606 checkContextMatch(t2);
1607 return new BoolExpr(
this, Native.mkBvaddNoUnderflow(nCtx(),
1608 t1.getNativeObject(), t2.getNativeObject()));
1619 checkContextMatch(t1);
1620 checkContextMatch(t2);
1621 return new BoolExpr(
this, Native.mkBvsubNoOverflow(nCtx(),
1622 t1.getNativeObject(), t2.getNativeObject()));
1633 checkContextMatch(t1);
1634 checkContextMatch(t2);
1635 return new BoolExpr(
this, Native.mkBvsubNoUnderflow(nCtx(), t1
1636 .getNativeObject(), t2.getNativeObject(), (isSigned)));
1647 checkContextMatch(t1);
1648 checkContextMatch(t2);
1649 return new BoolExpr(
this, Native.mkBvsdivNoOverflow(nCtx(),
1650 t1.getNativeObject(), t2.getNativeObject()));
1660 checkContextMatch(t);
1661 return new BoolExpr(
this, Native.mkBvnegNoOverflow(nCtx(),
1662 t.getNativeObject()));
1673 checkContextMatch(t1);
1674 checkContextMatch(t2);
1675 return new BoolExpr(
this, Native.mkBvmulNoOverflow(nCtx(), t1
1676 .getNativeObject(), t2.getNativeObject(), (isSigned)));
1687 checkContextMatch(t1);
1688 checkContextMatch(t2);
1689 return new BoolExpr(
this, Native.mkBvmulNoUnderflow(nCtx(),
1690 t1.getNativeObject(), t2.getNativeObject()));
1705 public <D extends Sort, R extends Sort> ArrayExpr<D, R> mkArrayConst(
String name, D domain, R
range)
1708 return (ArrayExpr<D, R>) mkConst(mkSymbol(name), mkArraySort(domain,
range));
1723 public <D extends Sort, R extends Sort> Expr<R> mkSelect(Expr<ArraySort<D, R>> a, Expr<D> i)
1725 checkContextMatch(a);
1726 checkContextMatch(i);
1727 return (Expr<R>) Expr.create(
1729 Native.mkSelect(nCtx(), a.getNativeObject(),
1730 i.getNativeObject()));
1745 public <R extends Sort> Expr<R> mkSelect(Expr<ArraySort<Sort, R>> a, Expr<?>[] args)
1747 checkContextMatch(a);
1748 checkContextMatch(args);
1749 return (Expr<R>) Expr.create(
1751 Native.mkSelectN(nCtx(), a.getNativeObject(), args.length, AST.arrayToNative(args)));
1770 public <D extends Sort, R extends Sort> ArrayExpr<D, R> mkStore(Expr<ArraySort<D, R>> a, Expr<D> i, Expr<R> v)
1772 checkContextMatch(a);
1773 checkContextMatch(i);
1774 checkContextMatch(v);
1775 return new ArrayExpr<>(
this, Native.mkStore(nCtx(), a.getNativeObject(),
1776 i.getNativeObject(), v.getNativeObject()));
1795 public <R extends Sort> ArrayExpr<Sort, R> mkStore(Expr<ArraySort<Sort, R>> a, Expr<?>[] args, Expr<R> v)
1797 checkContextMatch(a);
1798 checkContextMatch(args);
1799 checkContextMatch(v);
1800 return new ArrayExpr<>(
this, Native.mkStoreN(nCtx(), a.getNativeObject(),
1801 args.length, AST.arrayToNative(args), v.getNativeObject()));
1813 public <D extends Sort, R extends Sort> ArrayExpr<D, R> mkConstArray(D domain, Expr<R> v)
1815 checkContextMatch(domain);
1816 checkContextMatch(v);
1817 return new ArrayExpr<>(
this, Native.mkConstArray(nCtx(),
1818 domain.getNativeObject(), v.getNativeObject()));
1837 checkContextMatch(f);
1838 checkContextMatch(args);
1852 checkContextMatch(array);
1854 Native.mkArrayDefault(nCtx(), array.getNativeObject()));
1860 public <D extends Sort, R extends Sort> Expr<D> mkArrayExt(Expr<ArraySort<D, R>> arg1, Expr<ArraySort<D, R>> arg2)
1862 checkContextMatch(arg1);
1863 checkContextMatch(arg2);
1864 return (Expr<D>) Expr.create(
this, Native.mkArrayExt(nCtx(), arg1.getNativeObject(), arg2.getNativeObject()));
1871 public <D extends Sort> SetSort<D> mkSetSort(D ty)
1873 checkContextMatch(ty);
1874 return new SetSort<>(
this, ty);
1880 public <D extends Sort> ArrayExpr<D, BoolSort> mkEmptySet(D domain)
1882 checkContextMatch(domain);
1883 return (ArrayExpr<D, BoolSort>) Expr.create(
this,
1884 Native.mkEmptySet(nCtx(), domain.getNativeObject()));
1890 public <D extends Sort> ArrayExpr<D, BoolSort> mkFullSet(D domain)
1892 checkContextMatch(domain);
1893 return (ArrayExpr<D, BoolSort>) Expr.create(
this,
1894 Native.mkFullSet(nCtx(), domain.getNativeObject()));
1900 public <D extends Sort> ArrayExpr<D, BoolSort> mkSetAdd(Expr<ArraySort<D, BoolSort>>
set, Expr<D> element)
1902 checkContextMatch(
set);
1903 checkContextMatch(element);
1904 return (ArrayExpr<D, BoolSort>) Expr.create(
this,
1905 Native.mkSetAdd(nCtx(),
set.getNativeObject(),
1906 element.getNativeObject()));
1912 public <D extends Sort> ArrayExpr<D, BoolSort> mkSetDel(Expr<ArraySort<D, BoolSort>>
set, Expr<D> element)
1914 checkContextMatch(
set);
1915 checkContextMatch(element);
1916 return (ArrayExpr<D, BoolSort>)Expr.create(
this,
1917 Native.mkSetDel(nCtx(),
set.getNativeObject(),
1918 element.getNativeObject()));
1927 checkContextMatch(args);
1929 Native.mkSetUnion(nCtx(), args.length,
1939 checkContextMatch(args);
1941 Native.mkSetIntersect(nCtx(), args.length,
1950 checkContextMatch(arg1);
1951 checkContextMatch(arg2);
1953 Native.mkSetDifference(nCtx(), arg1.getNativeObject(),
1954 arg2.getNativeObject()));
1960 public <D extends Sort> ArrayExpr<D, BoolSort> mkSetComplement(Expr<ArraySort<D, BoolSort>> arg)
1962 checkContextMatch(arg);
1963 return (ArrayExpr<D, BoolSort>)Expr.create(
this,
1964 Native.mkSetComplement(nCtx(), arg.getNativeObject()));
1970 public <D extends Sort> BoolExpr mkSetMembership(Expr<D> elem, Expr<ArraySort<D, BoolSort>>
set)
1972 checkContextMatch(elem);
1973 checkContextMatch(
set);
1974 return (BoolExpr) Expr.create(
this,
1975 Native.mkSetMember(nCtx(), elem.getNativeObject(),
1976 set.getNativeObject()));
1982 public <D extends Sort> BoolExpr mkSetSubset(Expr<ArraySort<D, BoolSort>> arg1, Expr<ArraySort<D, BoolSort>> arg2)
1984 checkContextMatch(arg1);
1985 checkContextMatch(arg2);
1986 return (BoolExpr) Expr.create(
this,
1987 Native.mkSetSubset(nCtx(), arg1.getNativeObject(),
1988 arg2.getNativeObject()));
1999 public <R extends Sort> SeqExpr<R> mkEmptySeq(R s)
2001 checkContextMatch(s);
2002 return (SeqExpr<R>) Expr.create(
this, Native.mkSeqEmpty(nCtx(), s.getNativeObject()));
2008 public <R extends Sort> SeqExpr<R> mkUnit(Expr<R> elem)
2010 checkContextMatch(elem);
2011 return (SeqExpr<R>) Expr.create(
this, Native.mkSeqUnit(nCtx(), elem.getNativeObject()));
2019 StringBuilder buf =
new StringBuilder();
2020 for (
int i = 0; i < s.length(); ++i) {
2021 int code = s.codePointAt(i);
2022 if (code <= 32 || 127 < code)
2023 buf.append(
String.format(
"\\u{%x}", code));
2025 buf.append(s.charAt(i));
2059 return (
IntExpr)
Expr.create(
this, Native.mkStrToInt(nCtx(), e.getNativeObject()));
2068 checkContextMatch(t);
2078 checkContextMatch(s);
2079 return (
IntExpr)
Expr.create(
this, Native.mkSeqLength(nCtx(), s.getNativeObject()));
2085 public <R extends Sort> BoolExpr mkPrefixOf(Expr<SeqSort<R>> s1, Expr<SeqSort<R>> s2)
2087 checkContextMatch(s1, s2);
2088 return (BoolExpr) Expr.create(
this, Native.mkSeqPrefix(nCtx(), s1.getNativeObject(), s2.getNativeObject()));
2094 public <R extends Sort> BoolExpr mkSuffixOf(Expr<SeqSort<R>> s1, Expr<SeqSort<R>> s2)
2096 checkContextMatch(s1, s2);
2097 return (BoolExpr)Expr.create(
this, Native.mkSeqSuffix(nCtx(), s1.getNativeObject(), s2.getNativeObject()));
2103 public <R extends Sort> BoolExpr mkContains(Expr<SeqSort<R>> s1, Expr<SeqSort<R>> s2)
2105 checkContextMatch(s1, s2);
2106 return (BoolExpr) Expr.create(
this, Native.mkSeqContains(nCtx(), s1.getNativeObject(), s2.getNativeObject()));
2115 checkContextMatch(s1, s2);
2116 return new BoolExpr(
this, Native.mkStrLt(nCtx(), s1.getNativeObject(), s2.getNativeObject()));
2124 checkContextMatch(s1, s2);
2125 return new BoolExpr(
this, Native.mkStrLe(nCtx(), s1.getNativeObject(), s2.getNativeObject()));
2134 checkContextMatch(s, index);
2135 return (
SeqExpr<R>)
Expr.create(
this, Native.mkSeqAt(nCtx(), s.getNativeObject(), index.getNativeObject()));
2141 public <R extends Sort> Expr<R> mkNth(Expr<SeqSort<R>> s, Expr<IntSort> index)
2143 checkContextMatch(s, index);
2144 return (Expr<R>) Expr.create(
this, Native.mkSeqNth(nCtx(), s.getNativeObject(), index.getNativeObject()));
2151 public <R extends Sort> SeqExpr<R> mkExtract(Expr<SeqSort<R>> s, Expr<IntSort> offset, Expr<IntSort> length)
2153 checkContextMatch(s, offset, length);
2154 return (SeqExpr<R>) Expr.create(
this, Native.mkSeqExtract(nCtx(), s.getNativeObject(), offset.getNativeObject(), length.getNativeObject()));
2160 public <R extends Sort> IntExpr mkIndexOf(Expr<SeqSort<R>> s, Expr<SeqSort<R>> substr, Expr<IntSort> offset)
2162 checkContextMatch(s, substr, offset);
2163 return (IntExpr)Expr.create(
this, Native.mkSeqIndex(nCtx(), s.getNativeObject(), substr.getNativeObject(), offset.getNativeObject()));
2169 public <R extends Sort> SeqExpr<R> mkReplace(Expr<SeqSort<R>> s, Expr<SeqSort<R>> src, Expr<SeqSort<R>> dst)
2171 checkContextMatch(s, src, dst);
2172 return (SeqExpr<R>) Expr.create(
this, Native.mkSeqReplace(nCtx(), s.getNativeObject(), src.getNativeObject(), dst.getNativeObject()));
2178 public <R extends Sort> ReExpr<R> mkToRe(Expr<SeqSort<R>> s)
2180 checkContextMatch(s);
2181 return (ReExpr<R>) Expr.create(
this, Native.mkSeqToRe(nCtx(), s.getNativeObject()));
2188 public <R extends Sort> BoolExpr mkInRe(Expr<SeqSort<R>> s, Expr<ReSort<R>> re)
2190 checkContextMatch(s, re);
2191 return (BoolExpr) Expr.create(
this, Native.mkSeqInRe(nCtx(), s.getNativeObject(), re.getNativeObject()));
2197 public <R extends Sort> ReExpr<R> mkStar(Expr<ReSort<R>> re)
2199 checkContextMatch(re);
2200 return (ReExpr<R>) Expr.create(
this, Native.mkReStar(nCtx(), re.getNativeObject()));
2206 public <R extends Sort> ReExpr<R> mkPower(Expr<ReSort<R>> re,
int n)
2208 return (ReExpr<R>) Expr.create(
this, Native.mkRePower(nCtx(), re.getNativeObject(), n));
2214 public <R extends Sort> ReExpr<R> mkLoop(Expr<ReSort<R>> re,
int lo,
int hi)
2216 return (ReExpr<R>) Expr.create(
this, Native.mkReLoop(nCtx(), re.getNativeObject(), lo, hi));
2222 public <R extends Sort> ReExpr<R> mkLoop(Expr<ReSort<R>> re,
int lo)
2224 return (ReExpr<R>) Expr.create(
this, Native.mkReLoop(nCtx(), re.getNativeObject(), lo, 0));
2231 public <R extends Sort> ReExpr<R> mkPlus(Expr<ReSort<R>> re)
2233 checkContextMatch(re);
2234 return (ReExpr<R>) Expr.create(
this, Native.mkRePlus(nCtx(), re.getNativeObject()));
2240 public <R extends Sort> ReExpr<R> mkOption(Expr<ReSort<R>> re)
2242 checkContextMatch(re);
2243 return (ReExpr<R>) Expr.create(
this, Native.mkReOption(nCtx(), re.getNativeObject()));
2249 public <R extends Sort> ReExpr<R> mkComplement(Expr<ReSort<R>> re)
2251 checkContextMatch(re);
2252 return (ReExpr<R>) Expr.create(
this, Native.mkReComplement(nCtx(), re.getNativeObject()));
2261 checkContextMatch(t);
2271 checkContextMatch(t);
2281 checkContextMatch(t);
2290 checkContextMatch(a, b);
2291 return (
ReExpr<R>)
Expr.create(
this, Native.mkReDiff(nCtx(), a.getNativeObject(), b.getNativeObject()));
2299 public <R extends Sort> ReExpr<R> mkEmptyRe(R s)
2301 return (ReExpr<R>) Expr.create(
this, Native.mkReEmpty(nCtx(), s.getNativeObject()));
2308 public <R extends Sort> ReExpr<R> mkFullRe(R s)
2310 return (ReExpr<R>) Expr.create(
this, Native.mkReFull(nCtx(), s.getNativeObject()));
2317 public <R extends Sort> ReExpr<R> mkAllcharRe(R s)
2319 return (ReExpr<R>) Expr.create(
this, Native.mkReAllchar(nCtx(), s.getNativeObject()));
2325 public <R extends Sort> ReExpr<R> mkRange(Expr<SeqSort<CharSort>> lo, Expr<SeqSort<CharSort>> hi)
2327 checkContextMatch(lo, hi);
2328 return (ReExpr<R>) Expr.create(
this, Native.mkReRange(nCtx(), lo.getNativeObject(), hi.getNativeObject()));
2336 checkContextMatch(ch1, ch2);
2337 return (
BoolExpr)
Expr.create(
this, Native.mkCharLe(nCtx(), ch1.getNativeObject(), ch2.getNativeObject()));
2345 checkContextMatch(ch);
2346 return (
IntExpr)
Expr.create(
this, Native.mkCharToInt(nCtx(), ch.getNativeObject()));
2354 checkContextMatch(ch);
2355 return (
BitVecExpr)
Expr.create(
this, Native.mkCharToBv(nCtx(), ch.getNativeObject()));
2363 checkContextMatch(bv);
2364 return (
Expr<CharSort>)
Expr.create(
this, Native.mkCharFromBv(nCtx(), bv.getNativeObject()));
2372 checkContextMatch(ch);
2373 return (
BoolExpr)
Expr.create(
this, Native.mkCharIsDigit(nCtx(), ch.getNativeObject()));
2381 checkContextMatch(args);
2390 checkContextMatch(args);
2399 checkContextMatch(args);
2408 checkContextMatch(args);
2417 checkContextMatch(args);
2434 checkContextMatch(ty);
2436 Native.mkNumeral(nCtx(), v, ty.getNativeObject()));
2449 public <R extends Sort> Expr<R> mkNumeral(
int v, R ty)
2451 checkContextMatch(ty);
2452 return (Expr<R>) Expr.create(
this, Native.mkInt(nCtx(), v, ty.getNativeObject()));
2465 public <R extends Sort> Expr<R> mkNumeral(
long v, R ty)
2467 checkContextMatch(ty);
2468 return (Expr<R>) Expr.create(
this,
2469 Native.mkInt64(nCtx(), v, ty.getNativeObject()));
2487 return new RatNum(
this, Native.mkReal(nCtx(), num, den));
2499 return new RatNum(
this, Native.mkNumeral(nCtx(), v, getRealSort()
2500 .getNativeObject()));
2512 return new RatNum(
this, Native.mkInt(nCtx(), v, getRealSort()
2513 .getNativeObject()));
2525 return new RatNum(
this, Native.mkInt64(nCtx(), v, getRealSort()
2526 .getNativeObject()));
2536 return new IntNum(
this, Native.mkNumeral(nCtx(), v, getIntSort()
2537 .getNativeObject()));
2549 return new IntNum(
this, Native.mkInt(nCtx(), v, getIntSort()
2550 .getNativeObject()));
2562 return new IntNum(
this, Native.mkInt64(nCtx(), v, getIntSort()
2563 .getNativeObject()));
2573 return (
BitVecNum) mkNumeral(v, mkBitVecSort(size));
2583 return (
BitVecNum) mkNumeral(v, mkBitVecSort(size));
2593 return (
BitVecNum) mkNumeral(v, mkBitVecSort(size));
2625 return Quantifier.
of(
this,
true, sorts, names, body, weight, patterns,
2626 noPatterns, quantifierID, skolemID);
2638 return Quantifier.
of(
this,
true, boundConstants, body, weight,
2639 patterns, noPatterns, quantifierID, skolemID);
2651 return Quantifier.
of(
this,
false, sorts, names, body, weight,
2652 patterns, noPatterns, quantifierID, skolemID);
2664 return Quantifier.
of(
this,
false, boundConstants, body, weight,
2665 patterns, noPatterns, quantifierID, skolemID);
2679 return mkForall(sorts, names, body, weight, patterns, noPatterns,
2680 quantifierID, skolemID);
2682 return mkExists(sorts, names, body, weight, patterns, noPatterns,
2683 quantifierID, skolemID);
2696 return mkForall(boundConstants, body, weight, patterns, noPatterns,
2697 quantifierID, skolemID);
2699 return mkExists(boundConstants, body, weight, patterns, noPatterns,
2700 quantifierID, skolemID);
2722 return Lambda.
of(
this, sorts, names, body);
2731 public <R extends Sort> Lambda<R> mkLambda(Expr<?>[] boundConstants, Expr<R> body)
2733 return Lambda.of(
this, boundConstants, body);
2753 Native.setAstPrintMode(nCtx(), value.toInt());
2774 return Native.benchmarkToSmtlibString(nCtx(), name, logic, status,
2775 attributes, assumptions.length,
2795 if (csn != cs || cdn != cd) {
2816 if (csn != cs || cdn != cd)
2836 public Goal mkGoal(
boolean models,
boolean unsatCores,
boolean proofs)
2838 return new Goal(
this, models, unsatCores, proofs);
2854 return Native.getNumTactics(nCtx());
2863 int n = getNumTactics();
2865 for (
int i = 0; i < n; i++)
2866 res[i] = Native.getTacticName(nCtx(), i);
2876 return Native.tacticGetDescr(nCtx(), name);
2884 return new Tactic(
this, name);
2894 checkContextMatch(t1);
2895 checkContextMatch(t2);
2896 checkContextMatch(ts);
2899 if (ts !=
null && ts.length > 0)
2901 last = ts[ts.length - 1].getNativeObject();
2902 for (
int i = ts.length - 2; i >= 0; i--) {
2903 last = Native.tacticAndThen(nCtx(), ts[i].getNativeObject(),
2909 last = Native.tacticAndThen(nCtx(), t2.getNativeObject(), last);
2910 return new Tactic(
this, Native.tacticAndThen(nCtx(),
2911 t1.getNativeObject(), last));
2913 return new Tactic(
this, Native.tacticAndThen(nCtx(),
2914 t1.getNativeObject(), t2.getNativeObject()));
2925 return andThen(t1, t2, ts);
2935 checkContextMatch(t1);
2936 checkContextMatch(t2);
2937 return new Tactic(
this, Native.tacticOrElse(nCtx(),
2938 t1.getNativeObject(), t2.getNativeObject()));
2949 checkContextMatch(t);
2950 return new Tactic(
this, Native.tacticTryFor(nCtx(),
2951 t.getNativeObject(), ms));
2962 checkContextMatch(t);
2963 checkContextMatch(p);
2964 return new Tactic(
this, Native.tacticWhen(nCtx(), p.getNativeObject(),
2965 t.getNativeObject()));
2975 checkContextMatch(p);
2976 checkContextMatch(t1);
2977 checkContextMatch(t2);
2978 return new Tactic(
this, Native.tacticCond(nCtx(), p.getNativeObject(),
2979 t1.getNativeObject(), t2.getNativeObject()));
2988 checkContextMatch(t);
2989 return new Tactic(
this, Native.tacticRepeat(nCtx(),
2990 t.getNativeObject(),
max));
2998 return new Tactic(
this, Native.tacticSkip(nCtx()));
3006 return new Tactic(
this, Native.tacticFail(nCtx()));
3015 checkContextMatch(p);
3017 Native.tacticFailIf(nCtx(), p.getNativeObject()));
3026 return new Tactic(
this, Native.tacticFailIfNotDecided(nCtx()));
3035 checkContextMatch(t);
3036 checkContextMatch(p);
3037 return new Tactic(
this, Native.tacticUsingParams(nCtx(),
3038 t.getNativeObject(), p.getNativeObject()));
3049 return usingParams(t, p);
3057 checkContextMatch(t);
3058 return new Tactic(
this, Native.tacticParOr(nCtx(),
3068 checkContextMatch(t1);
3069 checkContextMatch(t2);
3070 return new Tactic(
this, Native.tacticParAndThen(nCtx(),
3071 t1.getNativeObject(), t2.getNativeObject()));
3081 Native.interrupt(nCtx());
3089 return Native.getNumProbes(nCtx());
3098 int n = getNumProbes();
3100 for (
int i = 0; i < n; i++)
3101 res[i] = Native.getProbeName(nCtx(), i);
3111 return Native.probeGetDescr(nCtx(), name);
3119 return new Probe(
this, name);
3127 return new Probe(
this, Native.probeConst(nCtx(), val));
3136 checkContextMatch(p1);
3137 checkContextMatch(p2);
3138 return new Probe(
this, Native.probeLt(nCtx(), p1.getNativeObject(),
3139 p2.getNativeObject()));
3148 checkContextMatch(p1);
3149 checkContextMatch(p2);
3150 return new Probe(
this, Native.probeGt(nCtx(), p1.getNativeObject(),
3151 p2.getNativeObject()));
3161 checkContextMatch(p1);
3162 checkContextMatch(p2);
3163 return new Probe(
this, Native.probeLe(nCtx(), p1.getNativeObject(),
3164 p2.getNativeObject()));
3174 checkContextMatch(p1);
3175 checkContextMatch(p2);
3176 return new Probe(
this, Native.probeGe(nCtx(), p1.getNativeObject(),
3177 p2.getNativeObject()));
3186 checkContextMatch(p1);
3187 checkContextMatch(p2);
3188 return new Probe(
this, Native.probeEq(nCtx(), p1.getNativeObject(),
3189 p2.getNativeObject()));
3197 checkContextMatch(p1);
3198 checkContextMatch(p2);
3199 return new Probe(
this, Native.probeAnd(nCtx(), p1.getNativeObject(),
3200 p2.getNativeObject()));
3208 checkContextMatch(p1);
3209 checkContextMatch(p2);
3210 return new Probe(
this, Native.probeOr(nCtx(), p1.getNativeObject(),
3211 p2.getNativeObject()));
3219 checkContextMatch(p);
3220 return new Probe(
this, Native.probeNot(nCtx(), p.getNativeObject()));
3232 return mkSolver((
Symbol)
null);
3246 return new Solver(
this, Native.mkSolver(nCtx()));
3248 return new Solver(
this, Native.mkSolverForLogic(nCtx(),
3249 logic.getNativeObject()));
3258 return mkSolver(mkSymbol(logic));
3266 return new Solver(
this, Native.mkSimpleSolver(nCtx()));
3278 return new Solver(
this, Native.mkSolverFromTactic(nCtx(),
3279 t.getNativeObject()));
3314 return new FPRMExpr(
this, Native.mkFpaRoundNearestTiesToEven(nCtx()));
3323 return new FPRMNum(
this, Native.mkFpaRne(nCtx()));
3332 return new FPRMNum(
this, Native.mkFpaRoundNearestTiesToAway(nCtx()));
3341 return new FPRMNum(
this, Native.mkFpaRna(nCtx()));
3350 return new FPRMNum(
this, Native.mkFpaRoundTowardPositive(nCtx()));
3359 return new FPRMNum(
this, Native.mkFpaRtp(nCtx()));
3368 return new FPRMNum(
this, Native.mkFpaRoundTowardNegative(nCtx()));
3377 return new FPRMNum(
this, Native.mkFpaRtn(nCtx()));
3386 return new FPRMNum(
this, Native.mkFpaRoundTowardZero(nCtx()));
3395 return new FPRMNum(
this, Native.mkFpaRtz(nCtx()));
3406 return new FPSort(
this, ebits, sbits);
3415 return new FPSort(
this, Native.mkFpaSortHalf(nCtx()));
3424 return new FPSort(
this, Native.mkFpaSort16(nCtx()));
3433 return new FPSort(
this, Native.mkFpaSortSingle(nCtx()));
3442 return new FPSort(
this, Native.mkFpaSort32(nCtx()));
3451 return new FPSort(
this, Native.mkFpaSortDouble(nCtx()));
3460 return new FPSort(
this, Native.mkFpaSort64(nCtx()));
3469 return new FPSort(
this, Native.mkFpaSortQuadruple(nCtx()));
3478 return new FPSort(
this, Native.mkFpaSort128(nCtx()));
3489 return new FPNum(
this, Native.mkFpaNan(nCtx(), s.getNativeObject()));
3500 return new FPNum(
this, Native.mkFpaInf(nCtx(), s.getNativeObject(), negative));
3511 return new FPNum(
this, Native.mkFpaZero(nCtx(), s.getNativeObject(), negative));
3522 return new FPNum(
this, Native.mkFpaNumeralFloat(nCtx(), v, s.getNativeObject()));
3533 return new FPNum(
this, Native.mkFpaNumeralDouble(nCtx(), v, s.getNativeObject()));
3544 return new FPNum(
this, Native.mkFpaNumeralInt(nCtx(), v, s.getNativeObject()));
3557 return new FPNum(
this, Native.mkFpaNumeralIntUint(nCtx(), sgn, exp, sig, s.getNativeObject()));
3570 return new FPNum(
this, Native.mkFpaNumeralInt64Uint64(nCtx(), sgn, exp, sig, s.getNativeObject()));
3581 return mkFPNumeral(v, s);
3592 return mkFPNumeral(v, s);
3604 return mkFPNumeral(v, s);
3617 return mkFPNumeral(sgn, exp, sig, s);
3630 return mkFPNumeral(sgn, exp, sig, s);
3641 return new FPExpr(
this, Native.mkFpaAbs(nCtx(), t.getNativeObject()));
3651 return new FPExpr(
this, Native.mkFpaNeg(nCtx(), t.getNativeObject()));
3663 return new FPExpr(
this, Native.mkFpaAdd(nCtx(), rm.getNativeObject(), t1.getNativeObject(), t2.getNativeObject()));
3675 return new FPExpr(
this, Native.mkFpaSub(nCtx(), rm.getNativeObject(), t1.getNativeObject(), t2.getNativeObject()));
3687 return new FPExpr(
this, Native.mkFpaMul(nCtx(), rm.getNativeObject(), t1.getNativeObject(), t2.getNativeObject()));
3699 return new FPExpr(
this, Native.mkFpaDiv(nCtx(), rm.getNativeObject(), t1.getNativeObject(), t2.getNativeObject()));
3714 return new FPExpr(
this, Native.mkFpaFma(nCtx(), rm.getNativeObject(), t1.getNativeObject(), t2.getNativeObject(), t3.getNativeObject()));
3725 return new FPExpr(
this, Native.mkFpaSqrt(nCtx(), rm.getNativeObject(), t.getNativeObject()));
3736 return new FPExpr(
this, Native.mkFpaRem(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3748 return new FPExpr(
this, Native.mkFpaRoundToIntegral(nCtx(), rm.getNativeObject(), t.getNativeObject()));
3759 return new FPExpr(
this, Native.mkFpaMin(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3770 return new FPExpr(
this, Native.mkFpaMax(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3781 return new BoolExpr(
this, Native.mkFpaLeq(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3792 return new BoolExpr(
this, Native.mkFpaLt(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3803 return new BoolExpr(
this, Native.mkFpaGeq(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3814 return new BoolExpr(
this, Native.mkFpaGt(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3827 return new BoolExpr(
this, Native.mkFpaEq(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3837 return new BoolExpr(
this, Native.mkFpaIsNormal(nCtx(), t.getNativeObject()));
3847 return new BoolExpr(
this, Native.mkFpaIsSubnormal(nCtx(), t.getNativeObject()));
3857 return new BoolExpr(
this, Native.mkFpaIsZero(nCtx(), t.getNativeObject()));
3867 return new BoolExpr(
this, Native.mkFpaIsInfinite(nCtx(), t.getNativeObject()));
3877 return new BoolExpr(
this, Native.mkFpaIsNan(nCtx(), t.getNativeObject()));
3887 return new BoolExpr(
this, Native.mkFpaIsNegative(nCtx(), t.getNativeObject()));
3897 return new BoolExpr(
this, Native.mkFpaIsPositive(nCtx(), t.getNativeObject()));
3915 return new FPExpr(
this, Native.mkFpaFp(nCtx(), sgn.getNativeObject(), sig.getNativeObject(), exp.getNativeObject()));
3931 return new FPExpr(
this, Native.mkFpaToFpBv(nCtx(), bv.getNativeObject(), s.getNativeObject()));
3947 return new FPExpr(
this, Native.mkFpaToFpFloat(nCtx(), rm.getNativeObject(), t.getNativeObject(), s.getNativeObject()));
3963 return new FPExpr(
this, Native.mkFpaToFpReal(nCtx(), rm.getNativeObject(), t.getNativeObject(), s.getNativeObject()));
3982 return new FPExpr(
this, Native.mkFpaToFpSigned(nCtx(), rm.getNativeObject(), t.getNativeObject(), s.getNativeObject()));
3984 return new FPExpr(
this, Native.mkFpaToFpUnsigned(nCtx(), rm.getNativeObject(), t.getNativeObject(), s.getNativeObject()));
3999 return new FPExpr(
this, Native.mkFpaToFpFloat(nCtx(), s.getNativeObject(), rm.getNativeObject(), t.getNativeObject()));
4017 return new BitVecExpr(
this, Native.mkFpaToSbv(nCtx(), rm.getNativeObject(), t.getNativeObject(), sz));
4019 return new BitVecExpr(
this, Native.mkFpaToUbv(nCtx(), rm.getNativeObject(), t.getNativeObject(), sz));
4033 return new RealExpr(
this, Native.mkFpaToReal(nCtx(), t.getNativeObject()));
4048 return new BitVecExpr(
this, Native.mkFpaToIeeeBv(nCtx(), t.getNativeObject()));
4066 return new BitVecExpr(
this, Native.mkFpaToFpIntReal(nCtx(), rm.getNativeObject(), exp.getNativeObject(), sig.getNativeObject(), s.getNativeObject()));
4077 Native.mkLinearOrder(
4079 sort.getNativeObject(),
4090 public <R extends Sort> FuncDecl<BoolSort> mkPartialOrder(R sort,
int index) {
4091 return (FuncDecl<BoolSort>) FuncDecl.create(
4093 Native.mkPartialOrder(
4095 sort.getNativeObject(),
4113 return AST.create(
this, nativeObject);
4130 return a.getNativeObject();
4139 return Native.simplifyGetHelp(nCtx());
4147 return new ParamDescrs(
this, Native.simplifyGetParamDescrs(nCtx()));
4160 Native.updateParamValue(nCtx(),
id, value);
4172 void checkContextMatch(
Z3Object other)
4174 if (
this != other.getContext())
4178 void checkContextMatch(Z3Object other1, Z3Object other2)
4180 checkContextMatch(other1);
4181 checkContextMatch(other2);
4184 void checkContextMatch(Z3Object other1, Z3Object other2, Z3Object other3)
4186 checkContextMatch(other1);
4187 checkContextMatch(other2);
4188 checkContextMatch(other3);
4191 void checkContextMatch(Z3Object[] arr)
4194 for (Z3Object a : arr)
4195 checkContextMatch(a);
4198 private ASTDecRefQueue m_AST_DRQ =
new ASTDecRefQueue();
4199 private ASTMapDecRefQueue m_ASTMap_DRQ =
new ASTMapDecRefQueue();
4200 private ASTVectorDecRefQueue m_ASTVector_DRQ =
new ASTVectorDecRefQueue();
4201 private ApplyResultDecRefQueue m_ApplyResult_DRQ =
new ApplyResultDecRefQueue();
4202 private FuncInterpEntryDecRefQueue m_FuncEntry_DRQ =
new FuncInterpEntryDecRefQueue();
4203 private FuncInterpDecRefQueue m_FuncInterp_DRQ =
new FuncInterpDecRefQueue();
4204 private GoalDecRefQueue m_Goal_DRQ =
new GoalDecRefQueue();
4205 private ModelDecRefQueue m_Model_DRQ =
new ModelDecRefQueue();
4206 private ParamsDecRefQueue m_Params_DRQ =
new ParamsDecRefQueue();
4207 private ParamDescrsDecRefQueue m_ParamDescrs_DRQ =
new ParamDescrsDecRefQueue();
4208 private ProbeDecRefQueue m_Probe_DRQ =
new ProbeDecRefQueue();
4209 private SolverDecRefQueue m_Solver_DRQ =
new SolverDecRefQueue();
4210 private StatisticsDecRefQueue m_Statistics_DRQ =
new StatisticsDecRefQueue();
4211 private TacticDecRefQueue m_Tactic_DRQ =
new TacticDecRefQueue();
4212 private FixedpointDecRefQueue m_Fixedpoint_DRQ =
new FixedpointDecRefQueue();
4213 private OptimizeDecRefQueue m_Optimize_DRQ =
new OptimizeDecRefQueue();
4214 private ConstructorDecRefQueue m_Constructor_DRQ =
new ConstructorDecRefQueue();
4215 private ConstructorListDecRefQueue m_ConstructorList_DRQ =
4216 new ConstructorListDecRefQueue();
4219 return m_Constructor_DRQ;
4223 return m_ConstructorList_DRQ;
4233 return m_ASTMap_DRQ;
4238 return m_ASTVector_DRQ;
4243 return m_ApplyResult_DRQ;
4248 return m_FuncEntry_DRQ;
4253 return m_FuncInterp_DRQ;
4268 return m_Params_DRQ;
4273 return m_ParamDescrs_DRQ;
4283 return m_Solver_DRQ;
4288 return m_Statistics_DRQ;
4293 return m_Tactic_DRQ;
4298 return m_Fixedpoint_DRQ;
4303 return m_Optimize_DRQ;
4312 m_AST_DRQ.forceClear(
this);
4313 m_ASTMap_DRQ.forceClear(
this);
4314 m_ASTVector_DRQ.forceClear(
this);
4315 m_ApplyResult_DRQ.forceClear(
this);
4316 m_FuncEntry_DRQ.forceClear(
this);
4317 m_FuncInterp_DRQ.forceClear(
this);
4318 m_Goal_DRQ.forceClear(
this);
4319 m_Model_DRQ.forceClear(
this);
4320 m_Params_DRQ.forceClear(
this);
4321 m_Probe_DRQ.forceClear(
this);
4322 m_Solver_DRQ.forceClear(
this);
4323 m_Optimize_DRQ.forceClear(
this);
4324 m_Statistics_DRQ.forceClear(
this);
4325 m_Tactic_DRQ.forceClear(
this);
4326 m_Fixedpoint_DRQ.forceClear(
this);
4331 m_stringSort =
null;
4333 synchronized (creation_lock) {
4334 Native.delContext(m_ctx);
BoolExpr[] ToBoolExprArray()
Probe ge(Probe p1, Probe p2)
Solver mkSolver(String logic)
Tactic repeat(Tactic t, int max)
BitVecExpr mkBVXOR(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
final BoolExpr mkDistinct(Expr<?>... args)
BitVecExpr mkBVUDiv(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
String getProbeDescription(String name)
FPNum mkFP(boolean sgn, long exp, long sig, FPSort s)
final< D extends Sort > ArrayExpr< D, BoolSort > mkSetIntersection(Expr< ArraySort< D, BoolSort > >... args)
BoolExpr mkFPIsPositive(Expr< FPSort > t)
BitVecExpr mkBVNOR(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
FPExpr mkFPToFP(Expr< FPRMSort > rm, Expr< BitVecSort > t, FPSort s, boolean signed)
FPRMExpr mkFPRoundNearestTiesToEven()
Expr< CharSort > charFromBv(BitVecExpr bv)
IntExpr stringToInt(Expr< SeqSort< CharSort > > e)
Fixedpoint mkFixedpoint()
Tactic usingParams(Tactic t, Params p)
Tactic parOr(Tactic... t)
BoolExpr mkBVULE(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
BoolExpr mkBVSubNoOverflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
BoolExpr mkBVNegNoOverflow(Expr< BitVecSort > t)
Tactic then(Tactic t1, Tactic t2, Tactic... ts)
FPExpr mkFPMax(Expr< FPSort > t1, Expr< FPSort > t2)
IntExpr mkBV2Int(Expr< BitVecSort > t, boolean signed)
FPSort mkFPSort(int ebits, int sbits)
BoolExpr MkStringLe(SeqSort< CharSort > s1, SeqSort< CharSort > s2)
BoolExpr mkBVSDivNoOverflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Probe le(Probe p1, Probe p2)
SeqExpr< CharSort > mkString(String s)
AST wrapAST(long nativeObject)
UninterpretedSort mkUninterpretedSort(Symbol s)
BitVecExpr mkBVXNOR(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
BoolExpr mkImplies(Expr< BoolSort > t1, Expr< BoolSort > t2)
BoolExpr mkBVAddNoOverflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2, boolean isSigned)
BitVecExpr mkBVRotateRight(int i, Expr< BitVecSort > t)
RealExpr mkInt2Real(Expr< IntSort > t)
BitVecExpr mkBVLSHR(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
FPNum mkFPNumeral(boolean sgn, int exp, int sig, FPSort s)
FPNum mkFP(double v, FPSort s)
BoolExpr mkLe(Expr<? extends ArithSort > t1, Expr<? extends ArithSort > t2)
IDecRefQueue< FuncInterp<?> > getFuncInterpDRQ()
IntExpr mkReal2Int(Expr< RealSort > t)
FPNum mkFPInf(FPSort s, boolean negative)
FPExpr mkFPRoundToIntegral(Expr< FPRMSort > rm, Expr< FPSort > t)
BoolExpr mkAtLeast(Expr< BoolSort >[] args, int k)
BitVecExpr mkBVSMod(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
BitVecExpr mkInt2BV(int n, Expr< IntSort > t)
BoolExpr mkBVSGE(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
BitVecExpr mkBVConst(Symbol name, int size)
BitVecExpr mkExtract(int high, int low, Expr< BitVecSort > t)
FPRMNum mkFPRoundTowardZero()
BoolExpr mkFPGEq(Expr< FPSort > t1, Expr< FPSort > t2)
Probe or(Probe p1, Probe p2)
IDecRefQueue< ASTMap > getASTMapDRQ()
BitVecExpr mkBVURem(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
final< D extends Sort, R1 extends Sort, R2 extends Sort > ArrayExpr< D, R2 > mkMap(FuncDecl< R2 > f, Expr< ArraySort< D, R1 > >... args)
Tactic cond(Probe p, Tactic t1, Tactic t2)
IDecRefQueue< Statistics > getStatisticsDRQ()
BoolExpr mkBVSGT(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
IDecRefQueue< Model > getModelDRQ()
BitVecExpr mkBVConst(String name, int size)
IDecRefQueue< Optimize > getOptimizeDRQ()
BoolExpr mkAtMost(Expr< BoolSort >[] args, int k)
IDecRefQueue< AST > getASTDRQ()
BoolExpr mkFPIsSubnormal(Expr< FPSort > t)
IntExpr mkMod(Expr< IntSort > t1, Expr< IntSort > t2)
FPExpr mkFPToFP(Expr< FPRMSort > rm, RealExpr t, FPSort s)
BoolExpr mkNot(Expr< BoolSort > a)
FPExpr mkFPSub(Expr< FPRMSort > rm, Expr< FPSort > t1, Expr< FPSort > t2)
SeqExpr< CharSort > intToString(Expr< IntSort > e)
BoolExpr mkBVMulNoOverflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2, boolean isSigned)
FPExpr mkFPSqrt(Expr< FPRMSort > rm, Expr< FPSort > t)
FPNum mkFPNumeral(int v, FPSort s)
FPExpr mkFPMul(Expr< FPRMSort > rm, Expr< FPSort > t1, Expr< FPSort > t2)
BitVecExpr mkConcat(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
IDecRefQueue< ApplyResult > getApplyResultDRQ()
BitVecExpr mkSignExt(int i, Expr< BitVecSort > t)
BitVecExpr mkBVAdd(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
FPNum mkFP(boolean sgn, int exp, int sig, FPSort s)
BoolExpr MkStringLt(SeqSort< CharSort > s1, SeqSort< CharSort > s2)
void updateParamValue(String id, String value)
BitVecExpr mkZeroExt(int i, Expr< BitVecSort > t)
SeqExpr< CharSort > ubvToString(Expr< BitVecSort > e)
final< R extends Sort > ReExpr< R > mkConcat(ReExpr< R >... t)
BoolExpr mkFPLt(Expr< FPSort > t1, Expr< FPSort > t2)
BitVecExpr mkBVRedAND(Expr< BitVecSort > t)
BitVecNum mkBV(long v, int size)
BitVecExpr mkBVSRem(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
FPNum mkFPNumeral(float v, FPSort s)
IDecRefQueue< ParamDescrs > getParamDescrsDRQ()
Tactic when(Probe p, Tactic t)
IDecRefQueue< Goal > getGoalDRQ()
Probe mkProbe(String name)
BoolExpr mkPBLe(int[] coeffs, Expr< BoolSort >[] args, int k)
RealExpr mkRealConst(String name)
final< R extends ArithSort > ArithExpr< R > mkAdd(Expr<? extends R >... t)
Tactic failIfNotDecided()
ParamDescrs getSimplifyParameterDescriptions()
BitVecExpr mkBVRotateRight(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
SeqExpr< CharSort > sbvToString(Expr< BitVecSort > e)
Probe gt(Probe p1, Probe p2)
BoolExpr mkFPIsNaN(Expr< FPSort > t)
BoolExpr mkEq(Expr<?> x, Expr<?> y)
Tactic with(Tactic t, Params p)
BitVecExpr mkBVASHR(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
BoolExpr[] parseSMTLIB2String(String str, Symbol[] sortNames, Sort[] sorts, Symbol[] declNames, FuncDecl<?>[] decls)
String[] getTacticNames()
String benchmarkToSMTString(String name, String logic, String status, String attributes, Expr< BoolSort >[] assumptions, Expr< BoolSort > formula)
FPRMNum mkFPRoundNearestTiesToAway()
BoolExpr mkIsDigit(Expr< CharSort > ch)
BoolExpr mkBool(boolean value)
BitVecExpr mkBVMul(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
BitVecExpr mkBVSub(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
TupleSort mkTupleSort(Symbol name, Symbol[] fieldNames, Sort[] fieldSorts)
BitVecExpr mkBVOR(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
BoolExpr mkLt(Expr<? extends ArithSort > t1, Expr<? extends ArithSort > t2)
final Pattern mkPattern(Expr<?>... terms)
BitVecExpr mkRepeat(int i, Expr< BitVecSort > t)
BoolExpr mkXor(Expr< BoolSort > t1, Expr< BoolSort > t2)
FPRMNum mkFPRoundTowardNegative()
IDecRefQueue< Params > getParamsDRQ()
Probe eq(Probe p1, Probe p2)
Quantifier mkForall(Sort[] sorts, Symbol[] names, Expr< BoolSort > body, int weight, Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
BitVecExpr mkBVRotateLeft(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
IDecRefQueue< Solver > getSolverDRQ()
Quantifier mkQuantifier(boolean universal, Expr<?>[] boundConstants, Expr< BoolSort > body, int weight, Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
BitVecExpr mkBVRedOR(Expr< BitVecSort > t)
BoolExpr mkBVUGE(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
FPExpr mkFPDiv(Expr< FPRMSort > rm, Expr< FPSort > t1, Expr< FPSort > t2)
BitVecExpr mkBVNAND(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
FPExpr mkFPRem(Expr< FPSort > t1, Expr< FPSort > t2)
SeqSort< CharSort > getStringSort()
Quantifier mkQuantifier(boolean universal, Sort[] sorts, Symbol[] names, Expr< BoolSort > body, int weight, Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
IntExpr mkIntConst(String name)
Solver mkSolver(Tactic t)
BoolExpr[] parseSMTLIB2File(String fileName, Symbol[] sortNames, Sort[] sorts, Symbol[] declNames, FuncDecl<?>[] decls)
Tactic andThen(Tactic t1, Tactic t2, Tactic... ts)
final< R extends Sort > Expr< R > mkApp(FuncDecl< R > f, Expr<?>... args)
BoolExpr mkBVAddNoUnderflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
BoolExpr mkBVSubNoUnderflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2, boolean isSigned)
BoolExpr mkFPIsZero(Expr< FPSort > t)
BitVecExpr charToBv(Expr< CharSort > ch)
IntExpr mkIntConst(Symbol name)
IDecRefQueue< ConstructorList<?> > getConstructorListDRQ()
BitVecExpr mkBVNeg(Expr< BitVecSort > t)
Tactic mkTactic(String name)
BoolExpr mkBVSLE(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
FPNum mkFPNumeral(double v, FPSort s)
Tactic parAndThen(Tactic t1, Tactic t2)
BoolExpr mkGt(Expr<? extends ArithSort > t1, Expr<? extends ArithSort > t2)
BitVecNum mkBV(int v, int size)
Context(Map< String, String > settings)
IDecRefQueue< FuncInterp.Entry<?> > getFuncEntryDRQ()
final< R extends Sort > ReExpr< R > mkIntersect(Expr< ReSort< R > >... t)
final< R extends ArithSort > ArithExpr< R > mkMul(Expr<? extends R >... t)
BoolExpr mkBVMulNoUnderflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
BitVecExpr mkBVSDiv(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
FPRMSort mkFPRoundingModeSort()
RealExpr mkRealConst(Symbol name)
String getTacticDescription(String name)
IDecRefQueue< Probe > getProbeDRQ()
Solver mkSolver(Symbol logic)
BoolExpr mkFPEq(Expr< FPSort > t1, Expr< FPSort > t2)
BoolExpr mkFPLEq(Expr< FPSort > t1, Expr< FPSort > t2)
RatNum mkReal(int num, int den)
BitVecSort mkBitVecSort(int size)
FPExpr mkFPToFP(Expr< BitVecSort > bv, FPSort s)
BoolExpr mkBVSLT(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
BoolExpr mkFPGt(Expr< FPSort > t1, Expr< FPSort > t2)
BoolExpr mkIff(Expr< BoolSort > t1, Expr< BoolSort > t2)
BoolExpr mkGe(Expr<? extends ArithSort > t1, Expr<? extends ArithSort > t2)
BitVecExpr mkFPToFP(Expr< FPRMSort > rm, Expr< IntSort > exp, Expr< RealSort > sig, FPSort s)
BoolExpr mkIsInteger(Expr< RealSort > t)
FPExpr mkFPToFP(Expr< FPRMSort > rm, FPExpr t, FPSort s)
Probe constProbe(double val)
BoolExpr mkFPIsNegative(Expr< FPSort > t)
BoolExpr mkBoolConst(String name)
RealExpr mkFPToReal(Expr< FPSort > t)
FPExpr mkFP(Expr< BitVecSort > sgn, Expr< BitVecSort > sig, Expr< BitVecSort > exp)
FPExpr mkFPToFP(FPSort s, Expr< FPRMSort > rm, Expr< FPSort > t)
FPExpr mkFPNeg(Expr< FPSort > t)
IDecRefQueue< Tactic > getTacticDRQ()
final< R extends Sort > SeqExpr< R > mkConcat(Expr< SeqSort< R > >... t)
BoolExpr mkCharLe(Expr< CharSort > ch1, Expr< CharSort > ch2)
FPNum mkFPNumeral(boolean sgn, long exp, long sig, FPSort s)
SeqSort< CharSort > mkStringSort()
FPSort mkFPSortQuadruple()
FPRMNum mkFPRoundTowardPositive()
Quantifier mkExists(Expr<?>[] boundConstants, Expr< BoolSort > body, int weight, Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
final< D extends Sort > ArrayExpr< D, BoolSort > mkSetUnion(Expr< ArraySort< D, BoolSort > >... args)
BoolExpr mkBVULT(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
BoolExpr mkFPIsNormal(Expr< FPSort > t)
DatatypeSort< Object >[] mkDatatypeSorts(String[] names, Constructor< Object >[][] c)
Probe and(Probe p1, Probe p2)
IntExpr charToInt(Expr< CharSort > ch)
Tactic tryFor(Tactic t, int ms)
FPExpr mkFPFMA(Expr< FPRMSort > rm, Expr< FPSort > t1, Expr< FPSort > t2, Expr< FPSort > t3)
UninterpretedSort mkUninterpretedSort(String str)
void setPrintMode(Z3_ast_print_mode value)
DatatypeSort< Object >[] mkDatatypeSorts(Symbol[] names, Constructor< Object >[][] c)
final BoolExpr mkAnd(Expr< BoolSort >... t)
BitVecNum mkBV(String v, int size)
BitVecExpr mkBVRotateLeft(int i, Expr< BitVecSort > t)
Probe lt(Probe p1, Probe p2)
Quantifier mkForall(Expr<?>[] boundConstants, Expr< BoolSort > body, int weight, Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
IntExpr mkRem(Expr< IntSort > t1, Expr< IntSort > t2)
BitVecExpr mkBVNot(Expr< BitVecSort > t)
final< R extends ArithSort > ArithExpr< R > mkSub(Expr<? extends R >... t)
BitVecExpr mkBVAND(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
FPExpr mkFPAbs(Expr< FPSort > t)
BoolExpr mkPBEq(int[] coeffs, Expr< BoolSort >[] args, int k)
Goal mkGoal(boolean models, boolean unsatCores, boolean proofs)
IDecRefQueue< Constructor<?> > getConstructorDRQ()
FPExpr mkFPAdd(Expr< FPRMSort > rm, Expr< FPSort > t1, Expr< FPSort > t2)
BoolExpr mkBVUGT(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
FPNum mkFP(float v, FPSort s)
final BoolExpr mkOr(Expr< BoolSort >... t)
BitVecExpr mkBVSHL(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Quantifier mkExists(Sort[] sorts, Symbol[] names, Expr< BoolSort > body, int weight, Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
BitVecExpr mkFPToIEEEBV(Expr< FPSort > t)
FPExpr mkFPMin(Expr< FPSort > t1, Expr< FPSort > t2)
Tactic orElse(Tactic t1, Tactic t2)
IDecRefQueue< Fixedpoint > getFixedpointDRQ()
FPNum mkFP(int v, FPSort s)
final< R extends Sort > ReExpr< R > mkUnion(Expr< ReSort< R > >... t)
IntSymbol mkSymbol(int i)
StringSymbol mkSymbol(String name)
FPNum mkFPZero(FPSort s, boolean negative)
BoolExpr mkFPIsInfinite(Expr< FPSort > t)
BoolExpr mkBoolConst(Symbol name)
IDecRefQueue< ASTVector > getASTVectorDRQ()
BitVecExpr mkFPToBV(Expr< FPRMSort > rm, Expr< FPSort > t, int sz, boolean signed)
BoolExpr mkPBGe(int[] coeffs, Expr< BoolSort >[] args, int k)
static< R extends Sort > Lambda< R > of(Context ctx, Sort[] sorts, Symbol[] names, Expr< R > body)
static Quantifier of(Context ctx, boolean isForall, Sort[] sorts, Symbol[] names, Expr< BoolSort > body, int weight, Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
static long[] arrayToNative(Z3Object[] a)
static int arrayLength(Z3Object[] a)
Z3_ast_print_mode
Z3 pretty printing modes (See Z3_set_ast_print_mode).
expr range(expr const &lo, expr const &hi)
expr max(expr const &a, expr const &b)
def String(name, ctx=None)
def FPSort(ebits, sbits, ctx=None)
def TupleSort(name, sorts, ctx=None)
def BitVecSort(sz, ctx=None)