z3 0.0.20160330 → 0.0.20160427

data/lib/z3/model.rb

@@ -11,7 +11,9 @@ class Z3::Model
   end
 
   def consts
-    (0...num_consts).map{|i| Z3::FuncDecl.new(Z3::LowLevel.model_get_const_decl(self, i)) }
+    (0...num_consts).map do |i|
+      Z3::FuncDecl.new(Z3::LowLevel.model_get_const_decl(self, i))
+    end
   end
 
   def num_sorts
@@ -23,7 +25,7 @@ class Z3::Model
   end
 
   def model_eval(ast, model_completion=false)
-    Z3::Value.new_from_pointer(Z3::LowLevel.model_eval(self, ast, model_completion))
+    Z3::Expr.new_from_pointer(Z3::LowLevel.model_eval(self, ast, model_completion))
   end
 
   def [](ast)
@@ -40,10 +42,9 @@ class Z3::Model
 
   def each
     consts.sort_by(&:name).each do |c|
-      _ast = Z3::LowLevel.model_get_const_interp(self, c)
       yield(
-        c.name,
-        Z3::Value.new_from_pointer(_ast)
+        c.range.var(c.name),
+        Z3::Expr.new_from_pointer(Z3::LowLevel.model_get_const_interp(self, c))
       )
     end
   end

data/lib/z3/printer.rb

@@ -0,0 +1,26 @@
+module Z3
+  class Printer
+    def format(a)
+      case a.ast_kind
+      when :numeral
+        format_numeral(a)
+      when :app
+        a.sexpr
+      when :var
+        a.sexpr
+      when :quantifier
+        a.sexpr
+      when :func_decl
+        a.sexpr
+      when :unknown
+        a.sexpr
+      else
+        raise Z3::Exception, "Unknown AST kind #{a.ast_kind}"
+      end
+    end
+
+    def format_numeral(a)
+      Z3::LowLevel.get_numeral_string(a)
+    end
+  end
+end

data/lib/z3/solver.rb

@@ -34,11 +34,7 @@ module Z3
 
     def assertions
       _ast_vector = Z3::LowLevel.solver_get_assertions(self)
-      n = Z3::VeryLowLevel.Z3_ast_vector_size(Z3::LowLevel._ctx_pointer, _ast_vector)
-      (0...n).map{|i|
-        _ast = Z3::VeryLowLevel.Z3_ast_vector_get(Z3::LowLevel._ctx_pointer, _ast_vector, i)
-        Z3::Value.new_from_pointer(_ast)
-      }
+      Z3::LowLevel.unpack_ast_vector(_ast_vector)
     end
 
     def prove!(ast)

data/lib/z3/sort/bitvec_sort.rb

@@ -4,12 +4,12 @@ module Z3
       super LowLevel.mk_bv_sort(n)
     end
 
-    def value_class
-      BitvecValue
+    def expr_class
+      BitvecExpr
     end
 
     def from_const(val)
-      if val.is_a?(Integer) or val.is_a?(Float)
+      if val.is_a?(Integer)
         new LowLevel.mk_numeral(val.to_s, self)
       else
         raise Z3::Exception, "Cannot convert #{val.class} to #{self.class}"

data/lib/z3/sort/bool_sort.rb

@@ -4,15 +4,15 @@ module Z3
       super LowLevel.mk_bool_sort
     end
 
-    def value_class
-      BoolValue
+    def expr_class
+      BoolExpr
     end
 
     def from_const(val)
       if val == true
-        BoolValue.new(LowLevel.mk_true, self)
+        BoolExpr.new(LowLevel.mk_true, self)
       elsif val == false
-        BoolValue.new(LowLevel.mk_false, self)
+        BoolExpr.new(LowLevel.mk_false, self)
       else
         raise Z3::Exception, "Cannot convert #{val.class} to #{self.class}"
       end

data/lib/z3/sort/int_sort.rb

@@ -4,8 +4,8 @@ module Z3
       super LowLevel.mk_int_sort
     end
 
-    def value_class
-      IntValue
+    def expr_class
+      IntExpr
     end
 
     def from_const(val)

data/lib/z3/sort/real_sort.rb

@@ -4,12 +4,12 @@ module Z3
       super LowLevel.mk_real_sort
     end
 
