z3 0.0.20180624 → 0.0.20180629

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c5b58b092ac3d83d29341b7286e74068497c6f3e59232b8b0e23373a5e2e4eb
-  data.tar.gz: 5dfef87be452768052ece356eb0cd52f0725556769937d0030b1403a9422946e
+  metadata.gz: 9b62645ba88a89cc0c81a5f2088f4b919953d778d99f52af3798cd6b9f130e61
+  data.tar.gz: 97269d402d845d9192c558c271c2448cdc420d3c93d6bf2f3e2afb0238b039cc
 SHA512:
-  metadata.gz: 209cd2c1ced0b55bfad330f725b296075b14651af5d7faee5e236e920a9c48d8e65db30a7b31aabc0b4744aca2389aae8ea5db78815e9fbde5c8f9e379fba091
-  data.tar.gz: 43d4e8ec32e9a3eb433ea6a73b9e713ccd75182be3702be42ee2f60592a1c61a5a56ba0c0aca3711477fa7d6d5dfe85e21b5922701b38bdbef2882ce57569d71
+  metadata.gz: 2bc073a01310b704b5e64d5d6bd26f31b1b061e38f9d9edb3a0fed0e2e2db2989fbac863c35c7213d5f81ba0a74ec2d95c16c440ad8d0550d5ce842d1b843c64
+  data.tar.gz: 390f2516225de2bf7887ed42597587e53f3ec0c3ebe89d85c2aa43c54717e4dee3cb485c5d62199c94467866c776491de4ea758fec6f1b80f32689b577da7cb7

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/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)

data/lib/z3/sort/bitvec_sort.rb

@@ -1,6 +1,7 @@
 module Z3
   class BitvecSort < Sort
     def initialize(n)
+      raise Z3::Exception, "Bitvec width must be positive" unless n >= 1
       super LowLevel.mk_bv_sort(n)
     end
 

data/lib/z3/sort/sort.rb

@@ -57,12 +57,16 @@ module Z3
     end
 
     def var(name)
