def test_is_methods(self): from fractions import Fraction as pyFraction self.assertFalse(is_pysmt_fraction(4)) self.assertTrue(is_pysmt_fraction(Fraction(4))) self.assertFalse(is_pysmt_integer(4.0)) self.assertTrue(is_pysmt_integer(Integer(4))) self.assertTrue(is_python_integer(int(2))) if PY2: self.assertTrue(is_python_integer(long(2))) if HAS_GMPY: from gmpy2 import mpz self.assertTrue(is_python_integer(mpz(1))) if HAS_GMPY: from gmpy2 import mpz, mpq self.assertTrue(is_python_rational(mpz(1))) self.assertTrue(is_python_rational(mpq(1))) if PY2: self.assertTrue(is_python_rational(long(1))) self.assertTrue(is_python_rational(pyFraction(5))) self.assertTrue(is_python_rational(3)) self.assertTrue(is_python_boolean(True)) self.assertTrue(is_python_boolean(False))
def test_is_methods(self): self.assertFalse(is_pysmt_fraction(4)) self.assertTrue(is_pysmt_fraction(Fraction(4))) self.assertFalse(is_pysmt_integer(4.0)) self.assertTrue(is_pysmt_integer(Integer(4))) self.assertTrue(is_python_integer(int(2))) if PY2: self.assertTrue(is_python_integer(long(2))) if HAS_GMPY: from gmpy2 import mpz self.assertTrue(is_python_integer(mpz(1))) if HAS_GMPY: from gmpy2 import mpz, mpq self.assertTrue(is_python_rational(mpz(1))) self.assertTrue(is_python_rational(mpq(1))) if PY2: self.assertTrue(is_python_rational(long(1))) self.assertTrue(is_python_rational(pyFraction(5))) self.assertTrue(is_python_rational(3)) self.assertTrue(is_python_boolean(True)) self.assertTrue(is_python_boolean(False))
def __init__(self, **base_options): SolverOptions.__init__(self, **base_options) if self.unsat_cores_mode is not None: raise PysmtValueError("'unsat_cores_mode' option not supported.") # Set Defaults self.preprocessing = True self.propagation_limit = None self.more_important_lit = None self.less_important_lit = None self.global_default_phase = None self.enable_trace_generation = False self.output = None self.verbosity = 0 for k, v in self.solver_options.items(): if k == "enable_trace_generation": if v not in (True, False): raise PysmtValueError("Invalid value for %s: %s" % \ (str(k),str(v))) elif k == "output": if v is not None and not hasattr(v, "fileno"): raise PysmtValueError("Invalid value for %s: %s" % \ (str(k),str(v))) elif k == "global_default_phase": if v is not None and v not in PicosatOptions.ALL_GLOBAL_DEFAULT_PHASE: raise PysmtValueError("Invalid value for %s: %s" % \ (str(k),str(v))) elif k == "preprocessing": if v not in (True, False): raise PysmtValueError("Invalid value for %s: %s" % \ (str(k),str(v))) elif k == "verbosity": if not is_python_integer(v): raise PysmtValueError("Invalid value for %s: %s" % \ (str(k),str(v))) elif k == "propagation_limit": if not is_python_integer(v): raise PysmtValueError("Invalid value for %s: %s" % \ (str(k),str(v))) elif k in ("more_important_lit", "less_important_lit"): if v is not None: try: valid = all(x.is_symbol(types.BOOL) for x in v) except: valid = False if not valid: raise PysmtValueError("'more_important_lit' and " "'less_important_lit' require a " "list of Boolean variables") else: raise PysmtValueError("Unrecognized option '%s'." % k) # Store option setattr(self, k, v) # Consistency if self.output is not None and self.verbosity == 0: self.verbosity = 1
def __init__(self, **base_options): SolverOptions.__init__(self, **base_options) if self.unsat_cores_mode is not None: raise PysmtValueError("'unsat_cores_mode' option not supported.") # Set Defaults self.preprocessing = True self.propagation_limit = None self.more_important_lit = None self.less_important_lit = None self.global_default_phase = None self.enable_trace_generation = False self.output = None self.verbosity = 0 for k,v in self.solver_options.items(): if k == "enable_trace_generation": if v not in (True, False): raise PysmtValueError("Invalid value for %s: %s" % \ (str(k),str(v))) elif k == "output": if v is not None and not hasattr(v, "fileno"): raise PysmtValueError("Invalid value for %s: %s" % \ (str(k),str(v))) elif k == "global_default_phase": if v is not None and v not in PicosatOptions.ALL_GLOBAL_DEFAULT_PHASE: raise PysmtValueError("Invalid value for %s: %s" % \ (str(k),str(v))) elif k == "preprocessing": if v not in (True, False): raise PysmtValueError("Invalid value for %s: %s" % \ (str(k),str(v))) elif k == "verbosity": if not is_python_integer(v): raise PysmtValueError("Invalid value for %s: %s" % \ (str(k),str(v))) elif k == "propagation_limit": if not is_python_integer(v): raise PysmtValueError("Invalid value for %s: %s" % \ (str(k),str(v))) elif k in ("more_important_lit", "less_important_lit"): if v is not None: try: valid = all(x.is_symbol(types.BOOL) for x in v) except: valid = False if not valid: raise PysmtValueError("'more_important_lit' and " "'less_important_lit' require a " "list of Boolean variables") else: raise PysmtValueError("Unrecognized option '%s'." % k) # Store option setattr(self, k, v) # Consistency if self.output is not None and self.verbosity == 0: self.verbosity = 1
def BVExtract(self, formula, start=0, end=None): """Returns the slice of formula from start to end (inclusive).""" if end is None: end = formula.bv_width()-1 assert is_python_integer(start) and is_python_integer(end) assert end >= start and start >= 0, "Start: %d ; End: %d" % (start,end) size = end-start+1 assert size <= formula.bv_width(), \ "Invalid size: start=%d, end=%d, width=%d" % \ (start, end, formula.bv_width()) return self.create_node(node_type=op.BV_EXTRACT, args=(formula,), payload=(size, start, end))
def BVLShr(self, left, right): """Returns the logical right shift the BV.""" if is_python_integer(right): right = self.BV(right, left.bv_width()) return self.create_node(node_type=op.BV_LSHR, args=(left, right), payload=(left.bv_width(),))
def SBV(self, value, width=None): """Returns a constant of type BitVector interpreting the sign. If the specified value is an integer, it is converted in the 2-complement representation of the given number, otherwise the behavior is the same as BV(). """ if is_python_integer(value): if width is None: raise PysmtValueError("Need to specify a width for the constant") min_val = -(2**(width-1)) max_val = (2**(width-1)) - 1 if value < min_val: raise PysmtValueError("Cannot represent a value (%d) lower " \ "than %d in %d bits" % (value, min_val, width)) if value > max_val: raise PysmtValueError("Cannot represent a value (%d) greater " \ "than %d in %d bits" % (value, max_val, width)) if value >= 0: return self.BV(value, width) else: comp_value = (2**width) + value # value is negative! return self.BV(comp_value, width) else: return self.BV(value, width=width)
def BVAShr(self, left, right): """Returns the RIGHT arithmetic rotation of the left BV by the number of steps specified by the right BV.""" if is_python_integer(right): right = self.BV(right, left.bv_width()) return self.create_node(node_type=op.BV_ASHR, args=(left, right), payload=(left.bv_width(),))
def BVRor(self, formula, steps): """Returns the RIGHT rotation of the BV by the number of steps.""" if not is_python_integer(steps): raise PysmtTypeError("BVRor: 'steps' should be an integer. Got %s" \ % steps) return self.create_node(node_type=op.BV_ROR, args=(formula,), payload=(formula.bv_width(), steps))
def __rsub__(self, left): # Swap operators to perform right-subtract # For BVs we might need to build the BV constant if self.get_type().is_bv_type(): if is_python_integer(left): left = _mgr().BV(left, width=self.bv_width()) return left._apply_infix(self, _mgr().BVSub) # (x - y) = (-y + x) minus_self = -self return minus_self._apply_infix(left, _mgr().Plus)
def walk_bv_rotate(self, formula, args, **kwargs): #pylint: disable=unused-argument target_width = formula.bv_width() rot_step = formula.bv_rotation_step() if is_python_integer( rot_step ) and target_width < formula.bv_rotation_step() or target_width < 0: return None if target_width != args[0].width: return None return BVType(target_width)
def BVZExt(self, formula, increase): """Returns the extension of the BV with 'increase' additional bits New bits are set to zero. """ if not is_python_integer(increase): raise PysmtTypeError("BVZext: 'increase' should be an integer. " "Got %s" % increase) return self.create_node(node_type=op.BV_ZEXT, args=(formula,), payload=(formula.bv_width()+increase, increase))
def BVSExt(self, formula, increase): """Returns the signed extension of the BV with 'increase' additional bits New bits are set according to the most-significant-bit. """ if not is_python_integer(increase): raise PysmtTypeError("BVSext: 'increase' should be an integer. " "Got %s" % increase) return self.create_node(node_type=op.BV_SEXT, args=(formula,), payload=(formula.bv_width()+increase, increase))
def _apply_infix(self, right, function, bv_function=None): if _env().enable_infix_notation: mgr = _mgr() # BVs # Default bv_function to function if bv_function is None: bv_function = function if _is_bv(self): if is_python_integer(right): right = mgr.BV(right, width=self.bv_width()) return bv_function(self, right) # Boolean, Integer and Arithmetic if is_python_boolean(right): right = mgr.Bool(right) elif is_python_integer(right): ty = self.get_type() if ty.is_real_type(): right = mgr.Real(right) else: right = mgr.Int(right) elif is_python_rational(right): right = mgr.Real(right) return function(self, right) else: raise PysmtModeError("Cannot use infix notation")
def _apply_infix(self, right, function, bv_function=None): if _env().enable_infix_notation: mgr = _mgr() # BVs # Default bv_function to function if bv_function is None: bv_function = function if _is_bv(self): if is_python_integer(right): right = mgr.BV(right, width=self.bv_width()) return bv_function(self, right) # Boolean, Integer and Arithmetic if is_python_boolean(right): right = mgr.Bool(right) elif is_python_integer(right): ty = self.get_type() if ty.is_real_type(): right = mgr.Real(right) else: right = mgr.Int(right) elif is_python_rational(right): right = mgr.Real(right) return function(self, right) else: raise Exception("Cannot use infix notation")
def BV(self, value, width=None): """Return a constant of type BitVector. value can be either: - a string of 0s and 1s - a string starting with "#b" followed by a sequence of 0s and 1s - an integer number s.t. 0 <= value < 2**width In order to create the BV representation of a signed integer, the SBV() method shall be used. """ if type(value) is str: if value.startswith("#b"): str_width = len(value)-2 value = int(value[2:],2) elif all(v in ["0", "1"] for v in value): str_width = len(value) value = int(value, 2) else: raise PysmtValueError("Expecting binary value as string, got " \ "%s instead." % value) if width is not None and width != str_width: raise PysmtValueError("Specified width does not match string " \ "width (%d != %d)" % (width, str_width)) width = str_width if width is None: raise PysmtValueError("Need to specify a width for the constant") if is_pysmt_integer(value): _value = value elif is_python_integer(value): _value = pysmt_integer_from_integer(value) else: raise PysmtTypeError("Invalid type in constant. The type was: %s" \ % str(type(value))) if _value < 0: raise PysmtValueError("Cannot specify a negative value: %d" \ % _value) if _value >= 2**width: raise PysmtValueError("Cannot express %d in %d bits" \ % (_value, width)) return self.create_node(node_type=op.BV_CONSTANT, args=tuple(), payload=(_value, width))
def walk_bv_rotate(self, formula): if formula.is_bv_ror(): rotate_type = "rotate_right" else: assert formula.is_bv_rol() rotate_type = "rotate_left" rot_step = formula.bv_rotation_step() if is_python_integer(rot_step): self.write("((_ %s %d) " % (rotate_type, rot_step)) yield formula.arg(0) else: self.write("(ext_%s " % rotate_type) yield formula.arg(0) self.write(" ") yield rot_step self.write(")")
def Int(self, value): """Return a constant of type INT.""" if value in self.int_constants: return self.int_constants[value] if is_pysmt_integer(value): val = value elif is_python_integer(value): val = pysmt_integer_from_integer(value) else: raise PysmtTypeError("Invalid type in constant. The type was:" + \ str(type(value))) n = self.create_node(node_type=op.INT_CONSTANT, args=tuple(), payload=val) self.int_constants[value] = n return n