-    def value_class
-      RealValue
+    def expr_class
+      RealExpr
     end
 
     def from_const(val)
-      if val.is_a?(Integer) or val.is_a?(Float)
+      if val.is_a?(Integer) or (val.is_a?(Float) and val.finite?)
         new LowLevel.mk_numeral(val.to_s, self)
       else
         raise Z3::Exception, "Cannot convert #{val.class} to #{self.class}"
@@ -17,9 +17,9 @@ module Z3
     end
 
     def from_value(val)
-      if val.is_a?(IntValue)
+      if val.is_a?(IntExpr)
         new LowLevel.mk_int2real(val)
-      elsif val.is_a?(RealValue)
+      elsif val.is_a?(RealExpr)
         val
       else
         raise Z3::Exception, "Cannot convert #{val.class} to #{self.class}"

data/lib/z3/sort/sort.rb

@@ -1,13 +1,13 @@
 module Z3
-  class Sort
-    attr_reader :_sort
-    def initialize(_sort)
-      @_sort = _sort
+  class Sort < AST
+    def initialize(_ast)
+      super(_ast)
+      raise Z3::Exception, "Sorts must have AST kind sort" unless ast_kind == :sort
     end
 
     include Comparable
     def ==(other)
-      other.is_a?(Sort) and @_sort == other._sort
+      other.is_a?(Sort) and @_ast == other._ast
     end
 
     def >(other)
@@ -59,7 +59,7 @@ module Z3
 
     # We pretend to be a class, sort of
     def new(_ast)
-      value_class.new(_ast, self)
+      expr_class.new(_ast, self)
     end
 
     def value_class
@@ -71,6 +71,21 @@ module Z3
       raise Z3::Exception, "Can't convert #{v.sort} into #{self}"
     end
 
-    private_class_method :new
+    def self.from_pointer(_sort)
+      kind = Z3::VeryLowLevel.Z3_get_sort_kind(Z3::LowLevel._ctx_pointer, _sort)
+      case kind
+      when 1
+        BoolSort.new
+      when 2
+        IntSort.new
+      when 3
+        RealSort.new
+      when 4
+        n = Z3::VeryLowLevel.Z3_get_bv_sort_size(Z3::LowLevel._ctx_pointer, _sort)
+        BitvecSort.new(n)
+      else
+        raise "Unknown sort kind #{kind}"
+      end
+    end
   end
 end

data/lib/z3/very_low_level.rb

@@ -29,7 +29,7 @@ module Z3::VeryLowLevel
   callback :error_handler, [:pointer, :int], :void
   attach_function :Z3_get_version, [:pointer, :pointer, :pointer, :pointer], :void
   attach_function :Z3_set_error_handler, [:ctx_pointer, :error_handler], :void
-  attach_function :Z3_mk_context, [], :ctx_pointer
+  attach_function :Z3_mk_context, [:config_pointer], :ctx_pointer
   attach_function :Z3_model_eval, [:ctx_pointer, :model_pointer, :ast_pointer, :bool, :pointer], :int
   attach_function :Z3_mk_and, [:ctx_pointer, :int, :pointer], :ast_pointer
   attach_function :Z3_mk_or, [:ctx_pointer, :int, :pointer], :ast_pointer

data/spec/bitvec_expr_spec.rb

