Ejemplo n.º 1
0
 def test_nor(self):
     for i in range(0, NUM_TESTS):
         a = random.randint(MIN_TEST, MAX_TEST)
         b = random.randint(MIN_TEST, MAX_TEST)
         correct = opfunc.inv(opfunc.or_(a, b))
         mips_machine.registers["T1"] = a
         mips_machine.registers["T2"] = b
         assemble("nor $t3, $t1, $t2", 'mips', mips_machine)
         self.assertEqual(mips_machine.registers["T3"], correct)
Ejemplo n.º 2
0
    def _intertwining_basis(self, a):
        r"""
        Return a basis for the set of homomorphisms between
        this representation and the same representation conjugated by
        [a,0; 0,1], where a is a generator of `(Z/p^uZ)^\times`. These are
        the "candidates" for extending the rep to a `\mathrm{GL}_2`-rep.

        Depending on the example, the hom-space has dimension either `1` or `2`.

        EXAMPLES::

            sage: from sage.modular.local_comp.type_space import example_type_space
            sage: example_type_space(2)._intertwining_basis(2)
            [
            [ 1 -2  1  0]
            [ 1 -1  0  1]
            [ 1  0 -1  1]
            [ 0  1 -2  1]
            ]
            sage: example_type_space(3)._intertwining_basis(2)
            [
            [ 1  0]  [0 1]
            [-1 -1], [1 0]
            ]
        """
        if self.conductor() % 2:
            f = self.prime() ** (self.u() + 1)
        else:
            f = self.prime() ** self.u()

        # f is smallest p-power such that rho is trivial modulo f
        ainv = (~Zmod(f)(a)).lift()
        gens = self._group_gens()
        gensconj = [[x[0], ainv*x[1], a*x[2], x[3]] for x in gens]
        rgens = [self._rho_s(x) for x in gens]
        rgensinv = [operator.inv(_) for _ in rgens]
        rgensconj = [self._rho_s(x) for x in gensconj]

        rows = []
        MS = rgens[0].parent()
        for m in MS.basis():
            rows.append([])
            for i in range(len(gens)):
                rows[-1] += (m - rgensinv[i] * m * rgensconj[i]).list()
        S = matrix(rows).left_kernel()
        return [MS(u.list()) for u in S.gens()]
Ejemplo n.º 3
0
 def test_invert(self):
     self.failUnless(operator.inv(4) == -5)
Ejemplo n.º 4
0
def n_inv(a):
    """safe inv"""
    return o.inv(intify(a))
Ejemplo n.º 5
0
def inv(a):
    return operator.inv(a)
