Python precedence.precedence函数代码示例

    def _print_Add(self, expr):
        args = list(expr.args)

        # Now we need to sort the factors in Add, which are in "rest". Any
        # ordering is fine, but some ordering looks better and some looks bad.
        # This particular solution is slow, but it ensures a sane ordering. It
        # can of course be improved:

        args.sort(Basic._compare_pretty)
        PREC = precedence(expr)
        l = []
        for term in args:
            t = self._print(term)
            if t.startswith('-'):
                sign = "-"
                t = t[1:]
            else:
                sign = "+"
            if precedence(term) < PREC:
                l.extend([sign, "(%s)"%t])
            else:
                l.extend([sign, t])
        sign = l.pop(0)
        if sign=='+':
            sign = ""
        return sign + ' '.join(l)

def test_Number():
    assert precedence(Integer(0)) == PRECEDENCE["Atom"]
    assert precedence(Integer(1)) == PRECEDENCE["Atom"]
    assert precedence(Integer(-1)) == PRECEDENCE["Add"]
    assert precedence(Integer(10)) == PRECEDENCE["Atom"]
    assert precedence(Rational(5, 2)) == PRECEDENCE["Mul"]
    assert precedence(Rational(-5, 2)) == PRECEDENCE["Add"]
    assert precedence(Float(5)) == PRECEDENCE["Atom"]
    assert precedence(Float(-5)) == PRECEDENCE["Add"]
    assert precedence(oo) == PRECEDENCE["Atom"]
    assert precedence(-oo) == PRECEDENCE["Add"]

    def _print_Relational(self, expr):

        charmap = {"==": "Eq", "!=": "Ne", ":=": "Assignment"}

        if expr.rel_op in charmap:
            return "%s(%s, %s)" % (charmap[expr.rel_op], expr.lhs, expr.rhs)

        return "%s %s %s" % (
            self.parenthesize(expr.lhs, precedence(expr)),
            self._relationals.get(expr.rel_op) or expr.rel_op,
            self.parenthesize(expr.rhs, precedence(expr)),
        )

 def _print_Pow(self, expr):
   if expr.exp == 2:
     PREC = precedence(expr)
     s = str(self.parenthesize(expr.base, PREC))
     return '%s*%s' % (s,s)
   else:
     return super(CCodePrinter,self)._print_Pow(expr)

    def parenthesize(self, item, level):
        printed = self._print(item)

        if precedence(item) <= level:
            return "(%s)" % printed
        else:
            return printed

 def _print_Pow(self, expr):
     PREC = precedence(expr)
     if expr.exp is S.NegativeOne:
         return '1/%s'%(self.parenthesize(expr.base, PREC))
     else:
         return '%s**%s'%(self.parenthesize(expr.base, PREC),
                          self.parenthesize(expr.exp, PREC))

    def _print_Pow(self, expr, rational=False):
        PREC = precedence(expr)

        #if expr.base is RootOfUnity:
        #    return 'Exp['+str(2*expr.base.n)+ 'I Pi /'+ str(expr.base.n) + ']'

        if expr.exp is S.Half and not rational:
            return "sqrt(%s)" % self._print(expr.base)

        if expr.is_commutative:
            if -expr.exp is S.Half and not rational:
                # Note: Don't test "expr.exp == -S.Half" here, because that will
                # match -0.5, which we don't want.
                return "1/sqrt(%s)" % self._print(expr.base)
            if expr.exp is -S.One:
                # Similarly to the S.Half case, don't test with "==" here.
                return '1/%s' % self.parenthesize(expr.base, PREC)

        e = self.parenthesize(expr.exp, PREC)
        if self.printmethod == '_sympyrepr' and expr.exp.is_Rational and expr.exp.q != 1:
            # the parenthesized exp should be '(Rational(a, b))' so strip parens,
            # but just check to be sure.
            if e.startswith('(Rational'):
                return '%s^%s' % (self.parenthesize(expr.base, PREC), e[1:-1])
        return '%s^%s' % (self.parenthesize(expr.base, PREC), e)

    def _print_Pow(self, expr, rational=False):
        # WARNING: Code mostly copied from sympy source code!
        from sympy.core import S
        from sympy.printing.precedence import precedence

        PREC = precedence(expr)

        if expr.exp is S.Half and not rational:
            return "sqrt(%s)" % self._print(expr.base)

        if expr.is_commutative:
            if -expr.exp is S.Half and not rational:
                # Note: Don't test "expr.exp == -S.Half" here, because that will
                # match -0.5, which we don't want.
                return "1/sqrt(%s)" % self._print(expr.base)
            if expr.exp is -S.One:
                # Similarly to the S.Half case, don't test with "==" here.
                return '1/%s' % self.parenthesize(expr.base, PREC)

        e = self.parenthesize(expr.exp, PREC)
        if self.printmethod == '_sympyrepr' and expr.exp.is_Rational and expr.exp.q != 1:
            # the parenthesized exp should be '(Rational(a, b))' so strip parens,
            # but just check to be sure.
            if e.startswith('(Rational'):
                e = e[1:-1]

        # Changes below this line!
        if e == "2":
            return '{0}*{0}'.format(self.parenthesize(expr.base, PREC))
        elif e == "3":
            return '{0}*{0}*{0}'.format(self.parenthesize(expr.base, PREC))
        else:
            return 'pow(%s,%s)' % (self.parenthesize(expr.base, PREC), e)

    def _print_Pow(self, expr):
        prec = precedence(expr)

        if expr.exp == -1:
            return '1/%s' % (self.parenthesize(expr.base, prec))
        else:
            return '%s^%s' % (self.parenthesize(expr.base, prec),
                              self.parenthesize(expr.exp, prec))

 def _print_Mul(self, expr):
     PREC = precedence(expr)
     c, nc = expr.args_cnc()
     res = super(MCodePrinter, self)._print_Mul(expr.func(*c))
     if nc:
         res += '*'
         res += '**'.join(self.parenthesize(a, PREC) for a in nc)
     return res

    def _print_Mul(self, expr):
        coeff, terms = expr.as_coeff_mul()
        if coeff.is_negative:
            coeff = -coeff
            if coeff is not S.One:
                terms = (coeff,) + terms
            sign = "-"
        else:
            terms = (coeff,) + terms
            sign = ""

        a = [] # items in the numerator
        b = [] # items that are in the denominator (if any)

        if self.order != 'old':
            args = expr._new_rawargs(*terms).as_ordered_factors()
        else:
            args = terms

        # Gather args for numerator/denominator
        for item in args:
            if item.is_Pow and item.exp.is_Rational and item.exp.is_negative:
                b.append(Pow(item.base, -item.exp))
            elif item.is_Rational and item is not S.Infinity:
                if item.p != 1:
                    a.append(Rational(item.p))
                if item.q != 1:
                    b.append(Rational(item.q))
            else:
                a.append(item)

        if len(a)==0:
            a = [S.One]

        a_str = map(lambda x:self.parenthesize(x, precedence(expr)), a)
        b_str = map(lambda x:self.parenthesize(x, precedence(expr)), b)

        if len(b)==0:
            return sign + '*'.join(a_str)
        elif len(b)==1:
            if len(a)==1 and not (a[0].is_Atom or a[0].is_Add):
                return sign + "%s/"%a_str[0] + '*'.join(b_str)
            else:
                return sign + '*'.join(a_str) + "/%s"%b_str[0]
        else:
            return sign + '*'.join(a_str) + "/(%s)"%'*'.join(b_str)

 def _print_Pow(self, expr):
     PREC = precedence(expr)
     if expr.exp is S.NegativeOne:
         return '1.0/%s'%(self.parenthesize(expr.base, PREC))
     elif expr.exp == 0.5:
         return 'sqrt(%s)' % self._print(expr.base)
     else:
         return StrPrinter._print_Pow(self, expr)

 def _print_Pow(self, expr):
     PREC = precedence(expr)
     if expr.exp == -1:
         return "1.0/%s" % (self.parenthesize(expr.base, PREC))
     elif expr.exp == 0.5:
         return "sqrt(%s)" % self._print(expr.base)
     else:
         return "pow(%s, %s)" % (self._print(expr.base), self._print(expr.exp))

 def _print_Pow(self, expr):
     PREC = precedence(expr)
     if expr.exp == -1:
         return '1/%s' % (self.parenthesize(expr.base, PREC))
     elif expr.exp == 0.5:
         return 'Math.sqrt(%s)' % self._print(expr.base)
     else:
         return 'Math.pow(%s, %s)' % (self._print(expr.base),
                              self._print(expr.exp))

 def _print_Pow(self, expr):
     PREC = precedence(expr)
     if expr.exp.is_Rational and expr.exp.p == 1 and expr.exp.q == 2:
         return 'sqrt(%s)' % self._print(expr.base)
     if expr.exp.is_Rational and expr.exp.is_negative:
         return '1/%s'%self._print(expr.base**abs(expr.exp))
     else:
         return '%s^%s'%(self.parenthesize(expr.base, PREC),
                          self.parenthesize(expr.exp, PREC))