z3 0.0.20160427 → 0.0.20161008

data/lib/z3/expr/float_expr.rb

@@ -0,0 +1,185 @@
+module Z3
+  class FloatExpr < Expr
+
+    def ==(other)
+      FloatExpr.Eq(self, other)
+    end
+
+    def !=(other)
+      FloatExpr.Ne(self, other)
+    end
+
+    def <(other)
+      FloatExpr.Lt(self, other)
+    end
+
+    def <=(other)
+      FloatExpr.Le(self, other)
+    end
+
+    def >(other)
+      FloatExpr.Gt(self, other)
+    end
+
+    def >=(other)
+      FloatExpr.Ge(self, other)
+    end
+
+    def add(other, mode)
+      FloatExpr.Add(self, other, mode)
+    end
+
+    def sub(other, mode)
+      FloatExpr.Sub(self, other, mode)
+    end
+
+    def mul(other, mode)
+      FloatExpr.Mul(self, other, mode)
+    end
+
+    def div(other, mode)
+      FloatExpr.Div(self, other, mode)
+    end
+
+    def rem(other)
+      FloatExpr.Rem(self, other)
+    end
+
+    def abs
+      sort.new LowLevel.mk_fpa_abs(self)
+    end
+
+    def -@
+      sort.new LowLevel.mk_fpa_neg(self)
+    end
+
+    def infinite?
+      BoolSort.new.new LowLevel.mk_fpa_is_infinite(self)
+    end
+
+    def nan?
+      BoolSort.new.new LowLevel.mk_fpa_is_nan(self)
+    end
+
+    def negative?
+      BoolSort.new.new LowLevel.mk_fpa_is_negative(self)
+    end
+
+    def normal?
+      BoolSort.new.new LowLevel.mk_fpa_is_normal(self)
+    end
+
+    def positive?
+      BoolSort.new.new LowLevel.mk_fpa_is_positive(self)
+    end
+
+    def subnormal?
+      BoolSort.new.new LowLevel.mk_fpa_is_subnormal(self)
+    end
+
+    def zero?
+      BoolSort.new.new LowLevel.mk_fpa_is_zero(self)
+    end
+
+    def max(other)
+      FloatExpr.Max(self, other)
+    end
+
+    def min(other)
+      FloatExpr.Min(self, other)
+    end
+
+    def exponent_string
+      LowLevel.fpa_get_numeral_exponent_string(self)
+    end
+
+    def significand_string
+      LowLevel.fpa_get_numeral_significand_string(self)
+    end
+
+    public_class_method :new
+
+    class << self
+      def coerce_to_same_float_sort(*args)
+        args = coerce_to_same_sort(*args)
+        raise Z3::Exception, "Float value with same sizes expected" unless args[0].is_a?(FloatExpr)
+        args
+      end
+
+      def coerce_to_mode_sort(m)
+        raise Z3::Exception, "Mode expected" unless m.is_a?(RoundingModeExpr)
+        m
+      end
+
+      def Eq(a, b)
+        a, b = coerce_to_same_float_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_fpa_eq(a, b))
+      end
+
+      def Ne(a, b)
+        ~Eq(a,b)
+      end
+
+      def Gt(a, b)
+        a, b = coerce_to_same_float_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_fpa_gt(a, b))
+      end
+
+      def Lt(a, b)
+        a, b = coerce_to_same_float_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_fpa_lt(a, b))
+      end
+
+      def Ge(a, b)
+        a, b = coerce_to_same_float_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_fpa_geq(a, b))
+      end
+
+      def Le(a, b)
+        a, b = coerce_to_same_float_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_fpa_leq(a, b))
+      end
+
+      def Add(a, b, m)
+        a, b = coerce_to_same_float_sort(a, b)
+        m = coerce_to_mode_sort(m)
+        a.sort.new(LowLevel.mk_fpa_add(m, a, b))
+      end
+
+      def Sub(a, b, m)
+        a, b = coerce_to_same_float_sort(a, b)
+        m = coerce_to_mode_sort(m)
+        a.sort.new(LowLevel.mk_fpa_sub(m, a, b))
+      end
+
+      def Mul(a, b, m)
+        a, b = coerce_to_same_float_sort(a, b)
+        m = coerce_to_mode_sort(m)
+        a.sort.new(LowLevel.mk_fpa_mul(m, a, b))
+      end
+
+      def Div(a, b, m)
+        a, b = coerce_to_same_float_sort(a, b)
+        m = coerce_to_mode_sort(m)
+        a.sort.new(LowLevel.mk_fpa_div(m, a, b))
+      end
+
+      def Rem(a, b)
+        a, b = coerce_to_same_float_sort(a, b)
+        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
+
+      def Min(a, b)
+        a, b = coerce_to_same_float_sort(a, b)
+        a.sort.new(LowLevel.mk_fpa_min(a, b))
+      end
+    end
+  end
+end