@@ -0,0 +1,55 @@
+describe Z3::BitvecExpr do
+  let(:a) { Z3::Bitvec("a", 8) }
+  let(:b) { Z3::Bitvec("b", 8) }
+  let(:c) { Z3::Bitvec("c", 8) }
+  let(:x) { Z3::Bool("x") }
+
+  it "==" do
+    expect([a == 2, b == -254, x == (a == b)]).to have_solution(x => true)
+    expect([a == 2, b == 2, x == (a == b)]).to have_solution(x => true)
+    expect([a == 2, b == 3, x == (a == b)]).to have_solution(x => false)
+  end
+
+  it "!=" do
+    expect([a == 2, b == -254, x == (a != b)]).to have_solution(x => false)
+    expect([a == 2, b == 2, x == (a != b)]).to have_solution(x => false)
+    expect([a == 2, b == 3, x == (a != b)]).to have_solution(x => true)
+  end
+
+  it "+" do
+    expect([a == 2, b == 40, c == (a + b)]).to have_solution(c => 42)
+    expect([a == 200, b == 40, c == (a + b)]).to have_solution(c => 240)
+    expect([a == -1, b == -1, c == (a + b)]).to have_solution(c => 254)
+  end
+
+  it "-" do
+    expect([a == 50, b == 8, c == (a - b)]).to have_solution(c => 42)
+    expect([a == 200, b == 40, c == (a - b)]).to have_solution(c => 160)
+    expect([a == 40, b == 200, c == (a - b)]).to have_solution(c => 96)
+  end
+
+  it "*" do
+    expect([a == 3, b == 40, c == (a * b)]).to have_solution(c => 120)
+    expect([a == 30, b == 42, c == (a * b)]).to have_solution(c => 236)
+  end
+
+  it "&" do
+    expect([a == 50, b == 27, c == (a & b)]).to have_solution(c => 18)
+  end
+
+  it "|" do
+    expect([a == 50, b == 27, c == (a | b)]).to have_solution(c => 59)
+  end
+
+  it "^" do
+    expect([a == 50, b == 27, c == (a ^ b)]).to have_solution(c => 41)
+  end
+
+  it "unary -" do
+    expect([a == 50, b == -a]).to have_solution(b => 206)
+  end
+
+  it "~" do
+    expect([a == 50, b == ~a]).to have_solution(b => 205)
+  end
+end

data/spec/bitvec_sort_spec.rb

@@ -0,0 +1,34 @@
+describe Z3::BitvecSort do
+  let(:bv3) { Z3::BitvecSort.new(3) }
+  let(:bv8) { Z3::BitvecSort.new(8) }
+  let(:bv32) { Z3::BitvecSort.new(32) }
+
+  it "can instantiate constants - 32 bit" do
+    expect(bv32.from_const(0).inspect).to eq("Bitvec(32)<0>")
+    expect(bv32.from_const(42).inspect).to eq("Bitvec(32)<42>")
+    expect(bv32.from_const(0x1234_5678_9abc).inspect).to eq("Bitvec(32)<1450744508>")
+    expect(bv32.from_const(-0x1234_5678_9abc).inspect).to eq("Bitvec(32)<2844222788>")
+  end
+
+  it "can instantiate constants - 8 bit" do
+    expect(bv8.from_const(0).inspect).to eq("Bitvec(8)<0>")
+    expect(bv8.from_const(42).inspect).to eq("Bitvec(8)<42>")
+    expect(bv8.from_const(0x1234_5678_9abc).inspect).to eq("Bitvec(8)<188>")
+    expect(bv8.from_const(-0x1234_5678_9abc).inspect).to eq("Bitvec(8)<68>")
+  end
+
+  it "can instantiate constants - 3 bit" do
+    expect(bv3.from_const(-1).inspect).to eq("Bitvec(3)<7>")
+  end
+
+  it "raisesbv32 exception when trying to convert constants of wrong type" do
+    expect{ bv32.from_const(true) }.to raise_error(Z3::Exception)
+    expect{ bv32.from_const(false) }.to raise_error(Z3::Exception)
+    expect{ bv32.from_const(0.0) }.to raise_error(Z3::Exception)
+  end
+
+  it "can instantiate variables" do
+    expect(Z3.Bitvec("a", 8).inspect).to eq("Bitvec(8)<a>")
+    expect(Z3.Bitvec("a", 32).inspect).to eq("Bitvec(32)<a>")
+  end
+end

data/spec/bool_expr_spec.rb

@@ -0,0 +1,65 @@
+describe Z3::BoolExpr do
+  let(:a) { Z3::Bool("a") }
+  let(:b) { Z3::Bool("b") }
+  let(:c) { Z3::Bool("c") }
+  let(:x) { Z3::Int("x") }
+
+  it "&" do
+    expect([a ==  true, b ==  true, c == (a & b)]).to have_solution(c =>  true)
+    expect([a ==  true, b == false, c == (a & b)]).to have_solution(c => false)
+    expect([a == false, b ==  true, c == (a & b)]).to have_solution(c => false)
+    expect([a == false, b == false, c == (a & b)]).to have_solution(c => false)
+  end
+
+  it "|" do
+    expect([a ==  true, b ==  true, c == (a | b)]).to have_solution(c =>  true)
+    expect([a ==  true, b == false, c == (a | b)]).to have_solution(c =>  true)
+    expect([a == false, b ==  true, c == (a | b)]).to have_solution(c =>  true)
+    expect([a == false, b == false, c == (a | b)]).to have_solution(c => false)
+  end
+
+  it "^" do
+    expect([a ==  true, b ==  true, c == (a ^ b)]).to have_solution(c => false)
+    expect([a ==  true, b == false, c == (a ^ b)]).to have_solution(c =>  true)
+    expect([a == false, b ==  true, c == (a ^ b)]).to have_solution(c =>  true)
+    expect([a == false, b == false, c == (a ^ b)]).to have_solution(c => false)
+  end
+
+  it "!=" do
+    expect([a ==  true, b ==  true, c == (a != b)]).to have_solution(c => false)
+    expect([a ==  true, b == false, c == (a != b)]).to have_solution(c =>  true)
+    expect([a == false, b ==  true, c == (a != b)]).to have_solution(c =>  true)
+    expect([a == false, b == false, c == (a != b)]).to have_solution(c => false)
+  end
+
+  it "implies" do
+    expect([a ==  true, b ==  true, c == a.implies(b)]).to have_solution(c =>  true)
+    expect([a ==  true, b == false, c == a.implies(b)]).to have_solution(c => false)
+    expect([a == false, b ==  true, c == a.implies(b)]).to have_solution(c =>  true)
+    expect([a == false, b == false, c == a.implies(b)]).to have_solution(c =>  true)
+  end
+
+  it "iff" do
+    expect([a ==  true, b ==  true, c == a.iff(b)]).to have_solution(c =>  true)
+    expect([a ==  true, b == false, c == a.iff(b)]).to have_solution(c => false)
+    expect([a == false, b ==  true, c == a.iff(b)]).to have_solution(c => false)
+    expect([a == false, b == false, c == a.iff(b)]).to have_solution(c =>  true)
+  end
+
+  it "==" do
+    expect([a ==  true, b ==  true, c == (a == b)]).to have_solution(c =>  true)
+    expect([a ==  true, b == false, c == (a == b)]).to have_solution(c => false)
+    expect([a == false, b ==  true, c == (a == b)]).to have_solution(c => false)
+    expect([a == false, b == false, c == (a == b)]).to have_solution(c =>  true)
+  end
+
+  it "~" do
+    expect([a ==  true, b == ~a]).to have_solution(b => false)
+    expect([a == false, b == ~a]).to have_solution(b =>  true)
+   end
+
+   it "if then else" do
+     expect([a ==  true, x == a.ite(2, 3)]).to have_solution(x => 2)
+     expect([a == false, x == a.ite(2, 3)]).to have_solution(x => 3)
+   end
+end

data/spec/bool_sort_spec.rb

@@ -0,0 +1,20 @@
+describe Z3::BoolSort do
+  it "can instantiate constants" do
+    expect(subject.from_const(true).inspect).to eq("Bool<true>")
+    expect(subject.from_const(false).inspect).to eq("Bool<false>")
+  end
+
+  it "raises exception when trying to convert constants of wrong type" do
+    expect{ subject.from_const(0) }.to raise_error(Z3::Exception)
+    expect{ subject.from_const(0.0) }.to raise_error(Z3::Exception)
+  end
+
+  it "interface constructors" do
+    expect(Z3.True.inspect).to eq("Bool<true>")
+    expect(Z3.False.inspect).to eq("Bool<false>")
+  end
+
+  it "can instantiate variables" do
+    expect(Z3.Bool("a").inspect).to eq("Bool<a>")
+  end
+end

data/spec/{value_spec.rb → expr_spec.rb}

@@ -1,4 +1,4 @@
-describe Z3::Value do
+describe Z3::Expr do
   let(:a) { Z3.Int("a") }
   let(:b) { Z3.Int("b") }
   let(:c) { Z3.Bool("c") }
@@ -17,8 +17,8 @@ describe Z3::Value do
   end
 
   it "#inspect" do
