z3 0.0.20160427 → 0.0.20161008

data/lib/z3/model.rb

@@ -1,51 +1,53 @@
-class Z3::Model
-  include Enumerable
+module Z3
+  class Model
+    include Enumerable
 
-  attr_reader :_model
-  def initialize(_model)
-    @_model = _model
-  end
+    attr_reader :_model
+    def initialize(_model)
+      @_model = _model
+    end
 
-  def num_consts
-    Z3::LowLevel.model_get_num_consts(self)
-  end
+    def num_consts
+      LowLevel.model_get_num_consts(self)
+    end
 
-  def consts
-    (0...num_consts).map do |i|
-      Z3::FuncDecl.new(Z3::LowLevel.model_get_const_decl(self, i))
+    def consts
+      (0...num_consts).map do |i|
+        FuncDecl.new(LowLevel.model_get_const_decl(self, i))
+      end
     end
-  end
 
-  def num_sorts
-    Z3::LowLevel.model_get_num_sorts(self)
-  end
+    def num_sorts
+      LowLevel.model_get_num_sorts(self)
+    end
 
-  def num_funcs
-    Z3::LowLevel.model_get_num_funcs(self)
-  end
+    def num_funcs
+      LowLevel.model_get_num_funcs(self)
+    end
 
-  def model_eval(ast, model_completion=false)
-    Z3::Expr.new_from_pointer(Z3::LowLevel.model_eval(self, ast, model_completion))
-  end
+    def model_eval(ast, model_completion=false)
+      Expr.new_from_pointer(LowLevel.model_eval(self, ast, model_completion))
+    end
 
-  def [](ast)
-    model_eval(ast)
-  end
+    def [](ast)
+      model_eval(ast)
+    end
 
-  def to_s
-    "Z3::Model<#{ map{|n,v| "#{n}=#{v}"}.join(", ") }>"
-  end
+    def to_s
+      "Z3::Model<#{ map{|n,v| "#{n}=#{v}"}.join(", ") }>"
+    end
 
-  def inspect
-    to_s
-  end
+    def inspect
+      to_s
+    end
 
-  def each
-    consts.sort_by(&:name).each do |c|
-      yield(
-        c.range.var(c.name),
-        Z3::Expr.new_from_pointer(Z3::LowLevel.model_get_const_interp(self, c))
-      )
+    def each
+      consts.sort_by(&:name).each do |c|
+        yield(
+          c.range.var(c.name),
+          Expr.new_from_pointer(LowLevel.model_get_const_interp(self, c))
+        )
+      end
     end
   end
 end

data/lib/z3/printer.rb

@@ -1,26 +1,68 @@
 module Z3
   class Printer
     def format(a)
+      format_ast(a).to_s
+    end
+
+    private
+
+    class PrintedExpr
+      attr_reader :str, :priority
+      def initialize(str, priority=false)
+        @str = str
+        @priority = priority
+      end
+      def to_s
+        @str
+      end
+      def enforce_parentheses
+        if @priority
+          "(#{@str})"
+        else
+          @str
+        end
+      end
+    end
+
+    def format_ast(a)
       case a.ast_kind
       when :numeral
-        format_numeral(a)
+        PrintedExpr.new(Z3::LowLevel.get_numeral_string(a))
       when :app
-        a.sexpr
-      when :var
-        a.sexpr
-      when :quantifier
-        a.sexpr
-      when :func_decl
-        a.sexpr
-      when :unknown
-        a.sexpr
+        format_app(a)
+      when :var, :quantifier, :func_decl, :unknown
+        PrintedExpr.new(a.sexpr)
       else
         raise Z3::Exception, "Unknown AST kind #{a.ast_kind}"
       end
     end
 
