z3 0.0.20180624 → 0.0.20211213

data/lib/z3/ast.rb

@@ -46,6 +46,14 @@ module Z3
       sort.new(LowLevel.simplify(self))
     end
 
+    def eql?(other)
+      self.class == other.class and self._ast == other._ast
+    end
+
+    def hash
+      _ast.address
+    end
+
     private_class_method :new
   end
 end

data/lib/z3/expr/bitvec_expr.rb

@@ -64,6 +64,16 @@ module Z3
       sort.new(LowLevel.mk_rotate_right(num, self))
     end
 
+    def extract(hi, lo)
+      raise Z3::Exception, "Trying to extract bits out of range" unless sort.size > hi and hi >= lo and lo >= 0
+      BitvecSort.new(hi - lo + 1).new(LowLevel.mk_extract(hi, lo, self))
+    end
+
+    def concat(other)
+      raise Z3::Exception, "Can only concatenate another Bitvec" unless other.is_a?(BitvecExpr)
+      BitvecSort.new(sort.size + other.sort.size).new(LowLevel.mk_concat(self, other))
+    end
+
     def zero_ext(size)
       BitvecSort.new(sort.size + size).new(LowLevel.mk_zero_ext(size, self))
     end

data/lib/z3/expr/expr.rb

@@ -1,10 +1,11 @@
 module Z3
   class Expr < AST
     attr_reader :sort
+
     def initialize(_ast, sort)
       super(_ast)
       @sort = sort
-      raise Z3::Exception, "Values must have AST kind numeral or app" unless [:numeral, :app].include?(ast_kind)
+      raise Z3::Exception, "Values must have AST kind numeral, app, or quantifier" unless [:numeral, :app, :quantifier].include?(ast_kind)
     end
 
     def inspect
@@ -22,7 +23,7 @@ module Z3
     class << self
       def coerce_to_same_sort(*args)
         # This will raise exception unless one of the sorts is highest
-        max_sort = args.map{|a| a.is_a?(Expr) ? a.sort : Expr.sort_for_const(a)}.max
+        max_sort = args.map { |a| a.is_a?(Expr) ? a.sort : Expr.sort_for_const(a) }.max
         args.map do |a|
           max_sort.cast(a)
         end
@@ -110,11 +111,11 @@ module Z3
         when BoolExpr
           BoolSort.new.new(Z3::LowLevel.mk_and(args))
         when BitvecExpr
-          args.inject do |a,b|
+          args.inject do |a, b|
             a.sort.new(Z3::LowLevel.mk_bvand(a, b))
           end
         else
-          raise Z3::Exception, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
+          raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} exprs, only Bool and Bitvec"
         end
       end
 
@@ -124,11 +125,11 @@ module Z3
         when BoolExpr
           BoolSort.new.new(Z3::LowLevel.mk_or(args))
         when BitvecExpr
-          args.inject do |a,b|
+          args.inject do |a, b|
             a.sort.new(Z3::LowLevel.mk_bvor(a, b))
           end
         else
-          raise Z3::Exception, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
+          raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} exprs, only Bool and Bitvec"
         end
       end
 
@@ -136,15 +137,15 @@ module Z3
         args = coerce_to_same_sort(*args)
         case args[0]
         when BoolExpr
-          args.inject do |a,b|
+          args.inject do |a, b|
             BoolSort.new.new(Z3::LowLevel.mk_xor(a, b))
           end
         when BitvecExpr
-          args.inject do |a,b|
+          args.inject do |a, b|
             a.sort.new(Z3::LowLevel.mk_bvxor(a, b))
           end
         else
-          raise Z3::Exception, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
+          raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} exprs, only Bool and Bitvec"
         end
       end
 
@@ -155,8 +156,8 @@ module Z3
         when ArithExpr
           args[0].sort.new(LowLevel.mk_add(args))
         when BitvecExpr
-          args.inject do |a,b|
-            a.sort.new(LowLevel.mk_bvadd(a,b))
+          args.inject do |a, b|
+            a.sort.new(LowLevel.mk_bvadd(a, b))
           end
         else
           raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} exprs, only Int/Real/Bitvec"
@@ -169,8 +170,8 @@ module Z3
         when ArithExpr
           args[0].sort.new(LowLevel.mk_sub(args))
         when BitvecExpr
