z3 0.0.20180203 → 0.0.20180616

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82ddc6984f24ee79d2dcd7fba162818c0bce9959f6f7c4daad11305b09ac84b8
-  data.tar.gz: 977d33cbd061672c85297e19dba7612c2f67bc0b5785ab1a67da828f17678b65
+  metadata.gz: e1a008f1afd884efa0e1dc6e9964e9f0be381bd77884a2526a07bff5efe64212
+  data.tar.gz: d9379bd2084cb2e5222856da043d58e8ddd399cd86abdce01f0243464e2c6097
 SHA512:
-  metadata.gz: 49db1f83e829f4b982abb5aea5014f9b64f6e558ee945a3d4d451227004fbd562cc5cddda955b3148582bedc73e2d8e251bf1198f87454145fe22e889bb9eaba
-  data.tar.gz: edcd476f98a22595b6a60a11606aec007b7852b7447904413c57388f3a8d6d06c5a058cc72d115f85ce61ebcb57d02c51c66535928b30a6f7de78f5a94ccc852
+  metadata.gz: 27b7f713bedcbe819207d9d120d081366a274d9f61c952625e7256d3c5f7d177ba6de6d55f31971c06e084fcefa80c52004cd271d7dc7163753daf61e156edcc
+  data.tar.gz: a6f97e4b4916e5189a94bc439bc174342dae679fec6a246ac1a4c6c4245d7355b619cf922515913e41f5d9070b719c0a562ca9682d4d37fcbe6b1d6959c0033b

data/README.md