-    def format_numeral(a)
-      Z3::LowLevel.get_numeral_string(a)
+    def format_app(a)
+      if LowLevel::is_algebraic_number(a)
+        PrintedExpr.new(LowLevel::get_numeral_decimal_string(a, 10))
+      elsif LowLevel::is_as_array(a)
+        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)
+        s = a.significand_string
+        e = a.exponent_string
+        e = "+#{e}" if e[0] != "-"
+        PrintedExpr.new("#{s}B#{e}")
+      else
+        decl = a.func_decl
+        name = decl.name
+        args = a.arguments.map{|x| format_ast(x)}
+        return PrintedExpr.new(name, false) if args.size == 0
+        # All operators
+        if name !~ /[a-z0-9]/
+          if args.size == 2
+            return PrintedExpr.new("#{args[0].enforce_parentheses} #{name} #{args[1].enforce_parentheses}", true)
+          elsif args.size == 1
+            return PrintedExpr.new("#{name}#{args[0].enforce_parentheses}", true)
+          end
+        end
+        PrintedExpr.new("#{name}(#{args.join(", ")})")
+      end
     end
   end
 end

data/lib/z3/probe.rb

@@ -0,0 +1,69 @@
+module Z3
+  class Probe
+    attr_reader :_probe
+    def initialize(_probe)
+      @_probe = _probe
+      LowLevel.probe_inc_ref(self)
+    end
+
+    def &(other)
+      raise Z3::Exception, "Probe required" unless other.is_a?(Probe)
+      Probe.new LowLevel.probe_and(self, other)
+    end
+
+    def |(other)
+      raise Z3::Exception, "Probe required" unless other.is_a?(Probe)
+      Probe.new LowLevel.probe_or(self, other)
+    end
+
+    def ~
+      Probe.new LowLevel.probe_not(self)
+    end
+
+    def ==(other)
+      raise Z3::Exception, "Probe required" unless other.is_a?(Probe)
+      Probe.new LowLevel.probe_eq(self, other)
+    end
+
+    def >=(other)
+      raise Z3::Exception, "Probe required" unless other.is_a?(Probe)
+      Probe.new LowLevel.probe_ge(self, other)
+    end
+
+    def >(other)
+      raise Z3::Exception, "Probe required" unless other.is_a?(Probe)
+      Probe.new LowLevel.probe_gt(self, other)
+    end
+
+    def <=(other)
+      raise Z3::Exception, "Probe required" unless other.is_a?(Probe)
+      Probe.new LowLevel.probe_le(self, other)
+    end
+
+    def <(other)
+      raise Z3::Exception, "Probe required" unless other.is_a?(Probe)
+      Probe.new LowLevel.probe_lt(self, other)
+    end
+
+    def apply(goal)
+      raise Z3::Exception, "Goal required" unless goal.is_a?(Goal)
+      LowLevel.probe_apply(self, goal)
+    end
+
+    class <<self
+      def const(num)
+        raise Z3::Exception, "Number required" unless num.is_a?(Numeric)
+        new LowLevel.probe_const(num.to_f)
+      end
+
+      def names
+        (0...LowLevel.get_num_probes).map{|i| LowLevel.get_probe_name(i) }
+      end
+
+      def named(str)
+        raise Z3::Exception, "#{str} not on list of known probes, available: #{names.join(" ")}" unless names.include?(str)
+        new LowLevel.mk_probe(str)
+      end
+    end
+  end
+end

data/lib/z3/solver.rb

@@ -2,39 +2,44 @@ module Z3
   class Solver
     attr_reader :_solver
     def initialize
-      @_solver = Z3::LowLevel.mk_solver
-      Z3::LowLevel.solver_inc_ref(self)
+      @_solver = LowLevel.mk_solver
+      LowLevel.solver_inc_ref(self)
     end
 
     def push
-      Z3::LowLevel.solver_push(self)
+      LowLevel.solver_push(self)
     end
 
     def pop(n=1)
-      Z3::LowLevel.solver_pop(self, n)
+      LowLevel.solver_pop(self, n)
     end
 
     def reset
-      Z3::LowLevel.solver_reset(self)
+      LowLevel.solver_reset(self)
     end
 
     def assert(ast)