data/lib/z3/expr/int_expr.rb

@@ -1,15 +1,30 @@
 module Z3
-  class IntExpr < Expr
-    include ArithExpr
-
+  class IntExpr < ArithExpr
     def mod(other)
-      ::Z3.Mod(self, other)
+      IntExpr.Mod(self, other)
     end
 
     def rem(other)
-      ::Z3.Rem(self, other)
+      IntExpr.Rem(self, other)
     end
 
     public_class_method :new
+    class << self
+      def coerce_to_same_int_sort(*args)
+        args = coerce_to_same_sort(*args)
+        raise Z3::Exception, "Int value expected" unless args[0].is_a?(IntExpr)
+        args
+      end
+
+      def Mod(a, b)
+        a, b = coerce_to_same_int_sort(a, b)
+        a.sort.new(LowLevel.mk_mod(a, b))
+      end
+
+      def Rem(a, b)
+        a, b = coerce_to_same_int_sort(a, b)
+        a.sort.new(LowLevel.mk_rem(a, b))
+      end
+    end
   end
 end

data/lib/z3/expr/real_expr.rb

@@ -1,7 +1,5 @@
 module Z3
-  class RealExpr < Expr
-    include ArithExpr
-
+  class RealExpr < ArithExpr
     public_class_method :new
   end
 end

data/lib/z3/expr/rounding_mode_expr.rb

@@ -0,0 +1,5 @@
+module Z3
+  class RoundingModeExpr < Expr
+    public_class_method :new
+  end
+end

data/lib/z3/expr/set_expr.rb

@@ -0,0 +1,66 @@
+module Z3
+  class SetExpr < Expr
+    public_class_method :new
+
+    def element_sort
+      sort.element_sort
+    end
+
+    def is_superset_of(other)
+      SetExpr.Subset(other, self)
+    end
+
+    def is_subset_of(other)
+      SetExpr.Subset(self, other)
+    end
+
+    def complement
+      sort.new(LowLevel.mk_set_complement(self))
+    end
+
+    def union(other)
+      SetExpr.Union(self, other)
+    end
+
+    def intersection(other)
+      SetExpr.Union(self, other)
+    end
+
+    def difference(other)
+      SetExpr.Difference(self, other)
+    end
+
+    def include?(element)
+      element = element_sort.cast(element)
+      BoolSort.new.new(LowLevel.mk_set_member(element, self))
+    end
+
+    class << self
+      def coerce_to_same_set_sort(*args)
+        args = coerce_to_same_sort(*args)
+        raise Z3::Exception, "Set value with same element sort expected" unless args[0].is_a?(SetExpr)
+        args
+      end
+
+      def Subset(a, b)
+        a, b = coerce_to_same_set_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_set_subset(a, b))
+      end
+
+      def Union(*args)
+        args = coerce_to_same_set_sort(*args)
+        args[0].sort.new(LowLevel.mk_set_union(args))
+      end
+
+      def Intersection(*args)
+        args = coerce_to_same_set_sort(*args)
+        args[0].sort.new(LowLevel.mk_set_intersect(args))
+      end
+
+      def Difference(a, b)
+        a, b = coerce_to_same_set_sort(a, b)
+        a.sort.new(LowLevel.mk_set_difference(a, b))
+      end
+    end
+  end
+end

data/lib/z3/func_decl.rb

