fix APIs, add python API

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>

src/api/python/z3.py

@@ -297,6 +297,10 @@ class AstRef(Z3PPObject):
         """Return a pointer to the corresponding C Z3_ast object."""
         return self.ast
 
+    def get_id(self):
+	"""Return unique identifier for object. It can be used for hash-tables and maps."""
+	return Z3_get_ast_id(self.ctx_ref(), self.as_ast())
+
     def ctx_ref(self):
         """Return a reference to the C context where this AST node is stored."""
         return self.ctx.ref()
@@ -447,6 +451,9 @@ class SortRef(AstRef):
     def as_ast(self):
         return Z3_sort_to_ast(self.ctx_ref(), self.ast)
 
+    def get_id(self):
+	return Z3_get_ast_id(self.ctx_ref(), self.as_ast())
+
     def kind(self):
         """Return the Z3 internal kind of a sort. This method can be used to test if `self` is one of the Z3 builtin sorts.
         
@@ -585,6 +592,9 @@ class FuncDeclRef(AstRef):
     def as_ast(self):
         return Z3_func_decl_to_ast(self.ctx_ref(), self.ast)
 
+    def get_id(self):
+	return Z3_get_ast_id(self.ctx_ref(), self.as_ast())
+
     def as_func_decl(self):
         return self.ast
 
@@ -730,6 +740,9 @@ class ExprRef(AstRef):
     def as_ast(self):
         return self.ast
 
+    def get_id(self):
+	return Z3_get_ast_id(self.ctx_ref(), self.as_ast())
+
     def sort(self):
         """Return the sort of expression `self`.
         
@@ -1505,6 +1518,9 @@ class PatternRef(ExprRef):
     def as_ast(self):
         return Z3_pattern_to_ast(self.ctx_ref(), self.ast)
 
+    def get_id(self):
+	return Z3_get_ast_id(self.ctx_ref(), self.as_ast())
+
 def is_pattern(a):
     """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
 
@@ -1567,6 +1583,9 @@ class QuantifierRef(BoolRef):
     def as_ast(self):
         return self.ast
 
+    def get_id(self):
+	return Z3_get_ast_id(self.ctx_ref(), self.as_ast())
+
     def sort(self):
         """Return the Boolean sort."""
         return BoolSort(self.ctx)
@@ -6251,6 +6270,107 @@ class Fixedpoint(Z3PPObject):
         else:
             return Exists(self.vars, fml)
 
+
+#########################################
+#
+# Optimize
+#
+#########################################
+
+class OptimizeObjective:
+    def __init__(self, value):
+	self.value = value	
+
+class Optimize(Z3PPObject):
+    """Optimize API provides methods for solving using objective functions and weighted soft constraints"""
+     
+    def __init__(self, ctx=None):
+        self.ctx    = _get_ctx(ctx)
+	self.optimize = Z3_mk_optimize(self.ctx.ref())
+        Z3_optimize_inc_ref(self.ctx.ref(), self.optimize)
+
+    def __del__(self):
+        if self.optimize != None:
+            Z3_optimize_dec_ref(self.ctx.ref(), self.optimize)
+
+    def set(self, *args, **keys):
+        """Set a configuration option. The method `help()` return a string containing all available options.        
+        """
+        p = args2params(args, keys, self.ctx)
+        Z3_optimize_set_params(self.ctx.ref(), self.optimize, p.params)
+
+    def help(self):
+        """Display a string describing all available options."""
+        print(Z3_optimize_get_help(self.ctx.ref(), self.optimize))
+            
+    def param_descrs(self):
+        """Return the parameter description set."""
+        return ParamDescrsRef(Z3_optimize_get_param_descrs(self.ctx.ref(), self.optimize), self.ctx)
+    
+    def assert_exprs(self, *args):
+        """Assert constraints as background axioms for the optimize solver."""
+        args = _get_args(args)
+        for arg in args:
+            if isinstance(arg, Goal) or isinstance(arg, AstVector):
+                for f in arg:
+                    Z3_optimize_assert(self.ctx.ref(), self.optimize, f.as_ast())
+            else:
+                Z3_optimize_assert(self.ctx.ref(), self.optimize, arg.as_ast())
+
+    def add(self, *args):
+        """Assert constraints as background axioms for the optimize solver. Alias for assert_expr."""
+        self.assert_exprs(*args)
+
+    def add_soft(self, arg, weight = None):
+	"""Add soft constraint with optional weight."""
+	pass
+
+    def maximize(self, arg):
+	"""Add objective function to maximize."""
+	return OptimizeObjective(Z3_optimize_maximize(self.ctx.ref(), self.optimize, arg.as_ast()))
+
+    def minimize(self, arg):
+	"""Add objective function to minimize."""
+	return OptimizeObjective(Z3_optimize_minimize(self.ctx.ref(), self.optimize, arg.as_ast()))
+
+    def check(self):
+	"""Check satisfiability while optimizing objective functions."""
+	return CheckSatResult(Z3_optimize_check(self.ctx.ref(), self.optimize))
+
+    def model(self):
+	"""Return a model for the last check()."""
+	try:
+	    return ModelRef(Z3_optimize_get_model(self.ctx.ref(), self.optimize), self.ctx)
+	except Z3Exception:
+	    raise Z3Exception("model is not available")
+
+    def lower(self, obj):
+	if not isinstance(obj, OptimizeObjective):
+	    raise Z3Exception("Expecting objective handle returned by maximize/minimize")
+	return _to_expr_ref(Z3_optimize_get_lower(self.ctx.ref(), self.optimize, obj.value), self.ctx)
+
+    def upper(self, obj):
+	if not isinstance(obj, OptimizeObjective):
+	    raise Z3Exception("Expecting objective handle returned by maximize/minimize")
+	return _to_expr_ref(Z3_optimize_get_upper(self.ctx.ref(), self.optimize, obj.value), self.ctx)    
+    
+    def __repr__(self):
+        """Return a formatted string with all added rules and constraints."""
+        return self.sexpr()
+
+    def sexpr(self):
+        """Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.        
+        """
+        return Z3_optimize_to_string(self.ctx.ref(), self.optimize)
+    
+    def statistics(self):
+        """Return statistics for the last `query()`.
+        """
+        return Statistics(Z3_optimize_get_statistics(self.ctx.ref(), self.optimize), self.ctx)
+
+
+        
+
 #########################################
 #
 # ApplyResult

src/api/python/z3types.py

@@ -78,6 +78,10 @@ class FixedpointObj(ctypes.c_void_p):
   def __init__(self, fixedpoint): self._as_parameter_ = fixedpoint
   def from_param(obj): return obj
 
+class OptimizeObj(ctypes.c_void_p):
+  def __init__(self, optimize): self._as_parameter_ = optimize
+  def from_param(obj): return obj
+
 class ModelObj(ctypes.c_void_p):
   def __init__(self, model): self._as_parameter_ = model
   def from_param(obj): return obj