-    expect(a.inspect).to eq("Value<a :: Int>")
-    expect((e+f).inspect).to eq("Value<(+ e f) :: Real>")
+    expect(a.inspect).to eq("Int<a>")
+    expect((e+f).inspect).to eq("Real<(+ e f)>")
   end
 
   describe "#~" do

data/spec/int_expr_spec.rb

@@ -0,0 +1,78 @@
+describe Z3::IntExpr do
+  let(:a) { Z3::Int("a") }
+  let(:b) { Z3::Int("b") }
+  let(:c) { Z3::Int("c") }
+  let(:x) { Z3::Bool("x") }
+
+  it "+" do
+    expect([a == 2, b == 4, c == a + b]).to have_solution(c => 6)
+  end
+
+  it "-" do
+    expect([a == 2, b == 4, c == a - b]).to have_solution(c => -2)
+  end
+
+  it "*" do
+    expect([a == 2, b == 4, c == a * b]).to have_solution(c => 8)
+  end
+
+  it "/" do
+    expect([a ==  10, b ==  3, c == a / b]).to have_solution(c =>  3)
+    expect([a == -10, b ==  3, c == a / b]).to have_solution(c => -4)
+    expect([a ==  10, b == -3, c == a / b]).to have_solution(c => -3)
+    expect([a == -10, b == -3, c == a / b]).to have_solution(c =>  4)
+  end
+
+  # Can't say these make much sense, but let's document what Z3 actually does
+  it "rem" do
+    expect([a ==  10, b ==  3, c == a.rem(b)]).to have_solution(c => 10 -  3 *  3)
+    expect([a == -10, b ==  3, c == a.rem(b)]).to have_solution(c =>-10 -  3 * -4)
+    expect([a ==  10, b == -3, c == a.rem(b)]).to have_solution(c =>-( 10 - -3 * -3))
+    expect([a == -10, b == -3, c == a.rem(b)]).to have_solution(c =>-(-10 - -3 *  4))
+  end
+
+  it "mod" do
+    expect([a ==  10, b ==  3, c == a.mod(b)]).to have_solution(c => 1)
+    expect([a ==  10, b == -3, c == a.mod(b)]).to have_solution(c => 1)
+    expect([a == -10, b ==  3, c == a.mod(b)]).to have_solution(c => 2)
+    expect([a == -10, b == -3, c == a.mod(b)]).to have_solution(c => 2)
+  end
+
+  it "==" do
+    expect([a == 2, b == 2, x == (a == b)]).to have_solution(x => true)
+    expect([a == 2, b == 3, x == (a == b)]).to have_solution(x => false)
+  end
+
+  it "!=" do
+    expect([a == 2, b == 2, x == (a != b)]).to have_solution(x => false)
+    expect([a == 2, b == 3, x == (a != b)]).to have_solution(x => true)
+  end
+
+  it ">" do
+    expect([a == 3, b == 2, x == (a > b)]).to have_solution(x => true)
+    expect([a == 2, b == 2, x == (a > b)]).to have_solution(x => false)
+    expect([a == 1, b == 2, x == (a > b)]).to have_solution(x => false)
+  end
+
+  it ">=" do
+    expect([a == 3, b == 2, x == (a >= b)]).to have_solution(x => true)
+    expect([a == 2, b == 2, x == (a >= b)]).to have_solution(x => true)
+    expect([a == 1, b == 2, x == (a >= b)]).to have_solution(x => false)
+  end
+
+  it "<" do
+    expect([a == 3, b == 2, x == (a < b)]).to have_solution(x => false)
+    expect([a == 2, b == 2, x == (a < b)]).to have_solution(x => false)
+    expect([a == 1, b == 2, x == (a < b)]).to have_solution(x => true)
+  end
+
+  it "<=" do
+    expect([a == 3, b == 2, x == (a <= b)]).to have_solution(x => false)
+    expect([a == 2, b == 2, x == (a <= b)]).to have_solution(x => true)
+    expect([a == 1, b == 2, x == (a <= b)]).to have_solution(x => true)
+  end
+
+  it "**" do
+    expect([a == 3, b == 4, c == (a ** b)]).to have_solution(c => 81)
+  end
+end