z3 0.0.20180616 → 0.0.20180624

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1a008f1afd884efa0e1dc6e9964e9f0be381bd77884a2526a07bff5efe64212
-  data.tar.gz: d9379bd2084cb2e5222856da043d58e8ddd399cd86abdce01f0243464e2c6097
+  metadata.gz: 4c5b58b092ac3d83d29341b7286e74068497c6f3e59232b8b0e23373a5e2e4eb
+  data.tar.gz: 5dfef87be452768052ece356eb0cd52f0725556769937d0030b1403a9422946e
 SHA512:
-  metadata.gz: 27b7f713bedcbe819207d9d120d081366a274d9f61c952625e7256d3c5f7d177ba6de6d55f31971c06e084fcefa80c52004cd271d7dc7163753daf61e156edcc
-  data.tar.gz: a6f97e4b4916e5189a94bc439bc174342dae679fec6a246ac1a4c6c4245d7355b619cf922515913e41f5d9070b719c0a562ca9682d4d37fcbe6b1d6959c0033b
+  metadata.gz: 209cd2c1ced0b55bfad330f725b296075b14651af5d7faee5e236e920a9c48d8e65db30a7b31aabc0b4744aca2389aae8ea5db78815e9fbde5c8f9e379fba091
+  data.tar.gz: 43d4e8ec32e9a3eb433ea6a73b9e713ccd75182be3702be42ee2f60592a1c61a5a56ba0c0aca3711477fa7d6d5dfe85e21b5922701b38bdbef2882ce57569d71

data/lib/z3/hacks.rb

@@ -0,0 +1,92 @@
+# This is going to slow down ruby, but the alternative is very inconsistent API
+module EqualityHacks
+  def ==(other)
+    if other.is_a?(Z3::Expr)
+      return other == self
+    end
+    super
+  end
+
+  def !=(other)
+    if other.is_a?(Z3::Expr)
+      return other != self
+    end
+    super
+  end
+end
+
+module CompareHacks
+  def ==(other)
+    if other.is_a?(Z3::Expr)
+      raise ArgumentError.new unless other.respond_to?(:coerce)
+      a, b = other.coerce(self)
+      return a == b
+    end
+    super
+  end
+
+  def !=(other)
+    if other.is_a?(Z3::Expr)
+      raise ArgumentError.new unless other.respond_to?(:coerce)
+      a, b = other.coerce(self)
+      return a != b
+    end
+    super
+  end
+
+  def >=(other)
+    if other.is_a?(Z3::Expr)
+      raise ArgumentError.new unless other.respond_to?(:coerce)
+      a, b = other.coerce(self)
+      return a >= b
+    end
+    super
+  end
+
+  def >(other)
+    if other.is_a?(Z3::Expr)
+      raise ArgumentError.new unless other.respond_to?(:coerce)
+      a, b = other.coerce(self)
+      return a > b
+    end
+    super
+  end
+
+  def <=(other)
+    if other.is_a?(Z3::Expr)
+      raise ArgumentError.new unless other.respond_to?(:coerce)
+      a, b = other.coerce(self)
+      return a <= b
+    end
+    super
+  end
+
+  def <(other)
+    if other.is_a?(Z3::Expr)
+      raise ArgumentError.new unless other.respond_to?(:coerce)
+      a, b = other.coerce(self)
+      return a < b
+    end
+    super
+  end
+end
+
+class TrueClass
+  prepend EqualityHacks
+end
+
+class FalseClass
+  prepend EqualityHacks
+end
+
+class Rational
+  prepend CompareHacks
+end
+
+class Integer
+  prepend CompareHacks
+end
+
+class Float
+  prepend CompareHacks
+end

data/lib/z3/low_level.rb

@@ -23,7 +23,7 @@ module Z3
 
       def model_eval(model, ast, model_completion)
         rv_ptr = FFI::MemoryPointer.new(:pointer)
-        result = Z3::VeryLowLevel.Z3_model_eval(_ctx_pointer, model._model, ast._ast, !!model_completion, rv_ptr)
+        result = Z3::VeryLowLevel.Z3_model_eval(_ctx_pointer, model._model, ast._ast, !!model_completion, rv_ptr) & 0xFF
         if result == 1
           rv_ptr.get_pointer(0)
         else

data/lib/z3.rb

@@ -49,3 +49,6 @@ require_relative "z3/interface"
 
 # Printer
 require_relative "z3/printer"
+
+# Hacks
+require_relative "z3/hacks"

data/spec/expr_spec.rb

@@ -68,21 +68,25 @@ module Z3
     %W[+ - * <= < >= >].each do |op|
       describe "#{op} arithmetic operator" do
         it "allows + of int or real variables" do
-          expect((a.send op, b).sexpr).to eq "(#{op} a b)"
-          expect((e.send op, f).sexpr).to eq "(#{op} e f)"
+          expect(a.send(op, b).sexpr).to eq "(#{op} a b)"
+          expect(e.send(op, f).sexpr).to eq "(#{op} e f)"
         end
 
         it "casts to correct type if possible" do
-          expect((a.send op, e).sexpr).to eq "(#{op} (to_real a) e)"
-          expect((e.send op, a).sexpr).to eq "(#{op} e (to_real a))"
-          expect((a.send op, 42).sexpr).to eq "(#{op} a 42)"
-          expect((42.send op, a).sexpr).to eq "(#{op} 42 a)"
-          expect((a.send op, 42.5).sexpr).to eq "(#{op} (to_real a) (/ 85.0 2.0))"
-          expect((42.5.send op, a).sexpr).to eq "(#{op} (/ 85.0 2.0) (to_real a))"
-          expect((e.send op, 42).sexpr).to eq "(#{op} e 42.0)"
-          expect((42.send op, e).sexpr).to eq "(#{op} 42.0 e)"
-          expect((e.send op, 42.5).sexpr).to eq "(#{op} e (/ 85.0 2.0))"
-          expect((42.5.send op, e).sexpr).to eq "(#{op} (/ 85.0 2.0) e)"
+          expect(a.send(op, e).sexpr).to eq "(#{op} (to_real a) e)"
+          expect(e.send(op, a).sexpr).to eq "(#{op} e (to_real a))"
+          expect(a.send(op, 42).sexpr).to eq "(#{op} a 42)"
+          expect(42.send(op, a).sexpr).to eq "(#{op} 42 a)"
+          expect(a.send(op, 42.5).sexpr).to eq "(#{op} (to_real a) (/ 85.0 2.0))"
+          expect(42.5.send(op, a).sexpr).to eq "(#{op} (/ 85.0 2.0) (to_real a))"
+          expect(a.send(op, Rational(19, 7)).sexpr).to eq "(#{op} (to_real a) (/ 19.0 7.0))"
+          expect(Rational(19, 7).send(op, a).sexpr).to eq "(#{op} (/ 19.0 7.0) (to_real a))"
+          expect(e.send(op, 42).sexpr).to eq "(#{op} e 42.0)"
+          expect(42.send(op, e).sexpr).to eq "(#{op} 42.0 e)"
+          expect(e.send(op, 42.5).sexpr).to eq "(#{op} e (/ 85.0 2.0))"
+          expect(42.5.send(op, e).sexpr).to eq "(#{op} (/ 85.0 2.0) e)"
+          expect(e.send(op, Rational(19, 7)).sexpr).to eq "(#{op} e (/ 19.0 7.0))"
+          expect(Rational(19, 7).send(op, e).sexpr).to eq "(#{op} (/ 19.0 7.0) e)"
         end
 
         it "raises exception if type cast is not possible" do
@@ -113,18 +117,19 @@ module Z3
 
       it "casts to correct type if possible" do
         expect((a == 42).sexpr).to eq "(= a 42)"
-        # https://bugs.ruby-lang.org/issues/14437
-        #expect((42 == a).sexpr).to eq "(= a 42)"
+        expect((42 == a).sexpr).to eq "(= 42 a)"
         expect((a == e).sexpr).to eq "(= (to_real a) e)"
         expect((e == a).sexpr).to eq "(= e (to_real a))"
         expect((c == true).sexpr).to eq "(= c true)"
         expect((c == false).sexpr).to eq "(= c false)"
         expect((a == 42.5).sexpr).to eq "(= (to_real a) (/ 85.0 2.0))"
-        # expect((42.5 == a).sexpr).to eq "(= (to_real a) (/ 85.0 2.0))"
+        expect((42.5 == a).sexpr).to eq "(= (/ 85.0 2.0) (to_real a))"
         expect((e == 42.5).sexpr).to eq "(= e (/ 85.0 2.0))"
-        # expect((42.5 == e).sexpr).to eq "(= e (/ 85.0 2.0))"
-        # expect((true == c).sexpr).to eq "(= true c)"
-        # expect((false == c).sexpr).to eq "(= false c)"
+        expect((42.5 == e).sexpr).to eq "(= (/ 85.0 2.0) e)"
+        expect((Rational(19, 7) == e).sexpr).to eq "(= (/ 19.0 7.0) e)"
+        expect((e == Rational(19, 7)).sexpr).to eq "(= e (/ 19.0 7.0))"
+        expect((true == c).sexpr).to eq "(= c true)"
+        expect((false == c).sexpr).to eq "(= c false)"
       end
 
       it "raises exception if type cast is not possible" do
