def _print_Relational(self, expr): return "{0} {1} {2}".format(self.parenthesize(expr.lhs, _precedence(expr)), _relational_map_matlab[expr.rel_op], self.parenthesize(expr.rhs, _precedence(expr))) return '{0}({1}, {2})'.format(_relational_map_matlab[expr.rel_op], self._print(expr.lhs), self._print(expr.rhs))
def _print_Relational(self, expr): if self._namespace == "ufl.": return 'ufl.{0}({1}, {2})'.format(_relational_map[expr.rel_op].lower(), self._print(expr.lhs), self._print(expr.rhs)) return "{0} {1} {2}".format(self.parenthesize(expr.lhs, _precedence(expr)), expr.rel_op, self.parenthesize(expr.rhs, _precedence(expr)))
def _print_Pow(self, expr, rational=False): PREC = _precedence(expr) if expr.exp.is_integer and int(expr.exp) == 1: return self.parenthesize(expr.base, PREC) if expr.exp is sp.S.NegativeOne: return "1.0/{0}".format(self.parenthesize(expr.base, PREC)) if expr.exp.is_integer and int(expr.exp) in [2, 3]: return "({0})".format(\ "*".join(self.parenthesize(expr.base, PREC) \ for i in xrange(int(expr.exp))), PREC) if expr.exp.is_integer and int(expr.exp) in [-2, -3]: return "1.0/({0})".format(\ "*".join(self.parenthesize(expr.base, PREC) \ for i in xrange(-int(expr.exp))), PREC) if expr.exp is sp.S.Half and not rational: return "{0}sqrt({1})".format(self._namespace, self._print(expr.base)) if expr.exp == -0.5: return "1/{0}sqrt({1})".format(self._namespace, self._print(expr.base)) if self._namespace == "ufl.": return "{0}elem_pow({1}, {2})".format(self._namespace, self._print(expr.base), self._print(expr.exp)) if self._namespace in ["np.", "numpy."]: return "{0}power({1}, {2})".format(self._namespace, self._print(expr.base), self._print(expr.exp)) return "{0}pow({1}, {2})".format(self._namespace, self._print(expr.base), self._print(expr.exp))
def _print_Or(self, expr): PREC = _precedence(expr) if self._namespace == "ufl.": if len(expr.args) != 2: error("UFL does not support more than 2 operands to Or") return "ufl.Or({0}, {1})".format(self._print(expr.args[0]), self._print(expr.args[1])) return "Or({0})".format(", ".join(self._print(arg) for arg in expr.args[::-1]))
def _print_Mul(self, expr): prec = _precedence(expr) if self.order not in ('old', 'none'): args = expr.as_ordered_factors() else: # use make_args in case expr was something like -x -> x args = sp.Mul.make_args(expr) args = tuple(args) if _coeff_isneg(expr): # If negative and -1 is the first arg: remove it if args[0].is_integer and int(args[0]) == 1: args = args[1:] else: args = (-args[0],) + args[1:] sign = "-" else: sign = "" # If first argument is Mul we do not want to add a parentesize if isinstance(args[0], sp.Mul): prec -= 1 a = [] # items in the numerator b = [] # items that are in the denominator (if any) # 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(sp.Pow(item.base, -item.exp, evaluate=False)) else: b.append(sp.Pow(item.base, -item.exp)) elif item.is_Rational and item is not sp.S.Infinity: if item.p != 1: a.append(sp.Rational(item.p)) if item.q != 1: b.append(sp.Rational(item.q)) else: a.append(item) a = a or [sp.S.One] a_str = map(lambda x:self.parenthesize(x, prec), a) b_str = map(lambda x:self.parenthesize(x, prec), 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 + "{0}/".format(a_str[0]) + '*'.join(b_str) else: return sign + '*'.join(a_str) + "/{0}".format(b_str[0]) else: return sign + '*'.join(a_str) + "/({0})".format('*'.join(b_str))
def _print_And(self, expr): PREC = _precedence(expr) if self._namespace == "ufl.": if len(expr.args) != 2: error("UFL does not support more than 2 operands to And") return "ufl.And({0}, {1})".format(self._print(expr.args[0]), self._print(expr.args[1])) return " and ".join(self.parenthesize(arg, PREC) for arg in expr.args[::-1]) return "{0} and {1}".format(self.parenthesize(expr.args[0], PREC), self.parenthesize(expr.args[1], PREC))
def _print_Pow(self, expr): PREC = _precedence(expr) if expr.exp.is_integer and int(expr.exp) == 1: return self.parenthesize(expr.base, PREC) if expr.exp is sp.S.NegativeOne: return '1.0/{0}'.format(self.parenthesize(expr.base, PREC)) if expr.exp == 0.5: return 'sqrt({0})'.format(self._print(expr.base)) # FIXME: Fix paranthesises return '{0}^{1}'.format(self.parenthesize(expr.base, PREC), self.parenthesize(expr.exp, PREC))
def _print_Or(self, expr): PREC = _precedence(expr) return " | ".join(self.parenthesize(arg, PREC) for arg in expr.args[::-1])
def _print_Not(self, expr): PREC = _precedence(expr) return "~" + self.parenthesize(expr.args[0], PREC)