Python operator.__xor__方法代码示例

# 需要导入模块: import operator [as 别名]
# 或者: from operator import __xor__ [as 别名]
def __xor__(self, other):                                      
        '''
        Take a bitwise 'XOR' of the bit vector on which the method is invoked with
        the argument bit vector.  Return the result as a new bit vector.  If the two
        bit vectors are not of the same size, pad the shorter one with zeros from the
        left.
        '''
        if self.size < other.size:                                  
            bv1 = self._resize_pad_from_left(other.size - self.size)
            bv2 = other                                             
        elif self.size > other.size:                                
            bv1 = self                                              
            bv2 = other._resize_pad_from_left(self.size - other.size)
        else:                                                        
            bv1 = self                                               
            bv2 = other                                             
        res = BitVector( size = bv1.size )                          
        lpb = map(operator.__xor__, bv1.vector, bv2.vector)         
        res.vector = array.array( 'H', lpb )                        
        return res 

# 需要导入模块: import operator [as 别名]
# 或者: from operator import __xor__ [as 别名]
def __init__(self):
        Backend.__init__(self)
        # self._make_raw_ops(set(expression_operations) - set(expression_set_operations), op_module=BackendVSA)
        self._make_expr_ops(set(expression_set_operations), op_class=self)
        self._make_raw_ops(set(backend_operations_vsa_compliant), op_module=BackendVSA)

        self._op_raw['StridedInterval'] = BackendVSA.CreateStridedInterval
        self._op_raw['ValueSet'] = ValueSet.__init__
        self._op_raw['AbstractLocation'] = AbstractLocation.__init__
        self._op_raw['Reverse'] = BackendVSA.Reverse
        self._op_raw['If'] = self.If
        self._op_expr['BVV'] = self.BVV
        self._op_expr['BoolV'] = self.BoolV
        self._op_expr['BVS'] = self.BVS

        # reduceable
        self._op_raw['__add__'] = self._op_add
        self._op_raw['__sub__'] = self._op_sub
        self._op_raw['__mul__'] = self._op_mul
        self._op_raw['__or__'] = self._op_or
        self._op_raw['__xor__'] = self._op_xor
        self._op_raw['__and__'] = self._op_and
        self._op_raw['__mod__'] = self._op_mod 

# 需要导入模块: import operator [as 别名]
# 或者: from operator import __xor__ [as 别名]
def _op_xor(*args):
        return reduce(operator.__xor__, args) 

# 需要导入模块: import operator [as 别名]
# 或者: from operator import __xor__ [as 别名]
def __init__(self):
        Backend.__init__(self)
        self._make_raw_ops(set(backend_operations) - { 'If' }, op_module=bv)
        self._make_raw_ops(backend_strings_operations, op_module=strings)
        self._make_raw_ops(backend_fp_operations, op_module=fp)
        self._op_raw['If'] = self._If
        self._op_raw['BVV'] = self.BVV
        self._op_raw['StringV'] = self.StringV
        self._op_raw['FPV'] = self.FPV

        # reduceable
        self._op_raw['__add__'] = self._op_add
        self._op_raw['__sub__'] = self._op_sub
        self._op_raw['__mul__'] = self._op_mul
        self._op_raw['__or__'] = self._op_or
        self._op_raw['__xor__'] = self._op_xor
        self._op_raw['__and__'] = self._op_and

        # unary
        self._op_raw['__invert__'] = self._op_not
        self._op_raw['__neg__'] = self._op_neg

        # boolean ops
        self._op_raw['And'] = self._op_and
        self._op_raw['Or'] = self._op_or
        self._op_raw['Xor'] = self._op_xor
        self._op_raw['Not'] = self._op_boolnot

        self._cache_objects = False 

# 需要导入模块: import operator [as 别名]
# 或者: from operator import __xor__ [as 别名]
def propagateXor( x, y):
    return propagateBitwise(x, y, operator.__xor__, False, False) 