@@ -132,8 +137,8 @@ module Z3
         expect{e == c}.to raise_error(ArgumentError)
         expect{a == true}.to raise_error(ArgumentError)
         expect{e == true}.to raise_error(ArgumentError)
-        # expect{true == a}.to raise_error(ArgumentError)
-        # expect{true == e}.to raise_error(ArgumentError)
+        expect{true == a}.to raise_error(ArgumentError)
+        expect{true == e}.to raise_error(ArgumentError)
         expect{c == 42}.to raise_error(ArgumentError)
         expect{c == 42.5}.to raise_error(ArgumentError)
         expect{42 == c}.to raise_error(ArgumentError)
@@ -150,18 +155,17 @@ module Z3
 
       it "casts to correct type if possible" do
         expect((a != 42).sexpr).to eq "(distinct a 42)"
-        # https://bugs.ruby-lang.org/issues/14437
-        # expect((42 != a).sexpr).to eq "(distinct a 42)"
+        expect((42 != a).sexpr).to eq "(distinct 42 a)"
         expect((a != e).sexpr).to eq "(distinct (to_real a) e)"
         expect((e != a).sexpr).to eq "(distinct e (to_real a))"
         expect((c != true).sexpr).to eq "(distinct c true)"
         expect((c != false).sexpr).to eq "(distinct c false)"
         expect((a != 42.5).sexpr).to eq "(distinct (to_real a) (/ 85.0 2.0))"
-        # expect((42.5 != a).sexpr).to eq "(distinct (to_real a) (/ 85.0 2.0))"
+        expect((42.5 != a).sexpr).to eq "(distinct (/ 85.0 2.0) (to_real a))"
         expect((e != 42.5).sexpr).to eq "(distinct e (/ 85.0 2.0))"
-        # expect((42.5 != e).sexpr).to eq "(distinct e (/ 85.0 2.0))"
-        # expect((true != c).sexpr).to eq "(distinct true c)"
-        # expect((false != c).sexpr).to eq "(distinct false c)"
+        expect((42.5 != e).sexpr).to eq "(distinct (/ 85.0 2.0) e)"
+        expect((true != c).sexpr).to eq "(distinct c true)"
+        expect((false != c).sexpr).to eq "(distinct c false)"
       end
 
       it "raises exception if type cast is not possible" do
@@ -169,12 +173,13 @@ module Z3
         expect{e != c}.to raise_error(ArgumentError)
         expect{a != true}.to raise_error(ArgumentError)
         expect{e != true}.to raise_error(ArgumentError)
-        # expect{true != a}.to raise_error(ArgumentError)
-        # expect{true != e}.to raise_error(ArgumentError)
+        expect{true != a}.to raise_error(ArgumentError)
+        expect{true != e}.to raise_error(ArgumentError)
         expect{c != 42}.to raise_error(ArgumentError)
         expect{c != 42.5}.to raise_error(ArgumentError)
-        # expect{42 != c}.to raise_error(ArgumentError)
-        # expect{42.5 != c}.to raise_error(ArgumentError)
+        expect{c != Rational(19, 7)}.to raise_error(ArgumentError)
+        expect{42 != c}.to raise_error(ArgumentError)
+        expect{Rational(19, 7) != c}.to raise_error(ArgumentError)
       end
     end
   end

data/spec/integration/knights_puzzle_spec.rb

@@ -1,5 +1,5 @@
 # There are multiple solutions, so this test is nondeterministic
-# Changing it to one returned by z3 4.6.0, but perhaps it needs some serious fixing
+# Changing it to one returned by z3 4.7.1, but perhaps it needs some serious fixing
 describe "Knights Swap Puzzle" do
   it do
     expect("knights_puzzle").to have_output <<EOF

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: z3
 version: !ruby/object:Gem::Version
-  version: 0.0.20180616
+  version: 0.0.20180624
 platform: ruby
 authors:
 - Tomasz Wegrzanowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-16 00:00:00.000000000 Z
+date: 2018-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -173,6 +173,7 @@ files:
 - lib/z3/expr/set_expr.rb
 - lib/z3/func_decl.rb
 - lib/z3/goal.rb
+- lib/z3/hacks.rb
 - lib/z3/interface.rb
 - lib/z3/low_level.rb
 - lib/z3/low_level_auto.rb