-          args.inject do |a,b|
-            a.sort.new(LowLevel.mk_bvsub(a,b))
+          args.inject do |a, b|
+            a.sort.new(LowLevel.mk_bvsub(a, b))
           end
         else
           raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} values, only Int/Real/Bitvec"
@@ -183,8 +184,8 @@ module Z3
         when ArithExpr
           args[0].sort.new(LowLevel.mk_mul(args))
         when BitvecExpr
-          args.inject do |a,b|
-            a.sort.new(LowLevel.mk_bvmul(a,b))
+          args.inject do |a, b|
+            a.sort.new(LowLevel.mk_bvmul(a, b))
           end
         else
           raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} values, only Int/Real/Bitvec"

data/lib/z3/low_level.rb

@@ -9,7 +9,7 @@ module Z3
         b = FFI::MemoryPointer.new(:int)
         c = FFI::MemoryPointer.new(:int)
         d = FFI::MemoryPointer.new(:int)
-        Z3::VeryLowLevel.Z3_get_version(a,b,c,d)
+        Z3::VeryLowLevel.Z3_get_version(a, b, c, d)
         [a.get_uint(0), b.get_uint(0), c.get_uint(0), d.get_uint(0)]
       end
 
@@ -63,6 +63,10 @@ module Z3
         Z3::VeryLowLevel.Z3_mk_set_intersect(_ctx_pointer, asts.size, asts_vector(asts))
       end
 
+      def optimize_check(optimize, asts)
+        Z3::VeryLowLevel.Z3_optimize_check(_ctx_pointer, optimize._optimize, asts.size, asts_vector(asts))
+      end
+
       # Should be private
 
       def unpack_ast_vector(_ast_vector)
@@ -96,7 +100,7 @@ module Z3
       private
 
       def asts_vector(args)
-        raise if args.empty?
+        # raise if args.empty?
         c_args = FFI::MemoryPointer.new(:pointer, args.size)
         c_args.write_array_of_pointer args.map(&:_ast)
         c_args

data/lib/z3/low_level_auto.rb

@@ -25,6 +25,14 @@ module Z3
         VeryLowLevel.Z3_algebraic_ge(_ctx_pointer, ast1._ast, ast2._ast)
       end
 
+      def algebraic_get_i(ast) #=> :uint
+        VeryLowLevel.Z3_algebraic_get_i(_ctx_pointer, ast._ast)
+      end
+
+      def algebraic_get_poly(ast) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_algebraic_get_poly(_ctx_pointer, ast._ast)
+      end
+
       def algebraic_gt(ast1, ast2) #=> :bool
         VeryLowLevel.Z3_algebraic_gt(_ctx_pointer, ast1._ast, ast2._ast)
       end
@@ -77,10 +85,6 @@ module Z3
         VeryLowLevel.Z3_algebraic_sub(_ctx_pointer, ast1._ast, ast2._ast)
       end
 
-      def apply_result_convert_model(apply_result, num, model) #=> :model_pointer
-        VeryLowLevel.Z3_apply_result_convert_model(_ctx_pointer, apply_result._apply_result, num, model._model)
-      end
-
       def apply_result_dec_ref(apply_result) #=> :void
         VeryLowLevel.Z3_apply_result_dec_ref(_ctx_pointer, apply_result._apply_result)
       end
@@ -213,6 +217,10 @@ module Z3
         VeryLowLevel.Z3_enable_trace(str)
       end
 
+      def eval_smtlib2_string(str) #=> :string
+        VeryLowLevel.Z3_eval_smtlib2_string(_ctx_pointer, str)
+      end
+
       def finalize_memory #=> :void
         VeryLowLevel.Z3_finalize_memory()
       end
@@ -301,14 +309,6 @@ module Z3
         VeryLowLevel.Z3_fixedpoint_inc_ref(_ctx_pointer, fixedpoint._fixedpoint)
       end
 
-      def fixedpoint_pop(fixedpoint) #=> :void
-        VeryLowLevel.Z3_fixedpoint_pop(_ctx_pointer, fixedpoint._fixedpoint)
-      end
-
-      def fixedpoint_push(fixedpoint) #=> :void
-        VeryLowLevel.Z3_fixedpoint_push(_ctx_pointer, fixedpoint._fixedpoint)
-      end
-
       def fixedpoint_query(fixedpoint, ast) #=> :int
         VeryLowLevel.Z3_fixedpoint_query(_ctx_pointer, fixedpoint._fixedpoint, ast._ast)
       end
@@ -581,10 +581,6 @@ module Z3
         VeryLowLevel.Z3_get_index_value(_ctx_pointer, ast._ast)
       end
 
-      def get_interpolant(ast1, ast2, params) #=> :ast_vector_pointer
-        VeryLowLevel.Z3_get_interpolant(_ctx_pointer, ast1._ast, ast2._ast, params._params)
-      end
-
       def get_num_probes #=> :uint
         VeryLowLevel.Z3_get_num_probes(_ctx_pointer)
       end
@@ -593,10 +589,18 @@ module Z3
         VeryLowLevel.Z3_get_num_tactics(_ctx_pointer)
       end
 
+      def get_numeral_binary_string(ast) #=> :string
+        VeryLowLevel.Z3_get_numeral_binary_string(_ctx_pointer, ast._ast)
+      end
+
       def get_numeral_decimal_string(ast, num) #=> :string
         VeryLowLevel.Z3_get_numeral_decimal_string(_ctx_pointer, ast._ast, num)
       end
 
+      def get_numeral_double(ast) #=> :double
+        VeryLowLevel.Z3_get_numeral_double(_ctx_pointer, ast._ast)
+      end
+
       def get_numeral_string(ast) #=> :string
         VeryLowLevel.Z3_get_numeral_string(_ctx_pointer, ast._ast)
       end
@@ -605,10 +609,6 @@ module Z3
         VeryLowLevel.Z3_get_numerator(_ctx_pointer, ast._ast)
       end
 
-      def get_parser_error #=> :string
-        VeryLowLevel.Z3_get_parser_error(_ctx_pointer)
-      end
-
       def get_pattern(pattern, num) #=> :ast_pointer
         VeryLowLevel.Z3_get_pattern(_ctx_pointer, pattern._ast, num)
       end
@@ -661,6 +661,10 @@ module Z3
         VeryLowLevel.Z3_get_range(_ctx_pointer, func_decl._ast)
       end
 
+      def get_re_sort_basis(sort) #=> :sort_pointer
+        VeryLowLevel.Z3_get_re_sort_basis(_ctx_pointer, sort._ast)
+      end
+
       def get_relation_arity(sort) #=> :uint
         VeryLowLevel.Z3_get_relation_arity(_ctx_pointer, sort._ast)
       end
@@ -669,6 +673,10 @@ module Z3
         VeryLowLevel.Z3_get_relation_column(_ctx_pointer, sort._ast, num)
       end
 
+      def get_seq_sort_basis(sort) #=> :sort_pointer
+        VeryLowLevel.Z3_get_seq_sort_basis(_ctx_pointer, sort._ast)
+      end
+
       def get_sort(ast) #=> :sort_pointer
         VeryLowLevel.Z3_get_sort(_ctx_pointer, ast._ast)
       end
@@ -685,6 +693,10 @@ module Z3
         VeryLowLevel.Z3_get_sort_name(_ctx_pointer, sort._ast)
       end
 
+      def get_string_length(ast) #=> :uint
+        VeryLowLevel.Z3_get_string_length(_ctx_pointer, ast._ast)
+      end
+
       def get_symbol_int(sym) #=> :int
         VeryLowLevel.Z3_get_symbol_int(_ctx_pointer, sym)
       end
@@ -725,6 +737,10 @@ module Z3
         VeryLowLevel.Z3_goal_assert(_ctx_pointer, goal._goal, ast._ast)
       end
 
+      def goal_convert_model(goal, model) #=> :model_pointer
+        VeryLowLevel.Z3_goal_convert_model(_ctx_pointer, goal._goal, model._model)
+      end
+
       def goal_dec_ref(goal) #=> :void
         VeryLowLevel.Z3_goal_dec_ref(_ctx_pointer, goal._goal)
       end
@@ -769,6 +785,10 @@ module Z3
         VeryLowLevel.Z3_goal_size(_ctx_pointer, goal._goal)
       end
 
+      def goal_to_dimacs_string(goal, bool) #=> :string
+        VeryLowLevel.Z3_goal_to_dimacs_string(_ctx_pointer, goal._goal, bool)
+      end
+
       def goal_to_string(goal) #=> :string
         VeryLowLevel.Z3_goal_to_string(_ctx_pointer, goal._goal)
       end
@@ -781,10 +801,6 @@ module Z3
         VeryLowLevel.Z3_inc_ref(_ctx_pointer, ast._ast)
       end
 
-      def interpolation_profile #=> :string
-        VeryLowLevel.Z3_interpolation_profile(_ctx_pointer)
-      end
-
       def interrupt #=> :void
         VeryLowLevel.Z3_interrupt(_ctx_pointer)
       end
@@ -801,6 +817,10 @@ module Z3
         VeryLowLevel.Z3_is_as_array(_ctx_pointer, ast._ast)
       end
 
+      def is_char_sort(sort) #=> :bool
+        VeryLowLevel.Z3_is_char_sort(_ctx_pointer, sort._ast)
+      end
+
       def is_eq_ast(ast1, ast2) #=> :bool
         VeryLowLevel.Z3_is_eq_ast(_ctx_pointer, ast1._ast, ast2._ast)
       end
@@ -813,10 +833,18 @@ module Z3
         VeryLowLevel.Z3_is_eq_sort(_ctx_pointer, sort1._ast, sort2._ast)
       end
 
+      def is_lambda(ast) #=> :bool
+        VeryLowLevel.Z3_is_lambda(_ctx_pointer, ast._ast)
+      end
+
       def is_numeral_ast(ast) #=> :bool
         VeryLowLevel.Z3_is_numeral_ast(_ctx_pointer, ast._ast)
       end
 
+      def is_quantifier_exists(ast) #=> :bool
+        VeryLowLevel.Z3_is_quantifier_exists(_ctx_pointer, ast._ast)
+      end
+
       def is_quantifier_forall(ast) #=> :bool
         VeryLowLevel.Z3_is_quantifier_forall(_ctx_pointer, ast._ast)
       end
@@ -1009,6 +1037,30 @@ module Z3
         VeryLowLevel.Z3_mk_bvxor(_ctx_pointer, ast1._ast, ast2._ast)
       end
 
+      def mk_char_from_bv(ast) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_char_from_bv(_ctx_pointer, ast._ast)
+      end
+
+      def mk_char_is_digit(ast) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_char_is_digit(_ctx_pointer, ast._ast)
+      end
+
+      def mk_char_le(ast1, ast2) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_char_le(_ctx_pointer, ast1._ast, ast2._ast)
+      end
+
+      def mk_char_sort #=> :sort_pointer
+        VeryLowLevel.Z3_mk_char_sort(_ctx_pointer)
+      end
+
+      def mk_char_to_bv(ast) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_char_to_bv(_ctx_pointer, ast._ast)
+      end
+
+      def mk_char_to_int(ast) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_char_to_int(_ctx_pointer, ast._ast)
+      end
+
       def mk_concat(ast1, ast2) #=> :ast_pointer
         VeryLowLevel.Z3_mk_concat(_ctx_pointer, ast1._ast, ast2._ast)
       end
@@ -1033,6 +1085,10 @@ module Z3
         VeryLowLevel.Z3_mk_div(_ctx_pointer, ast1._ast, ast2._ast)
       end
 
+      def mk_divides(ast1, ast2) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_divides(_ctx_pointer, ast1._ast, ast2._ast)
+      end
+
       def mk_empty_set(sort) #=> :ast_pointer
         VeryLowLevel.Z3_mk_empty_set(_ctx_pointer, sort._ast)
       end
@@ -1349,14 +1405,6 @@ module Z3
         VeryLowLevel.Z3_mk_int_to_str(_ctx_pointer, ast._ast)
       end
 
-      def mk_interpolant(ast) #=> :ast_pointer
-        VeryLowLevel.Z3_mk_interpolant(_ctx_pointer, ast._ast)
-      end
-
-      def mk_interpolation_context(config) #=> :ctx_pointer
-        VeryLowLevel.Z3_mk_interpolation_context(config._config)
-      end
-
       def mk_is_int(ast) #=> :ast_pointer
         VeryLowLevel.Z3_mk_is_int(_ctx_pointer, ast._ast)
       end
@@ -1369,6 +1417,14 @@ module Z3
         VeryLowLevel.Z3_mk_le(_ctx_pointer, ast1._ast, ast2._ast)
       end
 
+      def mk_linear_order(sort, num) #=> :func_decl_pointer
+        VeryLowLevel.Z3_mk_linear_order(_ctx_pointer, sort._ast, num)
+      end
+
+      def mk_lstring(num, str) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_lstring(_ctx_pointer, num, str)
+      end
+
       def mk_lt(ast1, ast2) #=> :ast_pointer
         VeryLowLevel.Z3_mk_lt(_ctx_pointer, ast1._ast, ast2._ast)
       end
@@ -1397,6 +1453,14 @@ module Z3
         VeryLowLevel.Z3_mk_params(_ctx_pointer)
       end
 
+      def mk_partial_order(sort, num) #=> :func_decl_pointer
+        VeryLowLevel.Z3_mk_partial_order(_ctx_pointer, sort._ast, num)
+      end
+
+      def mk_piecewise_linear_order(sort, num) #=> :func_decl_pointer
+        VeryLowLevel.Z3_mk_piecewise_linear_order(_ctx_pointer, sort._ast, num)
+      end
+
       def mk_power(ast1, ast2) #=> :ast_pointer
         VeryLowLevel.Z3_mk_power(_ctx_pointer, ast1._ast, ast2._ast)
       end
@@ -1405,6 +1469,10 @@ module Z3
         VeryLowLevel.Z3_mk_probe(_ctx_pointer, str)
       end
 
+      def mk_re_allchar(sort) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_re_allchar(_ctx_pointer, sort._ast)
+      end
+
       def mk_re_complement(ast) #=> :ast_pointer
         VeryLowLevel.Z3_mk_re_complement(_ctx_pointer, ast._ast)
       end
@@ -1453,10 +1521,22 @@ module Z3
         VeryLowLevel.Z3_mk_rotate_right(_ctx_pointer, num, ast._ast)
       end
 
+      def mk_sbv_to_str(ast) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_sbv_to_str(_ctx_pointer, ast._ast)
+      end
+
       def mk_select(ast1, ast2) #=> :ast_pointer
         VeryLowLevel.Z3_mk_select(_ctx_pointer, ast1._ast, ast2._ast)
       end
 
+      def mk_seq_last_index(ast1, ast2) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_seq_last_index(_ctx_pointer, ast1._ast, ast2._ast)
+      end
+
+      def mk_seq_nth(ast1, ast2) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_seq_nth(_ctx_pointer, ast1._ast, ast2._ast)
+      end
+
       def mk_set_add(ast1, ast2) #=> :ast_pointer
         VeryLowLevel.Z3_mk_set_add(_ctx_pointer, ast1._ast, ast2._ast)
       end
@@ -1473,6 +1553,10 @@ module Z3
         VeryLowLevel.Z3_mk_set_difference(_ctx_pointer, ast1._ast, ast2._ast)
       end
 
+      def mk_set_has_size(ast1, ast2) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_set_has_size(_ctx_pointer, ast1._ast, ast2._ast)
+      end
+
       def mk_set_member(ast1, ast2) #=> :ast_pointer
         VeryLowLevel.Z3_mk_set_member(_ctx_pointer, ast1._ast, ast2._ast)
       end