@@ -1,5 +1,7 @@
 This is Ruby interface for Z3 [ https://github.com/Z3Prover/z3 ].
 
+Minimum required version is Z3 4.6.
+
 It's in very early stages of development. Pull requests always welcome.
 
 ### Interface
@@ -12,13 +14,16 @@ The interface is potentially unstable, and can change in the future.
 
 `Z3::VeryLowLever` and `Z3::LowLevel` are FFI interface for internal use, and they shouldn't be used directly. Also don't use any method starting with `_`. Doing this is likely to lead to segmentation faults unless extreme care is taken.
 
-### Requirements
-
-To use it, you'll need to install `z3`. On OSX that would be:
+A utility at `api/gen_api` will loop through a .h file and generate Ruby definitions. This will update the API when upstream changes `z3_api.h`
 
-    brew install z3
+## Building
 
-On other systems use appropriate package manager.
+```
+brew install z3
+rake gem:build
+bundle install
+rake spec
+```
 
 *NB: On Linux, since FFI will look for `libz3.so`, you might need to install `libz3-dev`using your usual package manager.*
 

data/lib/z3.rb

@@ -11,6 +11,7 @@ require_relative "z3/low_level_auto"
 require_relative "z3/ast"
 require_relative "z3/context"
 require_relative "z3/solver"
+require_relative "z3/optimize"
 require_relative "z3/model"
 require_relative "z3/exception"
 require_relative "z3/func_decl"

data/lib/z3/expr/expr.rb

@@ -34,7 +34,7 @@ module Z3
           BoolSort.new
         when Integer
           IntSort.new
-        when Float
+        when Float, Rational
           RealSort.new
         else
           raise Z3::Exception, "No idea how to autoconvert `#{a.class}': `#{a.inspect}'"

data/lib/z3/expr/float_expr.rb

@@ -89,8 +89,8 @@ module Z3
       FloatExpr.Min(self, other)
     end
 
-    def exponent_string
-      LowLevel.fpa_get_numeral_exponent_string(self)
+    def exponent_string(biased)
+      LowLevel.fpa_get_numeral_exponent_string(self, biased)
     end
 
     def significand_string
@@ -169,12 +169,12 @@ module Z3
         a.sort.new(LowLevel.mk_fpa_rem(a, b))
       end
 
-      # Weirdly this dies when trying to calll Z3_get_ast_kind, while min works on same call
-      #
-      # def Max(a, b)
-      #   a, b = coerce_to_same_float_sort(a, b)
-      #   a.sort.new(LowLevel.mk_fpa_max(a, b))
-      # end
+      # In older versons, this dies when trying to calll Z3_get_ast_kind, min works on same call
+      # Works in 4.6
+      def Max(a, b)
+        a, b = coerce_to_same_float_sort(a, b)
+        a.sort.new(LowLevel.mk_fpa_max(a, b))
+      end
 
       def Min(a, b)
         a, b = coerce_to_same_float_sort(a, b)

data/lib/z3/low_level_auto.rb

@@ -1,6 +1,14 @@
 module Z3
   module LowLevel
     class << self
+      def add_const_interp(model, func_decl, ast) #=> :void
+        VeryLowLevel.Z3_add_const_interp(_ctx_pointer, model._model, func_decl._ast, ast._ast)
+      end
+
+      def add_func_interp(model, func_decl, ast) #=> :func_interp_pointer
+        VeryLowLevel.Z3_add_func_interp(_ctx_pointer, model._model, func_decl._ast, ast._ast)
+      end
+
       def algebraic_add(ast1, ast2) #=> :ast_pointer
         VeryLowLevel.Z3_algebraic_add(_ctx_pointer, ast1._ast, ast2._ast)
       end
@@ -213,6 +221,10 @@ module Z3
         VeryLowLevel.Z3_fixedpoint_add_cover(_ctx_pointer, fixedpoint._fixedpoint, num, func_decl._ast, ast._ast)
       end
 
+      def fixedpoint_add_invariant(fixedpoint, func_decl, ast) #=> :void
+        VeryLowLevel.Z3_fixedpoint_add_invariant(_ctx_pointer, fixedpoint._fixedpoint, func_decl._ast, ast._ast)
+      end
+
       def fixedpoint_add_rule(fixedpoint, ast, sym) #=> :void
         VeryLowLevel.Z3_fixedpoint_add_rule(_ctx_pointer, fixedpoint._fixedpoint, ast._ast, sym)
       end
@@ -245,6 +257,10 @@ module Z3
         VeryLowLevel.Z3_fixedpoint_get_cover_delta(_ctx_pointer, fixedpoint._fixedpoint, num, func_decl._ast)
       end
 
+      def fixedpoint_get_ground_sat_answer(fixedpoint) #=> :ast_pointer
+        VeryLowLevel.Z3_fixedpoint_get_ground_sat_answer(_ctx_pointer, fixedpoint._fixedpoint)
+      end
+
       def fixedpoint_get_help(fixedpoint) #=> :string
         VeryLowLevel.Z3_fixedpoint_get_help(_ctx_pointer, fixedpoint._fixedpoint)
       end
@@ -257,14 +273,26 @@ module Z3
         VeryLowLevel.Z3_fixedpoint_get_param_descrs(_ctx_pointer, fixedpoint._fixedpoint)
       end
 
+      def fixedpoint_get_reachable(fixedpoint, func_decl) #=> :ast_pointer
+        VeryLowLevel.Z3_fixedpoint_get_reachable(_ctx_pointer, fixedpoint._fixedpoint, func_decl._ast)
+      end
+
       def fixedpoint_get_reason_unknown(fixedpoint) #=> :string
         VeryLowLevel.Z3_fixedpoint_get_reason_unknown(_ctx_pointer, fixedpoint._fixedpoint)
       end
 
+      def fixedpoint_get_rule_names_along_trace(fixedpoint) #=> :symbol_pointer
+        VeryLowLevel.Z3_fixedpoint_get_rule_names_along_trace(_ctx_pointer, fixedpoint._fixedpoint)
+      end
+
       def fixedpoint_get_rules(fixedpoint) #=> :ast_vector_pointer
         VeryLowLevel.Z3_fixedpoint_get_rules(_ctx_pointer, fixedpoint._fixedpoint)
       end
 
+      def fixedpoint_get_rules_along_trace(fixedpoint) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_fixedpoint_get_rules_along_trace(_ctx_pointer, fixedpoint._fixedpoint)
+      end
+
       def fixedpoint_get_statistics(fixedpoint) #=> :stats_pointer
         VeryLowLevel.Z3_fixedpoint_get_statistics(_ctx_pointer, fixedpoint._fixedpoint)
       end
@@ -285,6 +313,10 @@ module Z3
         VeryLowLevel.Z3_fixedpoint_query(_ctx_pointer, fixedpoint._fixedpoint, ast._ast)
       end
 
+      def fixedpoint_query_from_lvl(fixedpoint, ast, num) #=> :int
+        VeryLowLevel.Z3_fixedpoint_query_from_lvl(_ctx_pointer, fixedpoint._fixedpoint, ast._ast, num)
+      end
+
       def fixedpoint_register_relation(fixedpoint, func_decl) #=> :void
         VeryLowLevel.Z3_fixedpoint_register_relation(_ctx_pointer, fixedpoint._fixedpoint, func_decl._ast)
       end
@@ -301,8 +333,20 @@ module Z3
         VeryLowLevel.Z3_fpa_get_ebits(_ctx_pointer, sort._ast)
       end
 
-      def fpa_get_numeral_exponent_string(ast) #=> :string
-        VeryLowLevel.Z3_fpa_get_numeral_exponent_string(_ctx_pointer, ast._ast)
+      def fpa_get_numeral_exponent_bv(ast, bool) #=> :ast_pointer
+        VeryLowLevel.Z3_fpa_get_numeral_exponent_bv(_ctx_pointer, ast._ast, bool)
+      end
+
+      def fpa_get_numeral_exponent_string(ast, bool) #=> :string
+        VeryLowLevel.Z3_fpa_get_numeral_exponent_string(_ctx_pointer, ast._ast, bool)
+      end
+
+      def fpa_get_numeral_sign_bv(ast) #=> :ast_pointer
+        VeryLowLevel.Z3_fpa_get_numeral_sign_bv(_ctx_pointer, ast._ast)
+      end
+
+      def fpa_get_numeral_significand_bv(ast) #=> :ast_pointer
+        VeryLowLevel.Z3_fpa_get_numeral_significand_bv(_ctx_pointer, ast._ast)
       end
 
       def fpa_get_numeral_significand_string(ast) #=> :string
@@ -313,6 +357,34 @@ module Z3
         VeryLowLevel.Z3_fpa_get_sbits(_ctx_pointer, sort._ast)
       end
 
+      def fpa_is_numeral_inf(ast) #=> :bool
+        VeryLowLevel.Z3_fpa_is_numeral_inf(_ctx_pointer, ast._ast)
+      end
+
+      def fpa_is_numeral_nan(ast) #=> :bool
+        VeryLowLevel.Z3_fpa_is_numeral_nan(_ctx_pointer, ast._ast)
+      end
+
+      def fpa_is_numeral_negative(ast) #=> :bool
+        VeryLowLevel.Z3_fpa_is_numeral_negative(_ctx_pointer, ast._ast)
+      end
+
+      def fpa_is_numeral_normal(ast) #=> :bool
+        VeryLowLevel.Z3_fpa_is_numeral_normal(_ctx_pointer, ast._ast)
+      end
+
+      def fpa_is_numeral_positive(ast) #=> :bool
+        VeryLowLevel.Z3_fpa_is_numeral_positive(_ctx_pointer, ast._ast)
+      end
+
+      def fpa_is_numeral_subnormal(ast) #=> :bool
+        VeryLowLevel.Z3_fpa_is_numeral_subnormal(_ctx_pointer, ast._ast)
+      end
+
+      def fpa_is_numeral_zero(ast) #=> :bool
+        VeryLowLevel.Z3_fpa_is_numeral_zero(_ctx_pointer, ast._ast)
+      end
+
       def func_entry_dec_ref(func_entry) #=> :void
         VeryLowLevel.Z3_func_entry_dec_ref(_ctx_pointer, func_entry._func_entry)
       end
@@ -333,6 +405,10 @@ module Z3
         VeryLowLevel.Z3_func_entry_inc_ref(_ctx_pointer, func_entry._func_entry)
       end
 
+      def func_interp_add_entry(func_interp, ast_vector, ast) #=> :void
+        VeryLowLevel.Z3_func_interp_add_entry(_ctx_pointer, func_interp._func_interp, ast_vector, ast._ast)
+      end
+
       def func_interp_dec_ref(func_interp) #=> :void
         VeryLowLevel.Z3_func_interp_dec_ref(_ctx_pointer, func_interp._func_interp)
       end
@@ -357,6 +433,10 @@ module Z3
         VeryLowLevel.Z3_func_interp_inc_ref(_ctx_pointer, func_interp._func_interp)
       end
 
+      def func_interp_set_else(func_interp, ast) #=> :void
+        VeryLowLevel.Z3_func_interp_set_else(_ctx_pointer, func_interp._func_interp, ast._ast)
+      end
+
       def get_algebraic_number_lower(ast, num) #=> :ast_pointer
         VeryLowLevel.Z3_get_algebraic_number_lower(_ctx_pointer, ast._ast, num)
       end
@@ -489,6 +569,10 @@ module Z3
         VeryLowLevel.Z3_get_error_code(_ctx_pointer)
       end
 
+      def get_full_version #=> :string
+        VeryLowLevel.Z3_get_full_version()
+      end
+
       def get_func_decl_id(func_decl) #=> :uint
         VeryLowLevel.Z3_get_func_decl_id(_ctx_pointer, func_decl._ast)
       end
@@ -521,6 +605,10 @@ 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
@@ -745,6 +833,10 @@ module Z3
         VeryLowLevel.Z3_mk_array_sort(_ctx_pointer, sort1._ast, sort2._ast)
       end
 
+      def mk_as_array(func_decl) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_as_array(_ctx_pointer, func_decl._ast)
+      end
+
       def mk_ast_map #=> :ast_map_pointer
         VeryLowLevel.Z3_mk_ast_map(_ctx_pointer)
       end
@@ -1253,6 +1345,10 @@ module Z3
         VeryLowLevel.Z3_mk_int_symbol(_ctx_pointer, num)
       end
 
+      def mk_int_to_str(ast) #=> :ast_pointer
+        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
@@ -1281,6 +1377,10 @@ module Z3
         VeryLowLevel.Z3_mk_mod(_ctx_pointer, ast1._ast, ast2._ast)
       end
 
+      def mk_model #=> :model_pointer
+        VeryLowLevel.Z3_mk_model(_ctx_pointer)
+      end
+
       def mk_not(ast) #=> :ast_pointer
         VeryLowLevel.Z3_mk_not(_ctx_pointer, ast._ast)
       end
@@ -1305,6 +1405,26 @@ module Z3
         VeryLowLevel.Z3_mk_probe(_ctx_pointer, str)
       end
 
+      def mk_re_complement(ast) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_re_complement(_ctx_pointer, ast._ast)
+      end
+
+      def mk_re_empty(sort) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_re_empty(_ctx_pointer, sort._ast)
+      end
+
+      def mk_re_full(sort) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_re_full(_ctx_pointer, sort._ast)
+      end
+
+      def mk_re_loop(ast, num1, num2) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_re_loop(_ctx_pointer, ast._ast, num1, num2)
+      end
+
+      def mk_re_range(ast1, ast2) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_re_range(_ctx_pointer, ast1._ast, ast2._ast)
+      end
+
       def mk_real(num1, num2) #=> :ast_pointer
         VeryLowLevel.Z3_mk_real(_ctx_pointer, num1, num2)
       end
@@ -1389,6 +1509,10 @@ module Z3
         VeryLowLevel.Z3_mk_store(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
       end
 
+      def mk_str_to_int(ast) #=> :ast_pointer
+        VeryLowLevel.Z3_mk_str_to_int(_ctx_pointer, ast._ast)
+      end
+
       def mk_string_symbol(str) #=> :symbol_pointer
         VeryLowLevel.Z3_mk_string_symbol(_ctx_pointer, str)
       end
@@ -1429,6 +1553,10 @@ module Z3
         VeryLowLevel.Z3_model_dec_ref(_ctx_pointer, model._model)
       end
 
+      def model_extrapolate(model, ast) #=> :ast_pointer
+        VeryLowLevel.Z3_model_extrapolate(_ctx_pointer, model._model, ast._ast)
+      end
+
       def model_get_const_decl(model, num) #=> :func_decl_pointer
         VeryLowLevel.Z3_model_get_const_decl(_ctx_pointer, model._model, num)
       end
@@ -1493,6 +1621,18 @@ module Z3
         VeryLowLevel.Z3_optimize_dec_ref(_ctx_pointer, optimize._optimize)
       end
 
+      def optimize_from_file(optimize, str) #=> :void
+        VeryLowLevel.Z3_optimize_from_file(_ctx_pointer, optimize._optimize, str)
+      end
+
+      def optimize_from_string(optimize, str) #=> :void
+        VeryLowLevel.Z3_optimize_from_string(_ctx_pointer, optimize._optimize, str)
+      end
+
+      def optimize_get_assertions(optimize) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_optimize_get_assertions(_ctx_pointer, optimize._optimize)
+      end
+
       def optimize_get_help(optimize) #=> :string
         VeryLowLevel.Z3_optimize_get_help(_ctx_pointer, optimize._optimize)
       end
@@ -1501,10 +1641,18 @@ module Z3
         VeryLowLevel.Z3_optimize_get_lower(_ctx_pointer, optimize._optimize, num)
       end
 
+      def optimize_get_lower_as_vector(optimize, num) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_optimize_get_lower_as_vector(_ctx_pointer, optimize._optimize, num)
+      end
+
       def optimize_get_model(optimize) #=> :model_pointer
         VeryLowLevel.Z3_optimize_get_model(_ctx_pointer, optimize._optimize)
       end
 
+      def optimize_get_objectives(optimize) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_optimize_get_objectives(_ctx_pointer, optimize._optimize)
+      end
+
       def optimize_get_param_descrs(optimize) #=> :param_descrs_pointer
         VeryLowLevel.Z3_optimize_get_param_descrs(_ctx_pointer, optimize._optimize)
       end
@@ -1521,6 +1669,10 @@ module Z3
         VeryLowLevel.Z3_optimize_get_upper(_ctx_pointer, optimize._optimize, num)
       end
 
+      def optimize_get_upper_as_vector(optimize, num) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_optimize_get_upper_as_vector(_ctx_pointer, optimize._optimize, num)
+      end
+
       def optimize_inc_ref(optimize) #=> :void
         VeryLowLevel.Z3_optimize_inc_ref(_ctx_pointer, optimize._optimize)
       end
@@ -1665,6 +1817,10 @@ module Z3
         VeryLowLevel.Z3_probe_or(_ctx_pointer, probe1._probe, probe2._probe)
       end
 
+      def qe_lite(ast_vector, ast) #=> :ast_pointer
+        VeryLowLevel.Z3_qe_lite(_ctx_pointer, ast_vector, ast._ast)
+      end
+
       def rcf_add(num1, num2) #=> :rcf_num_pointer
         VeryLowLevel.Z3_rcf_add(_ctx_pointer, num1._rcf_num, num2._rcf_num)
       end
@@ -1789,10 +1945,22 @@ module Z3
         VeryLowLevel.Z3_solver_dec_ref(_ctx_pointer, solver._solver)
       end
 
+      def solver_from_file(solver, str) #=> :void
+        VeryLowLevel.Z3_solver_from_file(_ctx_pointer, solver._solver, str)
+      end
+
+      def solver_from_string(solver, str) #=> :void
+        VeryLowLevel.Z3_solver_from_string(_ctx_pointer, solver._solver, str)
+      end
+
       def solver_get_assertions(solver) #=> :ast_vector_pointer
         VeryLowLevel.Z3_solver_get_assertions(_ctx_pointer, solver._solver)
       end
 
+      def solver_get_consequences(solver, ast_vector1, ast_vector2, ast_vector3) #=> :int
+        VeryLowLevel.Z3_solver_get_consequences(_ctx_pointer, solver._solver, ast_vector1, ast_vector2, ast_vector3)
+      end
+
       def solver_get_help(solver) #=> :string
         VeryLowLevel.Z3_solver_get_help(_ctx_pointer, solver._solver)
       end

data/lib/z3/optimize.rb

@@ -0,0 +1,126 @@
+module Z3
+  class Optimize
+    attr_reader :_optimize
+    def initialize
+      @_optimize = LowLevel.mk_optimize
+      LowLevel.optimize_inc_ref(self)
+      reset_model!
+    end
+
+    def push
+      reset_model!
+      LowLevel.optimize_push(self)
+    end
+
+    def pop
+      reset_model!
+      LowLevel.optimize_pop(self)
+    end
+
+    def assert(ast)
+      reset_model!
+      LowLevel.optimize_assert(self, ast)
+    end
+
+    def assert_soft(ast)
+      reset_model!
+      LowLevel.optimize_assert_soft(self, ast)
+    end
+
+    def check
+      reset_model!
+      result = check_sat_results(LowLevel.optimize_check(self))
+      @has_model = true if result == :sat
+      result
+    end
+
+    def satisfiable?
+      case check
+      when :sat
+        true
+      when :unsat
+        false
+      else
+        raise Z3::Exception, "Satisfiability unknown"
+      end
+    end
+
+    def unsatisfiable?
+      case check
+      when :unsat
+        true
+      when :sat
+        false
+      else
+        raise Z3::Exception, "Satisfiability unknown"
+      end
+    end
+
+    def model
+      if @has_model
+        @model ||= Z3::Model.new(LowLevel.optimize_get_model(self))
+      else
+        raise Z3::Exception, "You need to check that it's satisfiable before asking for the model"
+      end
+    end
+
+    def assertions
+      _ast_vector = LowLevel.optimize_get_assertions(self)
+      LowLevel.unpack_ast_vector(_ast_vector)
+    end
+
+    def statistics
+      _stats = LowLevel::optimize_get_statistics(self)
+      LowLevel.unpack_statistics(_stats)
+    end
+
+    def prove!(ast)
+      @has_model = false
+      push
+      assert(~ast)
+      case check
+      when :sat
+        puts "Counterexample exists"
+        model.each do |n,v|
+          puts "* #{n} = #{v}"
+        end
+      when :unknown
+        puts "Unknown"
+      when :unsat
+        puts "Proven"
+      else
+        raise "Wrong SAT result #{r}"
+      end
+    ensure
+      pop
+    end
+
+
+    def reason_unknown
+      LowLevel.optimize_get_reason_unknown(self)
+    end
+
+    def maximize(ast)
+      LowLevel.optimize_maximize(self, ast)
+    end
+
+    def minimize(ast)
+      LowLevel.optimize_minimize(self, ast)
+    end
+
+    private
+
+    def reset_model!
+      @has_model = false
+      @model = nil
+    end
+
+    def check_sat_results(r)
+      {
+        -1 => :unsat,
+        0 => :unknown,
+        1 => :sat,
+      }[r] or raise Z3::Exception, "Wrong SAT result #{r}"
+    end
+  end
+end

data/lib/z3/printer.rb

@@ -44,9 +44,9 @@ module Z3
         decl = FuncDecl.new( LowLevel::get_as_array_func_decl(a) )
         PrintedExpr.new(decl.sexpr.gsub(/k!\d+/, "k!"))
       elsif a.func_decl.name == "fp.numeral" and a.sort.is_a?(FloatSort)
+        # This API chaged in Z3 4.6
         s = a.significand_string
-        e = a.exponent_string
-        e = "+#{e}" if e[0] != "-"
+        e = "%+d" % a.exponent_string(false).to_i
         PrintedExpr.new("#{s}B#{e}")
       else
         decl = a.func_decl

data/lib/z3/sort/real_sort.rb

@@ -9,7 +9,7 @@ module Z3
     end
 
     def from_const(val)
-      if val.is_a?(Integer) or (val.is_a?(Float) and val.finite?)
+      if val.is_a?(Integer) or (val.is_a?(Float) and val.finite?) or val.is_a?(Rational)
         new LowLevel.mk_numeral(val.to_s, self)
       else
         raise Z3::Exception, "Cannot convert #{val.class} to #{self.class}"

data/lib/z3/very_low_level_auto.rb

@@ -1,5 +1,7 @@
 module Z3
   module VeryLowLevel
+    attach_function :Z3_add_const_interp, [:ctx_pointer, :model_pointer, :func_decl_pointer, :ast_pointer], :void
+    attach_function :Z3_add_func_interp, [:ctx_pointer, :model_pointer, :func_decl_pointer, :ast_pointer], :func_interp_pointer
     attach_function :Z3_algebraic_add, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_algebraic_div, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_algebraic_eq, [:ctx_pointer, :ast_pointer, :ast_pointer], :bool
@@ -53,6 +55,7 @@ module Z3
     attach_function :Z3_enable_trace, [:string], :void
     attach_function :Z3_finalize_memory, [], :void
     attach_function :Z3_fixedpoint_add_cover, [:ctx_pointer, :fixedpoint_pointer, :int, :func_decl_pointer, :ast_pointer], :void
+    attach_function :Z3_fixedpoint_add_invariant, [:ctx_pointer, :fixedpoint_pointer, :func_decl_pointer, :ast_pointer], :void
     attach_function :Z3_fixedpoint_add_rule, [:ctx_pointer, :fixedpoint_pointer, :ast_pointer, :symbol_pointer], :void
     attach_function :Z3_fixedpoint_assert, [:ctx_pointer, :fixedpoint_pointer, :ast_pointer], :void
     attach_function :Z3_fixedpoint_dec_ref, [:ctx_pointer, :fixedpoint_pointer], :void
@@ -61,34 +64,51 @@ module Z3
     attach_function :Z3_fixedpoint_get_answer, [:ctx_pointer, :fixedpoint_pointer], :ast_pointer
     attach_function :Z3_fixedpoint_get_assertions, [:ctx_pointer, :fixedpoint_pointer], :ast_vector_pointer
     attach_function :Z3_fixedpoint_get_cover_delta, [:ctx_pointer, :fixedpoint_pointer, :int, :func_decl_pointer], :ast_pointer
+    attach_function :Z3_fixedpoint_get_ground_sat_answer, [:ctx_pointer, :fixedpoint_pointer], :ast_pointer
     attach_function :Z3_fixedpoint_get_help, [:ctx_pointer, :fixedpoint_pointer], :string
     attach_function :Z3_fixedpoint_get_num_levels, [:ctx_pointer, :fixedpoint_pointer, :func_decl_pointer], :uint
     attach_function :Z3_fixedpoint_get_param_descrs, [:ctx_pointer, :fixedpoint_pointer], :param_descrs_pointer
+    attach_function :Z3_fixedpoint_get_reachable, [:ctx_pointer, :fixedpoint_pointer, :func_decl_pointer], :ast_pointer
     attach_function :Z3_fixedpoint_get_reason_unknown, [:ctx_pointer, :fixedpoint_pointer], :string
+    attach_function :Z3_fixedpoint_get_rule_names_along_trace, [:ctx_pointer, :fixedpoint_pointer], :symbol_pointer
     attach_function :Z3_fixedpoint_get_rules, [:ctx_pointer, :fixedpoint_pointer], :ast_vector_pointer
+    attach_function :Z3_fixedpoint_get_rules_along_trace, [:ctx_pointer, :fixedpoint_pointer], :ast_vector_pointer
     attach_function :Z3_fixedpoint_get_statistics, [:ctx_pointer, :fixedpoint_pointer], :stats_pointer
     attach_function :Z3_fixedpoint_inc_ref, [:ctx_pointer, :fixedpoint_pointer], :void
     attach_function :Z3_fixedpoint_pop, [:ctx_pointer, :fixedpoint_pointer], :void
     attach_function :Z3_fixedpoint_push, [:ctx_pointer, :fixedpoint_pointer], :void
     attach_function :Z3_fixedpoint_query, [:ctx_pointer, :fixedpoint_pointer, :ast_pointer], :int
+    attach_function :Z3_fixedpoint_query_from_lvl, [:ctx_pointer, :fixedpoint_pointer, :ast_pointer, :uint], :int
     attach_function :Z3_fixedpoint_register_relation, [:ctx_pointer, :fixedpoint_pointer, :func_decl_pointer], :void
     attach_function :Z3_fixedpoint_set_params, [:ctx_pointer, :fixedpoint_pointer, :params_pointer], :void
     attach_function :Z3_fixedpoint_update_rule, [:ctx_pointer, :fixedpoint_pointer, :ast_pointer, :symbol_pointer], :void
     attach_function :Z3_fpa_get_ebits, [:ctx_pointer, :sort_pointer], :uint
-    attach_function :Z3_fpa_get_numeral_exponent_string, [:ctx_pointer, :ast_pointer], :string
+    attach_function :Z3_fpa_get_numeral_exponent_bv, [:ctx_pointer, :ast_pointer, :bool], :ast_pointer
+    attach_function :Z3_fpa_get_numeral_exponent_string, [:ctx_pointer, :ast_pointer, :bool], :string
+    attach_function :Z3_fpa_get_numeral_sign_bv, [:ctx_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_fpa_get_numeral_significand_bv, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_fpa_get_numeral_significand_string, [:ctx_pointer, :ast_pointer], :string
     attach_function :Z3_fpa_get_sbits, [:ctx_pointer, :sort_pointer], :uint
+    attach_function :Z3_fpa_is_numeral_inf, [:ctx_pointer, :ast_pointer], :bool
+    attach_function :Z3_fpa_is_numeral_nan, [:ctx_pointer, :ast_pointer], :bool
+    attach_function :Z3_fpa_is_numeral_negative, [:ctx_pointer, :ast_pointer], :bool
+    attach_function :Z3_fpa_is_numeral_normal, [:ctx_pointer, :ast_pointer], :bool
+    attach_function :Z3_fpa_is_numeral_positive, [:ctx_pointer, :ast_pointer], :bool
+    attach_function :Z3_fpa_is_numeral_subnormal, [:ctx_pointer, :ast_pointer], :bool
+    attach_function :Z3_fpa_is_numeral_zero, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_func_entry_dec_ref, [:ctx_pointer, :func_entry_pointer], :void
     attach_function :Z3_func_entry_get_arg, [:ctx_pointer, :func_entry_pointer, :uint], :ast_pointer
     attach_function :Z3_func_entry_get_num_args, [:ctx_pointer, :func_entry_pointer], :uint
     attach_function :Z3_func_entry_get_value, [:ctx_pointer, :func_entry_pointer], :ast_pointer
     attach_function :Z3_func_entry_inc_ref, [:ctx_pointer, :func_entry_pointer], :void
+    attach_function :Z3_func_interp_add_entry, [:ctx_pointer, :func_interp_pointer, :ast_vector_pointer, :ast_pointer], :void
     attach_function :Z3_func_interp_dec_ref, [:ctx_pointer, :func_interp_pointer], :void
     attach_function :Z3_func_interp_get_arity, [:ctx_pointer, :func_interp_pointer], :uint
     attach_function :Z3_func_interp_get_else, [:ctx_pointer, :func_interp_pointer], :ast_pointer
     attach_function :Z3_func_interp_get_entry, [:ctx_pointer, :func_interp_pointer, :uint], :func_entry_pointer
     attach_function :Z3_func_interp_get_num_entries, [:ctx_pointer, :func_interp_pointer], :uint
     attach_function :Z3_func_interp_inc_ref, [:ctx_pointer, :func_interp_pointer], :void
+    attach_function :Z3_func_interp_set_else, [:ctx_pointer, :func_interp_pointer, :ast_pointer], :void
     attach_function :Z3_get_algebraic_number_lower, [:ctx_pointer, :ast_pointer, :uint], :ast_pointer
     attach_function :Z3_get_algebraic_number_upper, [:ctx_pointer, :ast_pointer, :uint], :ast_pointer
     attach_function :Z3_get_app_arg, [:ctx_pointer, :app_pointer, :uint], :ast_pointer
@@ -122,6 +142,7 @@ module Z3
     attach_function :Z3_get_domain, [:ctx_pointer, :func_decl_pointer, :uint], :sort_pointer
     attach_function :Z3_get_domain_size, [:ctx_pointer, :func_decl_pointer], :uint
     attach_function :Z3_get_error_code, [:ctx_pointer], :uint
+    attach_function :Z3_get_full_version, [], :string
     attach_function :Z3_get_func_decl_id, [:ctx_pointer, :func_decl_pointer], :uint
     attach_function :Z3_get_index_value, [:ctx_pointer, :ast_pointer], :uint
     attach_function :Z3_get_interpolant, [:ctx_pointer, :ast_pointer, :ast_pointer, :params_pointer], :ast_vector_pointer
@@ -130,6 +151,7 @@ module Z3
     attach_function :Z3_get_numeral_decimal_string, [:ctx_pointer, :ast_pointer, :uint], :string
     attach_function :Z3_get_numeral_string, [:ctx_pointer, :ast_pointer], :string
     attach_function :Z3_get_numerator, [:ctx_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_get_parser_error, [:ctx_pointer], :string
     attach_function :Z3_get_pattern, [:ctx_pointer, :pattern_pointer, :uint], :ast_pointer
     attach_function :Z3_get_pattern_num_terms, [:ctx_pointer, :pattern_pointer], :uint
     attach_function :Z3_get_probe_name, [:ctx_pointer, :uint], :string
@@ -186,6 +208,7 @@ module Z3
     attach_function :Z3_is_well_sorted, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_mk_array_default, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_array_sort, [:ctx_pointer, :sort_pointer, :sort_pointer], :sort_pointer
+    attach_function :Z3_mk_as_array, [:ctx_pointer, :func_decl_pointer], :ast_pointer
     attach_function :Z3_mk_ast_map, [:ctx_pointer], :ast_map_pointer
     attach_function :Z3_mk_ast_vector, [:ctx_pointer], :ast_vector_pointer
     attach_function :Z3_mk_bool_sort, [:ctx_pointer], :sort_pointer
@@ -313,6 +336,7 @@ module Z3
     attach_function :Z3_mk_int64, [:ctx_pointer, :int64, :sort_pointer], :ast_pointer
     attach_function :Z3_mk_int_sort, [:ctx_pointer], :sort_pointer
     attach_function :Z3_mk_int_symbol, [:ctx_pointer, :int], :symbol_pointer
+    attach_function :Z3_mk_int_to_str, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_interpolant, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_interpolation_context, [:config_pointer], :ctx_pointer
     attach_function :Z3_mk_is_int, [:ctx_pointer, :ast_pointer], :ast_pointer
@@ -320,12 +344,18 @@ module Z3
     attach_function :Z3_mk_le, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_lt, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_mod, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_model, [:ctx_pointer], :model_pointer
     attach_function :Z3_mk_not, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_numeral, [:ctx_pointer, :string, :sort_pointer], :ast_pointer
     attach_function :Z3_mk_optimize, [:ctx_pointer], :optimize_pointer
     attach_function :Z3_mk_params, [:ctx_pointer], :params_pointer
     attach_function :Z3_mk_power, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_probe, [:ctx_pointer, :string], :probe_pointer
+    attach_function :Z3_mk_re_complement, [:ctx_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_re_empty, [:ctx_pointer, :sort_pointer], :ast_pointer
+    attach_function :Z3_mk_re_full, [:ctx_pointer, :sort_pointer], :ast_pointer
+    attach_function :Z3_mk_re_loop, [:ctx_pointer, :ast_pointer, :uint, :uint], :ast_pointer
+    attach_function :Z3_mk_re_range, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_real, [:ctx_pointer, :int, :int], :ast_pointer
     attach_function :Z3_mk_real2int, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_real_sort, [:ctx_pointer], :sort_pointer
@@ -347,6 +377,7 @@ module Z3
     attach_function :Z3_mk_solver_for_logic, [:ctx_pointer, :symbol_pointer], :solver_pointer
     attach_function :Z3_mk_solver_from_tactic, [:ctx_pointer, :tactic_pointer], :solver_pointer
     attach_function :Z3_mk_store, [:ctx_pointer, :ast_pointer, :ast_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_str_to_int, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_string_symbol, [:ctx_pointer, :string], :symbol_pointer
     attach_function :Z3_mk_tactic, [:ctx_pointer, :string], :tactic_pointer
     attach_function :Z3_mk_true, [:ctx_pointer], :ast_pointer
@@ -357,6 +388,7 @@ module Z3
     attach_function :Z3_mk_xor, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_zero_ext, [:ctx_pointer, :uint, :ast_pointer], :ast_pointer
     attach_function :Z3_model_dec_ref, [:ctx_pointer, :model_pointer], :void
+    attach_function :Z3_model_extrapolate, [:ctx_pointer, :model_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_model_get_const_decl, [:ctx_pointer, :model_pointer, :uint], :func_decl_pointer
     attach_function :Z3_model_get_const_interp, [:ctx_pointer, :model_pointer, :func_decl_pointer], :ast_pointer
     attach_function :Z3_model_get_func_decl, [:ctx_pointer, :model_pointer, :uint], :func_decl_pointer
@@ -373,13 +405,19 @@ module Z3
     attach_function :Z3_optimize_assert_soft, [:ctx_pointer, :optimize_pointer, :ast_pointer, :string, :symbol_pointer], :uint
     attach_function :Z3_optimize_check, [:ctx_pointer, :optimize_pointer], :int
     attach_function :Z3_optimize_dec_ref, [:ctx_pointer, :optimize_pointer], :void
+    attach_function :Z3_optimize_from_file, [:ctx_pointer, :optimize_pointer, :string], :void
+    attach_function :Z3_optimize_from_string, [:ctx_pointer, :optimize_pointer, :string], :void
+    attach_function :Z3_optimize_get_assertions, [:ctx_pointer, :optimize_pointer], :ast_vector_pointer
     attach_function :Z3_optimize_get_help, [:ctx_pointer, :optimize_pointer], :string
     attach_function :Z3_optimize_get_lower, [:ctx_pointer, :optimize_pointer, :uint], :ast_pointer
+    attach_function :Z3_optimize_get_lower_as_vector, [:ctx_pointer, :optimize_pointer, :uint], :ast_vector_pointer
     attach_function :Z3_optimize_get_model, [:ctx_pointer, :optimize_pointer], :model_pointer
+    attach_function :Z3_optimize_get_objectives, [:ctx_pointer, :optimize_pointer], :ast_vector_pointer
     attach_function :Z3_optimize_get_param_descrs, [:ctx_pointer, :optimize_pointer], :param_descrs_pointer
     attach_function :Z3_optimize_get_reason_unknown, [:ctx_pointer, :optimize_pointer], :string
     attach_function :Z3_optimize_get_statistics, [:ctx_pointer, :optimize_pointer], :stats_pointer
     attach_function :Z3_optimize_get_upper, [:ctx_pointer, :optimize_pointer, :uint], :ast_pointer
+    attach_function :Z3_optimize_get_upper_as_vector, [:ctx_pointer, :optimize_pointer, :uint], :ast_vector_pointer
     attach_function :Z3_optimize_inc_ref, [:ctx_pointer, :optimize_pointer], :void
     attach_function :Z3_optimize_maximize, [:ctx_pointer, :optimize_pointer, :ast_pointer], :uint
     attach_function :Z3_optimize_minimize, [:ctx_pointer, :optimize_pointer, :ast_pointer], :uint
@@ -416,6 +454,7 @@ module Z3
     attach_function :Z3_probe_lt, [:ctx_pointer, :probe_pointer, :probe_pointer], :probe_pointer
     attach_function :Z3_probe_not, [:ctx_pointer, :probe_pointer], :probe_pointer
     attach_function :Z3_probe_or, [:ctx_pointer, :probe_pointer, :probe_pointer], :probe_pointer
+    attach_function :Z3_qe_lite, [:ctx_pointer, :ast_vector_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_rcf_add, [:ctx_pointer, :rcf_num_pointer, :rcf_num_pointer], :rcf_num_pointer
     attach_function :Z3_rcf_del, [:ctx_pointer, :rcf_num_pointer], :void
     attach_function :Z3_rcf_div, [:ctx_pointer, :rcf_num_pointer, :rcf_num_pointer], :rcf_num_pointer
@@ -447,7 +486,10 @@ module Z3
     attach_function :Z3_solver_assert_and_track, [:ctx_pointer, :solver_pointer, :ast_pointer, :ast_pointer], :void
     attach_function :Z3_solver_check, [:ctx_pointer, :solver_pointer], :int
     attach_function :Z3_solver_dec_ref, [:ctx_pointer, :solver_pointer], :void
+    attach_function :Z3_solver_from_file, [:ctx_pointer, :solver_pointer, :string], :void
+    attach_function :Z3_solver_from_string, [:ctx_pointer, :solver_pointer, :string], :void
     attach_function :Z3_solver_get_assertions, [:ctx_pointer, :solver_pointer], :ast_vector_pointer
+    attach_function :Z3_solver_get_consequences, [:ctx_pointer, :solver_pointer, :ast_vector_pointer, :ast_vector_pointer, :ast_vector_pointer], :int
     attach_function :Z3_solver_get_help, [:ctx_pointer, :solver_pointer], :string
     attach_function :Z3_solver_get_model, [:ctx_pointer, :solver_pointer], :model_pointer
     attach_function :Z3_solver_get_num_scopes, [:ctx_pointer, :solver_pointer], :uint

data/spec/float_expr_spec.rb

@@ -1,6 +1,7 @@
 module Z3
   describe FloatExpr do
     let(:mode) { RoundingModeSort.new }
+    let(:float_single) { FloatSort.new(:single) }
     let(:float_double) { FloatSort.new(:double) }
     let(:a) { float_double.var("a") }
     let(:b) { float_double.var("b") }
@@ -62,12 +63,12 @@ module Z3
       )
     end
 
-    # Broken in z3
-    # it "max" do
-    #   expect([a == 2.0, b == 3.0, c == a.max(b)]).to have_solution(
-    #     c => float_double.from_const(3.0),
-    #   )
-    # end
+    # Broken in z3 before 4.6
+    it "max" do
+      expect([a == 2.0, b == 3.0, c == a.max(b)]).to have_solution(
+        c => float_double.from_const(3.0),
+      )
+    end
 
     it "min" do
       expect([a == 2.0, b == 3.0, c == a.min(b)]).to have_solution(
@@ -104,6 +105,15 @@ module Z3
       # Denormals changed
       if Z3.version >= '4.5'
         expect(float_double.from_const(1234 * 0.5**1040).to_s).to eq("0.00470733642578125B-1022")
+        expect(float_single.from_const(1234 * 0.5**136).to_s).to eq("1.205078125B-126")
+        # This is what we get, all of these are wrong, by a lot:
+        # expect(float_single.from_const(1234 * 0.5**137).to_s).to eq("0.205078125B-126")
+        # expect(float_single.from_const(1234 * 0.5**138).to_s).to eq("0.205078125B-126")
+        # expect(float_single.from_const(1234 * 0.5**139).to_s).to eq("0.205078125B-126")
+        #
+        # It's not even a bug in printer Z3_mk_fpa_numeral_double is broken for denormals
+        #
+        # Probably best revisit it in 4.7+
       else
         expect(float_double.from_const(1234 * 0.5**1040).to_s).to eq("1.205078125B-1030")
       end

data/spec/optimize_spec.rb

@@ -0,0 +1,76 @@
+# Optimize and Model specs are codependent, so half of functionality of each is tested in other class's tests
+module Z3
+  describe Optimize do
+    let(:optimize) { Optimize.new }
+    let(:a) { Z3.Int("a") }
+    let(:b) { Z3.Int("b") }
+
+    it "basic functionality" do
+      optimize.assert(a == b)
+      expect(optimize).to be_satisfiable
+      optimize.assert(a != b)
+      expect(optimize).to be_unsatisfiable
+    end
+
+    it "push/pop" do
+      optimize.assert(a == b)
+      optimize.push
+      optimize.assert(a != b)
+      expect(optimize).to be_unsatisfiable
+      optimize.pop
+      expect(optimize).to be_satisfiable
+    end
+
+    it "#assertions" do
+      optimize.assert a + b == 4
+      optimize.assert b >= 2
+      optimize.assert Z3.Or(a == 2, a == -2)
+      expect(optimize.assertions).to be_same_as([
+        a + b == 4,
+        b >= 2,
+        (a == 2) | (a == -2),
+      ])
+    end
+
+    it "#statistics" do
+      optimize.assert a + b == 4
+      optimize.assert b >= 2
+      optimize.assert Z3.Or(a == 2, a == -2)
+      stats = optimize.statistics
+      expect(stats.keys).to match_array(["rlimit count", "max memory", "memory", "num allocs"])
+    end
+
+    # This is a very simple example of unknown satisfiablity
+    # so we might need more complex one in the future
+    # Unlike Z3::Solver, this is unknown even 4.6.0
+    it "third way" do
+      optimize.assert a**3 == a
+      expect(optimize.check).to eq(:unknown)
+      expect{optimize.satisfiable?}.to raise_error("Satisfiability unknown")
+      expect{optimize.unsatisfiable?}.to raise_error("Satisfiability unknown")
+    end
+
+    it "third way" do
+      optimize.assert a**a == a
+      expect(optimize.check).to eq(:unknown)
+      expect{optimize.satisfiable?}.to raise_error("Satisfiability unknown")
+      expect{optimize.unsatisfiable?}.to raise_error("Satisfiability unknown")
+    end
+
+    it "maximize" do
+      optimize.assert a > 0
+      optimize.assert a < 10
+      optimize.maximize a
+      expect(optimize).to be_satisfiable
+      expect(optimize.model[a].to_i).to eq 9
+    end
+
+    it "maximize" do
+      optimize.assert a > 0
+      optimize.assert a < 10
+      optimize.minimize a
+      expect(optimize).to be_satisfiable
+      expect(optimize.model[a].to_i).to eq 1
+    end
+  end
+end

data/spec/real_expr_spec.rb

@@ -7,6 +7,7 @@ module Z3
 
     it "+" do
       expect([a == 2, b == 4, c == a + b]).to have_solution(c => 6)
+      expect([a == Rational(1,3), b == Rational(3,2), c == a + b]).to have_solution(c => "11/6")
     end
 
     it "-" do
@@ -67,6 +68,7 @@ module Z3
       expect([a == 3, b == -a]).to have_solution(b => -3)
       expect([a == 0, b == -a]).to have_solution(b => 0)
       expect([a == 3.5, b == -a]).to have_solution(b => "-7/2")
+      expect([a == Rational(4,3), b == -a]).to have_solution(b => "-4/3")
     end
   end
 end

data/spec/real_sort_spec.rb

@@ -9,6 +9,8 @@ module Z3
       expect(subject.from_const(-0.0).inspect).to eq("Real<0>")
       expect(subject.from_const(3.14).inspect).to eq("Real<157/50>")
       expect(subject.from_const(-3.14).inspect).to eq("Real<-157/50>")
+      expect(subject.from_const(Rational(22,7)).inspect).to eq("Real<22/7>")
+      expect(subject.from_const(Rational(-22,7)).inspect).to eq("Real<-22/7>")
     end
 
     it "raises exception when trying to convert constants of wrong type" do

data/spec/spec_helper.rb

@@ -11,28 +11,17 @@ require_relative "../lib/z3"
 
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  # rspec-expectations config goes here. You can use an alternate
-  # assertion/expectation library such as wrong or the stdlib/minitest
-  # assertions if you prefer.
   config.expect_with :rspec do |expectations|
-    # This option will default to `true` in RSpec 4. It makes the `description`
-    # and `failure_message` of custom matchers include text for helper methods
-    # defined using `chain`, e.g.:
-    #     be_bigger_than(2).and_smaller_than(4).description
-    #     # => "be bigger than 2 and smaller than 4"
-    # ...rather than:
-    #     # => "be bigger than 2"
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
   end
 
-  # rspec-mocks config goes here. You can use an alternate test double
-  # library (such as bogus or mocha) by changing the `mock_with` option here.
   config.mock_with :rspec do |mocks|
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended, and will default to
-    # `true` in RSpec 4.
     mocks.verify_partial_doubles = true
   end
+
+  config.define_derived_metadata do |meta|
+    meta[:aggregate_failures] = true
+  end
 end
 
 RSpec::Matchers.define :have_output do |expected|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: z3
 version: !ruby/object:Gem::Version
-  version: 0.0.20180203
+  version: 0.0.20180616
 platform: ruby
 authors:
 - Tomasz Wegrzanowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-03 00:00:00.000000000 Z
+date: 2018-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -177,6 +177,7 @@ files:
 - lib/z3/low_level.rb
 - lib/z3/low_level_auto.rb
 - lib/z3/model.rb
+- lib/z3/optimize.rb
 - lib/z3/printer.rb
 - lib/z3/probe.rb
 - lib/z3/solver.rb
@@ -231,6 +232,7 @@ files:
 - spec/integration/verbal_arithmetic_spec.rb
 - spec/integration/zebra_puzzle_spec.rb
 - spec/model_spec.rb
+- spec/optimize_spec.rb
 - spec/printer_spec.rb
 - spec/probe_spec.rb
 - spec/real_expr_spec.rb