@@ -6,26 +6,26 @@ module Z3
     end
 
     def name
-      Z3::LowLevel.get_symbol_string(Z3::LowLevel.get_decl_name(self))
+      LowLevel.get_symbol_string(LowLevel.get_decl_name(self))
     end
 
     def arity
-      Z3::LowLevel.get_arity(self)
+      LowLevel.get_arity(self)
     end
 
     def domain(i)
       a = arity
       raise Z3::Exception, "Trying to access domain #{i} but function arity is #{a}" if i < 0 or i >= a
-      Sort.from_pointer(Z3::LowLevel::get_domain(self, i))
+      Sort.from_pointer(LowLevel::get_domain(self, i))
     end
 
     def range
-      Sort.from_pointer(Z3::LowLevel::get_range(self))
+      Sort.from_pointer(LowLevel::get_range(self))
     end
 
     # def ast_parameter(i)
     #   # vs arity ?
-    #   Z3::Ast.new(Z3::LowLevel.get_decl_ast_parameter(self, i))
+    #   Z3::Ast.new(LowLevel.get_decl_ast_parameter(self, i))
     # end
 
     def to_s

data/lib/z3/goal.rb

@@ -0,0 +1,64 @@
+module Z3
+  class Goal
+    attr_reader :_goal
+    def initialize(_goal)
+      @_goal = _goal
+    end
+
+    def assert(ast)
+      raise Z3::Exception, "AST required" unless ast.is_a?(AST)
+      LowLevel.goal_assert(self, ast)
+    end
+
+    def reset
+      LowLevel.goal_reset(self)
+    end
+
+    def depth
+      LowLevel.goal_depth(self)
+    end
+
+    def size
+      LowLevel.goal_size(self)
+    end
+
+    def num_exprs
+      LowLevel.goal_num_exprs(self)
+    end
+
+    def precision
+      LowLevel.goal_precision(self)
+    end
+
+    def inconsistent?
+      # Does it convert bool or do we need to ?
+      LowLevel.goal_inconsistent(self)
+    end
+
+    def decided_sat?
+      # Does it convert bool or do we need to ?
+      LowLevel.goal_is_decided_sat(self)
+    end
+
+    def decided_unsat?
+      # Does it convert bool or do we need to ?
+      LowLevel.goal_is_decided_unsat(self)
+    end
+
+    def formula(num)
+      raise Z3::Exception, "Out of range" unless num.between?(0, size-1)
+      # We should probably deal with out of bounds here
+      Expr.new_from_pointer(LowLevel.goal_formula(self, num))
+    end
+
+    def to_s
+      LowLevel.goal_to_string(self)
+    end
+
+    class << self
+      def new(models=false, unsat_cores=false, proofs=false)
+        super LowLevel.mk_goal(!!models, !!unsat_cores, !!proofs)
+      end
+    end
+  end
+end

data/lib/z3/interface.rb

@@ -1,4 +1,6 @@
+# Everything here might go away
 module Z3
+  # Variables
   def Int(v)
     IntSort.new.var(v)
   end
@@ -15,6 +17,7 @@ module Z3
     BitvecSort.new(n).var(v)
   end
 
+  # Constants
   def True
     BoolSort.new.True
   end
@@ -27,205 +30,44 @@ module Z3
     Expr.sort_for_const(v).from_const(v)
   end
 