-      Z3::LowLevel.solver_assert(self, ast)
+      LowLevel.solver_assert(self, ast)
     end
 
     def check
-      check_sat_results(Z3::LowLevel.solver_check(self))
+      check_sat_results(LowLevel.solver_check(self))
     end
 
     def model
       Z3::Model.new(
-        Z3::LowLevel.solver_get_model(self)
+        LowLevel.solver_get_model(self)
       )
     end
 
     def assertions
-      _ast_vector = Z3::LowLevel.solver_get_assertions(self)
-      Z3::LowLevel.unpack_ast_vector(_ast_vector)
+      _ast_vector = LowLevel.solver_get_assertions(self)
+      LowLevel.unpack_ast_vector(_ast_vector)
+    end
+
+    def statistics
+      _stats = LowLevel::solver_get_statistics(self)
+      LowLevel.unpack_statistics(_stats)
     end
 
     def prove!(ast)
@@ -60,16 +65,11 @@ module Z3
     private
 
     def check_sat_results(r)
-      case r
-      when 1
-        :sat
-      when 0
-        :unknown
-      when -1
-        :unsat
-      else
-        raise "Wrong SAT result #{r}"
-      end
+      {
+        -1 => :unsat,
+        0 => :unknown,
+        1 => :sat,
+      }[r] or raise Z3::Exception, "Wrong SAT result #{r}"
     end
   end
 end

data/lib/z3/sort/array_sort.rb

@@ -0,0 +1,24 @@
+module Z3
+  class ArraySort < Sort
+    attr_reader :key_sort, :value_sort
+    def initialize(key_sort, value_sort)
+      @key_sort = key_sort
+      @value_sort = value_sort
+      super LowLevel.mk_array_sort(key_sort, value_sort)
+    end
+
+    def expr_class
+      ArrayExpr
+    end
+
+    def to_s
+      "Array(#{key_sort}, #{value_sort})"
+    end
+
+    def inspect
+      "ArraySort(#{key_sort}, #{value_sort})"
+    end
+
+    public_class_method :new
+  end
+end

data/lib/z3/sort/bitvec_sort.rb

@@ -30,7 +30,7 @@ module Z3
 
     def >(other)
       raise ArgumentError unless other.is_a?(Sort)
-      return true if other.is_a?(IntSort)
+      return true if other.is_a?(IntSort) # This is nasty...
       return true if other.is_a?(BitvecSort) and size > other.size
       false
     end

data/lib/z3/sort/float_sort.rb

@@ -0,0 +1,92 @@
+module Z3
+  class FloatSort < Sort
+    def initialize(e, s=nil)
+      if s.nil?
+        case e
+        when 16
+          super LowLevel.mk_fpa_sort_16
+        when 32
+          super LowLevel.mk_fpa_sort_32
+        when 64
+          super LowLevel.mk_fpa_sort_64
+        when 128
+          super LowLevel.mk_fpa_sort_128
+        when :half
+          super LowLevel.mk_fpa_sort_half
+        when :single
+          super LowLevel.mk_fpa_sort_single
+        when :double
+          super LowLevel.mk_fpa_sort_double
+        when :quadruple
+          super LowLevel.mk_fpa_sort_quadruple
+        else
+          raise "Unknown float type #{e}, use FloatSort.new(exponent_bits, significant_bits)"
+        end
+      else
+        super LowLevel.mk_fpa_sort(e, s)
+      end
+    end
+
+    def expr_class
+      FloatExpr
+    end
+
+    def from_const(val)
+      if val.is_a?(Float)
+        new LowLevel.mk_fpa_numeral_double(val, self)
+      elsif val.is_a?(Integer)
+        val_f = val.to_f
+        # FIXME, there are other constructors
+        raise Z3::Exception, "Out of range" unless val_f == val
+        new LowLevel.mk_fpa_numeral_double(val_f, self)
+      else
+        raise Z3::Exception, "Cannot convert #{val.class} to #{self.class}"
+      end
+    end
+
+    def >(other)
+      raise ArgumentError unless other.is_a?(Sort)
+      return true if other.is_a?(IntSort) # This is nasty...
+      return true if other.is_a?(RealSort) # This is nasty...
+      false
+    end
+
+    def ebits
+      LowLevel.fpa_get_ebits(self)
+    end
+
+    def sbits
+      LowLevel.fpa_get_sbits(self)
+    end
+
+    def to_s
+      "Float(#{ebits}, #{sbits})"
+    end
+
+    def inspect
+      "FloatSort(#{ebits}, #{sbits})"
+    end
+
+    def nan
+      new LowLevel.mk_fpa_nan(self)
+    end
+
+    def positive_infinity
+      new LowLevel.mk_fpa_inf(self, false)
+    end
+
+    def negative_infinity
+      new LowLevel.mk_fpa_inf(self, true)
+    end
+
+    def positive_zero
+      new LowLevel.mk_fpa_zero(self, false)
+    end
+
+    def negative_zero
+      new LowLevel.mk_fpa_zero(self, true)
+    end
+
+    public_class_method :new
+  end
+end

