ArithRef Class Reference

Inheritance diagram for ArithRef:

Public Member Functions
def	sort
def	is_int
def	is_real
def	__add__
def	__radd__
def	__mul__
def	__rmul__
def	__sub__
def	__rsub__
def	__pow__
def	__rpow__
def	__div__
def	__truediv__
def	__rdiv__
def	__rtruediv__
def	__mod__
def	__rmod__
def	__neg__
def	__pos__
def	__le__
def	__lt__
def	__gt__
def	__ge__

---

Detailed Description

Integer and Real expressions.

Definition at line 1942 of file z3py.py.

---

Member Function Documentation

def __add__	(		self,
			other
	)

Create the Z3 expression `self + other`.

>>> x = Int('x')
>>> y = Int('y')
>>> x + y
x + y
>>> (x + y).sort()
Int

Definition at line 1980 of file z3py.py.

    def __add__(self, other):
        """Create the Z3 expression `self + other`.
        
        >>> x = Int('x')
        >>> y = Int('y')
        >>> x + y
        x + y
        >>> (x + y).sort()
        Int
        """
        a, b = _coerce_exprs(self, other)
        return ArithRef(_mk_bin(Z3_mk_add, a, b), self.ctx)

def __div__	(		self,
			other
	)

Create the Z3 expression `other/self`.

>>> x = Int('x')
>>> y = Int('y')
>>> x/y
x/y
>>> (x/y).sort()
Int
>>> (x/y).sexpr()
'(div x y)'
>>> x = Real('x')
>>> y = Real('y')
>>> x/y
x/y
>>> (x/y).sort()
Real
>>> (x/y).sexpr()
'(/ x y)'