-  def And(*args)
-    args = coerce_to_same_sort(*args)
-    case args[0]
-    when BoolExpr
-      BoolSort.new.new(Z3::LowLevel.mk_and(args))
-    when BitvecExpr
-      args.inject do |a,b|
-        a.sort.new(Z3::LowLevel.mk_bvand(a, b))
-      end
-    else
-      raise ArgumentError, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
-    end
-  end
-
-  def Or(*args)
-    args = coerce_to_same_sort(*args)
-    case args[0]
-    when BoolExpr
-      BoolSort.new.new(Z3::LowLevel.mk_or(args))
-    when BitvecExpr
-      args.inject do |a,b|
-        a.sort.new(Z3::LowLevel.mk_bvor(a, b))
-      end
-    else
-      raise ArgumentError, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
-    end
-  end
-
-  def Xor(*args)
-    args = coerce_to_same_sort(*args)
-    case args[0]
-    when BoolExpr
-      args.inject do |a,b|
-        BoolSort.new.new(Z3::LowLevel.mk_xor(a, b))
-      end
-    when BitvecExpr
-      args.inject do |a,b|
-        a.sort.new(Z3::LowLevel.mk_bvxor(a, b))
-      end
-    else
-      raise ArgumentError, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
-    end
-  end
-
-  def Implies(a,b)
-    a, b = coerce_to_same_bool_sort(a, b)
-    BoolSort.new.new(Z3::LowLevel.mk_implies(a, b))
-  end
-
-  def Iff(a,b)
-    a, b = coerce_to_same_bool_sort(a, b)
-    BoolSort.new.new(Z3::LowLevel.mk_iff(a, b))
+  # Multiargument constructors
+  def Distinct(*args)
+    Expr.Distinct(*args)
   end
 
-  def IfThenElse(a, b, c)
-    a, = coerce_to_same_bool_sort(a)
-    b, c = coerce_to_same_sort(b, c)
-    b.sort.new(Z3::LowLevel.mk_ite(a, b, c))
+  def Eq(*args)
+    Expr.Eq(*args)
   end
 
   def Add(*args)
-    raise ArgumentError if args.empty?
-    args = coerce_to_same_sort(*args)
-    case args[0]
-    when ArithExpr
-      args[0].sort.new(LowLevel.mk_add(args))
-    when BitvecExpr
-      args.inject do |a,b|
-        a.sort.new(LowLevel.mk_bvadd(a,b))
-      end
-    else
-      raise ArgumentError, "Can't perform logic operations on #{args[0].sort} exprs, only Int/Real/Bitvec"
-    end
-  end
-
-  def Sub(*args)
-    args = coerce_to_same_sort(*args)
-    case args[0]
-    when ArithExpr
-      args[0].sort.new(LowLevel.mk_sub(args))
-    when BitvecExpr
-      args.inject do |a,b|
-        a.sort.new(LowLevel.mk_bvsub(a,b))
-      end
-    else
-      raise ArgumentError, "Can't perform logic operations on #{args[0].sort} values, only Int/Real/Bitvec"
-    end
+    Expr.Add(*args)
   end
 
   def Mul(*args)
-    args = coerce_to_same_sort(*args)
-    case args[0]
-    when ArithExpr
-      args[0].sort.new(LowLevel.mk_mul(args))
-    when BitvecExpr
-      args.inject do |a,b|
-        a.sort.new(LowLevel.mk_bvmul(a,b))
-      end
-    else
-      raise ArgumentError, "Can't perform logic operations on #{args[0].sort} values, only Int/Real/Bitvec"
-    end
-  end
-
-  def Div(a,b)
-    a, b = coerce_to_same_arith_sort(a, b)
-    a.sort.new(LowLevel.mk_div(a, b))
-  end
-
-  def Mod(a,b)
-    a, b = coerce_to_same_int_sort(a, b)
-    a.sort.new(LowLevel.mk_mod(a, b))
-  end
-
-  def Rem(a,b)
-    a, b = coerce_to_same_int_sort(a, b)
-    a.sort.new(LowLevel.mk_rem(a, b))
+    Expr.Mul(*args)
   end
 