Ejemplo n.º 6
0
    def test_sys_drawing(self):
        from IronPythonTest import DaysInt, DaysShort, DaysLong, DaysSByte, DaysByte, DaysUShort, DaysUInt, DaysULong
        from System.Drawing import Point, Size, PointF, SizeF, Rectangle, RectangleF
        x = Point()
        self.assertTrue(x == Point(0,0))
        x = Size()
        self.assertTrue(x == Size(0,0))
        x = PointF()
        self.assertTrue(x == PointF(0,0))
        x = SizeF()
        self.assertTrue(x == SizeF(0,0))
        x = Rectangle()
        self.assertTrue(x == Rectangle(0,0,0,0))
        x = RectangleF()
        self.assertTrue(x == RectangleF(0,0,0,0))

        p = Point(3,4)
        s = Size(2,9)

        q = p + s
        self.assertTrue(q == Point(5,13))
        self.assertTrue(q != Point(13,5))
        q = p - s
        self.assertTrue(q == Point(1,-5))
        self.assertTrue(q != Point(0,4))
        q += s
        self.assertTrue(q == Point(3,4))
        self.assertTrue(q != Point(2,4))
        q -= Size(1,2)
        self.assertTrue(q == Point(2,2))
        self.assertTrue(q != Point(1))

        t = s
        self.assertTrue(t == s)
        self.assertTrue(t != s - Size(1,0))
        t += Size(3,1)
        self.assertTrue(t == Size(5,10))
        self.assertTrue(t != Size(5,0))
        t -= Size(2,8)
        self.assertTrue(t == Size(3,2))
        self.assertTrue(t != Size(0,2))
        t = s + Size(-1,-2)
        self.assertTrue(t == Size(1,7))
        self.assertTrue(t != Size(1,5))
        t = s - Size(1,2)
        self.assertTrue(t == Size(1,7))
        self.assertTrue(t != Size(1,3))

        def weekdays(enum):
            return enum.Mon|enum.Tue|enum.Wed|enum.Thu|enum.Fri

        def weekend(enum):
            return enum.Sat|enum.Sun

        def enum_helper(enum):
            days = [enum.Mon,enum.Tue,enum.Wed,enum.Thu,enum.Fri,enum.Sat,enum.Sun]
            x = enum.Mon|enum.Tue|enum.Wed|enum.Thu|enum.Fri|enum.Sat|enum.Sun
            y = enum.Mon
            for day in days:
                y |= day
            self.assertTrue(x == y)
            self.assertFalse(x != y)
            if x == y:  # EqualRetBool
                b = True
            else :
                b = False
            self.assertTrue(b)

            self.assertTrue(x == weekdays(enum)|weekend(enum))
            self.assertTrue(x == (weekdays(enum)^weekend(enum)))
            self.assertTrue((weekdays(enum)&weekend(enum)) == enum["None"])
            self.assertTrue(weekdays(enum) == enum.Weekdays)
            self.assertTrue(weekend(enum) == enum.Weekend)
            self.assertTrue(weekdays(enum) != enum.Weekend)
            self.assertTrue(weekdays(enum) != weekend(enum))

        for e in [DaysInt, DaysShort, DaysLong, DaysSByte, DaysByte, DaysUShort, DaysUInt, DaysULong]:
            enum_helper(e)

        for e in [DaysInt, DaysShort, DaysLong, DaysSByte]:
            z = operator.inv(e.Mon)
            self.assertEqual(type(z), e)
            self.assertEqual(z.ToString(), "-2")

        for (e, v) in [ (DaysByte,254), (DaysUShort,65534), (DaysUInt,4294967294), (DaysULong,18446744073709551614) ]:
            z = operator.inv(e.Mon)
            self.assertEqual(type(z), e)
            self.assertEqual(z.ToString(), str(v))

        self.assertRaises(ValueError, lambda: DaysInt.Mon & DaysShort.Mon)
        self.assertRaises(ValueError, lambda: DaysInt.Mon | DaysShort.Mon)
        self.assertRaises(ValueError, lambda: DaysInt.Mon ^ DaysShort.Mon)
        self.assertRaises(ValueError, lambda: DaysInt.Mon & 1)
        self.assertRaises(ValueError, lambda: DaysInt.Mon | 1)
        self.assertRaises(ValueError, lambda: DaysInt.Mon ^ 1)

        def f():
            if DaysInt.Mon == DaysShort.Mon: return True
            return False

        self.assertEqual(f(), False)

        self.assertTrue(not DaysInt.Mon == None)
        self.assertTrue(DaysInt.Mon != None)
Ejemplo n.º 7
0
 def test_invert(self):
     #operator = self.module
     self.assertRaises(TypeError, operator.invert)
     self.assertRaises(TypeError, operator.invert, None)
     self.assertEqual(operator.inv(4), -5)
Ejemplo n.º 8
0
 def test_invert(self):
     self.failUnlessRaises(TypeError, operator.invert)
     self.failUnlessRaises(TypeError, operator.invert, None)
     self.failUnless(operator.inv(4) == -5)
Ejemplo n.º 9
0
from emmett import sdict
from emmett.orm.objects import Expression, Query, Set as DBSet
from functools import reduce
from typing import Any, Callable, Dict, Optional, Set, Union

from ..typing import ModelType
from .errors import QueryError
from .validation import op_validators

