Z3
Context.java
Go to the documentation of this file.
1
18package com.microsoft.z3;
19
20import static com.microsoft.z3.Constructor.of;
21
22import com.microsoft.z3.enumerations.Z3_ast_print_mode;
23
24import java.util.Map;
25
35@SuppressWarnings("unchecked")
36public class Context implements AutoCloseable {
37 private long m_ctx;
38 static final Object creation_lock = new Object();
39
40 public Context () {
41 synchronized (creation_lock) {
42 m_ctx = Native.mkContextRc(0);
43 init();
44 }
45 }
46
47 protected Context (long m_ctx) {
48 synchronized (creation_lock) {
49 this.m_ctx = m_ctx;
50 init();
51 }
52 }
53
54
72 public Context(Map<String, String> settings) {
73 synchronized (creation_lock) {
74 long cfg = Native.mkConfig();
75 for (Map.Entry<String, String> kv : settings.entrySet()) {
76 Native.setParamValue(cfg, kv.getKey(), kv.getValue());
77 }
78 m_ctx = Native.mkContextRc(cfg);
79 Native.delConfig(cfg);
80 init();
81 }
82 }
83
84 private void init() {
85 setPrintMode(Z3_ast_print_mode.Z3_PRINT_SMTLIB2_COMPLIANT);
86 Native.setInternalErrorHandler(m_ctx);
87 }
88
94 public IntSymbol mkSymbol(int i)
95 {
96 return new IntSymbol(this, i);
97 }
98
103 {
104 return new StringSymbol(this, name);
105 }
106
110 Symbol[] mkSymbols(String[] names)
111 {
112 if (names == null)
113 return new Symbol[0];
114 Symbol[] result = new Symbol[names.length];
115 for (int i = 0; i < names.length; ++i)
116 result[i] = mkSymbol(names[i]);
117 return result;
118 }
119
120 private BoolSort m_boolSort = null;
121 private IntSort m_intSort = null;
122 private RealSort m_realSort = null;
123 private SeqSort<CharSort> m_stringSort = null;
124
129 {
130 if (m_boolSort == null) {
131 m_boolSort = new BoolSort(this);
132 }
133 return m_boolSort;
134 }
135
140 {
141 if (m_intSort == null) {
142 m_intSort = new IntSort(this);
143 }
144 return m_intSort;
145 }
146
151 {
152 if (m_realSort == null) {
153 m_realSort = new RealSort(this);
154 }
155 return m_realSort;
156 }
157
162 {
163 return new BoolSort(this);
164 }
165
171 {
172 return new CharSort(this);
173 }
174
179 {
180 if (m_stringSort == null) {
181 m_stringSort = mkStringSort();
182 }
183 return m_stringSort;
184 }
185
190 {
191 checkContextMatch(s);
192 return new UninterpretedSort(this, s);
193 }
194
199 {
200 return mkUninterpretedSort(mkSymbol(str));
201 }
202
207 {
208 return new IntSort(this);
209 }
210
215 {
216 return new RealSort(this);
217 }
218
222 public BitVecSort mkBitVecSort(int size)
223 {
224 return new BitVecSort(this, Native.mkBvSort(nCtx(), size));
225 }
226
230 public <D extends Sort, R extends Sort> ArraySort<D, R> mkArraySort(D domain, R range)
231 {
232 checkContextMatch(domain);
233 checkContextMatch(range);
234 return new ArraySort<>(this, domain, range);
235 }
236
237
241 public <R extends Sort> ArraySort<Sort, R> mkArraySort(Sort[] domains, R range)
242 {
243 checkContextMatch(domains);
244 checkContextMatch(range);
245 return new ArraySort<>(this, domains, range);
246 }
247
252 {
253 return new SeqSort<>(this, Native.mkStringSort(nCtx()));
254 }
255
259 public <R extends Sort> SeqSort<R> mkSeqSort(R s)
260 {
261 return new SeqSort<>(this, Native.mkSeqSort(nCtx(), s.getNativeObject()));
262 }
263
267 public <R extends Sort> ReSort<R> mkReSort(R s)
268 {
269 return new ReSort<>(this, Native.mkReSort(nCtx(), s.getNativeObject()));
270 }
271
272
276 public TupleSort mkTupleSort(Symbol name, Symbol[] fieldNames,
277 Sort[] fieldSorts)
278 {
279 checkContextMatch(name);
280 checkContextMatch(fieldNames);
281 checkContextMatch(fieldSorts);
282 return new TupleSort(this, name, fieldNames.length, fieldNames,
283 fieldSorts);
284 }
285
289 public <R> EnumSort<R> mkEnumSort(Symbol name, Symbol... enumNames)
290
291 {
292 checkContextMatch(name);
293 checkContextMatch(enumNames);
294 return new EnumSort<>(this, name, enumNames);
295 }
296
300 public <R> EnumSort<R> mkEnumSort(String name, String... enumNames)
301
302 {
303 return new EnumSort<>(this, mkSymbol(name), mkSymbols(enumNames));
304 }
305
309 public <R extends Sort> ListSort<R> mkListSort(Symbol name, R elemSort)
310 {
311 checkContextMatch(name);
312 checkContextMatch(elemSort);
313 return new ListSort<>(this, name, elemSort);
314 }
315
319 public <R extends Sort> ListSort<R> mkListSort(String name, R elemSort)
320 {
321 checkContextMatch(elemSort);
322 return new ListSort<>(this, mkSymbol(name), elemSort);
323 }
324
328 public <R> FiniteDomainSort<R> mkFiniteDomainSort(Symbol name, long size)
329
330 {
331 checkContextMatch(name);
332 return new FiniteDomainSort<>(this, name, size);
333 }
334
338 public <R> FiniteDomainSort<R> mkFiniteDomainSort(String name, long size)
339
340 {
341 return new FiniteDomainSort<>(this, mkSymbol(name), size);
342 }
343
355 public <R> Constructor<R> mkConstructor(Symbol name, Symbol recognizer,
356 Symbol[] fieldNames, Sort[] sorts, int[] sortRefs)
357
358 {
359 return of(this, name, recognizer, fieldNames, sorts, sortRefs);
360 }
361
365 public <R> Constructor<R> mkConstructor(String name, String recognizer,
366 String[] fieldNames, Sort[] sorts, int[] sortRefs)
367 {
368 return of(this, mkSymbol(name), mkSymbol(recognizer), mkSymbols(fieldNames), sorts, sortRefs);
369 }
370
374 public <R> DatatypeSort<R> mkDatatypeSort(Symbol name, Constructor<R>[] constructors)
375 {
376 checkContextMatch(name);
377 checkContextMatch(constructors);
378 return new DatatypeSort<>(this, name, constructors);
379 }
380
384 public <R> DatatypeSort<R> mkDatatypeSort(String name, Constructor<R>[] constructors)
385
386 {
387 checkContextMatch(constructors);
388 return new DatatypeSort<>(this, mkSymbol(name), constructors);
389 }
390
397 {
398 checkContextMatch(names);
399 int n = names.length;
401 long[] n_constr = new long[n];
402 for (int i = 0; i < n; i++)
403 {
404 Constructor<Object>[] constructor = c[i];
405
406 checkContextMatch(constructor);
407 cla[i] = new ConstructorList<>(this, constructor);
408 n_constr[i] = cla[i].getNativeObject();
409 }
410 long[] n_res = new long[n];
411 Native.mkDatatypes(nCtx(), n, Symbol.arrayToNative(names), n_res,
412 n_constr);
413 DatatypeSort<Object>[] res = new DatatypeSort[n];
414 for (int i = 0; i < n; i++)
415 res[i] = new DatatypeSort<>(this, n_res[i]);
416 return res;
417 }
418
423
424 {
425 return mkDatatypeSorts(mkSymbols(names), c);
426 }
427
434 public <F extends Sort, R extends Sort> Expr<R> mkUpdateField(FuncDecl<F> field, Expr<R> t, Expr<F> v)
435 throws Z3Exception
436 {
437 return (Expr<R>) Expr.create(this,
438 Native.datatypeUpdateField
439 (nCtx(), field.getNativeObject(),
440 t.getNativeObject(), v.getNativeObject()));
441 }
442
443
447 public <R extends Sort> FuncDecl<R> mkFuncDecl(Symbol name, Sort[] domain, R range)
448 {
449 checkContextMatch(name);
450 checkContextMatch(domain);
451 checkContextMatch(range);
452 return new FuncDecl<>(this, name, domain, range);
453 }
454
458 public <R extends Sort> FuncDecl<R> mkFuncDecl(Symbol name, Sort domain, R range)
459
460 {
461 checkContextMatch(name);
462 checkContextMatch(domain);
463 checkContextMatch(range);
464 Sort[] q = new Sort[] { domain };
465 return new FuncDecl<>(this, name, q, range);
466 }
467
471 public <R extends Sort> FuncDecl<R> mkFuncDecl(String name, Sort[] domain, R range)
472
473 {
474 checkContextMatch(domain);
475 checkContextMatch(range);
476 return new FuncDecl<>(this, mkSymbol(name), domain, range);
477 }
478
482 public <R extends Sort> FuncDecl<R> mkFuncDecl(String name, Sort domain, R range)
483
484 {
485 checkContextMatch(domain);
486 checkContextMatch(range);
487 Sort[] q = new Sort[] { domain };
488 return new FuncDecl<>(this, mkSymbol(name), q, range);
489 }
490
494 public <R extends Sort> FuncDecl<R> mkRecFuncDecl(Symbol name, Sort[] domain, R range)
495 {
496 checkContextMatch(name);
497 checkContextMatch(domain);
498 checkContextMatch(range);
499 return new FuncDecl<>(this, name, domain, range, true);
500 }
501
502
509 public <R extends Sort> void AddRecDef(FuncDecl<R> f, Expr<?>[] args, Expr<R> body)
510 {
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());
516 }
517
524 public <R extends Sort> FuncDecl<R> mkFreshFuncDecl(String prefix, Sort[] domain, R range)
525
526 {
527 checkContextMatch(domain);
528 checkContextMatch(range);
529 return new FuncDecl<>(this, prefix, domain, range);
530 }
531
535 public <R extends Sort> FuncDecl<R> mkConstDecl(Symbol name, R range)
536 {
537 checkContextMatch(name);
538 checkContextMatch(range);
539 return new FuncDecl<>(this, name, null, range);
540 }
541
545 public <R extends Sort> FuncDecl<R> mkConstDecl(String name, R range)
546 {
547 checkContextMatch(range);
548 return new FuncDecl<>(this, mkSymbol(name), null, range);
549 }
550
557 public <R extends Sort> FuncDecl<R> mkFreshConstDecl(String prefix, R range)
558
559 {
560 checkContextMatch(range);
561 return new FuncDecl<>(this, prefix, null, range);
562 }
563
569 public <R extends Sort> Expr<R> mkBound(int index, R ty)
570 {
571 return (Expr<R>) Expr.create(this,
572 Native.mkBound(nCtx(), index, ty.getNativeObject()));
573 }
574
578 @SafeVarargs
579 public final Pattern mkPattern(Expr<?>... terms)
580 {
581 if (terms.length == 0)
582 throw new Z3Exception("Cannot create a pattern from zero terms");
583
584 long[] termsNative = AST.arrayToNative(terms);
585 return new Pattern(this, Native.mkPattern(nCtx(), terms.length,
586 termsNative));
587 }
588
593 public <R extends Sort> Expr<R> mkConst(Symbol name, R range)
594 {
595 checkContextMatch(name);
596 checkContextMatch(range);
597
598 return (Expr<R>) Expr.create(
599 this,
600 Native.mkConst(nCtx(), name.getNativeObject(),
601 range.getNativeObject()));
602 }
603
608 public <R extends Sort> Expr<R> mkConst(String name, R range)
609 {
610 return mkConst(mkSymbol(name), range);
611 }
612
617 public <R extends Sort> Expr<R> mkFreshConst(String prefix, R range)
618 {
619 checkContextMatch(range);
620 return (Expr<R>) Expr.create(this,
621 Native.mkFreshConst(nCtx(), prefix, range.getNativeObject()));
622 }
623
628 public <R extends Sort> Expr<R> mkConst(FuncDecl<R> f)
629 {
630 return mkApp(f, (Expr<?>[]) null);
631 }
632
637 {
638 return (BoolExpr) mkConst(name, getBoolSort());
639 }
640
645 {
646 return (BoolExpr) mkConst(mkSymbol(name), getBoolSort());
647 }
648
653 {
654 return (IntExpr) mkConst(name, getIntSort());
655 }
656
661 {
662 return (IntExpr) mkConst(name, getIntSort());
663 }
664
669 {
670 return (RealExpr) mkConst(name, getRealSort());
671 }
672
677 {
678 return (RealExpr) mkConst(name, getRealSort());
679 }
680
684 public BitVecExpr mkBVConst(Symbol name, int size)
685 {
686 return (BitVecExpr) mkConst(name, mkBitVecSort(size));
687 }
688
692 public BitVecExpr mkBVConst(String name, int size)
693 {
694 return (BitVecExpr) mkConst(name, mkBitVecSort(size));
695 }
696
700 @SafeVarargs
701 public final <R extends Sort> Expr<R> mkApp(FuncDecl<R> f, Expr<?>... args)
702 {
703 checkContextMatch(f);
704 checkContextMatch(args);
705 return Expr.create(this, f, args);
706 }
707
712 {
713 return new BoolExpr(this, Native.mkTrue(nCtx()));
714 }
715
720 {
721 return new BoolExpr(this, Native.mkFalse(nCtx()));
722 }
723
727 public BoolExpr mkBool(boolean value)
728 {
729 return value ? mkTrue() : mkFalse();
730 }
731
736 {
737 checkContextMatch(x);
738 checkContextMatch(y);
739 return new BoolExpr(this, Native.mkEq(nCtx(), x.getNativeObject(),
740 y.getNativeObject()));
741 }
742
746 @SafeVarargs
747 public final BoolExpr mkDistinct(Expr<?>... args)
748 {
749 checkContextMatch(args);
750 return new BoolExpr(this, Native.mkDistinct(nCtx(), args.length,
751 AST.arrayToNative(args)));
752 }
753
758 {
759 checkContextMatch(a);
760 return new BoolExpr(this, Native.mkNot(nCtx(), a.getNativeObject()));
761 }
762
770 public <R extends Sort> Expr<R> mkITE(Expr<BoolSort> t1, Expr<? extends R> t2, Expr<? extends R> t3)
771 {
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()));
777 }
778
783 {
784 checkContextMatch(t1);
785 checkContextMatch(t2);
786 return new BoolExpr(this, Native.mkIff(nCtx(), t1.getNativeObject(),
787 t2.getNativeObject()));
788 }
789
794 {
795 checkContextMatch(t1);
796 checkContextMatch(t2);
797 return new BoolExpr(this, Native.mkImplies(nCtx(),
798 t1.getNativeObject(), t2.getNativeObject()));
799 }
800
805 {
806 checkContextMatch(t1);
807 checkContextMatch(t2);
808 return new BoolExpr(this, Native.mkXor(nCtx(), t1.getNativeObject(),
809 t2.getNativeObject()));
810 }
811
815 @SafeVarargs
816 public final BoolExpr mkAnd(Expr<BoolSort>... t)
817 {
818 checkContextMatch(t);
819 return new BoolExpr(this, Native.mkAnd(nCtx(), t.length,
820 AST.arrayToNative(t)));
821 }
822
826 @SafeVarargs
827 public final BoolExpr mkOr(Expr<BoolSort>... t)
828 {
829 checkContextMatch(t);
830 return new BoolExpr(this, Native.mkOr(nCtx(), t.length,
831 AST.arrayToNative(t)));
832 }
833
837 @SafeVarargs
838 public final <R extends ArithSort> ArithExpr<R> mkAdd(Expr<? extends R>... t)
839 {
840 checkContextMatch(t);
841 return (ArithExpr<R>) Expr.create(this,
842 Native.mkAdd(nCtx(), t.length, AST.arrayToNative(t)));
843 }
844
848 @SafeVarargs
849 public final <R extends ArithSort> ArithExpr<R> mkMul(Expr<? extends R>... t)
850 {
851 checkContextMatch(t);
852 return (ArithExpr<R>) Expr.create(this,
853 Native.mkMul(nCtx(), t.length, AST.arrayToNative(t)));
854 }
855
859 @SafeVarargs
860 public final <R extends ArithSort> ArithExpr<R> mkSub(Expr<? extends R>... t)
861 {
862 checkContextMatch(t);
863 return (ArithExpr<R>) Expr.create(this,
864 Native.mkSub(nCtx(), t.length, AST.arrayToNative(t)));
865 }
866
870 public <R extends ArithSort> ArithExpr<R> mkUnaryMinus(Expr<R> t)
871 {
872 checkContextMatch(t);
873 return (ArithExpr<R>) Expr.create(this,
874 Native.mkUnaryMinus(nCtx(), t.getNativeObject()));
875 }
876
880 public <R extends ArithSort> ArithExpr<R> mkDiv(Expr<? extends R> t1, Expr<? extends R> t2)
881 {
882 checkContextMatch(t1);
883 checkContextMatch(t2);
884 return (ArithExpr<R>) Expr.create(this, Native.mkDiv(nCtx(),
885 t1.getNativeObject(), t2.getNativeObject()));
886 }
887
894 {
895 checkContextMatch(t1);
896 checkContextMatch(t2);
897 return new IntExpr(this, Native.mkMod(nCtx(), t1.getNativeObject(),
898 t2.getNativeObject()));
899 }
900
907 {
908 checkContextMatch(t1);
909 checkContextMatch(t2);
910 return new IntExpr(this, Native.mkRem(nCtx(), t1.getNativeObject(),
911 t2.getNativeObject()));
912 }
913
917 public <R extends ArithSort> ArithExpr<R> mkPower(Expr<? extends R> t1,
919 {
920 checkContextMatch(t1);
921 checkContextMatch(t2);
922 return (ArithExpr<R>) Expr.create(
923 this,
924 Native.mkPower(nCtx(), t1.getNativeObject(),
925 t2.getNativeObject()));
926 }
927
932 {
933 checkContextMatch(t1);
934 checkContextMatch(t2);
935 return new BoolExpr(this, Native.mkLt(nCtx(), t1.getNativeObject(),
936 t2.getNativeObject()));
937 }
938
943 {
944 checkContextMatch(t1);
945 checkContextMatch(t2);
946 return new BoolExpr(this, Native.mkLe(nCtx(), t1.getNativeObject(),
947 t2.getNativeObject()));
948 }
949
954 {
955 checkContextMatch(t1);
956 checkContextMatch(t2);
957 return new BoolExpr(this, Native.mkGt(nCtx(), t1.getNativeObject(),
958 t2.getNativeObject()));
959 }
960
965 {
966 checkContextMatch(t1);
967 checkContextMatch(t2);
968 return new BoolExpr(this, Native.mkGe(nCtx(), t1.getNativeObject(),
969 t2.getNativeObject()));
970 }
971
983 {
984 checkContextMatch(t);
985 return new RealExpr(this,
986 Native.mkInt2real(nCtx(), t.getNativeObject()));
987 }
988
996 {
997 checkContextMatch(t);
998 return new IntExpr(this, Native.mkReal2int(nCtx(), t.getNativeObject()));
999 }
1000
1005 {
1006 checkContextMatch(t);
1007 return new BoolExpr(this, Native.mkIsInt(nCtx(), t.getNativeObject()));
1008 }
1009
1016 {
1017 checkContextMatch(t);
1018 return new BitVecExpr(this, Native.mkBvnot(nCtx(), t.getNativeObject()));
1019 }
1020
1027 {
1028 checkContextMatch(t);
1029 return new BitVecExpr(this, Native.mkBvredand(nCtx(),
1030 t.getNativeObject()));
1031 }
1032
1039 {
1040 checkContextMatch(t);
1041 return new BitVecExpr(this, Native.mkBvredor(nCtx(),
1042 t.getNativeObject()));
1043 }
1044
1051 {
1052 checkContextMatch(t1);
1053 checkContextMatch(t2);
1054 return new BitVecExpr(this, Native.mkBvand(nCtx(),
1055 t1.getNativeObject(), t2.getNativeObject()));
1056 }
1057
1064 {
1065 checkContextMatch(t1);
1066 checkContextMatch(t2);
1067 return new BitVecExpr(this, Native.mkBvor(nCtx(), t1.getNativeObject(),
1068 t2.getNativeObject()));
1069 }
1070
1077 {
1078 checkContextMatch(t1);
1079 checkContextMatch(t2);
1080 return new BitVecExpr(this, Native.mkBvxor(nCtx(),
1081 t1.getNativeObject(), t2.getNativeObject()));
1082 }
1083
1090 {
1091 checkContextMatch(t1);
1092 checkContextMatch(t2);
1093 return new BitVecExpr(this, Native.mkBvnand(nCtx(),
1094 t1.getNativeObject(), t2.getNativeObject()));
1095 }
1096
1103 {
1104 checkContextMatch(t1);
1105 checkContextMatch(t2);
1106 return new BitVecExpr(this, Native.mkBvnor(nCtx(),
1107 t1.getNativeObject(), t2.getNativeObject()));
1108 }
1109
1116 {
1117 checkContextMatch(t1);
1118 checkContextMatch(t2);
1119 return new BitVecExpr(this, Native.mkBvxnor(nCtx(),
1120 t1.getNativeObject(), t2.getNativeObject()));
1121 }
1122
1129 {
1130 checkContextMatch(t);
1131 return new BitVecExpr(this, Native.mkBvneg(nCtx(), t.getNativeObject()));
1132 }
1133
1140 {
1141 checkContextMatch(t1);
1142 checkContextMatch(t2);
1143 return new BitVecExpr(this, Native.mkBvadd(nCtx(),
1144 t1.getNativeObject(), t2.getNativeObject()));
1145 }
1146
1153 {
1154 checkContextMatch(t1);
1155 checkContextMatch(t2);
1156 return new BitVecExpr(this, Native.mkBvsub(nCtx(),
1157 t1.getNativeObject(), t2.getNativeObject()));
1158 }
1159
1166 {
1167 checkContextMatch(t1);
1168 checkContextMatch(t2);
1169 return new BitVecExpr(this, Native.mkBvmul(nCtx(),
1170 t1.getNativeObject(), t2.getNativeObject()));
1171 }
1172
1181 {
1182 checkContextMatch(t1);
1183 checkContextMatch(t2);
1184 return new BitVecExpr(this, Native.mkBvudiv(nCtx(),
1185 t1.getNativeObject(), t2.getNativeObject()));
1186 }
1187
1202 {
1203 checkContextMatch(t1);
1204 checkContextMatch(t2);
1205 return new BitVecExpr(this, Native.mkBvsdiv(nCtx(),
1206 t1.getNativeObject(), t2.getNativeObject()));
1207 }
1208
1217 {
1218 checkContextMatch(t1);
1219 checkContextMatch(t2);
1220 return new BitVecExpr(this, Native.mkBvurem(nCtx(),
1221 t1.getNativeObject(), t2.getNativeObject()));
1222 }
1223
1235 {
1236 checkContextMatch(t1);
1237 checkContextMatch(t2);
1238 return new BitVecExpr(this, Native.mkBvsrem(nCtx(),
1239 t1.getNativeObject(), t2.getNativeObject()));
1240 }
1241
1249 {
1250 checkContextMatch(t1);
1251 checkContextMatch(t2);
1252 return new BitVecExpr(this, Native.mkBvsmod(nCtx(),
1253 t1.getNativeObject(), t2.getNativeObject()));
1254 }
1255
1262 {
1263 checkContextMatch(t1);
1264 checkContextMatch(t2);
1265 return new BoolExpr(this, Native.mkBvult(nCtx(), t1.getNativeObject(),
1266 t2.getNativeObject()));
1267 }
1268
1275 {
1276 checkContextMatch(t1);
1277 checkContextMatch(t2);
1278 return new BoolExpr(this, Native.mkBvslt(nCtx(), t1.getNativeObject(),
1279 t2.getNativeObject()));
1280 }
1281
1288 {
1289 checkContextMatch(t1);
1290 checkContextMatch(t2);
1291 return new BoolExpr(this, Native.mkBvule(nCtx(), t1.getNativeObject(),
1292 t2.getNativeObject()));
1293 }
1294
1301 {
1302 checkContextMatch(t1);
1303 checkContextMatch(t2);
1304 return new BoolExpr(this, Native.mkBvsle(nCtx(), t1.getNativeObject(),
1305 t2.getNativeObject()));
1306 }
1307
1314 {
1315 checkContextMatch(t1);
1316 checkContextMatch(t2);
1317 return new BoolExpr(this, Native.mkBvuge(nCtx(), t1.getNativeObject(),
1318 t2.getNativeObject()));
1319 }
1320
1327 {
1328 checkContextMatch(t1);
1329 checkContextMatch(t2);
1330 return new BoolExpr(this, Native.mkBvsge(nCtx(), t1.getNativeObject(),
1331 t2.getNativeObject()));
1332 }
1333
1340 {
1341 checkContextMatch(t1);
1342 checkContextMatch(t2);
1343 return new BoolExpr(this, Native.mkBvugt(nCtx(), t1.getNativeObject(),
1344 t2.getNativeObject()));
1345 }
1346
1353 {
1354 checkContextMatch(t1);
1355 checkContextMatch(t2);
1356 return new BoolExpr(this, Native.mkBvsgt(nCtx(), t1.getNativeObject(),
1357 t2.getNativeObject()));
1358 }
1359
1371 {
1372 checkContextMatch(t1);
1373 checkContextMatch(t2);
1374 return new BitVecExpr(this, Native.mkConcat(nCtx(),
1375 t1.getNativeObject(), t2.getNativeObject()));
1376 }
1377
1386 public BitVecExpr mkExtract(int high, int low, Expr<BitVecSort> t)
1387
1388 {
1389 checkContextMatch(t);
1390 return new BitVecExpr(this, Native.mkExtract(nCtx(), high, low,
1391 t.getNativeObject()));
1392 }
1393
1402 {
1403 checkContextMatch(t);
1404 return new BitVecExpr(this, Native.mkSignExt(nCtx(), i,
1405 t.getNativeObject()));
1406 }
1407
1416 {
1417 checkContextMatch(t);
1418 return new BitVecExpr(this, Native.mkZeroExt(nCtx(), i,
1419 t.getNativeObject()));
1420 }
1421
1428 {
1429 checkContextMatch(t);
1430 return new BitVecExpr(this, Native.mkRepeat(nCtx(), i,
1431 t.getNativeObject()));
1432 }
1433
1446 {
1447 checkContextMatch(t1);
1448 checkContextMatch(t2);
1449 return new BitVecExpr(this, Native.mkBvshl(nCtx(),
1450 t1.getNativeObject(), t2.getNativeObject()));
1451 }
1452
1465 {
1466 checkContextMatch(t1);
1467 checkContextMatch(t2);
1468 return new BitVecExpr(this, Native.mkBvlshr(nCtx(),
1469 t1.getNativeObject(), t2.getNativeObject()));
1470 }
1471
1485 {
1486 checkContextMatch(t1);
1487 checkContextMatch(t2);
1488 return new BitVecExpr(this, Native.mkBvashr(nCtx(),
1489 t1.getNativeObject(), t2.getNativeObject()));
1490 }
1491
1498 {
1499 checkContextMatch(t);
1500 return new BitVecExpr(this, Native.mkRotateLeft(nCtx(), i,
1501 t.getNativeObject()));
1502 }
1503
1510 {
1511 checkContextMatch(t);
1512 return new BitVecExpr(this, Native.mkRotateRight(nCtx(), i,
1513 t.getNativeObject()));
1514 }
1515
1523
1524 {
1525 checkContextMatch(t1);
1526 checkContextMatch(t2);
1527 return new BitVecExpr(this, Native.mkExtRotateLeft(nCtx(),
1528 t1.getNativeObject(), t2.getNativeObject()));
1529 }
1530
1538
1539 {
1540 checkContextMatch(t1);
1541 checkContextMatch(t2);
1542 return new BitVecExpr(this, Native.mkExtRotateRight(nCtx(),
1543 t1.getNativeObject(), t2.getNativeObject()));
1544 }
1545
1556 {
1557 checkContextMatch(t);
1558 return new BitVecExpr(this, Native.mkInt2bv(nCtx(), n,
1559 t.getNativeObject()));
1560 }
1561
1576 public IntExpr mkBV2Int(Expr<BitVecSort> t, boolean signed)
1577 {
1578 checkContextMatch(t);
1579 return new IntExpr(this, Native.mkBv2int(nCtx(), t.getNativeObject(),
1580 (signed)));
1581 }
1582
1589 boolean isSigned)
1590 {
1591 checkContextMatch(t1);
1592 checkContextMatch(t2);
1593 return new BoolExpr(this, Native.mkBvaddNoOverflow(nCtx(), t1
1594 .getNativeObject(), t2.getNativeObject(), (isSigned)));
1595 }
1596
1603
1604 {
1605 checkContextMatch(t1);
1606 checkContextMatch(t2);
1607 return new BoolExpr(this, Native.mkBvaddNoUnderflow(nCtx(),
1608 t1.getNativeObject(), t2.getNativeObject()));
1609 }
1610
1617
1618 {
1619 checkContextMatch(t1);
1620 checkContextMatch(t2);
1621 return new BoolExpr(this, Native.mkBvsubNoOverflow(nCtx(),
1622 t1.getNativeObject(), t2.getNativeObject()));
1623 }
1624
1631 boolean isSigned)
1632 {
1633 checkContextMatch(t1);
1634 checkContextMatch(t2);
1635 return new BoolExpr(this, Native.mkBvsubNoUnderflow(nCtx(), t1
1636 .getNativeObject(), t2.getNativeObject(), (isSigned)));
1637 }
1638
1645
1646 {
1647 checkContextMatch(t1);
1648 checkContextMatch(t2);
1649 return new BoolExpr(this, Native.mkBvsdivNoOverflow(nCtx(),
1650 t1.getNativeObject(), t2.getNativeObject()));
1651 }
1652
1659 {
1660 checkContextMatch(t);
1661 return new BoolExpr(this, Native.mkBvnegNoOverflow(nCtx(),
1662 t.getNativeObject()));
1663 }
1664
1671 boolean isSigned)
1672 {
1673 checkContextMatch(t1);
1674 checkContextMatch(t2);
1675 return new BoolExpr(this, Native.mkBvmulNoOverflow(nCtx(), t1
1676 .getNativeObject(), t2.getNativeObject(), (isSigned)));
1677 }
1678
1685
1686 {
1687 checkContextMatch(t1);
1688 checkContextMatch(t2);
1689 return new BoolExpr(this, Native.mkBvmulNoUnderflow(nCtx(),
1690 t1.getNativeObject(), t2.getNativeObject()));
1691 }
1692
1696 public <D extends Sort, R extends Sort> ArrayExpr<D, R> mkArrayConst(Symbol name, D domain, R range)
1697
1698 {
1699 return (ArrayExpr<D, R>) mkConst(name, mkArraySort(domain, range));
1700 }
1701
1705 public <D extends Sort, R extends Sort> ArrayExpr<D, R> mkArrayConst(String name, D domain, R range)
1706
1707 {
1708 return (ArrayExpr<D, R>) mkConst(mkSymbol(name), mkArraySort(domain, range));
1709 }
1710
1723 public <D extends Sort, R extends Sort> Expr<R> mkSelect(Expr<ArraySort<D, R>> a, Expr<D> i)
1724 {
1725 checkContextMatch(a);
1726 checkContextMatch(i);
1727 return (Expr<R>) Expr.create(
1728 this,
1729 Native.mkSelect(nCtx(), a.getNativeObject(),
1730 i.getNativeObject()));
1731 }
1732
1745 public <R extends Sort> Expr<R> mkSelect(Expr<ArraySort<Sort, R>> a, Expr<?>[] args)
1746 {
1747 checkContextMatch(a);
1748 checkContextMatch(args);
1749 return (Expr<R>) Expr.create(
1750 this,
1751 Native.mkSelectN(nCtx(), a.getNativeObject(), args.length, AST.arrayToNative(args)));
1752 }
1753
1770 public <D extends Sort, R extends Sort> ArrayExpr<D, R> mkStore(Expr<ArraySort<D, R>> a, Expr<D> i, Expr<R> v)
1771 {
1772 checkContextMatch(a);
1773 checkContextMatch(i);
1774 checkContextMatch(v);
1775 return new ArrayExpr<>(this, Native.mkStore(nCtx(), a.getNativeObject(),
1776 i.getNativeObject(), v.getNativeObject()));
1777 }
1778
1795 public <R extends Sort> ArrayExpr<Sort, R> mkStore(Expr<ArraySort<Sort, R>> a, Expr<?>[] args, Expr<R> v)
1796 {
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()));
1802 }
1803
1813 public <D extends Sort, R extends Sort> ArrayExpr<D, R> mkConstArray(D domain, Expr<R> v)
1814 {
1815 checkContextMatch(domain);
1816 checkContextMatch(v);
1817 return new ArrayExpr<>(this, Native.mkConstArray(nCtx(),
1818 domain.getNativeObject(), v.getNativeObject()));
1819 }
1820
1834 @SafeVarargs
1835 public final <D extends Sort, R1 extends Sort, R2 extends Sort> ArrayExpr<D, R2> mkMap(FuncDecl<R2> f, Expr<ArraySort<D, R1>>... args)
1836 {
1837 checkContextMatch(f);
1838 checkContextMatch(args);
1839 return (ArrayExpr<D, R2>) Expr.create(this, Native.mkMap(nCtx(),
1840 f.getNativeObject(), AST.arrayLength(args),
1841 AST.arrayToNative(args)));
1842 }
1843
1850 public <D extends Sort, R extends Sort> Expr<R> mkTermArray(Expr<ArraySort<D, R>> array)
1851 {
1852 checkContextMatch(array);
1853 return (Expr<R>) Expr.create(this,
1854 Native.mkArrayDefault(nCtx(), array.getNativeObject()));
1855 }
1856
1860 public <D extends Sort, R extends Sort> Expr<D> mkArrayExt(Expr<ArraySort<D, R>> arg1, Expr<ArraySort<D, R>> arg2)
1861 {
1862 checkContextMatch(arg1);
1863 checkContextMatch(arg2);
1864 return (Expr<D>) Expr.create(this, Native.mkArrayExt(nCtx(), arg1.getNativeObject(), arg2.getNativeObject()));
1865 }
1866
1867
1871 public <D extends Sort> SetSort<D> mkSetSort(D ty)
1872 {
1873 checkContextMatch(ty);
1874 return new SetSort<>(this, ty);
1875 }
1876
1880 public <D extends Sort> ArrayExpr<D, BoolSort> mkEmptySet(D domain)
1881 {
1882 checkContextMatch(domain);
1883 return (ArrayExpr<D, BoolSort>) Expr.create(this,
1884 Native.mkEmptySet(nCtx(), domain.getNativeObject()));
1885 }
1886
1890 public <D extends Sort> ArrayExpr<D, BoolSort> mkFullSet(D domain)
1891 {
1892 checkContextMatch(domain);
1893 return (ArrayExpr<D, BoolSort>) Expr.create(this,
1894 Native.mkFullSet(nCtx(), domain.getNativeObject()));
1895 }
1896
1900 public <D extends Sort> ArrayExpr<D, BoolSort> mkSetAdd(Expr<ArraySort<D, BoolSort>> set, Expr<D> element)
1901 {
1902 checkContextMatch(set);
1903 checkContextMatch(element);
1904 return (ArrayExpr<D, BoolSort>) Expr.create(this,
1905 Native.mkSetAdd(nCtx(), set.getNativeObject(),
1906 element.getNativeObject()));
1907 }
1908
1912 public <D extends Sort> ArrayExpr<D, BoolSort> mkSetDel(Expr<ArraySort<D, BoolSort>> set, Expr<D> element)
1913 {
1914 checkContextMatch(set);
1915 checkContextMatch(element);
1916 return (ArrayExpr<D, BoolSort>)Expr.create(this,
1917 Native.mkSetDel(nCtx(), set.getNativeObject(),
1918 element.getNativeObject()));
1919 }
1920
1924 @SafeVarargs
1925 public final <D extends Sort> ArrayExpr<D, BoolSort> mkSetUnion(Expr<ArraySort<D, BoolSort>>... args)
1926 {
1927 checkContextMatch(args);
1928 return (ArrayExpr<D, BoolSort>)Expr.create(this,
1929 Native.mkSetUnion(nCtx(), args.length,
1930 AST.arrayToNative(args)));
1931 }
1932
1936 @SafeVarargs
1938 {
1939 checkContextMatch(args);
1940 return (ArrayExpr<D, BoolSort>) Expr.create(this,
1941 Native.mkSetIntersect(nCtx(), args.length,
1942 AST.arrayToNative(args)));
1943 }
1944
1948 public <D extends Sort> ArrayExpr<D, BoolSort> mkSetDifference(Expr<ArraySort<D, BoolSort>> arg1, Expr<ArraySort<D, BoolSort>> arg2)
1949 {
1950 checkContextMatch(arg1);
1951 checkContextMatch(arg2);
1952 return (ArrayExpr<D, BoolSort>) Expr.create(this,
1953 Native.mkSetDifference(nCtx(), arg1.getNativeObject(),
1954 arg2.getNativeObject()));
1955 }
1956
1960 public <D extends Sort> ArrayExpr<D, BoolSort> mkSetComplement(Expr<ArraySort<D, BoolSort>> arg)
1961 {
1962 checkContextMatch(arg);
1963 return (ArrayExpr<D, BoolSort>)Expr.create(this,
1964 Native.mkSetComplement(nCtx(), arg.getNativeObject()));
1965 }
1966
1970 public <D extends Sort> BoolExpr mkSetMembership(Expr<D> elem, Expr<ArraySort<D, BoolSort>> set)
1971 {
1972 checkContextMatch(elem);
1973 checkContextMatch(set);
1974 return (BoolExpr) Expr.create(this,
1975 Native.mkSetMember(nCtx(), elem.getNativeObject(),
1976 set.getNativeObject()));
1977 }
1978
1982 public <D extends Sort> BoolExpr mkSetSubset(Expr<ArraySort<D, BoolSort>> arg1, Expr<ArraySort<D, BoolSort>> arg2)
1983 {
1984 checkContextMatch(arg1);
1985 checkContextMatch(arg2);
1986 return (BoolExpr) Expr.create(this,
1987 Native.mkSetSubset(nCtx(), arg1.getNativeObject(),
1988 arg2.getNativeObject()));
1989 }
1990
1991
1999 public <R extends Sort> SeqExpr<R> mkEmptySeq(R s)
2000 {
2001 checkContextMatch(s);
2002 return (SeqExpr<R>) Expr.create(this, Native.mkSeqEmpty(nCtx(), s.getNativeObject()));
2003 }
2004
2008 public <R extends Sort> SeqExpr<R> mkUnit(Expr<R> elem)
2009 {
2010 checkContextMatch(elem);
2011 return (SeqExpr<R>) Expr.create(this, Native.mkSeqUnit(nCtx(), elem.getNativeObject()));
2012 }
2013
2018 {
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));
2024 else
2025 buf.append(s.charAt(i));
2026 }
2027 return (SeqExpr<CharSort>) Expr.create(this, Native.mkString(nCtx(), buf.toString()));
2028 }
2029
2034 {
2035 return (SeqExpr<CharSort>) Expr.create(this, Native.mkIntToStr(nCtx(), e.getNativeObject()));
2036 }
2037
2042 {
2043 return (SeqExpr<CharSort>) Expr.create(this, Native.mkUbvToStr(nCtx(), e.getNativeObject()));
2044 }
2045
2050 {
2051 return (SeqExpr<CharSort>) Expr.create(this, Native.mkSbvToStr(nCtx(), e.getNativeObject()));
2052 }
2053
2058 {
2059 return (IntExpr) Expr.create(this, Native.mkStrToInt(nCtx(), e.getNativeObject()));
2060 }
2061
2065 @SafeVarargs
2066 public final <R extends Sort> SeqExpr<R> mkConcat(Expr<SeqSort<R>>... t)
2067 {
2068 checkContextMatch(t);
2069 return (SeqExpr<R>) Expr.create(this, Native.mkSeqConcat(nCtx(), t.length, AST.arrayToNative(t)));
2070 }
2071
2072
2076 public <R extends Sort> IntExpr mkLength(Expr<SeqSort<R>> s)
2077 {
2078 checkContextMatch(s);
2079 return (IntExpr) Expr.create(this, Native.mkSeqLength(nCtx(), s.getNativeObject()));
2080 }
2081
2085 public <R extends Sort> BoolExpr mkPrefixOf(Expr<SeqSort<R>> s1, Expr<SeqSort<R>> s2)
2086 {
2087 checkContextMatch(s1, s2);
2088 return (BoolExpr) Expr.create(this, Native.mkSeqPrefix(nCtx(), s1.getNativeObject(), s2.getNativeObject()));
2089 }
2090
2094 public <R extends Sort> BoolExpr mkSuffixOf(Expr<SeqSort<R>> s1, Expr<SeqSort<R>> s2)
2095 {
2096 checkContextMatch(s1, s2);
2097 return (BoolExpr)Expr.create(this, Native.mkSeqSuffix(nCtx(), s1.getNativeObject(), s2.getNativeObject()));
2098 }
2099
2103 public <R extends Sort> BoolExpr mkContains(Expr<SeqSort<R>> s1, Expr<SeqSort<R>> s2)
2104 {
2105 checkContextMatch(s1, s2);
2106 return (BoolExpr) Expr.create(this, Native.mkSeqContains(nCtx(), s1.getNativeObject(), s2.getNativeObject()));
2107 }
2108
2114 {
2115 checkContextMatch(s1, s2);
2116 return new BoolExpr(this, Native.mkStrLt(nCtx(), s1.getNativeObject(), s2.getNativeObject()));
2117 }
2118
2123 {
2124 checkContextMatch(s1, s2);
2125 return new BoolExpr(this, Native.mkStrLe(nCtx(), s1.getNativeObject(), s2.getNativeObject()));
2126 }
2127
2128
2132 public <R extends Sort> SeqExpr<R> mkAt(Expr<SeqSort<R>> s, Expr<IntSort> index)
2133 {
2134 checkContextMatch(s, index);
2135 return (SeqExpr<R>) Expr.create(this, Native.mkSeqAt(nCtx(), s.getNativeObject(), index.getNativeObject()));
2136 }
2137
2141 public <R extends Sort> Expr<R> mkNth(Expr<SeqSort<R>> s, Expr<IntSort> index)
2142 {
2143 checkContextMatch(s, index);
2144 return (Expr<R>) Expr.create(this, Native.mkSeqNth(nCtx(), s.getNativeObject(), index.getNativeObject()));
2145 }
2146
2147
2151 public <R extends Sort> SeqExpr<R> mkExtract(Expr<SeqSort<R>> s, Expr<IntSort> offset, Expr<IntSort> length)
2152 {
2153 checkContextMatch(s, offset, length);
2154 return (SeqExpr<R>) Expr.create(this, Native.mkSeqExtract(nCtx(), s.getNativeObject(), offset.getNativeObject(), length.getNativeObject()));
2155 }
2156
2160 public <R extends Sort> IntExpr mkIndexOf(Expr<SeqSort<R>> s, Expr<SeqSort<R>> substr, Expr<IntSort> offset)
2161 {
2162 checkContextMatch(s, substr, offset);
2163 return (IntExpr)Expr.create(this, Native.mkSeqIndex(nCtx(), s.getNativeObject(), substr.getNativeObject(), offset.getNativeObject()));
2164 }
2165
2169 public <R extends Sort> SeqExpr<R> mkReplace(Expr<SeqSort<R>> s, Expr<SeqSort<R>> src, Expr<SeqSort<R>> dst)
2170 {
2171 checkContextMatch(s, src, dst);
2172 return (SeqExpr<R>) Expr.create(this, Native.mkSeqReplace(nCtx(), s.getNativeObject(), src.getNativeObject(), dst.getNativeObject()));
2173 }
2174
2178 public <R extends Sort> ReExpr<R> mkToRe(Expr<SeqSort<R>> s)
2179 {
2180 checkContextMatch(s);
2181 return (ReExpr<R>) Expr.create(this, Native.mkSeqToRe(nCtx(), s.getNativeObject()));
2182 }
2183
2184
2188 public <R extends Sort> BoolExpr mkInRe(Expr<SeqSort<R>> s, Expr<ReSort<R>> re)
2189 {
2190 checkContextMatch(s, re);
2191 return (BoolExpr) Expr.create(this, Native.mkSeqInRe(nCtx(), s.getNativeObject(), re.getNativeObject()));
2192 }
2193
2197 public <R extends Sort> ReExpr<R> mkStar(Expr<ReSort<R>> re)
2198 {
2199 checkContextMatch(re);
2200 return (ReExpr<R>) Expr.create(this, Native.mkReStar(nCtx(), re.getNativeObject()));
2201 }
2202
2206 public <R extends Sort> ReExpr<R> mkPower(Expr<ReSort<R>> re, int n)
2207 {
2208 return (ReExpr<R>) Expr.create(this, Native.mkRePower(nCtx(), re.getNativeObject(), n));
2209 }
2210
2214 public <R extends Sort> ReExpr<R> mkLoop(Expr<ReSort<R>> re, int lo, int hi)
2215 {
2216 return (ReExpr<R>) Expr.create(this, Native.mkReLoop(nCtx(), re.getNativeObject(), lo, hi));
2217 }
2218
2222 public <R extends Sort> ReExpr<R> mkLoop(Expr<ReSort<R>> re, int lo)
2223 {
2224 return (ReExpr<R>) Expr.create(this, Native.mkReLoop(nCtx(), re.getNativeObject(), lo, 0));
2225 }
2226
2227
2231 public <R extends Sort> ReExpr<R> mkPlus(Expr<ReSort<R>> re)
2232 {
2233 checkContextMatch(re);
2234 return (ReExpr<R>) Expr.create(this, Native.mkRePlus(nCtx(), re.getNativeObject()));
2235 }
2236
2240 public <R extends Sort> ReExpr<R> mkOption(Expr<ReSort<R>> re)
2241 {
2242 checkContextMatch(re);
2243 return (ReExpr<R>) Expr.create(this, Native.mkReOption(nCtx(), re.getNativeObject()));
2244 }
2245
2249 public <R extends Sort> ReExpr<R> mkComplement(Expr<ReSort<R>> re)
2250 {
2251 checkContextMatch(re);
2252 return (ReExpr<R>) Expr.create(this, Native.mkReComplement(nCtx(), re.getNativeObject()));
2253 }
2254
2258 @SafeVarargs
2259 public final <R extends Sort> ReExpr<R> mkConcat(ReExpr<R>... t)
2260 {
2261 checkContextMatch(t);
2262 return (ReExpr<R>) Expr.create(this, Native.mkReConcat(nCtx(), t.length, AST.arrayToNative(t)));
2263 }
2264
2268 @SafeVarargs
2269 public final <R extends Sort> ReExpr<R> mkUnion(Expr<ReSort<R>>... t)
2270 {
2271 checkContextMatch(t);
2272 return (ReExpr<R>) Expr.create(this, Native.mkReUnion(nCtx(), t.length, AST.arrayToNative(t)));
2273 }
2274
2278 @SafeVarargs
2279 public final <R extends Sort> ReExpr<R> mkIntersect(Expr<ReSort<R>>... t)
2280 {
2281 checkContextMatch(t);
2282 return (ReExpr<R>) Expr.create(this, Native.mkReIntersect(nCtx(), t.length, AST.arrayToNative(t)));
2283 }
2284
2288 public <R extends Sort> ReExpr<R> mkDiff(Expr<ReSort<R>> a, Expr<ReSort<R>> b)
2289 {
2290 checkContextMatch(a, b);
2291 return (ReExpr<R>) Expr.create(this, Native.mkReDiff(nCtx(), a.getNativeObject(), b.getNativeObject()));
2292 }
2293
2294
2299 public <R extends Sort> ReExpr<R> mkEmptyRe(R s)
2300 {
2301 return (ReExpr<R>) Expr.create(this, Native.mkReEmpty(nCtx(), s.getNativeObject()));
2302 }
2303
2308 public <R extends Sort> ReExpr<R> mkFullRe(R s)
2309 {
2310 return (ReExpr<R>) Expr.create(this, Native.mkReFull(nCtx(), s.getNativeObject()));
2311 }
2312
2317 public <R extends Sort> ReExpr<R> mkAllcharRe(R s)
2318 {
2319 return (ReExpr<R>) Expr.create(this, Native.mkReAllchar(nCtx(), s.getNativeObject()));
2320 }
2321
2325 public <R extends Sort> ReExpr<R> mkRange(Expr<SeqSort<CharSort>> lo, Expr<SeqSort<CharSort>> hi)
2326 {
2327 checkContextMatch(lo, hi);
2328 return (ReExpr<R>) Expr.create(this, Native.mkReRange(nCtx(), lo.getNativeObject(), hi.getNativeObject()));
2329 }
2330
2335 {
2336 checkContextMatch(ch1, ch2);
2337 return (BoolExpr) Expr.create(this, Native.mkCharLe(nCtx(), ch1.getNativeObject(), ch2.getNativeObject()));
2338 }
2339
2344 {
2345 checkContextMatch(ch);
2346 return (IntExpr) Expr.create(this, Native.mkCharToInt(nCtx(), ch.getNativeObject()));
2347 }
2348
2353 {
2354 checkContextMatch(ch);
2355 return (BitVecExpr) Expr.create(this, Native.mkCharToBv(nCtx(), ch.getNativeObject()));
2356 }
2357
2362 {
2363 checkContextMatch(bv);
2364 return (Expr<CharSort>) Expr.create(this, Native.mkCharFromBv(nCtx(), bv.getNativeObject()));
2365 }
2366
2371 {
2372 checkContextMatch(ch);
2373 return (BoolExpr) Expr.create(this, Native.mkCharIsDigit(nCtx(), ch.getNativeObject()));
2374 }
2375
2379 public BoolExpr mkAtMost(Expr<BoolSort>[] args, int k)
2380 {
2381 checkContextMatch(args);
2382 return (BoolExpr) Expr.create(this, Native.mkAtmost(nCtx(), args.length, AST.arrayToNative(args), k));
2383 }
2384
2388 public BoolExpr mkAtLeast(Expr<BoolSort>[] args, int k)
2389 {
2390 checkContextMatch(args);
2391 return (BoolExpr) Expr.create(this, Native.mkAtleast(nCtx(), args.length, AST.arrayToNative(args), k));
2392 }
2393
2397 public BoolExpr mkPBLe(int[] coeffs, Expr<BoolSort>[] args, int k)
2398 {
2399 checkContextMatch(args);
2400 return (BoolExpr) Expr.create(this, Native.mkPble(nCtx(), args.length, AST.arrayToNative(args), coeffs, k));
2401 }
2402
2406 public BoolExpr mkPBGe(int[] coeffs, Expr<BoolSort>[] args, int k)
2407 {
2408 checkContextMatch(args);
2409 return (BoolExpr) Expr.create(this, Native.mkPbge(nCtx(), args.length, AST.arrayToNative(args), coeffs, k));
2410 }
2411
2415 public BoolExpr mkPBEq(int[] coeffs, Expr<BoolSort>[] args, int k)
2416 {
2417 checkContextMatch(args);
2418 return (BoolExpr) Expr.create(this, Native.mkPbeq(nCtx(), args.length, AST.arrayToNative(args), coeffs, k));
2419 }
2420
2432 public <R extends Sort> Expr<R> mkNumeral(String v, R ty)
2433 {
2434 checkContextMatch(ty);
2435 return (Expr<R>) Expr.create(this,
2436 Native.mkNumeral(nCtx(), v, ty.getNativeObject()));
2437 }
2438
2449 public <R extends Sort> Expr<R> mkNumeral(int v, R ty)
2450 {
2451 checkContextMatch(ty);
2452 return (Expr<R>) Expr.create(this, Native.mkInt(nCtx(), v, ty.getNativeObject()));
2453 }
2454
2465 public <R extends Sort> Expr<R> mkNumeral(long v, R ty)
2466 {
2467 checkContextMatch(ty);
2468 return (Expr<R>) Expr.create(this,
2469 Native.mkInt64(nCtx(), v, ty.getNativeObject()));
2470 }
2471
2481 public RatNum mkReal(int num, int den)
2482 {
2483 if (den == 0) {
2484 throw new Z3Exception("Denominator is zero");
2485 }
2486
2487 return new RatNum(this, Native.mkReal(nCtx(), num, den));
2488 }
2489
2497 {
2498
2499 return new RatNum(this, Native.mkNumeral(nCtx(), v, getRealSort()
2500 .getNativeObject()));
2501 }
2502
2509 public RatNum mkReal(int v)
2510 {
2511
2512 return new RatNum(this, Native.mkInt(nCtx(), v, getRealSort()
2513 .getNativeObject()));
2514 }
2515
2522 public RatNum mkReal(long v)
2523 {
2524
2525 return new RatNum(this, Native.mkInt64(nCtx(), v, getRealSort()
2526 .getNativeObject()));
2527 }
2528
2534 {
2535
2536 return new IntNum(this, Native.mkNumeral(nCtx(), v, getIntSort()
2537 .getNativeObject()));
2538 }
2539
2546 public IntNum mkInt(int v)
2547 {
2548
2549 return new IntNum(this, Native.mkInt(nCtx(), v, getIntSort()
2550 .getNativeObject()));
2551 }
2552
2559 public IntNum mkInt(long v)
2560 {
2561
2562 return new IntNum(this, Native.mkInt64(nCtx(), v, getIntSort()
2563 .getNativeObject()));
2564 }
2565
2571 public BitVecNum mkBV(String v, int size)
2572 {
2573 return (BitVecNum) mkNumeral(v, mkBitVecSort(size));
2574 }
2575
2581 public BitVecNum mkBV(int v, int size)
2582 {
2583 return (BitVecNum) mkNumeral(v, mkBitVecSort(size));
2584 }
2585
2591 public BitVecNum mkBV(long v, int size)
2592 {
2593 return (BitVecNum) mkNumeral(v, mkBitVecSort(size));
2594 }
2595
2621 public Quantifier mkForall(Sort[] sorts, Symbol[] names, Expr<BoolSort> body,
2622 int weight, Pattern[] patterns, Expr<?>[] noPatterns,
2623 Symbol quantifierID, Symbol skolemID)
2624 {
2625 return Quantifier.of(this, true, sorts, names, body, weight, patterns,
2626 noPatterns, quantifierID, skolemID);
2627 }
2628
2633 public Quantifier mkForall(Expr<?>[] boundConstants, Expr<BoolSort> body, int weight,
2634 Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID,
2635 Symbol skolemID)
2636 {
2637
2638 return Quantifier.of(this, true, boundConstants, body, weight,
2639 patterns, noPatterns, quantifierID, skolemID);
2640 }
2641
2646 public Quantifier mkExists(Sort[] sorts, Symbol[] names, Expr<BoolSort> body,
2647 int weight, Pattern[] patterns, Expr<?>[] noPatterns,
2648 Symbol quantifierID, Symbol skolemID)
2649 {
2650
2651 return Quantifier.of(this, false, sorts, names, body, weight,
2652 patterns, noPatterns, quantifierID, skolemID);
2653 }
2654
2659 public Quantifier mkExists(Expr<?>[] boundConstants, Expr<BoolSort> body, int weight,
2660 Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID,
2661 Symbol skolemID)
2662 {
2663
2664 return Quantifier.of(this, false, boundConstants, body, weight,
2665 patterns, noPatterns, quantifierID, skolemID);
2666 }
2667
2672 public Quantifier mkQuantifier(boolean universal, Sort[] sorts,
2673 Symbol[] names, Expr<BoolSort> body, int weight, Pattern[] patterns,
2674 Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
2675
2676 {
2677
2678 if (universal)
2679 return mkForall(sorts, names, body, weight, patterns, noPatterns,
2680 quantifierID, skolemID);
2681 else
2682 return mkExists(sorts, names, body, weight, patterns, noPatterns,
2683 quantifierID, skolemID);
2684 }
2685
2690 public Quantifier mkQuantifier(boolean universal, Expr<?>[] boundConstants,
2691 Expr<BoolSort> body, int weight, Pattern[] patterns, Expr<?>[] noPatterns,
2692 Symbol quantifierID, Symbol skolemID)
2693 {
2694
2695 if (universal)
2696 return mkForall(boundConstants, body, weight, patterns, noPatterns,
2697 quantifierID, skolemID);
2698 else
2699 return mkExists(boundConstants, body, weight, patterns, noPatterns,
2700 quantifierID, skolemID);
2701 }
2702
2720 public <R extends Sort> Lambda<R> mkLambda(Sort[] sorts, Symbol[] names, Expr<R> body)
2721 {
2722 return Lambda.of(this, sorts, names, body);
2723 }
2724
2731 public <R extends Sort> Lambda<R> mkLambda(Expr<?>[] boundConstants, Expr<R> body)
2732 {
2733 return Lambda.of(this, boundConstants, body);
2734 }
2735
2736
2752 {
2753 Native.setAstPrintMode(nCtx(), value.toInt());
2754 }
2755
2770 String status, String attributes, Expr<BoolSort>[] assumptions,
2771 Expr<BoolSort> formula)
2772 {
2773
2774 return Native.benchmarkToSmtlibString(nCtx(), name, logic, status,
2775 attributes, assumptions.length,
2776 AST.arrayToNative(assumptions), formula.getNativeObject());
2777 }
2778
2788 public BoolExpr[] parseSMTLIB2String(String str, Symbol[] sortNames,
2789 Sort[] sorts, Symbol[] declNames, FuncDecl<?>[] decls)
2790 {
2791 int csn = Symbol.arrayLength(sortNames);
2792 int cs = Sort.arrayLength(sorts);
2793 int cdn = Symbol.arrayLength(declNames);
2794 int cd = AST.arrayLength(decls);
2795 if (csn != cs || cdn != cd) {
2796 throw new Z3Exception("Argument size mismatch");
2797 }
2798 ASTVector v = new ASTVector(this, Native.parseSmtlib2String(nCtx(),
2799 str, AST.arrayLength(sorts), Symbol.arrayToNative(sortNames),
2800 AST.arrayToNative(sorts), AST.arrayLength(decls),
2801 Symbol.arrayToNative(declNames), AST.arrayToNative(decls)));
2802 return v.ToBoolExprArray();
2803 }
2804
2809 public BoolExpr[] parseSMTLIB2File(String fileName, Symbol[] sortNames,
2810 Sort[] sorts, Symbol[] declNames, FuncDecl<?>[] decls)
2811 {
2812 int csn = Symbol.arrayLength(sortNames);
2813 int cs = Sort.arrayLength(sorts);
2814 int cdn = Symbol.arrayLength(declNames);
2815 int cd = AST.arrayLength(decls);
2816 if (csn != cs || cdn != cd)
2817 throw new Z3Exception("Argument size mismatch");
2818 ASTVector v = new ASTVector(this, Native.parseSmtlib2File(nCtx(),
2819 fileName, AST.arrayLength(sorts),
2820 Symbol.arrayToNative(sortNames), AST.arrayToNative(sorts),
2821 AST.arrayLength(decls), Symbol.arrayToNative(declNames),
2822 AST.arrayToNative(decls)));
2823 return v.ToBoolExprArray();
2824 }
2825
2836 public Goal mkGoal(boolean models, boolean unsatCores, boolean proofs)
2837 {
2838 return new Goal(this, models, unsatCores, proofs);
2839 }
2840
2845 {
2846 return new Params(this);
2847 }
2848
2852 public int getNumTactics()
2853 {
2854 return Native.getNumTactics(nCtx());
2855 }
2856
2861 {
2862
2863 int n = getNumTactics();
2864 String[] res = new String[n];
2865 for (int i = 0; i < n; i++)
2866 res[i] = Native.getTacticName(nCtx(), i);
2867 return res;
2868 }
2869
2875 {
2876 return Native.tacticGetDescr(nCtx(), name);
2877 }
2878
2883 {
2884 return new Tactic(this, name);
2885 }
2886
2891 public Tactic andThen(Tactic t1, Tactic t2, Tactic... ts)
2892
2893 {
2894 checkContextMatch(t1);
2895 checkContextMatch(t2);
2896 checkContextMatch(ts);
2897
2898 long last = 0;
2899 if (ts != null && ts.length > 0)
2900 {
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(),
2904 last);
2905 }
2906 }
2907 if (last != 0)
2908 {
2909 last = Native.tacticAndThen(nCtx(), t2.getNativeObject(), last);
2910 return new Tactic(this, Native.tacticAndThen(nCtx(),
2911 t1.getNativeObject(), last));
2912 } else
2913 return new Tactic(this, Native.tacticAndThen(nCtx(),
2914 t1.getNativeObject(), t2.getNativeObject()));
2915 }
2916
2923 public Tactic then(Tactic t1, Tactic t2, Tactic... ts)
2924 {
2925 return andThen(t1, t2, ts);
2926 }
2927
2934 {
2935 checkContextMatch(t1);
2936 checkContextMatch(t2);
2937 return new Tactic(this, Native.tacticOrElse(nCtx(),
2938 t1.getNativeObject(), t2.getNativeObject()));
2939 }
2940
2947 public Tactic tryFor(Tactic t, int ms)
2948 {
2949 checkContextMatch(t);
2950 return new Tactic(this, Native.tacticTryFor(nCtx(),
2951 t.getNativeObject(), ms));
2952 }
2953
2961 {
2962 checkContextMatch(t);
2963 checkContextMatch(p);
2964 return new Tactic(this, Native.tacticWhen(nCtx(), p.getNativeObject(),
2965 t.getNativeObject()));
2966 }
2967
2973 public Tactic cond(Probe p, Tactic t1, Tactic t2)
2974 {
2975 checkContextMatch(p);
2976 checkContextMatch(t1);
2977 checkContextMatch(t2);
2978 return new Tactic(this, Native.tacticCond(nCtx(), p.getNativeObject(),
2979 t1.getNativeObject(), t2.getNativeObject()));
2980 }
2981
2986 public Tactic repeat(Tactic t, int max)
2987 {
2988 checkContextMatch(t);
2989 return new Tactic(this, Native.tacticRepeat(nCtx(),
2990 t.getNativeObject(), max));
2991 }
2992
2996 public Tactic skip()
2997 {
2998 return new Tactic(this, Native.tacticSkip(nCtx()));
2999 }
3000
3004 public Tactic fail()
3005 {
3006 return new Tactic(this, Native.tacticFail(nCtx()));
3007 }
3008
3014 {
3015 checkContextMatch(p);
3016 return new Tactic(this,
3017 Native.tacticFailIf(nCtx(), p.getNativeObject()));
3018 }
3019
3025 {
3026 return new Tactic(this, Native.tacticFailIfNotDecided(nCtx()));
3027 }
3028
3034 {
3035 checkContextMatch(t);
3036 checkContextMatch(p);
3037 return new Tactic(this, Native.tacticUsingParams(nCtx(),
3038 t.getNativeObject(), p.getNativeObject()));
3039 }
3040
3048 {
3049 return usingParams(t, p);
3050 }
3051
3055 public Tactic parOr(Tactic... t)
3056 {
3057 checkContextMatch(t);
3058 return new Tactic(this, Native.tacticParOr(nCtx(),
3060 }
3061
3067 {
3068 checkContextMatch(t1);
3069 checkContextMatch(t2);
3070 return new Tactic(this, Native.tacticParAndThen(nCtx(),
3071 t1.getNativeObject(), t2.getNativeObject()));
3072 }
3073
3079 public void interrupt()
3080 {
3081 Native.interrupt(nCtx());
3082 }
3083
3087 public int getNumProbes()
3088 {
3089 return Native.getNumProbes(nCtx());
3090 }
3091
3096 {
3097
3098 int n = getNumProbes();
3099 String[] res = new String[n];
3100 for (int i = 0; i < n; i++)
3101 res[i] = Native.getProbeName(nCtx(), i);
3102 return res;
3103 }
3104
3110 {
3111 return Native.probeGetDescr(nCtx(), name);
3112 }
3113
3117 public Probe mkProbe(String name)
3118 {
3119 return new Probe(this, name);
3120 }
3121
3125 public Probe constProbe(double val)
3126 {
3127 return new Probe(this, Native.probeConst(nCtx(), val));
3128 }
3129
3134 public Probe lt(Probe p1, Probe p2)
3135 {
3136 checkContextMatch(p1);
3137 checkContextMatch(p2);
3138 return new Probe(this, Native.probeLt(nCtx(), p1.getNativeObject(),
3139 p2.getNativeObject()));
3140 }
3141
3146 public Probe gt(Probe p1, Probe p2)
3147 {
3148 checkContextMatch(p1);
3149 checkContextMatch(p2);
3150 return new Probe(this, Native.probeGt(nCtx(), p1.getNativeObject(),
3151 p2.getNativeObject()));
3152 }
3153
3159 public Probe le(Probe p1, Probe p2)
3160 {
3161 checkContextMatch(p1);
3162 checkContextMatch(p2);
3163 return new Probe(this, Native.probeLe(nCtx(), p1.getNativeObject(),
3164 p2.getNativeObject()));
3165 }
3166
3172 public Probe ge(Probe p1, Probe p2)
3173 {
3174 checkContextMatch(p1);
3175 checkContextMatch(p2);
3176 return new Probe(this, Native.probeGe(nCtx(), p1.getNativeObject(),
3177 p2.getNativeObject()));
3178 }
3179
3184 public Probe eq(Probe p1, Probe p2)
3185 {
3186 checkContextMatch(p1);
3187 checkContextMatch(p2);
3188 return new Probe(this, Native.probeEq(nCtx(), p1.getNativeObject(),
3189 p2.getNativeObject()));
3190 }
3191
3195 public Probe and(Probe p1, Probe p2)
3196 {
3197 checkContextMatch(p1);
3198 checkContextMatch(p2);
3199 return new Probe(this, Native.probeAnd(nCtx(), p1.getNativeObject(),
3200 p2.getNativeObject()));
3201 }
3202
3206 public Probe or(Probe p1, Probe p2)
3207 {
3208 checkContextMatch(p1);
3209 checkContextMatch(p2);
3210 return new Probe(this, Native.probeOr(nCtx(), p1.getNativeObject(),
3211 p2.getNativeObject()));
3212 }
3213
3217 public Probe not(Probe p)
3218 {
3219 checkContextMatch(p);
3220 return new Probe(this, Native.probeNot(nCtx(), p.getNativeObject()));
3221 }
3222
3231 {
3232 return mkSolver((Symbol) null);
3233 }
3234
3242 public Solver mkSolver(Symbol logic)
3243 {
3244
3245 if (logic == null)
3246 return new Solver(this, Native.mkSolver(nCtx()));
3247 else
3248 return new Solver(this, Native.mkSolverForLogic(nCtx(),
3249 logic.getNativeObject()));
3250 }
3251
3256 public Solver mkSolver(String logic)
3257 {
3258 return mkSolver(mkSymbol(logic));
3259 }
3260
3265 {
3266 return new Solver(this, Native.mkSimpleSolver(nCtx()));
3267 }
3268
3276 {
3277
3278 return new Solver(this, Native.mkSolverFromTactic(nCtx(),
3279 t.getNativeObject()));
3280 }
3281
3286 {
3287 return new Fixedpoint(this);
3288 }
3289
3294 {
3295 return new Optimize(this);
3296 }
3297
3298
3304 {
3305 return new FPRMSort(this);
3306 }
3307
3313 {
3314 return new FPRMExpr(this, Native.mkFpaRoundNearestTiesToEven(nCtx()));
3315 }
3316
3322 {
3323 return new FPRMNum(this, Native.mkFpaRne(nCtx()));
3324 }
3325
3331 {
3332 return new FPRMNum(this, Native.mkFpaRoundNearestTiesToAway(nCtx()));
3333 }
3334
3340 {
3341 return new FPRMNum(this, Native.mkFpaRna(nCtx()));
3342 }
3343
3349 {
3350 return new FPRMNum(this, Native.mkFpaRoundTowardPositive(nCtx()));
3351 }
3352
3358 {
3359 return new FPRMNum(this, Native.mkFpaRtp(nCtx()));
3360 }
3361
3367 {
3368 return new FPRMNum(this, Native.mkFpaRoundTowardNegative(nCtx()));
3369 }
3370
3376 {
3377 return new FPRMNum(this, Native.mkFpaRtn(nCtx()));
3378 }
3379
3385 {
3386 return new FPRMNum(this, Native.mkFpaRoundTowardZero(nCtx()));
3387 }
3388
3394 {
3395 return new FPRMNum(this, Native.mkFpaRtz(nCtx()));
3396 }
3397
3404 public FPSort mkFPSort(int ebits, int sbits)
3405 {
3406 return new FPSort(this, ebits, sbits);
3407 }
3408
3414 {
3415 return new FPSort(this, Native.mkFpaSortHalf(nCtx()));
3416 }
3417
3423 {
3424 return new FPSort(this, Native.mkFpaSort16(nCtx()));
3425 }
3426
3432 {
3433 return new FPSort(this, Native.mkFpaSortSingle(nCtx()));
3434 }
3435
3441 {
3442 return new FPSort(this, Native.mkFpaSort32(nCtx()));
3443 }
3444
3450 {
3451 return new FPSort(this, Native.mkFpaSortDouble(nCtx()));
3452 }
3453
3459 {
3460 return new FPSort(this, Native.mkFpaSort64(nCtx()));
3461 }
3462
3468 {
3469 return new FPSort(this, Native.mkFpaSortQuadruple(nCtx()));
3470 }
3471
3477 {
3478 return new FPSort(this, Native.mkFpaSort128(nCtx()));
3479 }
3480
3481
3488 {
3489 return new FPNum(this, Native.mkFpaNan(nCtx(), s.getNativeObject()));
3490 }
3491
3498 public FPNum mkFPInf(FPSort s, boolean negative)
3499 {
3500 return new FPNum(this, Native.mkFpaInf(nCtx(), s.getNativeObject(), negative));
3501 }
3502
3509 public FPNum mkFPZero(FPSort s, boolean negative)
3510 {
3511 return new FPNum(this, Native.mkFpaZero(nCtx(), s.getNativeObject(), negative));
3512 }
3513
3520 public FPNum mkFPNumeral(float v, FPSort s)
3521 {
3522 return new FPNum(this, Native.mkFpaNumeralFloat(nCtx(), v, s.getNativeObject()));
3523 }
3524
3531 public FPNum mkFPNumeral(double v, FPSort s)
3532 {
3533 return new FPNum(this, Native.mkFpaNumeralDouble(nCtx(), v, s.getNativeObject()));
3534 }
3535
3542 public FPNum mkFPNumeral(int v, FPSort s)
3543 {
3544 return new FPNum(this, Native.mkFpaNumeralInt(nCtx(), v, s.getNativeObject()));
3545 }
3546
3555 public FPNum mkFPNumeral(boolean sgn, int exp, int sig, FPSort s)
3556 {
3557 return new FPNum(this, Native.mkFpaNumeralIntUint(nCtx(), sgn, exp, sig, s.getNativeObject()));
3558 }
3559
3568 public FPNum mkFPNumeral(boolean sgn, long exp, long sig, FPSort s)
3569 {
3570 return new FPNum(this, Native.mkFpaNumeralInt64Uint64(nCtx(), sgn, exp, sig, s.getNativeObject()));
3571 }
3572
3579 public FPNum mkFP(float v, FPSort s)
3580 {
3581 return mkFPNumeral(v, s);
3582 }
3583
3590 public FPNum mkFP(double v, FPSort s)
3591 {
3592 return mkFPNumeral(v, s);
3593 }
3594
3602 public FPNum mkFP(int v, FPSort s)
3603 {
3604 return mkFPNumeral(v, s);
3605 }
3606
3615 public FPNum mkFP(boolean sgn, int exp, int sig, FPSort s)
3616 {
3617 return mkFPNumeral(sgn, exp, sig, s);
3618 }
3619
3628 public FPNum mkFP(boolean sgn, long exp, long sig, FPSort s)
3629 {
3630 return mkFPNumeral(sgn, exp, sig, s);
3631 }
3632
3633
3640 {
3641 return new FPExpr(this, Native.mkFpaAbs(nCtx(), t.getNativeObject()));
3642 }
3643
3650 {
3651 return new FPExpr(this, Native.mkFpaNeg(nCtx(), t.getNativeObject()));
3652 }
3653
3662 {
3663 return new FPExpr(this, Native.mkFpaAdd(nCtx(), rm.getNativeObject(), t1.getNativeObject(), t2.getNativeObject()));
3664 }
3665
3674 {
3675 return new FPExpr(this, Native.mkFpaSub(nCtx(), rm.getNativeObject(), t1.getNativeObject(), t2.getNativeObject()));
3676 }
3677
3686 {
3687 return new FPExpr(this, Native.mkFpaMul(nCtx(), rm.getNativeObject(), t1.getNativeObject(), t2.getNativeObject()));
3688 }
3689
3698 {
3699 return new FPExpr(this, Native.mkFpaDiv(nCtx(), rm.getNativeObject(), t1.getNativeObject(), t2.getNativeObject()));
3700 }
3701
3713 {
3714 return new FPExpr(this, Native.mkFpaFma(nCtx(), rm.getNativeObject(), t1.getNativeObject(), t2.getNativeObject(), t3.getNativeObject()));
3715 }
3716
3724 {
3725 return new FPExpr(this, Native.mkFpaSqrt(nCtx(), rm.getNativeObject(), t.getNativeObject()));
3726 }
3727
3735 {
3736 return new FPExpr(this, Native.mkFpaRem(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3737 }
3738
3747 {
3748 return new FPExpr(this, Native.mkFpaRoundToIntegral(nCtx(), rm.getNativeObject(), t.getNativeObject()));
3749 }
3750
3758 {
3759 return new FPExpr(this, Native.mkFpaMin(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3760 }
3761
3769 {
3770 return new FPExpr(this, Native.mkFpaMax(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3771 }
3772
3780 {
3781 return new BoolExpr(this, Native.mkFpaLeq(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3782 }
3783
3791 {
3792 return new BoolExpr(this, Native.mkFpaLt(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3793 }
3794
3802 {
3803 return new BoolExpr(this, Native.mkFpaGeq(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3804 }
3805
3813 {
3814 return new BoolExpr(this, Native.mkFpaGt(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3815 }
3816
3826 {
3827 return new BoolExpr(this, Native.mkFpaEq(nCtx(), t1.getNativeObject(), t2.getNativeObject()));
3828 }
3829
3836 {
3837 return new BoolExpr(this, Native.mkFpaIsNormal(nCtx(), t.getNativeObject()));
3838 }
3839
3846 {
3847 return new BoolExpr(this, Native.mkFpaIsSubnormal(nCtx(), t.getNativeObject()));
3848 }
3849
3856 {
3857 return new BoolExpr(this, Native.mkFpaIsZero(nCtx(), t.getNativeObject()));
3858 }
3859
3866 {
3867 return new BoolExpr(this, Native.mkFpaIsInfinite(nCtx(), t.getNativeObject()));
3868 }
3869
3876 {
3877 return new BoolExpr(this, Native.mkFpaIsNan(nCtx(), t.getNativeObject()));
3878 }
3879
3886 {
3887 return new BoolExpr(this, Native.mkFpaIsNegative(nCtx(), t.getNativeObject()));
3888 }
3889
3896 {
3897 return new BoolExpr(this, Native.mkFpaIsPositive(nCtx(), t.getNativeObject()));
3898 }
3899
3914 {
3915 return new FPExpr(this, Native.mkFpaFp(nCtx(), sgn.getNativeObject(), sig.getNativeObject(), exp.getNativeObject()));
3916 }
3917
3930 {
3931 return new FPExpr(this, Native.mkFpaToFpBv(nCtx(), bv.getNativeObject(), s.getNativeObject()));
3932 }
3933
3946 {
3947 return new FPExpr(this, Native.mkFpaToFpFloat(nCtx(), rm.getNativeObject(), t.getNativeObject(), s.getNativeObject()));
3948 }
3949
3962 {
3963 return new FPExpr(this, Native.mkFpaToFpReal(nCtx(), rm.getNativeObject(), t.getNativeObject(), s.getNativeObject()));
3964 }
3965
3979 public FPExpr mkFPToFP(Expr<FPRMSort> rm, Expr<BitVecSort> t, FPSort s, boolean signed)
3980 {
3981 if (signed)
3982 return new FPExpr(this, Native.mkFpaToFpSigned(nCtx(), rm.getNativeObject(), t.getNativeObject(), s.getNativeObject()));
3983 else
3984 return new FPExpr(this, Native.mkFpaToFpUnsigned(nCtx(), rm.getNativeObject(), t.getNativeObject(), s.getNativeObject()));
3985 }
3986
3998 {
3999 return new FPExpr(this, Native.mkFpaToFpFloat(nCtx(), s.getNativeObject(), rm.getNativeObject(), t.getNativeObject()));
4000 }
4001
4014 public BitVecExpr mkFPToBV(Expr<FPRMSort> rm, Expr<FPSort> t, int sz, boolean signed)
4015 {
4016 if (signed)
4017 return new BitVecExpr(this, Native.mkFpaToSbv(nCtx(), rm.getNativeObject(), t.getNativeObject(), sz));
4018 else
4019 return new BitVecExpr(this, Native.mkFpaToUbv(nCtx(), rm.getNativeObject(), t.getNativeObject(), sz));
4020 }
4021
4032 {
4033 return new RealExpr(this, Native.mkFpaToReal(nCtx(), t.getNativeObject()));
4034 }
4035
4047 {
4048 return new BitVecExpr(this, Native.mkFpaToIeeeBv(nCtx(), t.getNativeObject()));
4049 }
4050
4065 {
4066 return new BitVecExpr(this, Native.mkFpaToFpIntReal(nCtx(), rm.getNativeObject(), exp.getNativeObject(), sig.getNativeObject(), s.getNativeObject()));
4067 }
4068
4074 public <R extends Sort> FuncDecl<BoolSort> mkLinearOrder(R sort, int index) {
4075 return (FuncDecl<BoolSort>) FuncDecl.create(
4076 this,
4077 Native.mkLinearOrder(
4078 nCtx(),
4079 sort.getNativeObject(),
4080 index
4081 )
4082 );
4083 }
4084
4090 public <R extends Sort> FuncDecl<BoolSort> mkPartialOrder(R sort, int index) {
4091 return (FuncDecl<BoolSort>) FuncDecl.create(
4092 this,
4093 Native.mkPartialOrder(
4094 nCtx(),
4095 sort.getNativeObject(),
4096 index
4097 )
4098 );
4099 }
4100
4111 public AST wrapAST(long nativeObject)
4112 {
4113 return AST.create(this, nativeObject);
4114 }
4115
4128 public long unwrapAST(AST a)
4129 {
4130 return a.getNativeObject();
4131 }
4132
4138 {
4139 return Native.simplifyGetHelp(nCtx());
4140 }
4141
4146 {
4147 return new ParamDescrs(this, Native.simplifyGetParamDescrs(nCtx()));
4148 }
4149
4158 public void updateParamValue(String id, String value)
4159 {
4160 Native.updateParamValue(nCtx(), id, value);
4161 }
4162
4163
4164 public long nCtx()
4165 {
4166 if (m_ctx == 0)
4167 throw new Z3Exception("Context closed");
4168 return m_ctx;
4169 }
4170
4171
4172 void checkContextMatch(Z3Object other)
4173 {
4174 if (this != other.getContext())
4175 throw new Z3Exception("Context mismatch");
4176 }
4177
4178 void checkContextMatch(Z3Object other1, Z3Object other2)
4179 {
4180 checkContextMatch(other1);
4181 checkContextMatch(other2);
4182 }
4183
4184 void checkContextMatch(Z3Object other1, Z3Object other2, Z3Object other3)
4185 {
4186 checkContextMatch(other1);
4187 checkContextMatch(other2);
4188 checkContextMatch(other3);
4189 }
4190
4191 void checkContextMatch(Z3Object[] arr)
4192 {
4193 if (arr != null)
4194 for (Z3Object a : arr)
4195 checkContextMatch(a);
4196 }
4197
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();
4217
4219 return m_Constructor_DRQ;
4220 }
4221
4223 return m_ConstructorList_DRQ;
4224 }
4225
4227 {
4228 return m_AST_DRQ;
4229 }
4230
4232 {
4233 return m_ASTMap_DRQ;
4234 }
4235
4237 {
4238 return m_ASTVector_DRQ;
4239 }
4240
4242 {
4243 return m_ApplyResult_DRQ;
4244 }
4245
4247 {
4248 return m_FuncEntry_DRQ;
4249 }
4250
4252 {
4253 return m_FuncInterp_DRQ;
4254 }
4255
4257 {
4258 return m_Goal_DRQ;
4259 }
4260
4262 {
4263 return m_Model_DRQ;
4264 }
4265
4267 {
4268 return m_Params_DRQ;
4269 }
4270
4272 {
4273 return m_ParamDescrs_DRQ;
4274 }
4275
4277 {
4278 return m_Probe_DRQ;
4279 }
4280
4282 {
4283 return m_Solver_DRQ;
4284 }
4285
4287 {
4288 return m_Statistics_DRQ;
4289 }
4290
4292 {
4293 return m_Tactic_DRQ;
4294 }
4295
4297 {
4298 return m_Fixedpoint_DRQ;
4299 }
4300
4302 {
4303 return m_Optimize_DRQ;
4304 }
4305
4309 @Override
4310 public void close()
4311 {
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);
4327
4328 m_boolSort = null;
4329 m_intSort = null;
4330 m_realSort = null;
4331 m_stringSort = null;
4332
4333 synchronized (creation_lock) {
4334 Native.delContext(m_ctx);
4335 }
4336 m_ctx = 0;
4337 }
4338}
BoolExpr[] ToBoolExprArray()
Definition: ASTVector.java:140
Probe ge(Probe p1, Probe p2)
Definition: Context.java:3172
Solver mkSolver(String logic)
Definition: Context.java:3256
Tactic repeat(Tactic t, int max)
Definition: Context.java:2986
BitVecExpr mkBVXOR(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1076
final BoolExpr mkDistinct(Expr<?>... args)
Definition: Context.java:747
BitVecExpr mkBVUDiv(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1180
String getProbeDescription(String name)
Definition: Context.java:3109
FPNum mkFP(boolean sgn, long exp, long sig, FPSort s)
Definition: Context.java:3628
final< D extends Sort > ArrayExpr< D, BoolSort > mkSetIntersection(Expr< ArraySort< D, BoolSort > >... args)
Definition: Context.java:1937
FPNum mkFPNaN(FPSort s)
Definition: Context.java:3487
BoolExpr mkFPIsPositive(Expr< FPSort > t)
Definition: Context.java:3895
BitVecExpr mkBVNOR(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1102
FPExpr mkFPToFP(Expr< FPRMSort > rm, Expr< BitVecSort > t, FPSort s, boolean signed)
Definition: Context.java:3979
FPRMExpr mkFPRoundNearestTiesToEven()
Definition: Context.java:3312
Expr< CharSort > charFromBv(BitVecExpr bv)
Definition: Context.java:2361
IntExpr stringToInt(Expr< SeqSort< CharSort > > e)
Definition: Context.java:2057
Fixedpoint mkFixedpoint()
Definition: Context.java:3285
Tactic usingParams(Tactic t, Params p)
Definition: Context.java:3033
Tactic parOr(Tactic... t)
Definition: Context.java:3055
BoolExpr mkBVULE(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1287
BoolExpr mkBVSubNoOverflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1616
BoolExpr mkBVNegNoOverflow(Expr< BitVecSort > t)
Definition: Context.java:1658
Tactic then(Tactic t1, Tactic t2, Tactic... ts)
Definition: Context.java:2923
FPExpr mkFPMax(Expr< FPSort > t1, Expr< FPSort > t2)
Definition: Context.java:3768
IntExpr mkBV2Int(Expr< BitVecSort > t, boolean signed)
Definition: Context.java:1576
FPSort mkFPSort(int ebits, int sbits)
Definition: Context.java:3404
BoolExpr MkStringLe(SeqSort< CharSort > s1, SeqSort< CharSort > s2)
Definition: Context.java:2122
BoolExpr mkBVSDivNoOverflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1644
Probe le(Probe p1, Probe p2)
Definition: Context.java:3159
SeqExpr< CharSort > mkString(String s)
Definition: Context.java:2017
AST wrapAST(long nativeObject)
Definition: Context.java:4111
UninterpretedSort mkUninterpretedSort(Symbol s)
Definition: Context.java:189
BitVecExpr mkBVXNOR(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1115
BoolExpr mkImplies(Expr< BoolSort > t1, Expr< BoolSort > t2)
Definition: Context.java:793
BoolExpr mkBVAddNoOverflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2, boolean isSigned)
Definition: Context.java:1588
BitVecExpr mkBVRotateRight(int i, Expr< BitVecSort > t)
Definition: Context.java:1509
RealExpr mkInt2Real(Expr< IntSort > t)
Definition: Context.java:982
BitVecExpr mkBVLSHR(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1464
FPNum mkFPNumeral(boolean sgn, int exp, int sig, FPSort s)
Definition: Context.java:3555
FPNum mkFP(double v, FPSort s)
Definition: Context.java:3590
BoolExpr mkLe(Expr<? extends ArithSort > t1, Expr<? extends ArithSort > t2)
Definition: Context.java:942
IDecRefQueue< FuncInterp<?> > getFuncInterpDRQ()
Definition: Context.java:4251
IntExpr mkReal2Int(Expr< RealSort > t)
Definition: Context.java:995
FPNum mkFPInf(FPSort s, boolean negative)
Definition: Context.java:3498
FPExpr mkFPRoundToIntegral(Expr< FPRMSort > rm, Expr< FPSort > t)
Definition: Context.java:3746
BoolExpr mkAtLeast(Expr< BoolSort >[] args, int k)
Definition: Context.java:2388
BitVecExpr mkBVSMod(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1248
BitVecExpr mkInt2BV(int n, Expr< IntSort > t)
Definition: Context.java:1555
BoolExpr mkBVSGE(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1326
BitVecExpr mkBVConst(Symbol name, int size)
Definition: Context.java:684
BitVecExpr mkExtract(int high, int low, Expr< BitVecSort > t)
Definition: Context.java:1386
FPRMNum mkFPRoundTowardZero()
Definition: Context.java:3384
BoolExpr mkFPGEq(Expr< FPSort > t1, Expr< FPSort > t2)
Definition: Context.java:3801
Probe or(Probe p1, Probe p2)
Definition: Context.java:3206
IDecRefQueue< ASTMap > getASTMapDRQ()
Definition: Context.java:4231
BitVecExpr mkBVURem(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1216
final< D extends Sort, R1 extends Sort, R2 extends Sort > ArrayExpr< D, R2 > mkMap(FuncDecl< R2 > f, Expr< ArraySort< D, R1 > >... args)
Definition: Context.java:1835
Tactic cond(Probe p, Tactic t1, Tactic t2)
Definition: Context.java:2973
IDecRefQueue< Statistics > getStatisticsDRQ()
Definition: Context.java:4286
BoolExpr mkBVSGT(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1352
IDecRefQueue< Model > getModelDRQ()
Definition: Context.java:4261
BitVecExpr mkBVConst(String name, int size)
Definition: Context.java:692
IDecRefQueue< Optimize > getOptimizeDRQ()
Definition: Context.java:4301
IntNum mkInt(long v)
Definition: Context.java:2559
BoolExpr mkAtMost(Expr< BoolSort >[] args, int k)
Definition: Context.java:2379
IDecRefQueue< AST > getASTDRQ()
Definition: Context.java:4226
BoolExpr mkFPIsSubnormal(Expr< FPSort > t)
Definition: Context.java:3845
IntExpr mkMod(Expr< IntSort > t1, Expr< IntSort > t2)
Definition: Context.java:893
FPExpr mkFPToFP(Expr< FPRMSort > rm, RealExpr t, FPSort s)
Definition: Context.java:3961
BoolExpr mkNot(Expr< BoolSort > a)
Definition: Context.java:757
FPExpr mkFPSub(Expr< FPRMSort > rm, Expr< FPSort > t1, Expr< FPSort > t2)
Definition: Context.java:3673
SeqExpr< CharSort > intToString(Expr< IntSort > e)
Definition: Context.java:2033
BoolExpr mkBVMulNoOverflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2, boolean isSigned)
Definition: Context.java:1670
FPExpr mkFPSqrt(Expr< FPRMSort > rm, Expr< FPSort > t)
Definition: Context.java:3723
FPNum mkFPNumeral(int v, FPSort s)
Definition: Context.java:3542
FPExpr mkFPMul(Expr< FPRMSort > rm, Expr< FPSort > t1, Expr< FPSort > t2)
Definition: Context.java:3685
BitVecExpr mkConcat(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1370
IDecRefQueue< ApplyResult > getApplyResultDRQ()
Definition: Context.java:4241
BitVecExpr mkSignExt(int i, Expr< BitVecSort > t)
Definition: Context.java:1401
BitVecExpr mkBVAdd(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1139
FPNum mkFP(boolean sgn, int exp, int sig, FPSort s)
Definition: Context.java:3615
BoolExpr MkStringLt(SeqSort< CharSort > s1, SeqSort< CharSort > s2)
Definition: Context.java:2113
void updateParamValue(String id, String value)
Definition: Context.java:4158
BitVecExpr mkZeroExt(int i, Expr< BitVecSort > t)
Definition: Context.java:1415
SeqExpr< CharSort > ubvToString(Expr< BitVecSort > e)
Definition: Context.java:2041
final< R extends Sort > ReExpr< R > mkConcat(ReExpr< R >... t)
Definition: Context.java:2259
Tactic failIf(Probe p)
Definition: Context.java:3013
BoolExpr mkFPLt(Expr< FPSort > t1, Expr< FPSort > t2)
Definition: Context.java:3790
BitVecExpr mkBVRedAND(Expr< BitVecSort > t)
Definition: Context.java:1026
BitVecNum mkBV(long v, int size)
Definition: Context.java:2591
BitVecExpr mkBVSRem(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1234
FPNum mkFPNumeral(float v, FPSort s)
Definition: Context.java:3520
IDecRefQueue< ParamDescrs > getParamDescrsDRQ()
Definition: Context.java:4271
Tactic when(Probe p, Tactic t)
Definition: Context.java:2960
IntNum mkInt(String v)
Definition: Context.java:2533
IDecRefQueue< Goal > getGoalDRQ()
Definition: Context.java:4256
Probe mkProbe(String name)
Definition: Context.java:3117
BoolExpr mkPBLe(int[] coeffs, Expr< BoolSort >[] args, int k)
Definition: Context.java:2397
RealExpr mkRealConst(String name)
Definition: Context.java:676
final< R extends ArithSort > ArithExpr< R > mkAdd(Expr<? extends R >... t)
Definition: Context.java:838
ParamDescrs getSimplifyParameterDescriptions()
Definition: Context.java:4145
BitVecExpr mkBVRotateRight(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1537
SeqExpr< CharSort > sbvToString(Expr< BitVecSort > e)
Definition: Context.java:2049
Probe gt(Probe p1, Probe p2)
Definition: Context.java:3146
BoolExpr mkFPIsNaN(Expr< FPSort > t)
Definition: Context.java:3875
BoolExpr mkEq(Expr<?> x, Expr<?> y)
Definition: Context.java:735
Tactic with(Tactic t, Params p)
Definition: Context.java:3047
BitVecExpr mkBVASHR(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1484
BoolExpr[] parseSMTLIB2String(String str, Symbol[] sortNames, Sort[] sorts, Symbol[] declNames, FuncDecl<?>[] decls)
Definition: Context.java:2788
String benchmarkToSMTString(String name, String logic, String status, String attributes, Expr< BoolSort >[] assumptions, Expr< BoolSort > formula)
Definition: Context.java:2769
FPRMNum mkFPRoundNearestTiesToAway()
Definition: Context.java:3330
BoolExpr mkIsDigit(Expr< CharSort > ch)
Definition: Context.java:2370
BoolExpr mkBool(boolean value)
Definition: Context.java:727
BitVecExpr mkBVMul(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1165
BitVecExpr mkBVSub(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1152
TupleSort mkTupleSort(Symbol name, Symbol[] fieldNames, Sort[] fieldSorts)
Definition: Context.java:276
BitVecExpr mkBVOR(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1063
BoolExpr mkLt(Expr<? extends ArithSort > t1, Expr<? extends ArithSort > t2)
Definition: Context.java:931
final Pattern mkPattern(Expr<?>... terms)
Definition: Context.java:579
BitVecExpr mkRepeat(int i, Expr< BitVecSort > t)
Definition: Context.java:1427
BoolExpr mkXor(Expr< BoolSort > t1, Expr< BoolSort > t2)
Definition: Context.java:804
FPRMNum mkFPRoundTowardNegative()
Definition: Context.java:3366
IDecRefQueue< Params > getParamsDRQ()
Definition: Context.java:4266
Probe eq(Probe p1, Probe p2)
Definition: Context.java:3184
Quantifier mkForall(Sort[] sorts, Symbol[] names, Expr< BoolSort > body, int weight, Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
Definition: Context.java:2621
BitVecExpr mkBVRotateLeft(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1522
IDecRefQueue< Solver > getSolverDRQ()
Definition: Context.java:4281
Quantifier mkQuantifier(boolean universal, Expr<?>[] boundConstants, Expr< BoolSort > body, int weight, Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
Definition: Context.java:2690
BitVecExpr mkBVRedOR(Expr< BitVecSort > t)
Definition: Context.java:1038
BoolExpr mkBVUGE(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1313
FPExpr mkFPDiv(Expr< FPRMSort > rm, Expr< FPSort > t1, Expr< FPSort > t2)
Definition: Context.java:3697
BitVecExpr mkBVNAND(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1089
FPExpr mkFPRem(Expr< FPSort > t1, Expr< FPSort > t2)
Definition: Context.java:3734
SeqSort< CharSort > getStringSort()
Definition: Context.java:178
Quantifier mkQuantifier(boolean universal, Sort[] sorts, Symbol[] names, Expr< BoolSort > body, int weight, Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
Definition: Context.java:2672
IntExpr mkIntConst(String name)
Definition: Context.java:660
Solver mkSolver(Tactic t)
Definition: Context.java:3275
BoolExpr[] parseSMTLIB2File(String fileName, Symbol[] sortNames, Sort[] sorts, Symbol[] declNames, FuncDecl<?>[] decls)
Definition: Context.java:2809
Tactic andThen(Tactic t1, Tactic t2, Tactic... ts)
Definition: Context.java:2891
final< R extends Sort > Expr< R > mkApp(FuncDecl< R > f, Expr<?>... args)
Definition: Context.java:701
BoolExpr mkBVAddNoUnderflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1602
BoolExpr mkBVSubNoUnderflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2, boolean isSigned)
Definition: Context.java:1630
BoolExpr mkFPIsZero(Expr< FPSort > t)
Definition: Context.java:3855
BitVecExpr charToBv(Expr< CharSort > ch)
Definition: Context.java:2352
IntExpr mkIntConst(Symbol name)
Definition: Context.java:652
IDecRefQueue< ConstructorList<?> > getConstructorListDRQ()
Definition: Context.java:4222
BitVecExpr mkBVNeg(Expr< BitVecSort > t)
Definition: Context.java:1128
Tactic mkTactic(String name)
Definition: Context.java:2882
BoolExpr mkBVSLE(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1300
FPNum mkFPNumeral(double v, FPSort s)
Definition: Context.java:3531
Tactic parAndThen(Tactic t1, Tactic t2)
Definition: Context.java:3066
RatNum mkReal(long v)
Definition: Context.java:2522
BoolExpr mkGt(Expr<? extends ArithSort > t1, Expr<? extends ArithSort > t2)
Definition: Context.java:953
BitVecNum mkBV(int v, int size)
Definition: Context.java:2581
Context(Map< String, String > settings)
Definition: Context.java:72
IDecRefQueue< FuncInterp.Entry<?> > getFuncEntryDRQ()
Definition: Context.java:4246
final< R extends Sort > ReExpr< R > mkIntersect(Expr< ReSort< R > >... t)
Definition: Context.java:2279
final< R extends ArithSort > ArithExpr< R > mkMul(Expr<? extends R >... t)
Definition: Context.java:849
BoolExpr mkBVMulNoUnderflow(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1684
BitVecExpr mkBVSDiv(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1201
FPRMSort mkFPRoundingModeSort()
Definition: Context.java:3303
RealExpr mkRealConst(Symbol name)
Definition: Context.java:668
String getTacticDescription(String name)
Definition: Context.java:2874
IDecRefQueue< Probe > getProbeDRQ()
Definition: Context.java:4276
Solver mkSolver(Symbol logic)
Definition: Context.java:3242
BoolExpr mkFPEq(Expr< FPSort > t1, Expr< FPSort > t2)
Definition: Context.java:3825
BoolExpr mkFPLEq(Expr< FPSort > t1, Expr< FPSort > t2)
Definition: Context.java:3779
RatNum mkReal(int num, int den)
Definition: Context.java:2481
BitVecSort mkBitVecSort(int size)
Definition: Context.java:222
FPExpr mkFPToFP(Expr< BitVecSort > bv, FPSort s)
Definition: Context.java:3929
BoolExpr mkBVSLT(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1274
BoolExpr mkFPGt(Expr< FPSort > t1, Expr< FPSort > t2)
Definition: Context.java:3812
BoolExpr mkIff(Expr< BoolSort > t1, Expr< BoolSort > t2)
Definition: Context.java:782
BoolExpr mkGe(Expr<? extends ArithSort > t1, Expr<? extends ArithSort > t2)
Definition: Context.java:964
BitVecExpr mkFPToFP(Expr< FPRMSort > rm, Expr< IntSort > exp, Expr< RealSort > sig, FPSort s)
Definition: Context.java:4064
BoolExpr mkIsInteger(Expr< RealSort > t)
Definition: Context.java:1004
FPExpr mkFPToFP(Expr< FPRMSort > rm, FPExpr t, FPSort s)
Definition: Context.java:3945
Probe constProbe(double val)
Definition: Context.java:3125
BoolExpr mkFPIsNegative(Expr< FPSort > t)
Definition: Context.java:3885
BoolExpr mkBoolConst(String name)
Definition: Context.java:644
RealExpr mkFPToReal(Expr< FPSort > t)
Definition: Context.java:4031
Probe not(Probe p)
Definition: Context.java:3217
FPExpr mkFP(Expr< BitVecSort > sgn, Expr< BitVecSort > sig, Expr< BitVecSort > exp)
Definition: Context.java:3913
FPExpr mkFPToFP(FPSort s, Expr< FPRMSort > rm, Expr< FPSort > t)
Definition: Context.java:3997
FPExpr mkFPNeg(Expr< FPSort > t)
Definition: Context.java:3649
IDecRefQueue< Tactic > getTacticDRQ()
Definition: Context.java:4291
final< R extends Sort > SeqExpr< R > mkConcat(Expr< SeqSort< R > >... t)
Definition: Context.java:2066
BoolExpr mkCharLe(Expr< CharSort > ch1, Expr< CharSort > ch2)
Definition: Context.java:2334
FPNum mkFPNumeral(boolean sgn, long exp, long sig, FPSort s)
Definition: Context.java:3568
SeqSort< CharSort > mkStringSort()
Definition: Context.java:251
RatNum mkReal(int v)
Definition: Context.java:2509
FPRMNum mkFPRoundTowardPositive()
Definition: Context.java:3348
Quantifier mkExists(Expr<?>[] boundConstants, Expr< BoolSort > body, int weight, Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
Definition: Context.java:2659
final< D extends Sort > ArrayExpr< D, BoolSort > mkSetUnion(Expr< ArraySort< D, BoolSort > >... args)
Definition: Context.java:1925
BoolExpr mkBVULT(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1261
BoolExpr mkFPIsNormal(Expr< FPSort > t)
Definition: Context.java:3835
DatatypeSort< Object >[] mkDatatypeSorts(String[] names, Constructor< Object >[][] c)
Definition: Context.java:422
Probe and(Probe p1, Probe p2)
Definition: Context.java:3195
IntExpr charToInt(Expr< CharSort > ch)
Definition: Context.java:2343
Tactic tryFor(Tactic t, int ms)
Definition: Context.java:2947
FPExpr mkFPFMA(Expr< FPRMSort > rm, Expr< FPSort > t1, Expr< FPSort > t2, Expr< FPSort > t3)
Definition: Context.java:3712
UninterpretedSort mkUninterpretedSort(String str)
Definition: Context.java:198
void setPrintMode(Z3_ast_print_mode value)
Definition: Context.java:2751
DatatypeSort< Object >[] mkDatatypeSorts(Symbol[] names, Constructor< Object >[][] c)
Definition: Context.java:396
final BoolExpr mkAnd(Expr< BoolSort >... t)
Definition: Context.java:816
BitVecNum mkBV(String v, int size)
Definition: Context.java:2571
BitVecExpr mkBVRotateLeft(int i, Expr< BitVecSort > t)
Definition: Context.java:1497
Probe lt(Probe p1, Probe p2)
Definition: Context.java:3134
Quantifier mkForall(Expr<?>[] boundConstants, Expr< BoolSort > body, int weight, Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
Definition: Context.java:2633
IntExpr mkRem(Expr< IntSort > t1, Expr< IntSort > t2)
Definition: Context.java:906
BitVecExpr mkBVNot(Expr< BitVecSort > t)
Definition: Context.java:1015
final< R extends ArithSort > ArithExpr< R > mkSub(Expr<? extends R >... t)
Definition: Context.java:860
BitVecExpr mkBVAND(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1050
FPExpr mkFPAbs(Expr< FPSort > t)
Definition: Context.java:3639
BoolExpr mkPBEq(int[] coeffs, Expr< BoolSort >[] args, int k)
Definition: Context.java:2415
Goal mkGoal(boolean models, boolean unsatCores, boolean proofs)
Definition: Context.java:2836
IDecRefQueue< Constructor<?> > getConstructorDRQ()
Definition: Context.java:4218
FPExpr mkFPAdd(Expr< FPRMSort > rm, Expr< FPSort > t1, Expr< FPSort > t2)
Definition: Context.java:3661
BoolExpr mkBVUGT(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1339
FPNum mkFP(float v, FPSort s)
Definition: Context.java:3579
final BoolExpr mkOr(Expr< BoolSort >... t)
Definition: Context.java:827
BitVecExpr mkBVSHL(Expr< BitVecSort > t1, Expr< BitVecSort > t2)
Definition: Context.java:1445
Quantifier mkExists(Sort[] sorts, Symbol[] names, Expr< BoolSort > body, int weight, Pattern[] patterns, Expr<?>[] noPatterns, Symbol quantifierID, Symbol skolemID)
Definition: Context.java:2646
BitVecExpr mkFPToIEEEBV(Expr< FPSort > t)
Definition: Context.java:4046
FPExpr mkFPMin(Expr< FPSort > t1, Expr< FPSort > t2)
Definition: Context.java:3757
Tactic orElse(Tactic t1, Tactic t2)
Definition: Context.java:2933
IDecRefQueue< Fixedpoint > getFixedpointDRQ()
Definition: Context.java:4296
RatNum mkReal(String v)
Definition: Context.java:2496
FPNum mkFP(int v, FPSort s)
Definition: Context.java:3602
final< R extends Sort > ReExpr< R > mkUnion(Expr< ReSort< R > >... t)
Definition: Context.java:2269
IntSymbol mkSymbol(int i)
Definition: Context.java:94
StringSymbol mkSymbol(String name)
Definition: Context.java:102
FPNum mkFPZero(FPSort s, boolean negative)
Definition: Context.java:3509
BoolExpr mkFPIsInfinite(Expr< FPSort > t)
Definition: Context.java:3865
BoolExpr mkBoolConst(Symbol name)
Definition: Context.java:636
IDecRefQueue< ASTVector > getASTVectorDRQ()
Definition: Context.java:4236
BitVecExpr mkFPToBV(Expr< FPRMSort > rm, Expr< FPSort > t, int sz, boolean signed)
Definition: Context.java:4014
BoolExpr mkPBGe(int[] coeffs, Expr< BoolSort >[] args, int k)
Definition: Context.java:2406
Definition: FuncInterp.java:32
static< R extends Sort > Lambda< R > of(Context ctx, Sort[] sorts, Symbol[] names, Expr< R > body)
Definition: Lambda.java:94
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)
Definition: Z3Object.java:73
static int arrayLength(Z3Object[] a)
Definition: Z3Object.java:83
Z3_ast_print_mode
Z3 pretty printing modes (See Z3_set_ast_print_mode).
Definition: z3_api.h:1317
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:3946
expr max(expr const &a, expr const &b)
Definition: z3++.h:1935
def IntSort(ctx=None)
Definition: z3py.py:3129
def Lambda(vs, body)
Definition: z3py.py:2252
def RealSort(ctx=None)
Definition: z3py.py:3146
def BoolSort(ctx=None)
Definition: z3py.py:1682
def Map(f, *args)
Definition: z3py.py:4814
def String(name, ctx=None)
Definition: z3py.py:10903
def CharSort(ctx=None)
Definition: z3py.py:10730
def FPSort(ebits, sbits, ctx=None)
Definition: z3py.py:9876
def TupleSort(name, sorts, ctx=None)
Definition: z3py.py:5354
def BitVecSort(sz, ctx=None)
Definition: z3py.py:3996