Definition at line 2077 of file z3py.py.

    def __div__(self, other):
        """Create the Z3 expression `other/self`.
        
        >>> x = Int('x')
        >>> y = Int('y')
        >>> x/y
        x/y
        >>> (x/y).sort()
        Int
        >>> (x/y).sexpr()
        '(div x y)'
        >>> x = Real('x')
        >>> y = Real('y')
        >>> x/y
        x/y
        >>> (x/y).sort()
        Real
        >>> (x/y).sexpr()
        '(/ x y)'
        """
        a, b = _coerce_exprs(self, other)
        return ArithRef(Z3_mk_div(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)

def __ge__	(		self,
			other
	)

Create the Z3 expression `other >= self`.

>>> x, y = Ints('x y')
>>> x >= y
x >= y
>>> y = Real('y')
>>> x >= y
ToReal(x) >= y

Definition at line 2211 of file z3py.py.

    def __ge__(self, other):
        """Create the Z3 expression `other >= self`.
        
        >>> x, y = Ints('x y')
        >>> x >= y
        x >= y
        >>> y = Real('y')
        >>> x >= y
        ToReal(x) >= y
        """
        a, b = _coerce_exprs(self, other)
        return BoolRef(Z3_mk_ge(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)

def __gt__	(		self,
			other
	)

Create the Z3 expression `other > self`.

>>> x, y = Ints('x y')
>>> x > y
x > y
>>> y = Real('y')
>>> x > y
ToReal(x) > y

Definition at line 2198 of file z3py.py.

02198 
02199     def __gt__(self, other):
02200         """Create the Z3 expression `other > self`.
02201         
02202         >>> x, y = Ints('x y')
02203         >>> x > y
02204         x > y
02205         >>> y = Real('y')
02206         >>> x > y
02207         ToReal(x) > y
02208         """
02209         a, b = _coerce_exprs(self, other)
02210         return BoolRef(Z3_mk_gt(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
        

def __le__	(		self,
			other
	)

Create the Z3 expression `other <= self`.

>>> x, y = Ints('x y')
>>> x <= y
x <= y
>>> y = Real('y')
>>> x <= y
ToReal(x) <= y

Definition at line 2172 of file z3py.py.

    def __le__(self, other):
        """Create the Z3 expression `other <= self`.
        
        >>> x, y = Ints('x y')
        >>> x <= y
        x <= y
        >>> y = Real('y')
        >>> x <= y
        ToReal(x) <= y
        """
        a, b = _coerce_exprs(self, other)
        return BoolRef(Z3_mk_le(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)

def __lt__	(		self,
			other
	)

Create the Z3 expression `other < self`.

>>> x, y = Ints('x y')
>>> x < y
x < y
>>> y = Real('y')
>>> x < y
ToReal(x) < y

Definition at line 2185 of file z3py.py.

    def __lt__(self, other):
        """Create the Z3 expression `other < self`.
        
        >>> x, y = Ints('x y')
        >>> x < y
        x < y
        >>> y = Real('y')
        >>> x < y
        ToReal(x) < y
        """
        a, b = _coerce_exprs(self, other)
        return BoolRef(Z3_mk_lt(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)

def __mod__	(		self,
			other
	)

Create the Z3 expression `other%self`.

>>> x = Int('x')
>>> y = Int('y')
>>> x % y
x%y
>>> simplify(IntVal(10) % IntVal(3))
1

Definition at line 2125 of file z3py.py.

    def __mod__(self, other):
        """Create the Z3 expression `other%self`.
        
        >>> x = Int('x')
        >>> y = Int('y')
        >>> x % y
        x%y
        >>> simplify(IntVal(10) % IntVal(3))
        1
        """
        a, b = _coerce_exprs(self, other)
        if __debug__:
            _z3_assert(a.is_int(), "Z3 integer expression expected")
        return ArithRef(Z3_mk_mod(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)

def __mul__	(		self,
			other
	)

Create the Z3 expression `self * other`.

>>> x = Real('x')
>>> y = Real('y')
>>> x * y
x*y
>>> (x * y).sort()
Real

Definition at line 2003 of file z3py.py.

    def __mul__(self, other):
        """Create the Z3 expression `self * other`.
        
        >>> x = Real('x')
        >>> y = Real('y')
        >>> x * y
        x*y
        >>> (x * y).sort()
        Real
        """
        a, b = _coerce_exprs(self, other)
        return ArithRef(_mk_bin(Z3_mk_mul, a, b), self.ctx)

def __neg__

(

self

)

Return an expression representing `-self`.

>>> x = Int('x')
>>> -x
-x
>>> simplify(-(-x))
x

Definition at line 2152 of file z3py.py.

02152 
02153     def __neg__(self):
02154         """Return an expression representing `-self`.
02155 
02156         >>> x = Int('x')
02157         >>> -x
02158         -x
02159         >>> simplify(-(-x))
02160         x
02161         """
02162         return ArithRef(Z3_mk_unary_minus(self.ctx_ref(), self.as_ast()), self.ctx)
    

def __pos__

(

self

)

Return `self`.

>>> x = Int('x')
>>> +x
x

Definition at line 2163 of file z3py.py.

    def __pos__(self):
        """Return `self`.
        
        >>> x = Int('x')
        >>> +x
        x
        """
        return self

def __pow__	(		self,
			other
	)

Create the Z3 expression `self**other` (** is the power operator).

>>> x = Real('x')
>>> x**3
x**3
>>> (x**3).sort()
Real
>>> simplify(IntVal(2)**8)
256

Definition at line 2049 of file z3py.py.

    def __pow__(self, other):
        """Create the Z3 expression `self**other` (** is the power operator).
        
        >>> x = Real('x')
        >>> x**3
        x**3
        >>> (x**3).sort()
        Real
        >>> simplify(IntVal(2)**8)
        256
        """
        a, b = _coerce_exprs(self, other)
        return ArithRef(Z3_mk_power(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)

def __radd__	(		self,
			other
	)

Create the Z3 expression `other + self`.

>>> x = Int('x')
>>> 10 + x
10 + x

Definition at line 1993 of file z3py.py.

    def __radd__(self, other):
        """Create the Z3 expression `other + self`.
        
        >>> x = Int('x')
        >>> 10 + x
        10 + x
        """
        a, b = _coerce_exprs(self, other)
        return ArithRef(_mk_bin(Z3_mk_add, b, a), self.ctx)

def __rdiv__	(		self,
			other
	)

Create the Z3 expression `other/self`.

>>> x = Int('x')
>>> 10/x
10/x
>>> (10/x).sexpr()
'(div 10 x)'
>>> x = Real('x')
>>> 10/x
10/x
>>> (10/x).sexpr()
'(/ 10.0 x)'

Definition at line 2104 of file z3py.py.

    def __rdiv__(self, other):
        """Create the Z3 expression `other/self`.
        
        >>> x = Int('x')
        >>> 10/x
        10/x
        >>> (10/x).sexpr()
        '(div 10 x)'
        >>> x = Real('x')
        >>> 10/x
        10/x
        >>> (10/x).sexpr()
        '(/ 10.0 x)'
        """
        a, b = _coerce_exprs(self, other)
        return ArithRef(Z3_mk_div(self.ctx_ref(), b.as_ast(), a.as_ast()), self.ctx)

def __rmod__	(		self,
			other
	)

Create the Z3 expression `other%self`.

>>> x = Int('x')
>>> 10 % x
10%x

Definition at line 2140 of file z3py.py.

    def __rmod__(self, other):
        """Create the Z3 expression `other%self`.
        
        >>> x = Int('x')
        >>> 10 % x
        10%x
        """
        a, b = _coerce_exprs(self, other)
        if __debug__:
            _z3_assert(a.is_int(), "Z3 integer expression expected")
        return ArithRef(Z3_mk_mod(self.ctx_ref(), b.as_ast(), a.as_ast()), self.ctx)

def __rmul__	(		self,
			other
	)

Create the Z3 expression `other * self`.

>>> x = Real('x')
>>> 10 * x
10*x

Definition at line 2016 of file z3py.py.

    def __rmul__(self, other):
        """Create the Z3 expression `other * self`.
        
        >>> x = Real('x')
        >>> 10 * x
        10*x
        """
        a, b = _coerce_exprs(self, other)
        return ArithRef(_mk_bin(Z3_mk_mul, b, a), self.ctx)

def __rpow__	(		self,
			other
	)

Create the Z3 expression `other**self` (** is the power operator).

>>> x = Real('x')
>>> 2**x
2**x
>>> (2**x).sort()
Real
>>> simplify(2**IntVal(8))
256

Definition at line 2063 of file z3py.py.

    def __rpow__(self, other):
        """Create the Z3 expression `other**self` (** is the power operator).
        
        >>> x = Real('x')
        >>> 2**x
        2**x
        >>> (2**x).sort()
        Real
        >>> simplify(2**IntVal(8))
        256
        """
        a, b = _coerce_exprs(self, other)
        return ArithRef(Z3_mk_power(self.ctx_ref(), b.as_ast(), a.as_ast()), self.ctx)

def __rsub__	(		self,
			other
	)

Create the Z3 expression `other - self`.

>>> x = Int('x')
>>> 10 - x
10 - x

Definition at line 2039 of file z3py.py.

    def __rsub__(self, other):
        """Create the Z3 expression `other - self`.
        
        >>> x = Int('x')
        >>> 10 - x
        10 - x
        """
        a, b = _coerce_exprs(self, other)
        return ArithRef(_mk_bin(Z3_mk_sub, b, a), self.ctx)

def __rtruediv__	(		self,
			other
	)

Create the Z3 expression `other/self`.

Definition at line 2121 of file z3py.py.

    def __rtruediv__(self, other):
        """Create the Z3 expression `other/self`."""
        return self.__rdiv__(other)

def __sub__	(		self,
			other
	)

Create the Z3 expression `self - other`.

>>> x = Int('x')
>>> y = Int('y')
>>> x - y
x - y
>>> (x - y).sort()
Int

Definition at line 2026 of file z3py.py.

    def __sub__(self, other):
        """Create the Z3 expression `self - other`.

        >>> x = Int('x')
        >>> y = Int('y')
        >>> x - y
        x - y
        >>> (x - y).sort()
        Int
        """
        a, b = _coerce_exprs(self, other)
        return ArithRef(_mk_bin(Z3_mk_sub, a, b), self.ctx)

def __truediv__	(		self,
			other
	)

Create the Z3 expression `other/self`.

Definition at line 2100 of file z3py.py.

    def __truediv__(self, other):
        """Create the Z3 expression `other/self`."""
        return self.__div__(other)

def is_int

(

self

)

Return `True` if `self` is an integer expression.

>>> x = Int('x')
>>> x.is_int()
True
>>> (x + 1).is_int()
True
>>> y = Real('y')
>>> (x + y).is_int()
False

Definition at line 1955 of file z3py.py.

    def is_int(self):
        """Return `True` if `self` is an integer expression.
        
        >>> x = Int('x')
        >>> x.is_int()
        True
        >>> (x + 1).is_int()
        True
        >>> y = Real('y')
        >>> (x + y).is_int()
        False
        """
        return self.sort().is_int()

def is_real

(

self

)

Return `True` if `self` is an real expression.

>>> x = Real('x')
>>> x.is_real()
True
>>> (x + 1).is_real()
True

Definition at line 1969 of file z3py.py.

    def is_real(self):
        """Return `True` if `self` is an real expression.
        
        >>> x = Real('x')
        >>> x.is_real()
        True
        >>> (x + 1).is_real()
        True
        """
        return self.sort().is_real()

def sort

(

self

)

Return the sort (type) of the arithmetical expression `self`.

>>> Int('x').sort()
Int
>>> (Real('x') + 1).sort()
Real

Reimplemented from ExprRef.

Definition at line 1945 of file z3py.py.

Referenced by ArithRef.__add__(), ArithRef.__div__(), ArithRef.__mul__(), ArithRef.__pow__(), ArithRef.__rpow__(), ArithRef.__sub__(), ArrayRef.domain(), ArithRef.is_int(), ArithRef.is_real(), and ArrayRef.range().

    def sort(self):
        """Return the sort (type) of the arithmetical expression `self`.
        
        >>> Int('x').sort()
        Int
        >>> (Real('x') + 1).sort()
        Real
        """
        return ArithSortRef(Z3_get_sort(self.ctx_ref(), self.as_ast()), self.ctx)