Merge branch 'master' of https://github.com/Z3Prover/z3 into new-ml-api

src/api/api_ast.cpp

@@ -1129,7 +1129,7 @@ extern "C" {
             case Z3_OP_SEQ_INDEX: return Z3_OP_SEQ_INDEX;
             case Z3_OP_SEQ_TO_RE: return Z3_OP_SEQ_TO_RE;
             case Z3_OP_SEQ_IN_RE: return Z3_OP_SEQ_IN_RE;
-                    
+
             case Z3_OP_RE_PLUS: return Z3_OP_RE_PLUS;
             case Z3_OP_RE_STAR: return Z3_OP_RE_STAR;
             case Z3_OP_RE_OPTION: return Z3_OP_RE_OPTION;
@@ -1186,9 +1186,14 @@ extern "C" {
             case OP_FPA_TO_IEEE_BV: return Z3_OP_FPA_TO_IEEE_BV;
             case OP_FPA_INTERNAL_BVWRAP:
             case OP_FPA_INTERNAL_BVUNWRAP:
+            case OP_FPA_INTERNAL_MIN_I:
+            case OP_FPA_INTERNAL_MAX_I:
+            case OP_FPA_INTERNAL_MIN_UNSPECIFIED:
+            case OP_FPA_INTERNAL_MAX_UNSPECIFIED:
             case OP_FPA_INTERNAL_TO_UBV_UNSPECIFIED:
             case OP_FPA_INTERNAL_TO_SBV_UNSPECIFIED:
             case OP_FPA_INTERNAL_TO_REAL_UNSPECIFIED:
+            case OP_FPA_INTERNAL_TO_IEEE_BV_UNSPECIFIED:
                 return Z3_OP_UNINTERPRETED;
             default:
                 UNREACHABLE();

src/api/c++/z3++.h

@@ -604,8 +604,16 @@ namespace z3 {
 
         /**
            \brief Return true if this expression is a numeral.
+           Specialized functions also return representations for the numerals as
+           small integers, 64 bit integers or rational or decimal strings.
         */
         bool is_numeral() const { return kind() == Z3_NUMERAL_AST; }
+        bool is_numeral_i64(__int64& i) const { bool r = 0 != Z3_get_numeral_int64(ctx(), m_ast, &i); check_error(); return r;}
+        bool is_numeral_u64(__uint64& i) const { bool r = 0 != Z3_get_numeral_uint64(ctx(), m_ast, &i); check_error(); return r;}
+        bool is_numeral_i(int& i) const { bool r = 0 != Z3_get_numeral_int(ctx(), m_ast, &i); check_error(); return r;}
+        bool is_numeral_u(unsigned& i) const { bool r = 0 != Z3_get_numeral_uint(ctx(), m_ast, &i); check_error(); return r;}
+        bool is_numeral(std::string& s) const { if (!is_numeral()) return false; s = Z3_get_numeral_string(ctx(), m_ast); check_error(); return true; }
+        bool is_numeral(std::string& s, unsigned precision) const { if (!is_numeral()) return false; s = Z3_get_numeral_decimal_string(ctx(), m_ast, precision); check_error(); return true; }
         /**
            \brief Return true if this expression is an application.
         */
@@ -622,11 +630,86 @@ namespace z3 {
            \brief Return true if this expression is a variable.
         */
         bool is_var() const { return kind() == Z3_VAR_AST; }
+        /**
+           \brief Return true if expression is an algebraic number.
+        */
+        bool is_algebraic() const { return 0 != Z3_is_algebraic_number(ctx(), m_ast); }
 
         /**
            \brief Return true if this expression is well sorted (aka type correct).
         */
         bool is_well_sorted() const { bool r = Z3_is_well_sorted(ctx(), m_ast) != 0; check_error(); return r; }
+        
+        /**
+           \brief Return string representation of numeral or algebraic number
+           This method assumes the expression is numeral or algebraic
+           
+           \pre is_numeral() || is_algebraic()
+        */
+        std::string get_decimal_string(int precision) const {
+            assert(is_numeral() || is_algebraic());
+            return std::string(Z3_get_numeral_decimal_string(ctx(), m_ast, precision));
+        }
+        
+        /**
+           \brief Return int value of numeral, throw if result cannot fit in
+           machine int
+           
+           \pre is_numeral()
+        */
+        int get_numeral_int() const {             
+            int result;
+            if (!is_numeral_i(result)) {
+                throw exception("numeral does not fit in machine int");
+            }
+            return result;
+        }
+        
+        /**
+           \brief Return uint value of numeral, throw if result cannot fit in
+           machine uint
+           
+           \pre is_numeral()
+        */
+        unsigned get_numeral_uint() const {
+            assert(is_numeral());
+            unsigned result;
+            if (!is_numeral_u(result)) {
+                throw exception("numeral does not fit in machine uint");
+            }
+            return result;
+        }
+        
+        /**
+           \brief Return __int64 value of numeral, throw if result cannot fit in
+           __int64
+           
+           \pre is_numeral()
+        */
+        __int64 get_numeral_int64() const {
+            assert(is_numeral());
+            __int64 result;
+            if (!is_numeral_i64(result)) {
+                throw exception("numeral does not fit in machine __int64");
+            }
+            return result;
+        }
+        
+        /**
+           \brief Return __uint64 value of numeral, throw if result cannot fit in
+           __uint64
+           
+           \pre is_numeral()
+        */
+        __uint64 get_numeral_uint64() const {
+            assert(is_numeral());
+            __uint64 result;
+            if (!is_numeral_u64(result)) {
+                throw exception("numeral does not fit in machine __uint64");
+            }
+            return result;
+        }
+           
 
         operator Z3_app() const { assert(is_app()); return reinterpret_cast<Z3_app>(m_ast); }
 

src/api/python/z3.py

@@ -3940,7 +3940,7 @@ class ArraySortRef(SortRef):
         >>> A.range()
         Bool
         """
-        return _to_sort_ref(Z3_get_array_sort_range(self.ctx_ref(), self.ast), self.ctx)
+        return _to_sort_ref(Z3_get_array_sort_range(self.ctx_ref(), self.ast), self.ctx)    
 
 class ArrayRef(ExprRef):
     """Array expressions. """
@@ -4162,6 +4162,7 @@ def Select(a, i):
         _z3_assert(is_array(a), "First argument must be a Z3 array expression")
     return a[i]
 
+    
 def Map(f, *args):
     """Return a Z3 map array expression.
 
@@ -8178,8 +8179,13 @@ class FPRef(ExprRef):
         return self
 
     def __neg__(self):
-        """Create the Z3 expression `-self`."""
-        return FPRef(fpNeg(self))
+        """Create the Z3 expression `-self`.
+        
+        >>> x = FP('x', Float32())
+        >>> -x
+        -x
+        """
+        return fpNeg(self)
 
     def __div__(self, other):
         """Create the Z3 expression `self / other`.