-  def Power(a, b)
-    # Wait, is this even legitimate that it's I**I and R**R?
-    a, b = coerce_to_same_arith_sort(a, b)
-    a.sort.new(LowLevel.mk_power(a, b))
-  end
-
-  def Eq(a, b)
-    a, b = coerce_to_same_sort(a, b)
-    BoolSort.new.new(LowLevel.mk_eq(a, b))
-  end
-
-  def Distinct(*args)
-    args = coerce_to_same_sort(*args)
-    BoolSort.new.new(LowLevel.mk_distinct(args))
-  end
-
-  def Gt(a, b)
-    a, b = coerce_to_same_sort(a, b)
-    case a
-    when ArithExpr
-      BoolSort.new.new(LowLevel.mk_gt(a, b))
-    when BitvecExpr
-      BoolSort.new.new(LowLevel.mk_bvsgt(a, b))
-    else
-      raise ArgumentError, "Can't compare #{a.sort} values"
-    end
-  end
-
-  def Ge(a, b)
-    a, b = coerce_to_same_sort(a, b)
-    case a
-    when ArithExpr
-      BoolSort.new.new(LowLevel.mk_ge(a, b))
-    when BitvecExpr
-      BoolSort.new.new(LowLevel.mk_bvsge(a, b))
-    else
-      raise ArgumentError, "Can't compare #{a.sort} values"
-    end
-  end
-
-  def Lt(a, b)
-    a, b = coerce_to_same_sort(a, b)
-    case a
-    when ArithExpr
-      BoolSort.new.new(LowLevel.mk_lt(a, b))
-    when BitvecExpr
-      BoolSort.new.new(LowLevel.mk_bvslt(a, b))
-    else
-      raise ArgumentError, "Can't compare #{a.sort} values"
-    end
+  def Or(*args)
+    BoolExpr.Or(*args)
   end
 
-  def Le(a, b)
-    a, b = coerce_to_same_sort(a, b)
-    case a
-    when ArithExpr
-      BoolSort.new.new(LowLevel.mk_le(a, b))
-    when BitvecExpr
-      BoolSort.new.new(LowLevel.mk_bvsle(a, b))
-    else
-      raise ArgumentError, "Can't compare #{a.sort} values"
-    end
+  def And(*args)
+    BoolExpr.And(*args)
   end
 
-  def Not(a)
-    a = Value.from_const(a) unless a.is_a?(Value)
-    raise Z3::Exception, "No idea how to autoconvert `#{a.class}': `#{a.inspect}'" unless a.is_a?(BoolValue)
-    BoolSort.new.new(LowLevel.mk_not(a))
+  def Xor(*args)
+    Expr.Xor(*args)
   end
 
-  # Presume arithmetic (sign-extend)
-  def RShift(a, b)
-    a, b = coerce_to_same_bv_sort(a, b)
-    a.sort.new(LowLevel.mk_bvashr(a, b))
+  def Implies(a,b)
+    BoolExpr.Implies(a,b)
   end
 
-  def LShift(a, b)
-    a, b = coerce_to_same_bv_sort(a, b)
-    a.sort.new(LowLevel.mk_bvshl(a, b))
+  def IfThenElse(a,b,c)
+    BoolExpr.IfThenElse(a,b,c)
   end
 
+  # Global functions
   def version
     LowLevel.get_version.join(".")
   end
@@ -234,49 +76,6 @@ module Z3
     LowLevel.global_param_set(k,v)
   end
 
-  private
-
-  def coerce_to_same_sort(*args)
-    # This will raise exception unless one of the sorts is highest
-    # So [true, IntSort]
-    max_sort = args.map{|a| a.is_a?(Expr) ? a.sort : Expr.sort_for_const(a)}.max
-    args.map do |a|
-      if a.is_a?(Expr)
-        if  a.sort == max_sort
-          a
-        else
-          max_sort.from_value(a)
-        end
-      else
-        max_sort.from_const(a)
-      end
-    end
-  end
-
-  def coerce_to_same_bool_sort(*args)
-    args = coerce_to_same_sort(*args)
-    raise Z3::Exception, "Bool value expected" unless args[0].is_a?(BoolExpr)
-    args
-  end
-
-  def coerce_to_same_arith_sort(*args)
-    args = coerce_to_same_sort(*args)
-    raise Z3::Exception, "Int or Real value expected" unless args[0].is_a?(IntExpr) or args[0].is_a?(RealExpr)
-    args
-  end
-
-  def coerce_to_same_bv_sort(*args)
-    args = coerce_to_same_sort(*args)
-    raise Z3::Exception, "Bitvec value with same size expected" unless args[0].is_a?(BitvecExpr)
-    args
-  end
-
-  def coerce_to_same_int_sort(*args)
-    args = coerce_to_same_sort(*args)
-    raise Z3::Exception, "Int value expected" unless args[0].is_a?(IntExpr)
-    args
-  end
-
   class << self
     include Z3
   end