mirror of
https://github.com/Z3Prover/z3
synced 2025-04-06 17:44:08 +00:00
Java type generics (#4832)
* Generify, needs some testing and review * Remove unnecessary change * Whoops, ? capture that type * Misread the docs, whoops * More permissible arithmetic operations * Implement believed Optimize generics * Missed a few generics * More permissible expr for arrays in parameters * More permissible expr for bitvecs in parameters * More permissible expr for bools in parameters * More permissible expr for fps in parameters * More permissible expr for fprms in parameters * More permissible expr for ints in parameters * More permissible expr for reals in parameters * Undo breaking name conflict due to type erasure; see notes * Whoops, fix typing of ReExpr * Sort corrections for Re, Seq * More permissible expr for regular expressions in parameters * Fix name conflict between sequences and regular expressions; see notes * Minor typo, big implications! * Make Constructor consistent, associate captured types with other unknown capture types for datatype consistency * More expressive; outputs of multiple datatype definitions are only known to be sort, not capture, and Constructor.of should make a capture * Be less dumb and just type it a little differently * Update examples, make sure to type Expr and FuncDecl sort returns * General fixups * Downgrade java version, make it only for the generic support, remove var and Expr[]::new construction * Turns out Java 8 hadn't figured out how to do stream generics yet. Didn't even show up in my IDE, weird
This commit is contained in:
Addison Crump
GitHub
parent
bb24b3f2be
commit
3bca1fbcd8
|
|
@ -599,7 +599,7 @@ class JavaExample
|
|||
System.out.println("QuantifierExample");
|
||||
Log.append("QuantifierExample");
|
||||
|
||||
Sort[] types = new Sort[3];
|
||||
IntSort[] types = new IntSort[3];
|
||||
IntExpr[] xs = new IntExpr[3];
|
||||
Symbol[] names = new Symbol[3];
|
||||
IntExpr[] vars = new IntExpr[3];
|
||||
|
|
@ -1398,7 +1398,7 @@ class JavaExample
|
|||
System.out.println("BitvectorExample1");
|
||||
Log.append("BitvectorExample1");
|
||||
|
||||
Sort bv_type = ctx.mkBitVecSort(32);
|
||||
BitVecSort bv_type = ctx.mkBitVecSort(32);
|
||||
BitVecExpr x = (BitVecExpr) ctx.mkConst("x", bv_type);
|
||||
BitVecNum zero = (BitVecNum) ctx.mkNumeral("0", bv_type);
|
||||
BitVecNum ten = ctx.mkBV(10, 32);
|
||||
|
|
@ -1420,7 +1420,7 @@ class JavaExample
|
|||
Log.append("BitvectorExample2");
|
||||
|
||||
/* construct x ^ y - 103 == x * y */
|
||||
Sort bv_type = ctx.mkBitVecSort(32);
|
||||
BitVecSort bv_type = ctx.mkBitVecSort(32);
|
||||
BitVecExpr x = ctx.mkBVConst("x", 32);
|
||||
BitVecExpr y = ctx.mkBVConst("y", 32);
|
||||
BitVecExpr x_xor_y = ctx.mkBVXOR(x, y);
|
||||
|
|
|
|||
2135
examples/java/JavaGenericExample.java
Normal file
2135
examples/java/JavaGenericExample.java
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -204,7 +204,7 @@ public class AST extends Z3Object implements Comparable<AST>
|
|||
switch (Z3_ast_kind.fromInt(Native.getAstKind(ctx.nCtx(), obj)))
|
||||
{
|
||||
case Z3_FUNC_DECL_AST:
|
||||
return new FuncDecl(ctx, obj);
|
||||
return new FuncDecl<>(ctx, obj);
|
||||
case Z3_QUANTIFIER_AST:
|
||||
return new Quantifier(ctx, obj);
|
||||
case Z3_SORT_AST:
|
||||
|
|
|
|||
|
|
@ -126,9 +126,9 @@ public class ASTVector extends Z3Object {
|
|||
/**
|
||||
* Translates the AST vector into an Expr[]
|
||||
* */
|
||||
public Expr[] ToExprArray() {
|
||||
public Expr<?>[] ToExprArray() {
|
||||
int n = size();
|
||||
Expr[] res = new Expr[n];
|
||||
Expr<?>[] res = new Expr[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = Expr.create(getContext(), get(i).getNativeObject());
|
||||
return res;
|
||||
|
|
@ -161,36 +161,36 @@ public class ASTVector extends Z3Object {
|
|||
/**
|
||||
* Translates the AST vector into an ArithExpr[]
|
||||
* */
|
||||
public ArithExpr[] ToArithExprExprArray()
|
||||
public ArithExpr<?>[] ToArithExprExprArray()
|
||||
{
|
||||
int n = size();
|
||||
ArithExpr[] res = new ArithExpr[n];
|
||||
ArithExpr<?>[] res = new ArithExpr[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = (ArithExpr)Expr.create(getContext(), get(i).getNativeObject());
|
||||
res[i] = (ArithExpr<?>)Expr.create(getContext(), get(i).getNativeObject());
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* Translates the AST vector into an ArrayExpr[]
|
||||
* */
|
||||
public ArrayExpr[] ToArrayExprArray()
|
||||
public ArrayExpr<?, ?>[] ToArrayExprArray()
|
||||
{
|
||||
int n = size();
|
||||
ArrayExpr[] res = new ArrayExpr[n];
|
||||
ArrayExpr<?, ?>[] res = new ArrayExpr[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = (ArrayExpr)Expr.create(getContext(), get(i).getNativeObject());
|
||||
res[i] = (ArrayExpr<?, ?>)Expr.create(getContext(), get(i).getNativeObject());
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* Translates the AST vector into an DatatypeExpr[]
|
||||
* */
|
||||
public DatatypeExpr[] ToDatatypeExprArray()
|
||||
public DatatypeExpr<?>[] ToDatatypeExprArray()
|
||||
{
|
||||
int n = size();
|
||||
DatatypeExpr[] res = new DatatypeExpr[n];
|
||||
DatatypeExpr<?>[] res = new DatatypeExpr[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = (DatatypeExpr)Expr.create(getContext(), get(i).getNativeObject());
|
||||
res[i] = (DatatypeExpr<?>)Expr.create(getContext(), get(i).getNativeObject());
|
||||
return res;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Arithmetic expressions (int/real)
|
||||
**/
|
||||
public class ArithExpr extends Expr
|
||||
public class ArithExpr<R extends ArithSort> extends Expr<R>
|
||||
{
|
||||
/**
|
||||
* Constructor for ArithExpr
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Array expressions
|
||||
**/
|
||||
public class ArrayExpr extends Expr
|
||||
public class ArrayExpr<D extends Sort, R extends Sort> extends Expr<ArraySort<D, R>>
|
||||
{
|
||||
/**
|
||||
* Constructor for ArrayExpr
|
||||
|
|
|
|||
|
|
@ -20,7 +20,8 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Array sorts.
|
||||
**/
|
||||
public class ArraySort extends Sort
|
||||
@SuppressWarnings("unchecked")
|
||||
public class ArraySort<D extends Sort, R extends Sort> extends Sort
|
||||
{
|
||||
/**
|
||||
* The domain of the array sort.
|
||||
|
|
@ -28,9 +29,9 @@ public class ArraySort extends Sort
|
|||
* @throws Z3Exception on error
|
||||
* @return a sort
|
||||
**/
|
||||
public Sort getDomain()
|
||||
public D getDomain()
|
||||
{
|
||||
return Sort.create(getContext(),
|
||||
return (D) Sort.create(getContext(),
|
||||
Native.getArraySortDomain(getContext().nCtx(), getNativeObject()));
|
||||
}
|
||||
|
||||
|
|
@ -40,9 +41,9 @@ public class ArraySort extends Sort
|
|||
* @throws Z3Exception on error
|
||||
* @return a sort
|
||||
**/
|
||||
public Sort getRange()
|
||||
public R getRange()
|
||||
{
|
||||
return Sort.create(getContext(),
|
||||
return (R) Sort.create(getContext(),
|
||||
Native.getArraySortRange(getContext().nCtx(), getNativeObject()));
|
||||
}
|
||||
|
||||
|
|
@ -51,13 +52,13 @@ public class ArraySort extends Sort
|
|||
super(ctx, obj);
|
||||
}
|
||||
|
||||
ArraySort(Context ctx, Sort domain, Sort range)
|
||||
ArraySort(Context ctx, D domain, R range)
|
||||
{
|
||||
super(ctx, Native.mkArraySort(ctx.nCtx(), domain.getNativeObject(),
|
||||
range.getNativeObject()));
|
||||
}
|
||||
|
||||
ArraySort(Context ctx, Sort[] domains, Sort range)
|
||||
ArraySort(Context ctx, Sort[] domains, R range)
|
||||
{
|
||||
super(ctx, Native.mkArraySortN(ctx.nCtx(), domains.length, AST.arrayToNative(domains),
|
||||
range.getNativeObject()));
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Bit-vector expressions
|
||||
**/
|
||||
public class BitVecExpr extends Expr
|
||||
public class BitVecExpr extends Expr<BitVecSort>
|
||||
{
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Boolean expressions
|
||||
**/
|
||||
public class BoolExpr extends Expr {
|
||||
public class BoolExpr extends Expr<BoolSort> {
|
||||
|
||||
/**
|
||||
* Constructor for BoolExpr
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Constructors are used for datatype sorts.
|
||||
**/
|
||||
public class Constructor extends Z3Object {
|
||||
public class Constructor<R> extends Z3Object {
|
||||
private final int n;
|
||||
|
||||
Constructor(Context ctx, int n, long nativeObj) {
|
||||
|
|
@ -44,13 +44,13 @@ public class Constructor extends Z3Object {
|
|||
* @throws Z3Exception
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public FuncDecl ConstructorDecl()
|
||||
public FuncDecl<DatatypeSort<R>> ConstructorDecl()
|
||||
{
|
||||
Native.LongPtr constructor = new Native.LongPtr();
|
||||
Native.LongPtr tester = new Native.LongPtr();
|
||||
long[] accessors = new long[n];
|
||||
Native.queryConstructor(getContext().nCtx(), getNativeObject(), n, constructor, tester, accessors);
|
||||
return new FuncDecl(getContext(), constructor.value);
|
||||
return new FuncDecl<>(getContext(), constructor.value);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -58,13 +58,13 @@ public class Constructor extends Z3Object {
|
|||
* @throws Z3Exception
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public FuncDecl getTesterDecl()
|
||||
public FuncDecl<BoolSort> getTesterDecl()
|
||||
{
|
||||
Native.LongPtr constructor = new Native.LongPtr();
|
||||
Native.LongPtr tester = new Native.LongPtr();
|
||||
long[] accessors = new long[n];
|
||||
Native.queryConstructor(getContext().nCtx(), getNativeObject(), n, constructor, tester, accessors);
|
||||
return new FuncDecl(getContext(), tester.value);
|
||||
return new FuncDecl<>(getContext(), tester.value);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -72,15 +72,15 @@ public class Constructor extends Z3Object {
|
|||
* @throws Z3Exception
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public FuncDecl[] getAccessorDecls()
|
||||
public FuncDecl<?>[] getAccessorDecls()
|
||||
{
|
||||
Native.LongPtr constructor = new Native.LongPtr();
|
||||
Native.LongPtr tester = new Native.LongPtr();
|
||||
long[] accessors = new long[n];
|
||||
Native.queryConstructor(getContext().nCtx(), getNativeObject(), n, constructor, tester, accessors);
|
||||
FuncDecl[] t = new FuncDecl[n];
|
||||
FuncDecl<?>[] t = new FuncDecl[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
t[i] = new FuncDecl(getContext(), accessors[i]);
|
||||
t[i] = new FuncDecl<>(getContext(), accessors[i]);
|
||||
return t;
|
||||
}
|
||||
|
||||
|
|
@ -94,7 +94,7 @@ public class Constructor extends Z3Object {
|
|||
getContext().getConstructorDRQ().storeReference(getContext(), this);
|
||||
}
|
||||
|
||||
static Constructor of(Context ctx, Symbol name, Symbol recognizer,
|
||||
static <R> Constructor<R> of(Context ctx, Symbol name, Symbol recognizer,
|
||||
Symbol[] fieldNames, Sort[] sorts, int[] sortRefs) {
|
||||
int n = AST.arrayLength(fieldNames);
|
||||
|
||||
|
|
@ -111,7 +111,7 @@ public class Constructor extends Z3Object {
|
|||
long nativeObj = Native.mkConstructor(ctx.nCtx(), name.getNativeObject(),
|
||||
recognizer.getNativeObject(), n, Symbol.arrayToNative(fieldNames),
|
||||
Sort.arrayToNative(sorts), sortRefs);
|
||||
return new Constructor(ctx, n, nativeObj);
|
||||
return new Constructor<>(ctx, n, nativeObj);
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
package com.microsoft.z3;
|
||||
|
||||
public class ConstructorDecRefQueue extends IDecRefQueue<Constructor> {
|
||||
public class ConstructorDecRefQueue extends IDecRefQueue<Constructor<?>> {
|
||||
public ConstructorDecRefQueue() {
|
||||
super();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Lists of constructors
|
||||
**/
|
||||
public class ConstructorList extends Z3Object {
|
||||
public class ConstructorList<R> extends Z3Object {
|
||||
|
||||
ConstructorList(Context ctx, long obj)
|
||||
{
|
||||
|
|
@ -37,7 +37,7 @@ public class ConstructorList extends Z3Object {
|
|||
getContext().getConstructorListDRQ().storeReference(getContext(), this);
|
||||
}
|
||||
|
||||
ConstructorList(Context ctx, Constructor[] constructors)
|
||||
ConstructorList(Context ctx, Constructor<R>[] constructors)
|
||||
{
|
||||
super(ctx, Native.mkConstructorList(ctx.nCtx(),
|
||||
constructors.length,
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
package com.microsoft.z3;
|
||||
|
||||
public class ConstructorListDecRefQueue extends IDecRefQueue<ConstructorList> {
|
||||
public class ConstructorListDecRefQueue extends IDecRefQueue<ConstructorList<?>> {
|
||||
public ConstructorListDecRefQueue() {
|
||||
super();
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Datatype expressions
|
||||
**/
|
||||
public class DatatypeExpr extends Expr
|
||||
public class DatatypeExpr<R extends Sort> extends Expr<DatatypeSort<R>>
|
||||
{
|
||||
/**
|
||||
* Constructor for DatatypeExpr
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Datatype sorts.
|
||||
**/
|
||||
public class DatatypeSort extends Sort
|
||||
public class DatatypeSort<R> extends Sort
|
||||
{
|
||||
/**
|
||||
* The number of constructors of the datatype sort.
|
||||
|
|
@ -39,12 +39,13 @@ public class DatatypeSort extends Sort
|
|||
* @throws Z3Exception
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public FuncDecl[] getConstructors()
|
||||
@SuppressWarnings("unchecked")
|
||||
public FuncDecl<DatatypeSort<R>>[] getConstructors()
|
||||
{
|
||||
int n = getNumConstructors();
|
||||
FuncDecl[] res = new FuncDecl[n];
|
||||
FuncDecl<DatatypeSort<R>>[] res = new FuncDecl[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = new FuncDecl(getContext(), Native.getDatatypeSortConstructor(
|
||||
res[i] = new FuncDecl<>(getContext(), Native.getDatatypeSortConstructor(
|
||||
getContext().nCtx(), getNativeObject(), i));
|
||||
return res;
|
||||
}
|
||||
|
|
@ -55,12 +56,13 @@ public class DatatypeSort extends Sort
|
|||
* @throws Z3Exception
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public FuncDecl[] getRecognizers()
|
||||
@SuppressWarnings("unchecked")
|
||||
public FuncDecl<BoolSort>[] getRecognizers()
|
||||
{
|
||||
int n = getNumConstructors();
|
||||
FuncDecl[] res = new FuncDecl[n];
|
||||
FuncDecl<BoolSort>[] res = new FuncDecl[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = new FuncDecl(getContext(), Native.getDatatypeSortRecognizer(
|
||||
res[i] = new FuncDecl<>(getContext(), Native.getDatatypeSortRecognizer(
|
||||
getContext().nCtx(), getNativeObject(), i));
|
||||
return res;
|
||||
}
|
||||
|
|
@ -71,20 +73,20 @@ public class DatatypeSort extends Sort
|
|||
* @throws Z3Exception
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public FuncDecl[][] getAccessors()
|
||||
public FuncDecl<?>[][] getAccessors()
|
||||
{
|
||||
|
||||
int n = getNumConstructors();
|
||||
FuncDecl[][] res = new FuncDecl[n][];
|
||||
FuncDecl<?>[][] res = new FuncDecl[n][];
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
FuncDecl fd = new FuncDecl(getContext(),
|
||||
FuncDecl<?> fd = new FuncDecl<>(getContext(),
|
||||
Native.getDatatypeSortConstructor(getContext().nCtx(),
|
||||
getNativeObject(), i));
|
||||
int ds = fd.getDomainSize();
|
||||
FuncDecl[] tmp = new FuncDecl[ds];
|
||||
FuncDecl<?>[] tmp = new FuncDecl[ds];
|
||||
for (int j = 0; j < ds; j++)
|
||||
tmp[j] = new FuncDecl(getContext(),
|
||||
tmp[j] = new FuncDecl<>(getContext(),
|
||||
Native.getDatatypeSortConstructorAccessor(getContext()
|
||||
.nCtx(), getNativeObject(), i, j));
|
||||
res[i] = tmp;
|
||||
|
|
@ -97,7 +99,7 @@ public class DatatypeSort extends Sort
|
|||
super(ctx, obj);
|
||||
}
|
||||
|
||||
DatatypeSort(Context ctx, Symbol name, Constructor[] constructors)
|
||||
DatatypeSort(Context ctx, Symbol name, Constructor<R>[] constructors)
|
||||
|
||||
{
|
||||
super(ctx, Native.mkDatatype(ctx.nCtx(), name.getNativeObject(),
|
||||
|
|
|
|||
|
|
@ -20,28 +20,29 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Enumeration sorts.
|
||||
**/
|
||||
public class EnumSort extends Sort
|
||||
@SuppressWarnings("unchecked")
|
||||
public class EnumSort<R> extends Sort
|
||||
{
|
||||
/**
|
||||
* The function declarations of the constants in the enumeration.
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public FuncDecl[] getConstDecls()
|
||||
public FuncDecl<EnumSort<R>>[] getConstDecls()
|
||||
{
|
||||
int n = Native.getDatatypeSortNumConstructors(getContext().nCtx(), getNativeObject());
|
||||
FuncDecl[] t = new FuncDecl[n];
|
||||
FuncDecl<?>[] t = new FuncDecl[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
t[i] = new FuncDecl(getContext(), Native.getDatatypeSortConstructor(getContext().nCtx(), getNativeObject(), i));
|
||||
return t;
|
||||
t[i] = new FuncDecl<>(getContext(), Native.getDatatypeSortConstructor(getContext().nCtx(), getNativeObject(), i));
|
||||
return (FuncDecl<EnumSort<R>>[]) t;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves the inx'th constant declaration in the enumeration.
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public FuncDecl getConstDecl(int inx)
|
||||
public FuncDecl<EnumSort<R>> getConstDecl(int inx)
|
||||
{
|
||||
return new FuncDecl(getContext(), Native.getDatatypeSortConstructor(getContext().nCtx(), getNativeObject(), inx));
|
||||
return new FuncDecl<>(getContext(), Native.getDatatypeSortConstructor(getContext().nCtx(), getNativeObject(), inx));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -49,13 +50,13 @@ public class EnumSort extends Sort
|
|||
* @throws Z3Exception on error
|
||||
* @return an Expr[]
|
||||
**/
|
||||
public Expr[] getConsts()
|
||||
public Expr<EnumSort<R>>[] getConsts()
|
||||
{
|
||||
FuncDecl[] cds = getConstDecls();
|
||||
Expr[] t = new Expr[cds.length];
|
||||
FuncDecl<?>[] cds = getConstDecls();
|
||||
Expr<?>[] t = new Expr[cds.length];
|
||||
for (int i = 0; i < t.length; i++)
|
||||
t[i] = getContext().mkApp(cds[i]);
|
||||
return t;
|
||||
return (Expr<EnumSort<R>>[]) t;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -63,7 +64,7 @@ public class EnumSort extends Sort
|
|||
* @throws Z3Exception on error
|
||||
* @return an Expr
|
||||
**/
|
||||
public Expr getConst(int inx)
|
||||
public Expr<EnumSort<R>> getConst(int inx)
|
||||
{
|
||||
return getContext().mkApp(getConstDecl(inx));
|
||||
}
|
||||
|
|
@ -72,12 +73,13 @@ public class EnumSort extends Sort
|
|||
* The test predicates for the constants in the enumeration.
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public FuncDecl[] getTesterDecls()
|
||||
@SuppressWarnings("unchecked")
|
||||
public FuncDecl<BoolSort>[] getTesterDecls()
|
||||
{
|
||||
int n = Native.getDatatypeSortNumConstructors(getContext().nCtx(), getNativeObject());
|
||||
FuncDecl[] t = new FuncDecl[n];
|
||||
FuncDecl<BoolSort>[] t = new FuncDecl[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
t[i] = new FuncDecl(getContext(), Native.getDatatypeSortRecognizer(getContext().nCtx(), getNativeObject(), i));
|
||||
t[i] = new FuncDecl<>(getContext(), Native.getDatatypeSortRecognizer(getContext().nCtx(), getNativeObject(), i));
|
||||
return t;
|
||||
}
|
||||
|
||||
|
|
@ -85,9 +87,9 @@ public class EnumSort extends Sort
|
|||
* Retrieves the inx'th tester/recognizer declaration in the enumeration.
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public FuncDecl getTesterDecl(int inx)
|
||||
public FuncDecl<BoolSort> getTesterDecl(int inx)
|
||||
{
|
||||
return new FuncDecl(getContext(), Native.getDatatypeSortRecognizer(getContext().nCtx(), getNativeObject(), inx));
|
||||
return new FuncDecl<>(getContext(), Native.getDatatypeSortRecognizer(getContext().nCtx(), getNativeObject(), inx));
|
||||
}
|
||||
|
||||
EnumSort(Context ctx, Symbol name, Symbol[] enumNames)
|
||||
|
|
|
|||
|
|
@ -27,14 +27,15 @@ import com.microsoft.z3.enumerations.Z3_sort_kind;
|
|||
/**
|
||||
* Expressions are terms.
|
||||
**/
|
||||
public class Expr extends AST
|
||||
@SuppressWarnings("unchecked")
|
||||
public class Expr<R extends Sort> extends AST
|
||||
{
|
||||
/**
|
||||
* Returns a simplified version of the expression
|
||||
* @return Expr
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public Expr simplify()
|
||||
public Expr<R> simplify()
|
||||
{
|
||||
return simplify(null);
|
||||
}
|
||||
|
|
@ -48,15 +49,15 @@ public class Expr extends AST
|
|||
* @return an Expr
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public Expr simplify(Params p)
|
||||
public Expr<R> simplify(Params p)
|
||||
{
|
||||
|
||||
if (p == null) {
|
||||
return Expr.create(getContext(),
|
||||
return (Expr<R>) Expr.create(getContext(),
|
||||
Native.simplify(getContext().nCtx(), getNativeObject()));
|
||||
}
|
||||
else {
|
||||
return Expr.create(
|
||||
return (Expr<R>) Expr.create(
|
||||
getContext(),
|
||||
Native.simplifyEx(getContext().nCtx(), getNativeObject(),
|
||||
p.getNativeObject()));
|
||||
|
|
@ -69,9 +70,9 @@ public class Expr extends AST
|
|||
* @return a FuncDecl
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public FuncDecl getFuncDecl()
|
||||
public FuncDecl<R> getFuncDecl()
|
||||
{
|
||||
return new FuncDecl(getContext(), Native.getAppDecl(getContext().nCtx(),
|
||||
return new FuncDecl<>(getContext(), Native.getAppDecl(getContext().nCtx(),
|
||||
getNativeObject()));
|
||||
}
|
||||
|
||||
|
|
@ -102,10 +103,10 @@ public class Expr extends AST
|
|||
* @throws Z3Exception on error
|
||||
* @return an Expr[]
|
||||
**/
|
||||
public Expr[] getArgs()
|
||||
public Expr<?>[] getArgs()
|
||||
{
|
||||
int n = getNumArgs();
|
||||
Expr[] res = new Expr[n];
|
||||
Expr<?>[] res = new Expr[n];
|
||||
for (int i = 0; i < n; i++) {
|
||||
res[i] = Expr.create(getContext(),
|
||||
Native.getAppArg(getContext().nCtx(), getNativeObject(), i));
|
||||
|
|
@ -120,13 +121,13 @@ public class Expr extends AST
|
|||
* @param args arguments
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public Expr update(Expr[] args)
|
||||
public Expr<R> update(Expr<?>[] args)
|
||||
{
|
||||
getContext().checkContextMatch(args);
|
||||
if (isApp() && args.length != getNumArgs()) {
|
||||
throw new Z3Exception("Number of arguments does not match");
|
||||
}
|
||||
return Expr.create(getContext(), Native.updateTerm(getContext().nCtx(), getNativeObject(),
|
||||
return (Expr<R>) Expr.create(getContext(), Native.updateTerm(getContext().nCtx(), getNativeObject(),
|
||||
args.length, Expr.arrayToNative(args)));
|
||||
}
|
||||
|
||||
|
|
@ -142,14 +143,14 @@ public class Expr extends AST
|
|||
* @throws Z3Exception on error
|
||||
* @return an Expr
|
||||
**/
|
||||
public Expr substitute(Expr[] from, Expr[] to)
|
||||
public Expr<R> substitute(Expr<?>[] from, Expr<?>[] to)
|
||||
{
|
||||
getContext().checkContextMatch(from);
|
||||
getContext().checkContextMatch(to);
|
||||
if (from.length != to.length) {
|
||||
throw new Z3Exception("Argument sizes do not match");
|
||||
}
|
||||
return Expr.create(getContext(), Native.substitute(getContext().nCtx(),
|
||||
return (Expr<R>) Expr.create(getContext(), Native.substitute(getContext().nCtx(),
|
||||
getNativeObject(), from.length, Expr.arrayToNative(from),
|
||||
Expr.arrayToNative(to)));
|
||||
}
|
||||
|
|
@ -161,7 +162,7 @@ public class Expr extends AST
|
|||
* @throws Z3Exception on error
|
||||
* @return an Expr
|
||||
**/
|
||||
public Expr substitute(Expr from, Expr to)
|
||||
public Expr<R> substitute(Expr<?> from, Expr<?> to)
|
||||
{
|
||||
return substitute(new Expr[] { from }, new Expr[] { to });
|
||||
}
|
||||
|
|
@ -176,11 +177,11 @@ public class Expr extends AST
|
|||
* @throws Z3Exception on error
|
||||
* @return an Expr
|
||||
**/
|
||||
public Expr substituteVars(Expr[] to)
|
||||
public Expr<R> substituteVars(Expr<?>[] to)
|
||||
{
|
||||
|
||||
getContext().checkContextMatch(to);
|
||||
return Expr.create(getContext(), Native.substituteVars(getContext().nCtx(),
|
||||
return (Expr<R>) Expr.create(getContext(), Native.substituteVars(getContext().nCtx(),
|
||||
getNativeObject(), to.length, Expr.arrayToNative(to)));
|
||||
}
|
||||
|
||||
|
|
@ -192,9 +193,9 @@ public class Expr extends AST
|
|||
* @return A copy of the term which is associated with {@code ctx}
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public Expr translate(Context ctx)
|
||||
public Expr<R> translate(Context ctx)
|
||||
{
|
||||
return (Expr) super.translate(ctx);
|
||||
return (Expr<R>) super.translate(ctx);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -232,9 +233,9 @@ public class Expr extends AST
|
|||
* @throws Z3Exception on error
|
||||
* @return a sort
|
||||
**/
|
||||
public Sort getSort()
|
||||
public R getSort()
|
||||
{
|
||||
return Sort.create(getContext(),
|
||||
return (R) Sort.create(getContext(),
|
||||
Native.getSort(getContext().nCtx(), getNativeObject()));
|
||||
}
|
||||
|
||||
|
|
@ -1635,7 +1636,7 @@ public class Expr extends AST
|
|||
|
||||
/**
|
||||
* Indicates whether the term is a proof by unit resolution
|
||||
* Remarks: T1: * (or l_1 ... l_n l_1' ... l_m') T2: (not l_1) ... T(n+1): (not l_n) * [unit-resolution T1 ... T(n+1)]: (or l_1' ... l_m')
|
||||
* Remarks: T1: * (or l_1 ... l_n l_1' ... l_m') T2: (not l_1) ... R(n+1): (not l_n) * [unit-resolution T1 ... R(n+1)]: (or l_1' ... l_m')
|
||||
* @throws Z3Exception on error
|
||||
* @return a boolean
|
||||
**/
|
||||
|
|
@ -1770,8 +1771,8 @@ public class Expr extends AST
|
|||
* The negation normal form steps NNF_POS and NNF_NEG are used in the
|
||||
* following cases: (a) When creating the NNF of a positive force
|
||||
* quantifier. The quantifier is retained (unless the bound variables are
|
||||
* eliminated). Example T1: q ~ q_new [nnf-pos T1]: (~ (forall (x T) q)
|
||||
* (forall (x T) q_new))
|
||||
* eliminated). Example T1: q ~ q_new [nnf-pos T1]: (~ (forall (x R) q)
|
||||
* (forall (x R) q_new))
|
||||
*
|
||||
* (b) When recursively creating NNF over Boolean formulas, where the
|
||||
* top-level connective is changed during NNF conversion. The relevant
|
||||
|
|
@ -2107,15 +2108,15 @@ public class Expr extends AST
|
|||
super.checkNativeObject(obj);
|
||||
}
|
||||
|
||||
static Expr create(Context ctx, FuncDecl f, Expr ... arguments)
|
||||
|
||||
static <U extends Sort> Expr<U> create(Context ctx, FuncDecl<U> f, Expr<?> ... arguments)
|
||||
{
|
||||
long obj = Native.mkApp(ctx.nCtx(), f.getNativeObject(),
|
||||
AST.arrayLength(arguments), AST.arrayToNative(arguments));
|
||||
return create(ctx, obj);
|
||||
return (Expr<U>) create(ctx, obj);
|
||||
}
|
||||
|
||||
static Expr create(Context ctx, long obj)
|
||||
// TODO generify, but it conflicts with AST.create
|
||||
static Expr<?> create(Context ctx, long obj)
|
||||
{
|
||||
Z3_ast_kind k = Z3_ast_kind.fromInt(Native.getAstKind(ctx.nCtx(), obj));
|
||||
if (k == Z3_ast_kind.Z3_QUANTIFIER_AST)
|
||||
|
|
@ -2143,7 +2144,7 @@ public class Expr extends AST
|
|||
return new FPRMNum(ctx, obj);
|
||||
case Z3_FINITE_DOMAIN_SORT:
|
||||
return new FiniteDomainNum(ctx, obj);
|
||||
default: ;
|
||||
default:
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2158,9 +2159,9 @@ public class Expr extends AST
|
|||
case Z3_BV_SORT:
|
||||
return new BitVecExpr(ctx, obj);
|
||||
case Z3_ARRAY_SORT:
|
||||
return new ArrayExpr(ctx, obj);
|
||||
return new ArrayExpr<>(ctx, obj);
|
||||
case Z3_DATATYPE_SORT:
|
||||
return new DatatypeExpr(ctx, obj);
|
||||
return new DatatypeExpr<>(ctx, obj);
|
||||
case Z3_FLOATING_POINT_SORT:
|
||||
return new FPExpr(ctx, obj);
|
||||
case Z3_ROUNDING_MODE_SORT:
|
||||
|
|
@ -2168,12 +2169,12 @@ public class Expr extends AST
|
|||
case Z3_FINITE_DOMAIN_SORT:
|
||||
return new FiniteDomainExpr(ctx, obj);
|
||||
case Z3_SEQ_SORT:
|
||||
return new SeqExpr(ctx, obj);
|
||||
return new SeqExpr<>(ctx, obj);
|
||||
case Z3_RE_SORT:
|
||||
return new ReExpr(ctx, obj);
|
||||
default: ;
|
||||
return new ReExpr<>(ctx, obj);
|
||||
default:
|
||||
}
|
||||
|
||||
return new Expr(ctx, obj);
|
||||
return new Expr<>(ctx, obj);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* FloatingPoint Expressions
|
||||
*/
|
||||
public class FPExpr extends Expr
|
||||
public class FPExpr extends Expr<FPSort>
|
||||
{
|
||||
/**
|
||||
* The number of exponent bits.
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* FloatingPoint RoundingMode Expressions
|
||||
*/
|
||||
public class FPRMExpr extends Expr
|
||||
public class FPRMExpr extends Expr<FPRMSort>
|
||||
{
|
||||
public FPRMExpr(Context ctx, long obj)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Finite-domain expressions
|
||||
**/
|
||||
public class FiniteDomainExpr extends Expr
|
||||
public class FiniteDomainExpr<R> extends Expr<FiniteDomainSort<R>>
|
||||
{
|
||||
/**
|
||||
* Constructor for FiniteDomainExpr
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ import java.math.BigInteger;
|
|||
/**
|
||||
* Finite-domain Numerals
|
||||
**/
|
||||
public class FiniteDomainNum extends FiniteDomainExpr
|
||||
public class FiniteDomainNum<R> extends FiniteDomainExpr<R>
|
||||
{
|
||||
|
||||
FiniteDomainNum(Context ctx, long obj)
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Finite domain sorts.
|
||||
**/
|
||||
public class FiniteDomainSort extends Sort
|
||||
public class FiniteDomainSort<R> extends Sort
|
||||
{
|
||||
/**
|
||||
* The size of the finite domain sort.
|
||||
|
|
|
|||
|
|
@ -62,10 +62,11 @@ public class Fixedpoint extends Z3Object
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public void add(BoolExpr ... constraints)
|
||||
@SafeVarargs
|
||||
public final void add(Expr<BoolSort>... constraints)
|
||||
{
|
||||
getContext().checkContextMatch(constraints);
|
||||
for (BoolExpr a : constraints)
|
||||
for (Expr<BoolSort> a : constraints)
|
||||
{
|
||||
Native.fixedpointAssert(getContext().nCtx(), getNativeObject(),
|
||||
a.getNativeObject());
|
||||
|
|
@ -77,9 +78,8 @@ public class Fixedpoint extends Z3Object
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public void registerRelation(FuncDecl f)
|
||||
public void registerRelation(FuncDecl<BoolSort> f)
|
||||
{
|
||||
|
||||
getContext().checkContextMatch(f);
|
||||
Native.fixedpointRegisterRelation(getContext().nCtx(), getNativeObject(),
|
||||
f.getNativeObject());
|
||||
|
|
@ -92,7 +92,7 @@ public class Fixedpoint extends Z3Object
|
|||
* @param name Nullable rule name.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public void addRule(BoolExpr rule, Symbol name) {
|
||||
public void addRule(Expr<BoolSort> rule, Symbol name) {
|
||||
getContext().checkContextMatch(rule);
|
||||
Native.fixedpointAddRule(getContext().nCtx(), getNativeObject(),
|
||||
rule.getNativeObject(), AST.getNativeObject(name));
|
||||
|
|
@ -103,7 +103,7 @@ public class Fixedpoint extends Z3Object
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public void addFact(FuncDecl pred, int ... args) {
|
||||
public void addFact(FuncDecl<BoolSort> pred, int ... args) {
|
||||
getContext().checkContextMatch(pred);
|
||||
Native.fixedpointAddFact(getContext().nCtx(), getNativeObject(),
|
||||
pred.getNativeObject(), args.length, args);
|
||||
|
|
@ -118,7 +118,7 @@ public class Fixedpoint extends Z3Object
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Status query(BoolExpr query) {
|
||||
public Status query(Expr<BoolSort> query) {
|
||||
getContext().checkContextMatch(query);
|
||||
Z3_lbool r = Z3_lbool.fromInt(Native.fixedpointQuery(getContext().nCtx(),
|
||||
getNativeObject(), query.getNativeObject()));
|
||||
|
|
@ -141,7 +141,7 @@ public class Fixedpoint extends Z3Object
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Status query(FuncDecl[] relations) {
|
||||
public Status query(FuncDecl<BoolSort>[] relations) {
|
||||
getContext().checkContextMatch(relations);
|
||||
Z3_lbool r = Z3_lbool.fromInt(Native.fixedpointQueryRelations(getContext()
|
||||
.nCtx(), getNativeObject(), AST.arrayLength(relations), AST
|
||||
|
|
@ -164,7 +164,7 @@ public class Fixedpoint extends Z3Object
|
|||
* @param name Nullable rule name.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public void updateRule(BoolExpr rule, Symbol name) {
|
||||
public void updateRule(Expr<BoolSort> rule, Symbol name) {
|
||||
getContext().checkContextMatch(rule);
|
||||
Native.fixedpointUpdateRule(getContext().nCtx(), getNativeObject(),
|
||||
rule.getNativeObject(), AST.getNativeObject(name));
|
||||
|
|
@ -176,7 +176,7 @@ public class Fixedpoint extends Z3Object
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Expr getAnswer()
|
||||
public Expr<?> getAnswer()
|
||||
{
|
||||
long ans = Native.fixedpointGetAnswer(getContext().nCtx(), getNativeObject());
|
||||
return (ans == 0) ? null : Expr.create(getContext(), ans);
|
||||
|
|
@ -194,7 +194,7 @@ public class Fixedpoint extends Z3Object
|
|||
/**
|
||||
* Retrieve the number of levels explored for a given predicate.
|
||||
**/
|
||||
public int getNumLevels(FuncDecl predicate)
|
||||
public int getNumLevels(FuncDecl<BoolSort> predicate)
|
||||
{
|
||||
return Native.fixedpointGetNumLevels(getContext().nCtx(), getNativeObject(),
|
||||
predicate.getNativeObject());
|
||||
|
|
@ -205,7 +205,7 @@ public class Fixedpoint extends Z3Object
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Expr getCoverDelta(int level, FuncDecl predicate)
|
||||
public Expr<?> getCoverDelta(int level, FuncDecl<BoolSort> predicate)
|
||||
{
|
||||
long res = Native.fixedpointGetCoverDelta(getContext().nCtx(),
|
||||
getNativeObject(), level, predicate.getNativeObject());
|
||||
|
|
@ -216,7 +216,7 @@ public class Fixedpoint extends Z3Object
|
|||
* Add <tt>property</tt> about the <tt>predicate</tt>. The property is added
|
||||
* at <tt>level</tt>.
|
||||
**/
|
||||
public void addCover(int level, FuncDecl predicate, Expr property)
|
||||
public void addCover(int level, FuncDecl<BoolSort> predicate, Expr<?> property)
|
||||
|
||||
{
|
||||
Native.fixedpointAddCover(getContext().nCtx(), getNativeObject(), level,
|
||||
|
|
@ -237,9 +237,8 @@ public class Fixedpoint extends Z3Object
|
|||
* Instrument the Datalog engine on which table representation to use for
|
||||
* recursive predicate.
|
||||
**/
|
||||
public void setPredicateRepresentation(FuncDecl f, Symbol[] kinds)
|
||||
public void setPredicateRepresentation(FuncDecl<BoolSort> f, Symbol[] kinds)
|
||||
{
|
||||
|
||||
Native.fixedpointSetPredicateRepresentation(getContext().nCtx(),
|
||||
getNativeObject(), f.getNativeObject(), AST.arrayLength(kinds),
|
||||
Symbol.arrayToNative(kinds));
|
||||
|
|
@ -249,9 +248,8 @@ public class Fixedpoint extends Z3Object
|
|||
/**
|
||||
* Convert benchmark given as set of axioms, rules and queries to a string.
|
||||
**/
|
||||
public String toString(BoolExpr[] queries)
|
||||
public String toString(Expr<BoolSort>[] queries)
|
||||
{
|
||||
|
||||
return Native.fixedpointToString(getContext().nCtx(), getNativeObject(),
|
||||
AST.arrayLength(queries), AST.arrayToNative(queries));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ import com.microsoft.z3.enumerations.Z3_parameter_kind;
|
|||
/**
|
||||
* Function declarations.
|
||||
**/
|
||||
public class FuncDecl extends AST
|
||||
public class FuncDecl<R extends Sort> extends AST
|
||||
{
|
||||
/**
|
||||
* Object comparison.
|
||||
|
|
@ -34,7 +34,7 @@ public class FuncDecl extends AST
|
|||
{
|
||||
if (o == this) return true;
|
||||
if (!(o instanceof FuncDecl)) return false;
|
||||
FuncDecl other = (FuncDecl) o;
|
||||
FuncDecl<?> other = (FuncDecl<?>) o;
|
||||
|
||||
return
|
||||
(getContext().nCtx() == other.getContext().nCtx()) &&
|
||||
|
|
@ -66,9 +66,10 @@ public class FuncDecl extends AST
|
|||
* @return A copy of the function declaration which is associated with {@code ctx}
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public FuncDecl translate(Context ctx)
|
||||
@SuppressWarnings("unchecked")
|
||||
public FuncDecl<R> translate(Context ctx)
|
||||
{
|
||||
return (FuncDecl) super.translate(ctx);
|
||||
return (FuncDecl<R>) super.translate(ctx);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -106,10 +107,10 @@ public class FuncDecl extends AST
|
|||
/**
|
||||
* The range of the function declaration
|
||||
**/
|
||||
public Sort getRange()
|
||||
@SuppressWarnings("unchecked")
|
||||
public R getRange()
|
||||
{
|
||||
|
||||
return Sort.create(getContext(),
|
||||
return (R) Sort.create(getContext(),
|
||||
Native.getRange(getContext().nCtx(), getNativeObject()));
|
||||
}
|
||||
|
||||
|
|
@ -178,7 +179,7 @@ public class FuncDecl extends AST
|
|||
getNativeObject(), i)));
|
||||
break;
|
||||
case Z3_PARAMETER_FUNC_DECL:
|
||||
res[i] = new Parameter(k, new FuncDecl(getContext(),
|
||||
res[i] = new Parameter(k, new FuncDecl<>(getContext(),
|
||||
Native.getDeclFuncDeclParameter(getContext().nCtx(),
|
||||
getNativeObject(), i)));
|
||||
break;
|
||||
|
|
@ -197,7 +198,7 @@ public class FuncDecl extends AST
|
|||
/**
|
||||
* Function declarations can have Parameters associated with them.
|
||||
**/
|
||||
public class Parameter
|
||||
public static class Parameter
|
||||
{
|
||||
private Z3_parameter_kind kind;
|
||||
private int i;
|
||||
|
|
@ -205,7 +206,7 @@ public class FuncDecl extends AST
|
|||
private Symbol sym;
|
||||
private Sort srt;
|
||||
private AST ast;
|
||||
private FuncDecl fd;
|
||||
private FuncDecl<?> fd;
|
||||
private String r;
|
||||
|
||||
/**
|
||||
|
|
@ -261,7 +262,7 @@ public class FuncDecl extends AST
|
|||
/**
|
||||
* The FunctionDeclaration value of the parameter.
|
||||
**/
|
||||
public FuncDecl getFuncDecl()
|
||||
public FuncDecl<?> getFuncDecl()
|
||||
{
|
||||
if (getParameterKind() != Z3_parameter_kind.Z3_PARAMETER_FUNC_DECL)
|
||||
throw new Z3Exception("parameter is not a function declaration");
|
||||
|
|
@ -316,7 +317,7 @@ public class FuncDecl extends AST
|
|||
this.ast = a;
|
||||
}
|
||||
|
||||
Parameter(Z3_parameter_kind k, FuncDecl fd)
|
||||
Parameter(Z3_parameter_kind k, FuncDecl<?> fd)
|
||||
{
|
||||
this.kind = k;
|
||||
this.fd = fd;
|
||||
|
|
@ -335,14 +336,14 @@ public class FuncDecl extends AST
|
|||
|
||||
}
|
||||
|
||||
FuncDecl(Context ctx, Symbol name, Sort[] domain, Sort range)
|
||||
FuncDecl(Context ctx, Symbol name, Sort[] domain, R range)
|
||||
{
|
||||
super(ctx, Native.mkFuncDecl(ctx.nCtx(), name.getNativeObject(),
|
||||
AST.arrayLength(domain), AST.arrayToNative(domain),
|
||||
range.getNativeObject()));
|
||||
}
|
||||
|
||||
FuncDecl(Context ctx, Symbol name, Sort[] domain, Sort range, boolean is_rec)
|
||||
FuncDecl(Context ctx, Symbol name, Sort[] domain, R range, boolean is_rec)
|
||||
{
|
||||
super(ctx, Native.mkRecFuncDecl(ctx.nCtx(), name.getNativeObject(),
|
||||
AST.arrayLength(domain), AST.arrayToNative(domain),
|
||||
|
|
@ -350,8 +351,7 @@ public class FuncDecl extends AST
|
|||
|
||||
}
|
||||
|
||||
FuncDecl(Context ctx, String prefix, Sort[] domain, Sort range)
|
||||
|
||||
FuncDecl(Context ctx, String prefix, Sort[] domain, R range)
|
||||
{
|
||||
super(ctx, Native.mkFreshFuncDecl(ctx.nCtx(), prefix,
|
||||
AST.arrayLength(domain), AST.arrayToNative(domain),
|
||||
|
|
@ -371,7 +371,7 @@ public class FuncDecl extends AST
|
|||
/**
|
||||
* Create expression that applies function to arguments.
|
||||
**/
|
||||
public Expr apply(Expr ... args)
|
||||
public Expr<R> apply(Expr<?> ... args)
|
||||
{
|
||||
getContext().checkContextMatch(args);
|
||||
return Expr.create(getContext(), this, args);
|
||||
|
|
|
|||
|
|
@ -22,13 +22,14 @@ package com.microsoft.z3;
|
|||
* Each entry in the finite map represents the value of a function given a set
|
||||
* of arguments.
|
||||
**/
|
||||
public class FuncInterp extends Z3Object {
|
||||
@SuppressWarnings("unchecked")
|
||||
public class FuncInterp<R extends Sort> extends Z3Object {
|
||||
|
||||
/**
|
||||
* An Entry object represents an element in the finite map used to encode a
|
||||
* function interpretation.
|
||||
**/
|
||||
public static class Entry extends Z3Object {
|
||||
public static class Entry<R extends Sort> extends Z3Object {
|
||||
|
||||
/**
|
||||
* Return the (symbolic) value of this entry.
|
||||
|
|
@ -36,9 +37,9 @@ public class FuncInterp extends Z3Object {
|
|||
* @throws Z3Exception
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public Expr getValue()
|
||||
public Expr<R> getValue()
|
||||
{
|
||||
return Expr.create(getContext(),
|
||||
return (Expr<R>) Expr.create(getContext(),
|
||||
Native.funcEntryGetValue(getContext().nCtx(), getNativeObject()));
|
||||
}
|
||||
|
||||
|
|
@ -57,10 +58,10 @@ public class FuncInterp extends Z3Object {
|
|||
* @throws Z3Exception
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public Expr[] getArgs()
|
||||
public Expr<?>[] getArgs()
|
||||
{
|
||||
int n = getNumArgs();
|
||||
Expr[] res = new Expr[n];
|
||||
Expr<?>[] res = new Expr[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = Expr.create(getContext(), Native.funcEntryGetArg(
|
||||
getContext().nCtx(), getNativeObject(), i));
|
||||
|
|
@ -75,7 +76,7 @@ public class FuncInterp extends Z3Object {
|
|||
{
|
||||
int n = getNumArgs();
|
||||
String res = "[";
|
||||
Expr[] args = getArgs();
|
||||
Expr<?>[] args = getArgs();
|
||||
for (int i = 0; i < n; i++)
|
||||
res += args[i] + ", ";
|
||||
return res + getValue() + "]";
|
||||
|
|
@ -112,12 +113,12 @@ public class FuncInterp extends Z3Object {
|
|||
* @throws Z3Exception
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public Entry[] getEntries()
|
||||
public Entry<R>[] getEntries()
|
||||
{
|
||||
int n = getNumEntries();
|
||||
Entry[] res = new Entry[n];
|
||||
Entry<R>[] res = new Entry[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = new Entry(getContext(), Native.funcInterpGetEntry(getContext()
|
||||
res[i] = new Entry<>(getContext(), Native.funcInterpGetEntry(getContext()
|
||||
.nCtx(), getNativeObject(), i));
|
||||
return res;
|
||||
}
|
||||
|
|
@ -129,9 +130,9 @@ public class FuncInterp extends Z3Object {
|
|||
* @throws Z3Exception on error
|
||||
* @return an Expr
|
||||
**/
|
||||
public Expr getElse()
|
||||
public Expr<R> getElse()
|
||||
{
|
||||
return Expr.create(getContext(),
|
||||
return (Expr<R>) Expr.create(getContext(),
|
||||
Native.funcInterpGetElse(getContext().nCtx(), getNativeObject()));
|
||||
}
|
||||
|
||||
|
|
@ -152,12 +153,12 @@ public class FuncInterp extends Z3Object {
|
|||
{
|
||||
String res = "";
|
||||
res += "[";
|
||||
for (Entry e : getEntries())
|
||||
for (Entry<R> e : getEntries())
|
||||
{
|
||||
int n = e.getNumArgs();
|
||||
if (n > 1)
|
||||
res += "[";
|
||||
Expr[] args = e.getArgs();
|
||||
Expr<?>[] args = e.getArgs();
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
if (i != 0)
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ Notes:
|
|||
|
||||
package com.microsoft.z3;
|
||||
|
||||
class FuncInterpDecRefQueue extends IDecRefQueue<FuncInterp>
|
||||
class FuncInterpDecRefQueue extends IDecRefQueue<FuncInterp<?>>
|
||||
{
|
||||
public FuncInterpDecRefQueue()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ Notes:
|
|||
|
||||
package com.microsoft.z3;
|
||||
|
||||
class FuncInterpEntryDecRefQueue extends IDecRefQueue<FuncInterp.Entry> {
|
||||
class FuncInterpEntryDecRefQueue extends IDecRefQueue<FuncInterp.Entry<?>> {
|
||||
public FuncInterpEntryDecRefQueue()
|
||||
{
|
||||
super();
|
||||
|
|
|
|||
|
|
@ -76,10 +76,11 @@ public class Goal extends Z3Object {
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public void add(BoolExpr ... constraints)
|
||||
@SafeVarargs
|
||||
public final void add(Expr<BoolSort>... constraints)
|
||||
{
|
||||
getContext().checkContextMatch(constraints);
|
||||
for (BoolExpr c : constraints)
|
||||
for (Expr<BoolSort> c : constraints)
|
||||
{
|
||||
Native.goalAssert(getContext().nCtx(), getNativeObject(),
|
||||
c.getNativeObject());
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Int expressions
|
||||
**/
|
||||
public class IntExpr extends ArithExpr
|
||||
public class IntExpr extends ArithExpr<IntSort>
|
||||
{
|
||||
/**
|
||||
* Constructor for IntExpr
|
||||
|
|
|
|||
|
|
@ -19,12 +19,11 @@ Notes:
|
|||
|
||||
package com.microsoft.z3;
|
||||
|
||||
import com.microsoft.z3.enumerations.Z3_ast_kind;
|
||||
|
||||
|
||||
/**
|
||||
* Lambda expressions.
|
||||
*/public class Lambda extends ArrayExpr
|
||||
*/
|
||||
public class Lambda<R extends Sort> extends ArrayExpr<Sort, R>
|
||||
{
|
||||
|
||||
/**
|
||||
|
|
@ -70,9 +69,10 @@ import com.microsoft.z3.enumerations.Z3_ast_kind;
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Expr getBody()
|
||||
@SuppressWarnings("unchecked")
|
||||
public Expr<R> getBody()
|
||||
{
|
||||
return Expr.create(getContext(), Native.getQuantifierBody(getContext()
|
||||
return (Expr<R>) Expr.create(getContext(), Native.getQuantifierBody(getContext()
|
||||
.nCtx(), getNativeObject()));
|
||||
}
|
||||
|
||||
|
|
@ -81,17 +81,17 @@ import com.microsoft.z3.enumerations.Z3_ast_kind;
|
|||
* Translates (copies) the quantifier to the Context {@code ctx}.
|
||||
*
|
||||
* @param ctx A context
|
||||
*
|
||||
*
|
||||
* @return A copy of the quantifier which is associated with {@code ctx}
|
||||
* @throws Z3Exception on error
|
||||
**/
|
||||
public Lambda translate(Context ctx)
|
||||
public Lambda<R> translate(Context ctx)
|
||||
{
|
||||
return (Lambda) super.translate(ctx);
|
||||
return (Lambda<R>) super.translate(ctx);
|
||||
}
|
||||
|
||||
|
||||
public static Lambda of(Context ctx, Sort[] sorts, Symbol[] names, Expr body)
|
||||
public static <R extends Sort> Lambda<R> of(Context ctx, Sort[] sorts, Symbol[] names, Expr<R> body)
|
||||
{
|
||||
ctx.checkContextMatch(sorts);
|
||||
ctx.checkContextMatch(names);
|
||||
|
|
@ -106,7 +106,7 @@ import com.microsoft.z3.enumerations.Z3_ast_kind;
|
|||
Symbol.arrayToNative(names),
|
||||
body.getNativeObject());
|
||||
|
||||
return new Lambda(ctx, nativeObject);
|
||||
return new Lambda<>(ctx, nativeObject);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -115,14 +115,14 @@ import com.microsoft.z3.enumerations.Z3_ast_kind;
|
|||
* @param body Body of the lambda expression.
|
||||
*/
|
||||
|
||||
public static Lambda of(Context ctx, Expr[] bound, Expr body) {
|
||||
public static <R extends Sort> Lambda<R> of(Context ctx, Expr<?>[] bound, Expr<R> body) {
|
||||
ctx.checkContextMatch(body);
|
||||
|
||||
|
||||
long nativeObject = Native.mkLambdaConst(ctx.nCtx(),
|
||||
AST.arrayLength(bound), AST.arrayToNative(bound),
|
||||
body.getNativeObject());
|
||||
return new Lambda(ctx, nativeObject);
|
||||
return new Lambda<>(ctx, nativeObject);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -22,22 +22,22 @@ import com.microsoft.z3.Native.LongPtr;
|
|||
/**
|
||||
* List sorts.
|
||||
**/
|
||||
public class ListSort extends Sort
|
||||
public class ListSort<R extends Sort> extends Sort
|
||||
{
|
||||
/**
|
||||
* The declaration of the nil function of this list sort.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public FuncDecl getNilDecl()
|
||||
public FuncDecl<ListSort<R>> getNilDecl()
|
||||
{
|
||||
return new FuncDecl(getContext(), Native.getDatatypeSortConstructor(getContext().nCtx(), getNativeObject(), 0));
|
||||
return new FuncDecl<>(getContext(), Native.getDatatypeSortConstructor(getContext().nCtx(), getNativeObject(), 0));
|
||||
}
|
||||
|
||||
/**
|
||||
* The empty list.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Expr getNil()
|
||||
public Expr<ListSort<R>> getNil()
|
||||
{
|
||||
return getContext().mkApp(getNilDecl());
|
||||
}
|
||||
|
|
@ -46,18 +46,18 @@ public class ListSort extends Sort
|
|||
* The declaration of the isNil function of this list sort.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public FuncDecl getIsNilDecl()
|
||||
public FuncDecl<BoolSort> getIsNilDecl()
|
||||
{
|
||||
return new FuncDecl(getContext(), Native.getDatatypeSortRecognizer(getContext().nCtx(), getNativeObject(), 0));
|
||||
return new FuncDecl<>(getContext(), Native.getDatatypeSortRecognizer(getContext().nCtx(), getNativeObject(), 0));
|
||||
}
|
||||
|
||||
/**
|
||||
* The declaration of the cons function of this list sort.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public FuncDecl getConsDecl()
|
||||
public FuncDecl<ListSort<R>> getConsDecl()
|
||||
{
|
||||
return new FuncDecl(getContext(), Native.getDatatypeSortConstructor(getContext().nCtx(), getNativeObject(), 1));
|
||||
return new FuncDecl<>(getContext(), Native.getDatatypeSortConstructor(getContext().nCtx(), getNativeObject(), 1));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -65,27 +65,27 @@ public class ListSort extends Sort
|
|||
* @throws Z3Exception
|
||||
*
|
||||
**/
|
||||
public FuncDecl getIsConsDecl()
|
||||
public FuncDecl<BoolSort> getIsConsDecl()
|
||||
{
|
||||
return new FuncDecl(getContext(), Native.getDatatypeSortRecognizer(getContext().nCtx(), getNativeObject(), 1));
|
||||
return new FuncDecl<>(getContext(), Native.getDatatypeSortRecognizer(getContext().nCtx(), getNativeObject(), 1));
|
||||
}
|
||||
|
||||
/**
|
||||
* The declaration of the head function of this list sort.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public FuncDecl getHeadDecl()
|
||||
public FuncDecl<R> getHeadDecl()
|
||||
{
|
||||
return new FuncDecl(getContext(), Native.getDatatypeSortConstructorAccessor(getContext().nCtx(), getNativeObject(), 1, 0));
|
||||
return new FuncDecl<>(getContext(), Native.getDatatypeSortConstructorAccessor(getContext().nCtx(), getNativeObject(), 1, 0));
|
||||
}
|
||||
|
||||
/**
|
||||
* The declaration of the tail function of this list sort.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public FuncDecl getTailDecl()
|
||||
public FuncDecl<ListSort<R>> getTailDecl()
|
||||
{
|
||||
return new FuncDecl(getContext(), Native.getDatatypeSortConstructorAccessor(getContext().nCtx(), getNativeObject(), 1, 1));
|
||||
return new FuncDecl<>(getContext(), Native.getDatatypeSortConstructorAccessor(getContext().nCtx(), getNativeObject(), 1, 1));
|
||||
}
|
||||
|
||||
ListSort(Context ctx, Symbol name, Sort elemSort)
|
||||
|
|
|
|||
|
|
@ -22,17 +22,18 @@ import com.microsoft.z3.enumerations.Z3_sort_kind;
|
|||
/**
|
||||
* A Model contains interpretations (assignments) of constants and functions.
|
||||
**/
|
||||
@SuppressWarnings("unchecked")
|
||||
public class Model extends Z3Object {
|
||||
/**
|
||||
* Retrieves the interpretation (the assignment) of {@code a} in
|
||||
* the model.
|
||||
* @param a A Constant
|
||||
*
|
||||
*
|
||||
* @return An expression if the constant has an interpretation in the model,
|
||||
* null otherwise.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Expr getConstInterp(Expr a)
|
||||
public <R extends Sort> Expr<R> getConstInterp(Expr<R> a)
|
||||
{
|
||||
getContext().checkContextMatch(a);
|
||||
return getConstInterp(a.getFuncDecl());
|
||||
|
|
@ -47,7 +48,7 @@ public class Model extends Z3Object {
|
|||
* null otherwise.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Expr getConstInterp(FuncDecl f)
|
||||
public <R extends Sort> Expr<R> getConstInterp(FuncDecl<R> f)
|
||||
{
|
||||
getContext().checkContextMatch(f);
|
||||
if (f.getArity() != 0)
|
||||
|
|
@ -59,7 +60,7 @@ public class Model extends Z3Object {
|
|||
if (n == 0)
|
||||
return null;
|
||||
else
|
||||
return Expr.create(getContext(), n);
|
||||
return (Expr<R>) Expr.create(getContext(), n);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -70,7 +71,7 @@ public class Model extends Z3Object {
|
|||
* the model, null otherwise.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public FuncInterp getFuncInterp(FuncDecl f)
|
||||
public <R extends Sort> FuncInterp<R> getFuncInterp(FuncDecl<R> f)
|
||||
{
|
||||
getContext().checkContextMatch(f);
|
||||
|
||||
|
|
@ -90,7 +91,7 @@ public class Model extends Z3Object {
|
|||
{
|
||||
if (Native.isAsArray(getContext().nCtx(), n)) {
|
||||
long fd = Native.getAsArrayFuncDecl(getContext().nCtx(), n);
|
||||
return getFuncInterp(new FuncDecl(getContext(), fd));
|
||||
return getFuncInterp(new FuncDecl<>(getContext(), fd));
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
|
@ -106,7 +107,7 @@ public class Model extends Z3Object {
|
|||
if (n == 0)
|
||||
return null;
|
||||
else
|
||||
return new FuncInterp(getContext(), n);
|
||||
return new FuncInterp<>(getContext(), n);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -123,12 +124,12 @@ public class Model extends Z3Object {
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public FuncDecl[] getConstDecls()
|
||||
public FuncDecl<?>[] getConstDecls()
|
||||
{
|
||||
int n = getNumConsts();
|
||||
FuncDecl[] res = new FuncDecl[n];
|
||||
FuncDecl<?>[] res = new FuncDecl[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = new FuncDecl(getContext(), Native.modelGetConstDecl(getContext()
|
||||
res[i] = new FuncDecl<>(getContext(), Native.modelGetConstDecl(getContext()
|
||||
.nCtx(), getNativeObject(), i));
|
||||
return res;
|
||||
}
|
||||
|
|
@ -146,12 +147,12 @@ public class Model extends Z3Object {
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public FuncDecl[] getFuncDecls()
|
||||
public FuncDecl<?>[] getFuncDecls()
|
||||
{
|
||||
int n = getNumFuncs();
|
||||
FuncDecl[] res = new FuncDecl[n];
|
||||
FuncDecl<?>[] res = new FuncDecl[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = new FuncDecl(getContext(), Native.modelGetFuncDecl(getContext()
|
||||
res[i] = new FuncDecl<>(getContext(), Native.modelGetFuncDecl(getContext()
|
||||
.nCtx(), getNativeObject(), i));
|
||||
return res;
|
||||
}
|
||||
|
|
@ -161,17 +162,17 @@ public class Model extends Z3Object {
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public FuncDecl[] getDecls()
|
||||
public FuncDecl<?>[] getDecls()
|
||||
{
|
||||
int nFuncs = getNumFuncs();
|
||||
int nConsts = getNumConsts();
|
||||
int n = nFuncs + nConsts;
|
||||
FuncDecl[] res = new FuncDecl[n];
|
||||
FuncDecl<?>[] res = new FuncDecl[n];
|
||||
for (int i = 0; i < nConsts; i++)
|
||||
res[i] = new FuncDecl(getContext(), Native.modelGetConstDecl(getContext()
|
||||
res[i] = new FuncDecl<>(getContext(), Native.modelGetConstDecl(getContext()
|
||||
.nCtx(), getNativeObject(), i));
|
||||
for (int i = 0; i < nFuncs; i++)
|
||||
res[nConsts + i] = new FuncDecl(getContext(), Native.modelGetFuncDecl(
|
||||
res[nConsts + i] = new FuncDecl<>(getContext(), Native.modelGetFuncDecl(
|
||||
getContext().nCtx(), getNativeObject(), i));
|
||||
return res;
|
||||
}
|
||||
|
|
@ -205,14 +206,14 @@ public class Model extends Z3Object {
|
|||
* @return The evaluation of {@code t} in the model.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Expr eval(Expr t, boolean completion)
|
||||
public <R extends Sort> Expr<R> eval(Expr<R> t, boolean completion)
|
||||
{
|
||||
Native.LongPtr v = new Native.LongPtr();
|
||||
if (!Native.modelEval(getContext().nCtx(), getNativeObject(),
|
||||
t.getNativeObject(), (completion), v))
|
||||
throw new ModelEvaluationFailedException();
|
||||
else
|
||||
return Expr.create(getContext(), v.value);
|
||||
return (Expr<R>) Expr.create(getContext(), v.value);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -220,7 +221,7 @@ public class Model extends Z3Object {
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Expr evaluate(Expr t, boolean completion)
|
||||
public <R extends Sort> Expr<R> evaluate(Expr<R> t, boolean completion)
|
||||
{
|
||||
return eval(t, completion);
|
||||
}
|
||||
|
|
@ -265,12 +266,12 @@ public class Model extends Z3Object {
|
|||
* of {@code s}
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Expr[] getSortUniverse(Sort s)
|
||||
public <R extends Sort> Expr<R>[] getSortUniverse(R s)
|
||||
{
|
||||
|
||||
ASTVector nUniv = new ASTVector(getContext(), Native.modelGetSortUniverse(
|
||||
getContext().nCtx(), getNativeObject(), s.getNativeObject()));
|
||||
return nUniv.ToExprArray();
|
||||
return (Expr<R>[]) nUniv.ToExprArray();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@ import com.microsoft.z3.enumerations.Z3_lbool;
|
|||
/**
|
||||
* Object for managing optimization context
|
||||
**/
|
||||
@SuppressWarnings("unchecked")
|
||||
public class Optimize extends Z3Object {
|
||||
|
||||
/**
|
||||
|
|
@ -55,10 +56,10 @@ public class Optimize extends Z3Object {
|
|||
/**
|
||||
* Assert a constraint (or multiple) into the optimize solver.
|
||||
**/
|
||||
public void Assert(BoolExpr ... constraints)
|
||||
public void Assert(Expr<BoolSort> ... constraints)
|
||||
{
|
||||
getContext().checkContextMatch(constraints);
|
||||
for (BoolExpr a : constraints)
|
||||
for (Expr<BoolSort> a : constraints)
|
||||
{
|
||||
Native.optimizeAssert(getContext().nCtx(), getNativeObject(), a.getNativeObject());
|
||||
}
|
||||
|
|
@ -67,7 +68,7 @@ public class Optimize extends Z3Object {
|
|||
/**
|
||||
* Alias for Assert.
|
||||
**/
|
||||
public void Add(BoolExpr ... constraints)
|
||||
public void Add(Expr<BoolSort> ... constraints)
|
||||
{
|
||||
Assert(constraints);
|
||||
}
|
||||
|
|
@ -75,7 +76,7 @@ public class Optimize extends Z3Object {
|
|||
/**
|
||||
* Handle to objectives returned by objective functions.
|
||||
**/
|
||||
public static class Handle {
|
||||
public static class Handle<R extends Sort> {
|
||||
|
||||
private final Optimize opt;
|
||||
private final int handle;
|
||||
|
|
@ -89,7 +90,7 @@ public class Optimize extends Z3Object {
|
|||
/**
|
||||
* Retrieve a lower bound for the objective handle.
|
||||
**/
|
||||
public Expr getLower()
|
||||
public Expr<R> getLower()
|
||||
{
|
||||
return opt.GetLower(handle);
|
||||
}
|
||||
|
|
@ -97,7 +98,7 @@ public class Optimize extends Z3Object {
|
|||
/**
|
||||
* Retrieve an upper bound for the objective handle.
|
||||
**/
|
||||
public Expr getUpper()
|
||||
public Expr<R> getUpper()
|
||||
{
|
||||
return opt.GetUpper(handle);
|
||||
}
|
||||
|
|
@ -110,7 +111,7 @@ public class Optimize extends Z3Object {
|
|||
* and otherwise is represented by the expression {@code value + eps * EPSILON},
|
||||
* where {@code EPSILON} is an arbitrarily small real number.
|
||||
*/
|
||||
public Expr[] getUpperAsVector()
|
||||
public Expr<?>[] getUpperAsVector()
|
||||
{
|
||||
return opt.GetUpperAsVector(handle);
|
||||
}
|
||||
|
|
@ -120,7 +121,7 @@ public class Optimize extends Z3Object {
|
|||
*
|
||||
* <p>See {@link #getUpperAsVector()} for triple semantics.
|
||||
*/
|
||||
public Expr[] getLowerAsVector()
|
||||
public Expr<?>[] getLowerAsVector()
|
||||
{
|
||||
return opt.GetLowerAsVector(handle);
|
||||
}
|
||||
|
|
@ -128,7 +129,7 @@ public class Optimize extends Z3Object {
|
|||
/**
|
||||
* Retrieve the value of an objective.
|
||||
**/
|
||||
public Expr getValue()
|
||||
public Expr<R> getValue()
|
||||
{
|
||||
return getLower();
|
||||
}
|
||||
|
|
@ -149,11 +150,11 @@ public class Optimize extends Z3Object {
|
|||
* Return an objective which associates with the group of constraints.
|
||||
*
|
||||
**/
|
||||
public Handle AssertSoft(BoolExpr constraint, int weight, String group)
|
||||
public Handle<?> AssertSoft(Expr<BoolSort> constraint, int weight, String group)
|
||||
{
|
||||
getContext().checkContextMatch(constraint);
|
||||
Symbol s = getContext().mkSymbol(group);
|
||||
return new Handle(this, Native.optimizeAssertSoft(getContext().nCtx(), getNativeObject(), constraint.getNativeObject(), Integer.toString(weight), s.getNativeObject()));
|
||||
return new Handle<>(this, Native.optimizeAssertSoft(getContext().nCtx(), getNativeObject(), constraint.getNativeObject(), Integer.toString(weight), s.getNativeObject()));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -161,7 +162,7 @@ public class Optimize extends Z3Object {
|
|||
* Produce a model that (when the objectives are bounded and
|
||||
* don't use strict inequalities) meets the objectives.
|
||||
**/
|
||||
public Status Check(Expr... assumptions)
|
||||
public Status Check(Expr<BoolSort>... assumptions)
|
||||
{
|
||||
Z3_lbool r;
|
||||
if (assumptions == null) {
|
||||
|
|
@ -243,34 +244,34 @@ public class Optimize extends Z3Object {
|
|||
* Return a handle to the objective. The handle is used as
|
||||
* to retrieve the values of objectives after calling Check.
|
||||
**/
|
||||
public Handle MkMaximize(Expr e)
|
||||
public <R extends Sort> Handle<R> MkMaximize(Expr<R> e)
|
||||
{
|
||||
return new Handle(this, Native.optimizeMaximize(getContext().nCtx(), getNativeObject(), e.getNativeObject()));
|
||||
return new Handle<>(this, Native.optimizeMaximize(getContext().nCtx(), getNativeObject(), e.getNativeObject()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Declare an arithmetical minimization objective.
|
||||
* Similar to MkMaximize.
|
||||
**/
|
||||
public Handle MkMinimize(Expr e)
|
||||
public <R extends Sort> Handle<R> MkMinimize(Expr<R> e)
|
||||
{
|
||||
return new Handle(this, Native.optimizeMinimize(getContext().nCtx(), getNativeObject(), e.getNativeObject()));
|
||||
return new Handle<>(this, Native.optimizeMinimize(getContext().nCtx(), getNativeObject(), e.getNativeObject()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve a lower bound for the objective handle.
|
||||
**/
|
||||
private Expr GetLower(int index)
|
||||
private <R extends Sort> Expr<R> GetLower(int index)
|
||||
{
|
||||
return Expr.create(getContext(), Native.optimizeGetLower(getContext().nCtx(), getNativeObject(), index));
|
||||
return (Expr<R>) Expr.create(getContext(), Native.optimizeGetLower(getContext().nCtx(), getNativeObject(), index));
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve an upper bound for the objective handle.
|
||||
**/
|
||||
private Expr GetUpper(int index)
|
||||
private <R extends Sort> Expr<R> GetUpper(int index)
|
||||
{
|
||||
return Expr.create(getContext(), Native.optimizeGetUpper(getContext().nCtx(), getNativeObject(), index));
|
||||
return (Expr<R>) Expr.create(getContext(), Native.optimizeGetUpper(getContext().nCtx(), getNativeObject(), index));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -278,7 +279,7 @@ public class Optimize extends Z3Object {
|
|||
*
|
||||
* <p>See {@link Handle#getUpperAsVector}.
|
||||
*/
|
||||
private Expr[] GetUpperAsVector(int index) {
|
||||
private Expr<?>[] GetUpperAsVector(int index) {
|
||||
return unpackObjectiveValueVector(
|
||||
Native.optimizeGetUpperAsVector(
|
||||
getContext().nCtx(), getNativeObject(), index
|
||||
|
|
@ -291,7 +292,7 @@ public class Optimize extends Z3Object {
|
|||
*
|
||||
* <p>See {@link Handle#getLowerAsVector}.
|
||||
*/
|
||||
private Expr[] GetLowerAsVector(int index) {
|
||||
private Expr<?>[] GetLowerAsVector(int index) {
|
||||
return unpackObjectiveValueVector(
|
||||
Native.optimizeGetLowerAsVector(
|
||||
getContext().nCtx(), getNativeObject(), index
|
||||
|
|
@ -299,12 +300,12 @@ public class Optimize extends Z3Object {
|
|||
);
|
||||
}
|
||||
|
||||
private Expr[] unpackObjectiveValueVector(long nativeVec) {
|
||||
private Expr<?>[] unpackObjectiveValueVector(long nativeVec) {
|
||||
ASTVector vec = new ASTVector(
|
||||
getContext(), nativeVec
|
||||
);
|
||||
return new Expr[] {
|
||||
(Expr) vec.get(0), (Expr) vec.get(1), (Expr) vec.get(2)
|
||||
(Expr<?>) vec.get(0), (Expr<?>) vec.get(1), (Expr<?>) vec.get(2)
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -355,7 +356,7 @@ public class Optimize extends Z3Object {
|
|||
/**
|
||||
* The set of asserted formulas.
|
||||
*/
|
||||
public Expr[] getObjectives()
|
||||
public Expr<?>[] getObjectives()
|
||||
{
|
||||
ASTVector objectives = new ASTVector(getContext(), Native.optimizeGetObjectives(getContext().nCtx(), getNativeObject()));
|
||||
return objectives.ToExprArray();
|
||||
|
|
|
|||
|
|
@ -36,11 +36,11 @@ public class Pattern extends AST
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Expr[] getTerms()
|
||||
public Expr<?>[] getTerms()
|
||||
{
|
||||
|
||||
int n = getNumTerms();
|
||||
Expr[] res = new Expr[n];
|
||||
Expr<?>[] res = new Expr[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = Expr.create(getContext(),
|
||||
Native.getPattern(getContext().nCtx(), getNativeObject(), i));
|
||||
|
|
|
|||
|
|
@ -139,9 +139,9 @@ public class Quantifier extends BoolExpr
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Expr getBody()
|
||||
public BoolExpr getBody()
|
||||
{
|
||||
return Expr.create(getContext(), Native.getQuantifierBody(getContext()
|
||||
return (BoolExpr) Expr.create(getContext(), Native.getQuantifierBody(getContext()
|
||||
.nCtx(), getNativeObject()));
|
||||
}
|
||||
|
||||
|
|
@ -168,7 +168,7 @@ public class Quantifier extends BoolExpr
|
|||
*/
|
||||
public static Quantifier of(
|
||||
Context ctx, boolean isForall, Sort[] sorts, Symbol[] names,
|
||||
Expr body, int weight, Pattern[] patterns, Expr[] noPatterns,
|
||||
Expr<BoolSort> body, int weight, Pattern[] patterns, Expr<?>[] noPatterns,
|
||||
Symbol quantifierID, Symbol skolemID) {
|
||||
ctx.checkContextMatch(patterns);
|
||||
ctx.checkContextMatch(noPatterns);
|
||||
|
|
@ -212,8 +212,8 @@ public class Quantifier extends BoolExpr
|
|||
* @param quantifierID Nullable quantifier identifier.
|
||||
* @param skolemID Nullable skolem identifier.
|
||||
*/
|
||||
public static Quantifier of(Context ctx, boolean isForall, Expr[] bound, Expr body,
|
||||
int weight, Pattern[] patterns, Expr[] noPatterns,
|
||||
public static Quantifier of(Context ctx, boolean isForall, Expr<?>[] bound, Expr<BoolSort> body,
|
||||
int weight, Pattern[] patterns, Expr<?>[] noPatterns,
|
||||
Symbol quantifierID, Symbol skolemID) {
|
||||
ctx.checkContextMatch(noPatterns);
|
||||
ctx.checkContextMatch(patterns);
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Re expressions
|
||||
**/
|
||||
public class ReExpr extends Expr
|
||||
public class ReExpr<R extends Sort> extends Expr<ReSort<R>>
|
||||
{
|
||||
/**
|
||||
* Constructor for ReExpr
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* A Regular expression sort
|
||||
**/
|
||||
public class ReSort extends Sort
|
||||
public class ReSort<R extends Sort> extends Sort
|
||||
{
|
||||
ReSort(Context ctx, long obj)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Real expressions
|
||||
**/
|
||||
public class RealExpr extends ArithExpr
|
||||
public class RealExpr extends ArithExpr<RealSort>
|
||||
{
|
||||
/**
|
||||
* Constructor for RealExpr
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Seq expressions
|
||||
**/
|
||||
public class SeqExpr extends Expr
|
||||
public class SeqExpr<R extends Sort> extends Expr<SeqSort<R>>
|
||||
{
|
||||
/**
|
||||
* Constructor for SeqExpr
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* A Sequence sort
|
||||
**/
|
||||
public class SeqSort extends Sort
|
||||
public class SeqSort<R extends Sort> extends Sort
|
||||
{
|
||||
SeqSort(Context ctx, long obj)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -20,14 +20,14 @@ package com.microsoft.z3;
|
|||
/**
|
||||
* Set sorts.
|
||||
**/
|
||||
public class SetSort extends Sort
|
||||
public class SetSort<D extends Sort> extends ArraySort<D, BoolSort>
|
||||
{
|
||||
SetSort(Context ctx, long obj)
|
||||
{
|
||||
super(ctx, obj);
|
||||
}
|
||||
|
||||
SetSort(Context ctx, Sort ty)
|
||||
SetSort(Context ctx, D ty)
|
||||
{
|
||||
super(ctx, Native.mkSetSort(ctx.nCtx(), ty.getNativeObject()));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@ import java.util.*;
|
|||
/**
|
||||
* Solvers.
|
||||
**/
|
||||
@SuppressWarnings("unchecked")
|
||||
public class Solver extends Z3Object {
|
||||
/**
|
||||
* A string that describes all available solver parameters.
|
||||
|
|
@ -122,10 +123,10 @@ public class Solver extends Z3Object {
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public void add(BoolExpr... constraints)
|
||||
public void add(Expr<BoolSort>... constraints)
|
||||
{
|
||||
getContext().checkContextMatch(constraints);
|
||||
for (BoolExpr a : constraints)
|
||||
for (Expr<BoolSort> a : constraints)
|
||||
{
|
||||
Native.solverAssert(getContext().nCtx(), getNativeObject(),
|
||||
a.getNativeObject());
|
||||
|
|
@ -147,7 +148,7 @@ public class Solver extends Z3Object {
|
|||
* and the Boolean literals
|
||||
* provided using {@link #check()} with assumptions.
|
||||
**/
|
||||
public void assertAndTrack(BoolExpr[] constraints, BoolExpr[] ps)
|
||||
public void assertAndTrack(Expr<BoolSort>[] constraints, Expr<BoolSort>[] ps)
|
||||
{
|
||||
getContext().checkContextMatch(constraints);
|
||||
getContext().checkContextMatch(ps);
|
||||
|
|
@ -174,7 +175,7 @@ public class Solver extends Z3Object {
|
|||
* and the Boolean literals
|
||||
* provided using {@link #check} with assumptions.
|
||||
*/
|
||||
public void assertAndTrack(BoolExpr constraint, BoolExpr p)
|
||||
public void assertAndTrack(Expr<BoolSort> constraint, Expr<BoolSort> p)
|
||||
{
|
||||
getContext().checkContextMatch(constraint);
|
||||
getContext().checkContextMatch(p);
|
||||
|
|
@ -229,7 +230,8 @@ public class Solver extends Z3Object {
|
|||
* @see #getUnsatCore
|
||||
* @see #getProof
|
||||
**/
|
||||
public Status check(Expr... assumptions)
|
||||
@SafeVarargs
|
||||
public final Status check(Expr<BoolSort>... assumptions)
|
||||
{
|
||||
Z3_lbool r;
|
||||
if (assumptions == null) {
|
||||
|
|
@ -250,6 +252,7 @@ public class Solver extends Z3Object {
|
|||
* @see #getUnsatCore
|
||||
* @see #getProof
|
||||
**/
|
||||
@SuppressWarnings("rawtypes")
|
||||
public Status check()
|
||||
{
|
||||
return check((Expr[]) null);
|
||||
|
|
@ -266,13 +269,13 @@ public class Solver extends Z3Object {
|
|||
* is fixed.
|
||||
*
|
||||
*/
|
||||
public Status getConsequences(BoolExpr[] assumptions, Expr[] variables, List<BoolExpr> consequences)
|
||||
public Status getConsequences(Expr<BoolSort>[] assumptions, Expr<?>[] variables, List<Expr<BoolSort>> consequences)
|
||||
{
|
||||
ASTVector result = new ASTVector(getContext());
|
||||
ASTVector asms = new ASTVector(getContext());
|
||||
ASTVector vars = new ASTVector(getContext());
|
||||
for (BoolExpr asm : assumptions) asms.push(asm);
|
||||
for (Expr v : variables) vars.push(v);
|
||||
for (Expr<BoolSort> asm : assumptions) asms.push(asm);
|
||||
for (Expr<?> v : variables) vars.push(v);
|
||||
int r = Native.solverGetConsequences(getContext().nCtx(), getNativeObject(), asms.getNativeObject(), vars.getNativeObject(), result.getNativeObject());
|
||||
for (int i = 0; i < result.size(); ++i) consequences.add((BoolExpr) Expr.create(getContext(), result.get(i).getNativeObject()));
|
||||
return lboolToStatus(Z3_lbool.fromInt(r));
|
||||
|
|
@ -307,7 +310,7 @@ public class Solver extends Z3Object {
|
|||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public Expr getProof()
|
||||
public Expr<?> getProof()
|
||||
{
|
||||
long x = Native.solverGetProof(getContext().nCtx(), getNativeObject());
|
||||
if (x == 0) {
|
||||
|
|
|
|||
|
|
@ -119,13 +119,13 @@ public class Sort extends AST
|
|||
switch (sk)
|
||||
{
|
||||
case Z3_ARRAY_SORT:
|
||||
return new ArraySort(ctx, obj);
|
||||
return new ArraySort<>(ctx, obj);
|
||||
case Z3_BOOL_SORT:
|
||||
return new BoolSort(ctx, obj);
|
||||
case Z3_BV_SORT:
|
||||
return new BitVecSort(ctx, obj);
|
||||
case Z3_DATATYPE_SORT:
|
||||
return new DatatypeSort(ctx, obj);
|
||||
return new DatatypeSort<>(ctx, obj);
|
||||
case Z3_INT_SORT:
|
||||
return new IntSort(ctx, obj);
|
||||
case Z3_REAL_SORT:
|
||||
|
|
@ -141,9 +141,9 @@ public class Sort extends AST
|
|||
case Z3_ROUNDING_MODE_SORT:
|
||||
return new FPRMSort(ctx, obj);
|
||||
case Z3_SEQ_SORT:
|
||||
return new SeqSort(ctx, obj);
|
||||
return new SeqSort<>(ctx, obj);
|
||||
case Z3_RE_SORT:
|
||||
return new ReSort(ctx, obj);
|
||||
return new ReSort<>(ctx, obj);
|
||||
default:
|
||||
throw new Z3Exception("Unknown sort kind");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,10 +26,10 @@ public class TupleSort extends Sort
|
|||
* The constructor function of the tuple.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public FuncDecl mkDecl()
|
||||
public FuncDecl<TupleSort> mkDecl()
|
||||
{
|
||||
|
||||
return new FuncDecl(getContext(), Native.getTupleSortMkDecl(getContext()
|
||||
return new FuncDecl<>(getContext(), Native.getTupleSortMkDecl(getContext()
|
||||
.nCtx(), getNativeObject()));
|
||||
}
|
||||
|
||||
|
|
@ -45,13 +45,13 @@ public class TupleSort extends Sort
|
|||
* The field declarations.
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
public FuncDecl[] getFieldDecls()
|
||||
public FuncDecl<?>[] getFieldDecls()
|
||||
{
|
||||
|
||||
int n = getNumFields();
|
||||
FuncDecl[] res = new FuncDecl[n];
|
||||
FuncDecl<?>[] res = new FuncDecl[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = new FuncDecl(getContext(), Native.getTupleSortFieldDecl(
|
||||
res[i] = new FuncDecl<>(getContext(), Native.getTupleSortFieldDecl(
|
||||
getContext().nCtx(), getNativeObject(), i));
|
||||
return res;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue