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 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 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", } 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_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_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_Add(self, expr): # purpose: print complex numbers nicely in Fortran. # collect the purely real and purely imaginary parts: pure_real = [] pure_imaginary = [] mixed = [] for arg in expr.args: if arg.is_number and arg.is_extended_real: pure_real.append(arg) elif arg.is_number and arg.is_imaginary: pure_imaginary.append(arg) else: mixed.append(arg) if len(pure_imaginary) > 0: if len(mixed) > 0: PREC = precedence(expr) term = Add(*mixed) t = self._print(term) if t.startswith('-'): sign = "-" t = t[1:] else: sign = "+" if precedence(term) < PREC: t = "(%s)" % t return "cmplx(%s,%s) %s %s" % ( self._print(Add(*pure_real)), self._print(-S.ImaginaryUnit * Add(*pure_imaginary)), sign, t, ) else: return "cmplx(%s,%s)" % ( self._print(Add(*pure_real)), self._print(-S.ImaginaryUnit * Add(*pure_imaginary)), ) else: return CodePrinter._print_Add(self, expr)
def _print_Add(self, expr, order=None): if self.order == 'none': terms = list(expr.args) else: terms = expr.as_ordered_terms(order=order or self.order) PREC = precedence(expr) l = [] for term in terms: 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 _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: if expr.base.is_integer: # Fortan intrinsic sqrt() does not accept integer argument if expr.base.is_Number: return 'sqrt(%s.0d0)' % self._print(expr.base) else: return 'sqrt(dble(%s))' % self._print(expr.base) else: return 'sqrt(%s)' % self._print(expr.base) else: return CodePrinter._print_Pow(self, expr)
def _print_Mul(self, expr): prec = precedence(expr) c, e = expr.as_coeff_Mul() if c < 0: expr = _keep_coeff(-c, e) sign = "-" else: sign = "" a = [] # items in the numerator b = [] # items that are in the denominator (if any) if self.order != 'none': args = expr.as_ordered_factors() else: # use make_args in case expr was something like -x -> x args = Mul.make_args(expr) multiple_ones = len([x for x in args if x == S.One]) > 1 # Gather args for numerator/denominator for item in args: if item.is_commutative and item.is_Pow and item.exp.is_Rational and item.exp.is_negative: if item.exp != -1: b.append(Pow(item.base, -item.exp, evaluate=False)) else: b.append(Pow(item.base, -item.exp)) elif item.is_Rational and item is not S.Infinity: if item.p != 1 or multiple_ones: a.append(Rational(item.p)) if item.q != 1: b.append(Rational(item.q)) else: a.append(item) a = a or [S.One] a_str = [self.parenthesize(x, prec) for x in a] b_str = [self.parenthesize(x, prec) for x in b] if len(b) == 0: return sign + '*'.join(a_str) elif len(b) == 1: return sign + '*'.join(a_str) + "/" + b_str[0] else: return sign + '*'.join(a_str) + "/(%s)" % '*'.join(b_str)
def _print_Pow(self, expr, rational=False): 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 == '_diofantrepr' 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 test_And_Or(): # precendence relations between logical operators, ... assert precedence(x & y) > precedence(x | y) assert precedence(~y) > precedence(x & y) # ... and with other operators (cfr. other programming languages) assert precedence(x + y) > precedence(x | y) assert precedence(x + y) > precedence(x & y) assert precedence(x * y) > precedence(x | y) assert precedence(x * y) > precedence(x & y) assert precedence(~y) > precedence(x * y) assert precedence(~y) > precedence(x - y) # double checks assert precedence(x & y) == PRECEDENCE['And'] assert precedence(x | y) == PRECEDENCE['Or'] assert precedence(~y) == PRECEDENCE['Not']
def test_Product(): assert precedence(Product(x, (x, y, y + 1))) == PRECEDENCE['Atom']
def test_Sum(): assert precedence(Sum(x, (x, y, y + 1))) == PRECEDENCE['Atom']
def test_Mul(): assert precedence(x * y) == PRECEDENCE['Mul'] assert precedence(-x * y) == PRECEDENCE['Add']
def test_Order(): assert precedence(Order(x)) == PRECEDENCE['Atom']
def test_Relational(): assert precedence(Rel(x + y, y, "<")) == PRECEDENCE["Relational"]
def test_Derivative(): assert precedence(Derivative(x, y)) == PRECEDENCE['Atom']
def _print_HadamardProduct(self, expr): return '.*'.join( [self.parenthesize(arg, precedence(expr)) for arg in expr.args])
def _print_MatAdd(self, expr): return ' + '.join( [self.parenthesize(arg, precedence(expr)) for arg in expr.args])
def test_And_Or(): # precendence relations between logical operators, ... assert precedence(x & y) > precedence(x | y) assert precedence(~y) > precedence(x & y) # ... and with other operators (cfr. other programming languages) assert precedence(x + y) > precedence(x | y) assert precedence(x + y) > precedence(x & y) assert precedence(x*y) > precedence(x | y) assert precedence(x*y) > precedence(x & y) assert precedence(~y) > precedence(x*y) assert precedence(~y) > precedence(x - y) # double checks assert precedence(x & y) == PRECEDENCE["And"] assert precedence(x | y) == PRECEDENCE["Or"] assert precedence(~y) == PRECEDENCE["Not"]
def test_Order(): assert precedence(Order(x)) == PRECEDENCE["Atom"]
def test_Symbol(): assert precedence(x) == PRECEDENCE["Atom"]
def test_Sum(): assert precedence(Sum(x, (x, y, y + 1))) == PRECEDENCE["Atom"]
def test_Relational(): assert precedence(Rel(x + y, y, "<")) == PRECEDENCE["Relational"]
def test_Product(): assert precedence(Product(x, (x, y, y + 1))) == PRECEDENCE["Atom"]
def test_Mul(): assert precedence(x*y) == PRECEDENCE["Mul"] assert precedence(-x*y) == PRECEDENCE["Add"]
def test_Pow(): assert precedence(x**y) == PRECEDENCE["Pow"] assert precedence(-x**y) == PRECEDENCE["Add"] assert precedence(x**-y) == PRECEDENCE["Pow"]
def test_Integral(): assert precedence(Integral(x, y)) == PRECEDENCE["Atom"]
def test_Function(): assert precedence(sin(x)) == PRECEDENCE['Func']
def _print_Mod(self, expr): PREC = precedence(expr) a, b = expr.args return '%s%%%s' % (self.parenthesize(a, PREC), self.parenthesize(b, PREC))
def test_Integral(): assert precedence(Integral(x, y)) == PRECEDENCE['Atom']
def _print_MatPow(self, expr): PREC = precedence(expr) return '%s**%s' % (self.parenthesize( expr.base, PREC), self.parenthesize(expr.exp, PREC))
def test_Add(): assert precedence(x + y) == PRECEDENCE["Add"] assert precedence(x*y + 1) == PRECEDENCE["Add"]
def test_Derivative(): assert precedence(Derivative(x, y)) == PRECEDENCE["Atom"]
def test_Pow(): assert precedence(x**y) == PRECEDENCE['Pow'] assert precedence(-x**y) == PRECEDENCE['Add'] assert precedence(x**-y) == PRECEDENCE['Pow']
def test_Function(): assert precedence(sin(x)) == PRECEDENCE["Atom"] assert precedence(Derivative(x, y)) == PRECEDENCE["Atom"]
def test_Relational(): assert precedence(Rel(x + y, y, '<')) == PRECEDENCE['Relational']
def test_Mul(): assert precedence(x * y) == PRECEDENCE["Mul"] assert precedence(-x * y) == PRECEDENCE["Add"]
def test_Symbol(): assert precedence(x) == PRECEDENCE['Atom']
def test_Function(): assert precedence(sin(x)) == PRECEDENCE["Func"]
def test_Add(): assert precedence(x + y) == PRECEDENCE['Add'] assert precedence(x * y + 1) == PRECEDENCE['Add']
def test_Pow(): assert precedence(x**y) == PRECEDENCE["Pow"] assert precedence(-x**y) == PRECEDENCE["Add"] assert precedence(x**-y) == PRECEDENCE["Pow"]