data/lib/z3/sort/rounding_mode_sort.rb

@@ -0,0 +1,41 @@
+module Z3
+  class RoundingModeSort < Sort
+    def initialize
+      super LowLevel.mk_fpa_rounding_mode_sort
+    end
+
+    def expr_class
+      RoundingModeExpr
+    end
+
+    def to_s
+      "RoundingMode"
+    end
+
+    def inspect
+      "RoundingModeSort"
+    end
+
+    def nearest_ties_away
+      RoundingModeExpr.new(LowLevel.mk_fpa_round_nearest_ties_to_away, self)
+    end
+
+    def nearest_ties_even
+      RoundingModeExpr.new(LowLevel.mk_fpa_round_nearest_ties_to_even, self)
+    end
+
+    def towards_zero
+      RoundingModeExpr.new(LowLevel.mk_fpa_round_toward_zero, self)
+    end
+
+    def towards_negative
+      RoundingModeExpr.new(LowLevel.mk_fpa_round_toward_negative, self)
+    end
+
+    def towards_positive
+      RoundingModeExpr.new(LowLevel.mk_fpa_round_toward_positive, self)
+    end
+
+    public_class_method :new
+  end
+end

data/lib/z3/sort/set_sort.rb

@@ -0,0 +1,31 @@
+module Z3
+  class SetSort < Sort
+    attr_reader :element_sort
+    def initialize(element_sort)
+      @element_sort = element_sort
+      super LowLevel.mk_set_sort(element_sort)
+    end
+
+    def expr_class
+      SetExpr
+    end
+
+    def to_s
+      "Set(#{element_sort})"
+    end
+
+    def inspect
+      "SetSort(#{element_sort})"
+    end
+
+    def Empty
+      new(LowLevel.mk_empty_set(self))
+    end
+
+    def Full
+      new(LowLevel.mk_full_set(self))
+    end
+
+    public_class_method :new
+  end
+end

data/lib/z3/sort/sort.rb

@@ -41,7 +41,15 @@ module Z3
     end
 
     def to_s
-      LowLevel.sort_to_string(self)
+      LowLevel.ast_to_string(self)
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      self.class.hash
     end
 
     def inspect