-      new(
-        LowLevel.mk_const(
-          LowLevel.mk_string_symbol(name),
-          self,
+      if name.is_a?(Enumerable)
+        name.map{|v| var(v)}
+      else
+        new(
+          LowLevel.mk_const(
+            LowLevel.mk_string_symbol(name),
+            self,
+          )
         )
-      )
+      end
     end
 
     # We pretend to be a class, sort of

data/spec/bitvec_expr_spec.rb

@@ -4,6 +4,7 @@ module Z3
     let(:b) { Z3.Bitvec("b", 8) }
     let(:c) { Z3.Bitvec("c", 8) }
     let(:d) { Z3.Bitvec("d", 12) }
+    let(:e) { Z3.Bitvec("e", 4) }
     let(:x) { Z3.Bool("x") }
 
     it "==" do
@@ -168,28 +169,28 @@ module Z3
       expect([a ==   127, b ==  1, x == a.signed_div_no_overflow?(b)]).to have_solution(x => true)
     end
 
-    ## This API is broken, z3 returns unevaluated bvsmul_noovfl(10, 10) instead of actual answer
-
-    # it "signed_mul_no_overflow?" do
-    #   expect([a ==   10, b ==   10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => true)
-    #   expect([a ==   20, b ==   10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
-    #   expect([a ==   20, b ==   20, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
-    #   expect([a ==  -10, b ==  -10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => true)
-    # end
-    #
-    # it "unsigned_mul_no_overflow?" do
-    #   expect([a ==   10, b ==   10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => true)
-    #   expect([a ==   20, b ==   10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => true)
-    #   expect([a ==   20, b ==   20, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => false)
-    #   expect([a ==  -10, b ==  -10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => false)
-    # end
-    #
+    it "signed_mul_no_overflow?" do
+      expect([a ==   10, b ==   10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => true)
+      expect([a ==   20, b ==   10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
+      expect([a ==   20, b ==   20, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
+      expect([a ==   10, b ==  -10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
+      expect([a ==  -10, b ==   10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
+      expect([a ==  -10, b ==  -10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
+    end
+
+    it "unsigned_mul_no_overflow?" do
+      expect([a ==   10, b ==   10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => true)
+      expect([a ==   20, b ==   10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => true)
+      expect([a ==   20, b ==   20, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => false)
+      expect([a ==  -10, b ==  -10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => false)
+    end
+
     # # Inherently signed, unsigned can't underflow
-    # it "signed_mul_no_underflow?" do
-    #   expect([a ==  -10, b ==  -10, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => true)
-    #   expect([a ==  -20, b ==  -20, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => true)
-    #   expect([a ==  -20, b ==   20, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => false)
-    # end
+    it "signed_mul_no_underflow?" do
+      expect([a ==  -10, b ==  -10, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => true)
+      expect([a ==  -20, b ==  -20, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => true)
+      expect([a ==  -20, b ==   20, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => false)
+    end
 
     it "zero_ext / sign_ext" do
       expect([a ==  100, d ==  a.zero_ext(4)]).to have_solution(d => 100)
@@ -204,5 +205,18 @@ module Z3
       expect([a == 0b0101_0110, b == a.rotate_right(1)]).to have_solution(b => 0b0_0101_011)
       expect([a == 0b0101_0110, b == a.rotate_right(4)]).to have_solution(b => 0b0110_0101)
     end
+
+    it "extract" do
+      expect([a == 0b0101_0110, e == a.extract(3, 0)]).to have_solution(e => 0b0110)
+      expect([a == 0b0101_0110, e == a.extract(7, 4)]).to have_solution(e => 0b0101)
+      expect{ a.extract(8, 4) }.to raise_error(Z3::Exception)
+      expect{ a.extract(2, 3) }.to raise_error(Z3::Exception)
+      expect{ a.extract(2, -1) }.to raise_error(Z3::Exception)
+    end
+
+    it "concat" do
+      expect([a == 0b0101_0110, e == 0b1101, d == a.concat(e)]).to have_solution(d => 0b0101_0110_1101)
+      expect([a == 0b0101_0110, e == 0b1101, d == e.concat(a)]).to have_solution(d => 0b1101_0101_0110)
+    end
   end
 end

data/spec/bitvec_sort_spec.rb

@@ -32,5 +32,9 @@ module Z3
       expect(Z3.Bitvec("a", 8).inspect).to eq("Bitvec(8)<a>")
       expect(Z3.Bitvec("a", 32).inspect).to eq("Bitvec(32)<a>")
     end
+
+    it "number of bits must be positive" do
+      expect{ Z3.Bitvec("a", 0) }.to raise_error(Z3::Exception)
+    end
   end
 end

data/spec/interface_spec.rb

@@ -0,0 +1,18 @@
+module Z3
+  describe "interface" do
+    it "single variables" do
+      expect(Z3.Bool("a")).to be_same_as(Z3::BoolSort.new.var("a"))
+      expect(Z3.Int("b")).to be_same_as(Z3::IntSort.new.var("b"))
+      expect(Z3.Real("c")).to be_same_as(Z3::RealSort.new.var("c"))
+      expect(Z3.Bitvec("d", 32)).to be_same_as(Z3::BitvecSort.new(32).var("d"))
+    end
+
+    it "multiple variables" do
+      expect(Z3.Int(%W[x y z])).to be_same_as([
+        Z3::IntSort.new.var("x"),
+        Z3::IntSort.new.var("y"),
+        Z3::IntSort.new.var("z"),
+      ])
+    end
+  end
+end

data/spec/printer_spec.rb

@@ -49,5 +49,35 @@ module Z3
         expect((-a) + (-b)).to stringify("(-a) + (-b)")
       end
     end
+
+    describe "bitvector operations" do
+      let(:a) { Z3.Bitvec("a", 32) }
+      let(:b) { Z3.Bitvec("b", 32) }
+
+      it "unary operators" do
+        expect(~a).to stringify("~a")
+        expect(-a).to stringify("-a")
+      end
+
+      it "binary operators" do
+        expect(a + b).to stringify("a + b")
+        expect(a - b).to stringify("a - b")
+        expect(a & b).to stringify("a & b")
+        expect(a ^ b).to stringify("a ^ b")
+        expect(a | b).to stringify("a | b")
+      end
+
+      it "special operators" do
+        expect(a.rotate_left(3)).to stringify("rotate_left(a, 3)")
+        expect(a.rotate_right(4)).to stringify("rotate_right(a, 4)")
+        expect(a.unsigned_lshift(5)).to stringify("bvshl(a, 5)")
+        expect(a.signed_rshift(6)).to stringify("bvashr(a, 6)")
+        expect(a.unsigned_lshift(7)).to stringify("bvshl(a, 7)")
+        expect(a.extract(20, 5)).to stringify("extract(a, 20, 5)")
+        expect(a.zero_ext(4)).to stringify("zero_extend(a, 4)")
+        expect(a.sign_ext(4)).to stringify("sign_extend(a, 4)")
+        expect(a.concat(b)).to stringify("concat(a, b)")
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: z3
 version: !ruby/object:Gem::Version
-  version: 0.0.20180624
+  version: 0.0.20180629
 platform: ruby
 authors:
 - Tomasz Wegrzanowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-24 00:00:00.000000000 Z
+date: 2018-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -232,6 +232,7 @@ files:
 - spec/integration/sudoku_spec.rb
 - spec/integration/verbal_arithmetic_spec.rb
 - spec/integration/zebra_puzzle_spec.rb
+- spec/interface_spec.rb
 - spec/model_spec.rb
 - spec/optimize_spec.rb
 - spec/printer_spec.rb