# 需要导入模块: import operator [as 别名]
# 或者: from operator import __xor__ [as 别名]
def test_xor(self):
        self._test_incompatible_types_fail(operator.__xor__)

        self.assertEqual(no_flags ^ no_flags, no_flags)
        self.assertEqual(no_flags ^ all_flags, all_flags)
        self.assertEqual(no_flags ^ f0, f0)
        self.assertEqual(no_flags ^ f1, f1)
        self.assertEqual(no_flags ^ f2, f2)
        self.assertEqual(no_flags ^ f01, f01)
        self.assertEqual(no_flags ^ f02, f02)
        self.assertEqual(no_flags ^ f12, f12)

        self.assertEqual(f0 ^ no_flags, f0)
        self.assertEqual(f0 ^ all_flags, f12)
        self.assertEqual(f0 ^ f0, no_flags)
        self.assertEqual(f0 ^ f1, f01)
        self.assertEqual(f0 ^ f2, f02)
        self.assertEqual(f0 ^ f01, f1)
        self.assertEqual(f0 ^ f02, f2)
        self.assertEqual(f0 ^ f12, all_flags)

        self.assertEqual(f01 ^ no_flags, f01)
        self.assertEqual(f01 ^ all_flags, f2)
        self.assertEqual(f01 ^ f0, f1)
        self.assertEqual(f01 ^ f1, f0)
        self.assertEqual(f01 ^ f2, all_flags)
        self.assertEqual(f01 ^ f01, no_flags)
        self.assertEqual(f01 ^ f02, f12)
        self.assertEqual(f01 ^ f12, f02)

        self.assertEqual(all_flags ^ no_flags, all_flags)
        self.assertEqual(all_flags ^ all_flags, no_flags)
        self.assertEqual(all_flags ^ f0, f12)
        self.assertEqual(all_flags ^ f1, f02)
        self.assertEqual(all_flags ^ f2, f01)
        self.assertEqual(all_flags ^ f01, f2)
        self.assertEqual(all_flags ^ f02, f1)
        self.assertEqual(all_flags ^ f12, f0) 

# 需要导入模块: import operator [as 别名]
# 或者: from operator import __xor__ [as 别名]
def __xor__(self, other):  return _op2(self, other, operator.__xor__) 

# 需要导入模块: import operator [as 别名]
# 或者: from operator import __xor__ [as 别名]
def __rxor__(self, other):  return _op2(self, other, operator.__xor__, rev=True) 

# 需要导入模块: import operator [as 别名]
# 或者: from operator import __xor__ [as 别名]
def __init__(self, reuse_z3_solver=None, ast_cache_size=10000):
        Backend.__init__(self, solver_required=True)
        self._enable_simplification_cache = False
        self._hash_to_constraint = weakref.WeakValueDictionary()

        # Per-thread Z3 solver
        # This setting is treated as a global setting and is not supposed to be changed during runtime, unless you know
        # what you are doing.
        if reuse_z3_solver is None:
            reuse_z3_solver = True if os.environ.get('REUSE_Z3_SOLVER', "False").lower() in {"1", "true", "yes", "y"} \
                else False
        self.reuse_z3_solver = reuse_z3_solver

        self._ast_cache_size = ast_cache_size

        # and the operations
        all_ops = backend_fp_operations | backend_operations if supports_fp else backend_operations
        all_ops |= backend_strings_operations - {'StrIsDigit'} 
        for o in all_ops - {'BVV', 'BoolV', 'FPV', 'FPS', 'BitVec', 'StringV'}:
            self._op_raw[o] = getattr(self, '_op_raw_' + o)
        self._op_raw['Xor'] = self._op_raw_Xor

        self._op_raw['__ge__'] = self._op_raw_UGE
        self._op_raw['__gt__'] = self._op_raw_UGT
        self._op_raw['__le__'] = self._op_raw_ULE
        self._op_raw['__lt__'] = self._op_raw_ULT

        self._op_raw['Reverse'] = self._op_raw_Reverse
        self._op_raw['Identical'] = self._identical
        self._op_raw['fpToSBV'] = self._op_raw_fpToSBV
        self._op_raw['fpToUBV'] = self._op_raw_fpToUBV

        self._op_expr['BVS'] = self.BVS
        self._op_expr['BVV'] = self.BVV
        self._op_expr['FPV'] = self.FPV
        self._op_expr['FPS'] = self.FPS
        self._op_expr['BoolV'] = self.BoolV
        self._op_expr['BoolS'] = self.BoolS
        self._op_expr['StringV'] = self.StringV
        self._op_expr['StringS'] = self.StringS

        self._op_raw['__floordiv__'] = self._op_div
        self._op_raw['__mod__'] = self._op_mod

        # reduceable
        self._op_raw['__add__'] = self._op_add
        self._op_raw['__sub__'] = self._op_sub
        self._op_raw['__mul__'] = self._op_mul
        self._op_raw['__or__'] = self._op_or
        self._op_raw['__xor__'] = self._op_xor
        self._op_raw['__and__'] = self._op_and

    # XXX this is a HUGE HACK that should be removed whenever uninitialized gets moved to the
    # "proposed annotation backend" or wherever will prevent it from being part of the object
    # identity. also whenever the VSA attributes get the fuck out of BVS as well