@@ -1509,6 +1593,14 @@ module Z3
         VeryLowLevel.Z3_mk_store(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
       end
 
+      def mk_str_le(ast1, ast2) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_str_le(_ctx_pointer, ast1._ast, ast2._ast)
+      end
+
+      def mk_str_lt(ast1, ast2) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_str_lt(_ctx_pointer, ast1._ast, ast2._ast)
+      end
+
       def mk_str_to_int(ast) #=> :ast_pointer
         VeryLowLevel.Z3_mk_str_to_int(_ctx_pointer, ast._ast)
       end
@@ -1521,10 +1613,22 @@ module Z3
         VeryLowLevel.Z3_mk_tactic(_ctx_pointer, str)
       end
 
+      def mk_transitive_closure(func_decl) #=> :func_decl_pointer
+        VeryLowLevel.Z3_mk_transitive_closure(_ctx_pointer, func_decl._ast)
+      end
+
+      def mk_tree_order(sort, num) #=> :func_decl_pointer
+        VeryLowLevel.Z3_mk_tree_order(_ctx_pointer, sort._ast, num)
+      end
+
       def mk_true #=> :ast_pointer
         VeryLowLevel.Z3_mk_true(_ctx_pointer)
       end
 
+      def mk_ubv_to_str(ast) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_ubv_to_str(_ctx_pointer, ast._ast)
+      end
+
       def mk_unary_minus(ast) #=> :ast_pointer
         VeryLowLevel.Z3_mk_unary_minus(_ctx_pointer, ast._ast)
       end
@@ -1605,16 +1709,20 @@ module Z3
         VeryLowLevel.Z3_model_to_string(_ctx_pointer, model._model)
       end
 
+      def model_translate(model, context) #=> :model_pointer
+        VeryLowLevel.Z3_model_translate(_ctx_pointer, model._model, context._context)
+      end
+
       def optimize_assert(optimize, ast) #=> :void
         VeryLowLevel.Z3_optimize_assert(_ctx_pointer, optimize._optimize, ast._ast)
       end
 
-      def optimize_assert_soft(optimize, ast, str, sym) #=> :uint
-        VeryLowLevel.Z3_optimize_assert_soft(_ctx_pointer, optimize._optimize, ast._ast, str, sym)
+      def optimize_assert_and_track(optimize, ast1, ast2) #=> :void
+        VeryLowLevel.Z3_optimize_assert_and_track(_ctx_pointer, optimize._optimize, ast1._ast, ast2._ast)
       end
 
-      def optimize_check(optimize) #=> :int
-        VeryLowLevel.Z3_optimize_check(_ctx_pointer, optimize._optimize)
+      def optimize_assert_soft(optimize, ast, str, sym) #=> :uint
+        VeryLowLevel.Z3_optimize_assert_soft(_ctx_pointer, optimize._optimize, ast._ast, str, sym)
       end
 
       def optimize_dec_ref(optimize) #=> :void
@@ -1665,6 +1773,10 @@ module Z3
         VeryLowLevel.Z3_optimize_get_statistics(_ctx_pointer, optimize._optimize)
       end
 
+      def optimize_get_unsat_core(optimize) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_optimize_get_unsat_core(_ctx_pointer, optimize._optimize)
+      end
+
       def optimize_get_upper(optimize, num) #=> :ast_pointer
         VeryLowLevel.Z3_optimize_get_upper(_ctx_pointer, optimize._optimize, num)
       end
@@ -1941,6 +2053,10 @@ module Z3
         VeryLowLevel.Z3_solver_check(_ctx_pointer, solver._solver)
       end
 
+      def solver_cube(solver, ast_vector, num) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_solver_cube(_ctx_pointer, solver._solver, ast_vector, num)
+      end
+
       def solver_dec_ref(solver) #=> :void
         VeryLowLevel.Z3_solver_dec_ref(_ctx_pointer, solver._solver)
       end
@@ -1969,6 +2085,10 @@ module Z3
         VeryLowLevel.Z3_solver_get_model(_ctx_pointer, solver._solver)
       end
 
+      def solver_get_non_units(solver) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_solver_get_non_units(_ctx_pointer, solver._solver)
+      end
+
       def solver_get_num_scopes(solver) #=> :uint
         VeryLowLevel.Z3_solver_get_num_scopes(_ctx_pointer, solver._solver)
       end
@@ -1989,18 +2109,38 @@ module Z3
         VeryLowLevel.Z3_solver_get_statistics(_ctx_pointer, solver._solver)
       end
 
+      def solver_get_trail(solver) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_solver_get_trail(_ctx_pointer, solver._solver)
+      end
+
+      def solver_get_units(solver) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_solver_get_units(_ctx_pointer, solver._solver)
+      end
+
       def solver_get_unsat_core(solver) #=> :ast_vector_pointer
         VeryLowLevel.Z3_solver_get_unsat_core(_ctx_pointer, solver._solver)
       end
 
+      def solver_import_model_converter(solver1, solver2) #=> :void
+        VeryLowLevel.Z3_solver_import_model_converter(_ctx_pointer, solver1._solver, solver2._solver)
+      end
+
       def solver_inc_ref(solver) #=> :void
         VeryLowLevel.Z3_solver_inc_ref(_ctx_pointer, solver._solver)
       end
 
+      def solver_interrupt(solver) #=> :void
+        VeryLowLevel.Z3_solver_interrupt(_ctx_pointer, solver._solver)
+      end
+
       def solver_pop(solver, num) #=> :void
         VeryLowLevel.Z3_solver_pop(_ctx_pointer, solver._solver, num)
       end
 
+      def solver_propagate_register(solver, ast) #=> :uint
+        VeryLowLevel.Z3_solver_propagate_register(_ctx_pointer, solver._solver, ast._ast)
+      end
+
       def solver_push(solver) #=> :void
         VeryLowLevel.Z3_solver_push(_ctx_pointer, solver._solver)
       end
@@ -2013,6 +2153,10 @@ module Z3
         VeryLowLevel.Z3_solver_set_params(_ctx_pointer, solver._solver, params._params)
       end
 
+      def solver_to_dimacs_string(solver, bool) #=> :string
+        VeryLowLevel.Z3_solver_to_dimacs_string(_ctx_pointer, solver._solver, bool)
+      end
+
       def solver_to_string(solver) #=> :string
         VeryLowLevel.Z3_solver_to_string(_ctx_pointer, solver._solver)
       end

data/lib/z3/optimize.rb

@@ -1,7 +1,9 @@
 module Z3
   class Optimize
     attr_reader :_optimize
+
     def initialize
+      raise Z3::Exception, "This is known to crash in Z3 4.8.13"
       @_optimize = LowLevel.mk_optimize
       LowLevel.optimize_inc_ref(self)
       reset_model!
@@ -27,9 +29,9 @@ module Z3
       LowLevel.optimize_assert_soft(self, ast)
     end
 
-    def check
+    def check(*args)
       reset_model!
-      result = check_sat_results(LowLevel.optimize_check(self))
+      result = check_sat_results(LowLevel.optimize_check(self, args))
       @has_model = true if result == :sat
       result
     end
@@ -81,7 +83,7 @@ module Z3
       case check
       when :sat
         puts "Counterexample exists"
-        model.each do |n,v|
+        model.each do |n, v|
           puts "* #{n} = #{v}"
         end
       when :unknown
@@ -95,7 +97,6 @@ module Z3
       pop
     end
 
-
     def reason_unknown
       LowLevel.optimize_get_reason_unknown(self)
     end

data/lib/z3/printer.rb

@@ -53,7 +53,35 @@ module Z3
         name = decl.name
         args = a.arguments.map{|x| format_ast(x)}
         return PrintedExpr.new(name, false) if args.size == 0
-        # All operators
+
+        # Special case common Bitvec operators
+        case name
+        when "rotate_left", "rotate_right", "zero_extend", "sign_extend"
+          if args.size == 1
+            n = Z3::LowLevel.get_decl_int_parameter(a.func_decl, 0)
+            return PrintedExpr.new("#{name}(#{args[0]}, #{n})", true)
+          end
+        when "bvxor", "bvand", "bvor", "bvadd", "bvsub"
+          if args.size == 2
+            pretty_name = {"bvxor" => "^", "bvand" => "&", "bvor" => "|", "bvadd" => "+", "bvsub" => "-"}[name]
+            return PrintedExpr.new("#{args[0].enforce_parentheses} #{pretty_name} #{args[1].enforce_parentheses}", true)
+          end
+        when "bvnot"
+          if args.size == 1
+            return PrintedExpr.new("~#{args[0].enforce_parentheses}")
+          end
+        when "bvneg"
+          if args.size == 1
+            return PrintedExpr.new("-#{args[0].enforce_parentheses}")
+          end
+        when "extract"
+          if args.size == 1
+            u = Z3::LowLevel.get_decl_int_parameter(a.func_decl, 0)
+            v = Z3::LowLevel.get_decl_int_parameter(a.func_decl, 1)
+            return PrintedExpr.new("#{name}(#{args[0]}, #{u}, #{v})", true)
+          end
+        end
+
         if name !~ /[a-z0-9]/
           if args.size == 2
             return PrintedExpr.new("#{args[0].enforce_parentheses} #{name} #{args[1].enforce_parentheses}", true)