_query_operators = {
    '$and':
    operator.and_,
    '$or':
    operator.or_,
    '$not':
    lambda field, value: operator.inv(value),
    '$eq':
    operator.eq,
    '$neq':
    operator.ne,
    '$lt':
    operator.lt,
    '$gt':
    operator.gt,
    '$lte':
    operator.le,
    '$gte':
    operator.ge,
    '$in':
    lambda field, value: operator.methodcaller('belongs', value)(field),
    '$exists':
Ejemplo n.º 10
0
class Z3Context(Context):
    def __init__(self, *args, **kw):
        Context.__init__(self, *args, **kw)
        self.solver = z3.Solver()

    def __getitem__(self, key):
        if not isinstance(key, Sort) and key in self.storage:
            return self.storage[key]
        elif isinstance(key, Sort):
            if key.name in self.storage:
                return self.storage[key.name]
            val = self.new_from_sort(key)
            self.storage[key.name] = val
            return val
        else:
            raise ValueError("%s not found! %s. %s." %(key, type(key), self.storage))

    def new_from_sort(self, key):
        if isinstance(key, Bool):
            key = key.name
            val = z3.Bool(key)
            return val
        elif isinstance(key, Int):
            key = key.name
            val = z3.Int(key)
            return val
        elif isinstance(key, String):
            key = key.name
            val = z3.String(key)
            return val
        elif isinstance(key, BitVec):
            name = key.name
            size = key.size
            val = z3.BitVec(name, size)
            return val
        raise TypeError("%s not supported!" %type(key))

    def s_assert(self, expr):
        self.solver.assert_exprs(expr.cval(self))

    def s_check(self):
        res = self.solver.check()
        return res

    def s_model(self):
        try:
            m = self.solver.model()
            return self.process_model(m)
        except z3.Z3Exception:
            return {}

    def s_push(self):
        self.solver.push()

    def s_pop(self):
        self.solver.pop()

    def s_reset(self):
        self.solver.reset()

    def solve(self, AST):
        outputs = []
        self.s_reset()
        for node in AST:
            if isinstance(node, Sort):
                self.s_assert(node)
            elif isinstance(node, Let):
                self.s_assert(node.term)
            elif isinstance(node, Command):
                if node.cname == "push":
                    self.s_push()
                elif node.cname == "pop":
                    self.s_pop()
                elif node.cname == "check-sat":
                    logger.info("\n-------")
                    outputs.append(self.s_check())
                    logger.info("Check: %s" % outputs[-1])
                elif node.cname == "get-model":
                    outputs.append(self.s_model())
                    logger.info("Model: %s" % outputs[-1])
            else:
                raise ValueError("Command %s not supported!" %node)
        
        return outputs

    def process_model(self, z3_model):
        m = {}
        for v in z3_model:
            m[v.name()] = self.get_py_value(z3_model.get_interp(v))
        return m

    def get_py_value(self, assignment):
        if z3.is_ast(assignment):
            if z3.is_int_value(assignment):
                return assignment.as_long()
            if z3.is_bool(assignment):
                return z3.is_true(assignment)
            if z3.is_string_value(assignment):
                try:
                    val = assignment.as_string()[1:-1]  # remove quotes
                    val = val.replace("\\x00", "")
                    return str(val)
                # Z3 throws encoding errors. It can't decode its own solution..
                # TODO find a better fix.
                except UnicodeDecodeError:
                    val = assignment.as_ast()
                    return repr(val)
            raise ValueError("Unsupported Z3 type! %s" % type(assignment))
        
        return assignment

    BoolVal = lambda self, x : z3.BoolVal(x)
    StringVal = lambda self, x : z3.StringVal(x)
    IntVal = lambda self, x : z3.IntVal(x)
    BitVecVal = lambda self, val, size : z3.BitVecVal(val, size)

    And = lambda self, *x : z3.And(x)
    Or = lambda self, *x : z3.Or(x)
    Xor = lambda self, *x : reduce(xor, x)
    Implies = lambda self, x, y : z3.Implies(x, y)
    Distinct = lambda self, x, y : z3.Distinct(x, y)

    def Eq(self, x, y):
        # x = z3.String("x")
        # x == "test" #throws an error. This is a workaround for now.
        x = z3.StringVal(x) if isinstance(x,str) else x
        y = z3.StringVal(y) if isinstance(y,str) else y
        return eq(x,y)

    Not = lambda self, x : z3.Not(x)

    If = lambda self, *x : z3.If(*x)

    add = lambda self, *x : reduce(add, x)
    sub = lambda self, *x : reduce(sub, x) if len(x) > 1 else -x[0]
    mul = lambda self, *x : reduce(mul, x)
    
    lt = lambda self, *x : reduce(lt, x)
    le = lambda self, *x : reduce(le, x)
    gt = lambda self, *x : reduce(gt, x)
    ge = lambda self, *x : reduce(ge, x)

    concat = lambda self, *x : reduce(add, x)
    length = lambda self, x : z3.Length(x)
    contains = lambda self, x, y : z3.Contains(x, y)
    indexof = lambda self, x, y, z=0 : z3.IndexOf(x, y, z)
    extract = lambda self, x, y, z : z3.Extract(x, y, z)

    bvadd = add
    bvsub = sub
    bvmul = mul
    bvxor = Xor
    bvneg = lambda self, x : neg(x)
    bvnot = lambda self, x : inv(x)
    bvconcat = lambda self, *x : z3.Concat(*x)
    bvlshr = lambda self, x, y : z3.LShR(x, y)
    bvlshl = lambda self, x, y : z3.LShL(x, y)
    bvuge = lambda self, x, y : z3.UGE(x, y)
    bvurem = lambda self, x, y : z3.URem(x, y)

    # TODO Need to define all these with stuff in computation folder
    FPAbs = lambda self, *x : None
    FPNeg = lambda self, *x : None
    FPAdd = lambda self, *x : None
    FPSub = lambda self, *x : None
    FPMul = lambda self, *x : None
    FPDiv = lambda self, *x : None
    FPFMA = lambda self, *x : None
    FPRem = lambda self, *x : None
    FPSqrt = lambda self, *x : None
    FPRoundToIntegral = lambda self, *x : None
    FPMin = lambda self, *x : None
    FPMax = lambda self, *x : None
    FPLEQ = lambda self, *x : None
    FPLT = lambda self, *x : None
    FPGEQ = lambda self, *x : None
    FPGT = lambda self, *x : None
    FPEQ = lambda self, *x : None
    FPIsNormal = lambda self, *x : None
    FPIsSubNormal = lambda self, *x : None
    FPIsZero = lambda self, *x : None
    FPIsInfinite = lambda self, *x : None
    FPIsNan = lambda self, *x : None
    FPIsNegative = lambda self, *x : None
    FPIsPositive = lambda self, *x : None
Ejemplo n.º 11
0
print operator.mod(9,4)

#精确除法
print operator.truediv(9.04,4)

#绝对值
print operator.abs(-10)

#取反 相当于 -a
print operator.neg(-10)

#取反 相当于 ~a  
#~a = (-a)-1
#~10 = -11
#~(-10) = 9
print operator.inv(10)
print operator.inv(-10)
print operator.invert(10)
print operator.invert(-10)

#乘方 同a**b
print operator.pow(2,3)

#向左移位 同<< 相当于乘以2的相应次方
print operator.lshift(3,2)

#向右移位 同>> 相当于除以2的相应次方 取整
print operator.rshift(3,2)

#按位与 即 a&b
print operator.and_(1,8)
Ejemplo n.º 12
0
import operator
Ejemplo n.º 13
0
def inv(a):
    return operator.inv(a)
Ejemplo n.º 14
0
 def test_invert(self):
     self.failUnlessRaises(TypeError, operator.invert)
     self.failUnlessRaises(TypeError, operator.invert, None)
     self.assertEqual(operator.inv(4), -5)
Ejemplo n.º 15
0
a = 1
print id(a)
b = 1
print operator.is_(a, b)
b = 2
print operator.is_(a, b)

a = -1
print id(a)




print operator.index(1)

print operator.inv(8)

print operator.lshift(4, 1)


print operator.or_(2,4)


print operator.pos(30)



print operator.pow(2,8)


Ejemplo n.º 16
0
 def test_invert(self):
     self.assertRaises(TypeError, operator.invert)
     self.assertRaises(TypeError, operator.invert, None)
     self.assertTrue(operator.inv(4) == -5)
Ejemplo n.º 17
0
import operator
Ejemplo n.º 18
0
	def __invert__(self): return Vector([operator.inv(c) for c in self])
	def __neg__   (self): return Vector([operator.neg(c) for c in self])
Ejemplo n.º 19
0
# ===----------------------------------------------------------------------===

_inv, _shift, _rotate = map(Symbol,
'  ~   shift   rotate'.split())

from operator import inv

builtinEnvironment[_inv] = Procedure(
  params      = Tuple([
      (1, FractionCompatible),
    ]),
  defaults    = Tuple(),
  ellipsis    = False,
  environment = builtinEnvironment,
  body        = lambda eval_,env:inv(env[1]),
)

# ===----------------------------------------------------------------------===

_abs, _add, _sub, _div, _mul, _divmod, _pow = map(Symbol,
'abs     +     -     /     *   divmod   pow'.split())

from operator import add, sub, mul, truediv

builtinEnvironment[_add] = Procedure(
  params      = Tuple([
      (1, FractionCompatible),
      (2, FractionCompatible),
    ]),
  defaults    = Tuple(),