@@ -50,8 +58,8 @@ module Z3
 
     def var(name)
       new(
-        Z3::LowLevel.mk_const(
-          Z3::LowLevel.mk_string_symbol(name),
+        LowLevel.mk_const(
+          LowLevel.mk_string_symbol(name),
           self,
         )
       )
@@ -71,8 +79,20 @@ module Z3
       raise Z3::Exception, "Can't convert #{v.sort} into #{self}"
     end
 
+    def cast(a)
+      if a.is_a?(Expr)
+        if  a.sort == self
+          a
+        else
+          from_value(a)
+        end
+      else
+        from_const(a)
+      end
+    end
+
     def self.from_pointer(_sort)
-      kind = Z3::VeryLowLevel.Z3_get_sort_kind(Z3::LowLevel._ctx_pointer, _sort)
+      kind = VeryLowLevel.Z3_get_sort_kind(LowLevel._ctx_pointer, _sort)
       case kind
       when 1
         BoolSort.new
@@ -81,8 +101,22 @@ module Z3
       when 3
         RealSort.new
       when 4
-        n = Z3::VeryLowLevel.Z3_get_bv_sort_size(Z3::LowLevel._ctx_pointer, _sort)
+        n = VeryLowLevel.Z3_get_bv_sort_size(LowLevel._ctx_pointer, _sort)
         BitvecSort.new(n)
+      when 5
+        domain = from_pointer(VeryLowLevel.Z3_get_array_sort_domain(LowLevel._ctx_pointer, _sort))
+        range = from_pointer(VeryLowLevel.Z3_get_array_sort_range(LowLevel._ctx_pointer, _sort))
+        if range == BoolSort.new
+          SetSort.new(domain)
+        else
+          ArraySort.new(domain, range)
+        end
+      when 9
+        e = VeryLowLevel.Z3_fpa_get_ebits(LowLevel._ctx_pointer, _sort)
+        s = VeryLowLevel.Z3_fpa_get_sbits(LowLevel._ctx_pointer, _sort)
+        FloatSort.new(e, s)
+      when 10
+        RoundingModeSort.new
       else
         raise "Unknown sort kind #{kind}"
       end

data/lib/z3/tactic.rb

@@ -0,0 +1,69 @@
+module Z3
+  class Tactic
+    attr_reader :tactic
+    def initialize(_tactic)
+      @_tactic = _tactic
+    end
+
+    def help
+      LowLevel.tactic_get_help(self)
+    end
+
+    def or_else(other)
+      raise Z3::Exception, "Tactic required" unless other.is_a?(Tactic)
+      Tactic.new LowLevel.tactic_or_else(self, other)
+    end
+
+    def and_then(other)
+      raise Z3::Exception, "Tactic required" unless other.is_a?(Tactic)
+      Tactic.new LowLevel.tactic_and_then(self, other)
+    end
+
+    def parallel_and_then(other)
+      raise Z3::Exception, "Tactic required" unless other.is_a?(Tactic)
+      Tactic.new LowLevel.tactic_par_and_then(self, other)
+    end
+
+    def repeat(num)
+      raise Z3::Exception, "Nonnegative Integer required" unless num.is_a?(Integer) and num >= 0
+      Tactic.new LowLevel.tactic_repeat(self, num)
+    end
+
+    def try_for(time_ms)
+      raise Z3::Exception, "Nonnegative Integer required" unless time_ms.is_a?(Integer) and time_ms >= 0
+      Tactic.new LowLevel.tactic_try_for(self, time_ms)
+    end
+
+    class << self
+      def fail
+        new LowLevel.tactic_fail
+      end
+
+      def fail_if(probe)
+        raise Z3::Exception, "Prope required" unless probe.is_a?(Probe)
+        new LowLevel.tactic_fail_if(probe)
+      end
+
+      def fail_if_not_decided
+        new LowLevel.tactic_fail_if_not_decided
+      end
+
+      def skip
+        new LowLevel.tactic_skip
+      end
+
+      def when(probe, tactic)
+        raise Z3::Exception, "Prope required" unless probe.is_a?(Probe)
+        raise Z3::Exception, "Tactic required" unless tactic.is_a?(Tactic)
+        new LowLevel.tactic_when(probe, tactic)
+      end
+
+      def cond(probe, tactic1, tactic2)
+        raise Z3::Exception, "Prope required" unless probe.is_a?(Probe)
+        raise Z3::Exception, "Tactic required" unless tactic1.is_a?(Tactic)
+        raise Z3::Exception, "Tactic required" unless tactic2.is_a?(Tactic)
+        new LowLevel.tactic_cond(probe, tactic1, tactic2)
+      end
+    end
+  end
+end