sympy/printing/str.py

   1 """
   2 A Printer for generating readable representation of most sympy classes.
   3 """
   4
   5 from printer import Printer
   6 from sympy.printing.precedence import precedence, PRECEDENCE
   7 from sympy.core.basic import S
   8 from sympy.core.numbers import One, Rational
   9 from sympy.core.power import Pow
  10 from sympy.core.symbol import Symbol, Wild
  11 from sympy.core.basic import Basic
  12
  13 import sympy.mpmath.lib as mlib
  14
  15 class StrPrinter(Printer):
  16     def parenthesize(self, item, level):
  17         if precedence(item) <= level:
  18             return "(%s)"%self._print(item)
  19         else:
  20             return self._print(item)
  21
  22     def stringify(self, args, sep, level=0):
  23         return sep.join([self.parenthesize(item, level) for item in args])
  24
  25     def emptyPrinter(self, expr):
  26         if isinstance(expr, str):
  27             return expr
  28         elif isinstance(expr, Basic):
  29             if hasattr(expr, args):
  30                 return repr(expr)
  31             else:
  32                 raise
  33         else:
  34             return str(expr)
  35
  36     def _print_Add(self, expr):
  37         args = list(expr.args)
  38
  39         # Now we need to sort the factors in Add, which are in "rest". Any
  40         # ordering is fine, but some ordering looks better and some looks bad.
  41         # This particular solution is slow, but it ensures a sane ordering. It
  42         # can of course be improved:
  43
  44         args.sort(Basic._compare_pretty)
  45         PREC = precedence(expr)
  46         l = []
  47         for term in args:
  48             t = self._print(term)
  49             if t.startswith('-'):
  50                 sign = "-"
  51                 t = t[1:]
  52             else:
  53                 sign = "+"
  54             if precedence(term) < PREC:
  55                 l.extend([sign, "(%s)"%t])
  56             else:
  57                 l.extend([sign, t])
  58         sign = l.pop(0)
  59         if sign=='+':
  60             sign = ""
  61         return sign + ' '.join(l)
  62
  63     def _print_Basic(self, expr):
  64         l = [self._print(o) for o in expr.args]
  65         return expr.__class__.__name__ + "(%s)"%", ".join(l)
  66
  67     def _print_Catalan(self, expr):
  68         return 'Catalan'
  69
  70     def _print_ComplexInfinity(self, expr):
  71         return 'zoo'
  72
  73     def _print_Derivative(self, expr):
  74         return 'D(%s)'%", ".join(map(self._print, expr.args))
  75
  76     def _print_dict(self, expr):
  77         keys = expr.keys()
  78         keys.sort( Basic.compare_pretty )
  79
  80         items = []
  81         for key in keys:
  82             item = "%s: %s" % (self._print(key), self._print(expr[key]))
  83             items.append(item)
  84
  85         return "{%s}"%", ".join(items)
  86
  87     def _print_Dummy(self, expr):
  88         return '_' + expr.name
  89
  90     def _print_EulerGamma(self, expr):
  91         return 'EulerGamma'
  92
  93     def _print_Exp1(self, expr):
  94         return 'E'
  95
  96     def _print_Factorial(self, expr):
  97         return "%s!" % self.parenthesize(expr.args[0], PRECEDENCE["Pow"])
  98
  99     def _print_Function(self, expr):
 100         return expr.func.__name__ + "(%s)"%self.stringify(expr.args, ", ")
 101
 102     def _print_GeometryEntity(self, expr):
 103         # GeometryEntity is special -- it's base is tuple
 104         return str(expr)
 105
 106     def _print_GoldenRatio(self, expr):
 107         return 'GoldenRatio'
 108
 109     def _print_ImaginaryUnit(self, expr):
 110         return 'I'
 111
 112     def _print_Infinity(self, expr):
 113         return 'oo'
 114
 115     def _print_Integer(self, expr):
 116         return self._print(expr.p)
 117
 118     def _print_Integral(self, expr):
 119         def _xab_tostr(xab):
 120             x, ab = xab
 121             if ab is None:
 122                 return self._print(x)
 123             else:
 124                 return self._print((x,) + ab)
 125         L = ', '.join([_xab_tostr(l) for l in expr.limits])
 126         return 'Integral(%s, %s)' % (self._print(expr.function), L)
 127
 128     def _print_Interval(self, expr):
 129         return '[%s, %s]'%(expr.start, expr.end)
 130
 131     def _print_Limit(self, expr):
 132         e, z, z0, dir = expr.args
 133         if dir == "+":
 134             return "Limit(%s, %s, %s)" % (e, z, z0)
 135         else:
 136             return "Limit(%s, %s, %s, dir='%s')" % (e, z, z0, dir)
 137
 138     def _print_list(self, expr):
 139         return "[%s]"%self.stringify(expr, ", ")
 140
 141     def _print_Matrix(self, expr):
 142         return expr._format_str(lambda elem: self._print(elem))
 143
 144     def _print_Mul(self, expr):
 145         coeff, terms = expr.as_coeff_terms()
 146         if coeff.is_negative:
 147             coeff = -coeff
 148             if coeff is not S.One:
 149                 terms = (coeff,) + terms
 150             sign = "-"
 151         else:
 152             terms = (coeff,) + terms
 153             sign = ""
 154
 155         a = [] # items in the numerator
 156         b = [] # items that are in the denominator (if any)
 157
 158         # Gather terms for numerator/denominator
 159         for item in terms:
 160             if item.is_Pow and item.exp.is_Rational and item.exp.is_negative:
 161                 b.append(Pow(item.base, -item.exp))
 162             elif item.is_Rational:
 163                 if item.p != 1:
 164                     a.append(Rational(item.p))
 165                 if item.q != 1:
 166                     b.append(Rational(item.q))
 167             else:
 168                 a.append(item)
 169
 170         if len(a)==0:
 171             a = [S.One]
 172
 173         a_str = map(lambda x:self.parenthesize(x, precedence(expr)), a)
 174         b_str = map(lambda x:self.parenthesize(x, precedence(expr)), b)
 175
 176         if len(b)==0:
 177             return sign + '*'.join(a_str)
 178         elif len(b)==1:
 179             if len(a)==1 and not (a[0].is_Atom or a[0].is_Add):
 180                 return sign + "1/%s*"%b_str[0] + '*'.join(a_str)
 181             else:
 182                 return sign + '*'.join(a_str) + "/%s"%b_str[0]
 183         else:
 184             return sign + '*'.join(a_str) + "/(%s)"%'*'.join(b_str)
 185
 186     def _print_NaN(self, expr):
 187         return 'nan'
 188
 189     def _print_NegativeInfinity(self, expr):
 190         return '-oo'
 191
 192     def _print_NegativeOne(self, expr):
 193         return "-1"
 194
 195     def _print_Normal(self, expr):
 196         return "Normal(%s, %s)"%(expr.mu, expr.sigma)
 197
 198     def _print_One(self, expr):
 199         return "1"
 200
 201     def _print_Order(self, expr):
 202         if len(expr.symbols) <= 1:
 203             return 'O(%s)'%self._print(expr.expr)
 204         else:
 205             return 'O(%s)'%self.stringify(expr.args, ', ', 0)
 206
 207     def _print_PDF(self, expr):
 208         return 'PDF(%s, (%s, %s, %s))' % \
 209             (self._print(expr.pdf.args[1]), self._print(expr.pdf.args[0]), \
 210             self._print(expr.domain[0]), self._print(expr.domain[1]))
 211
 212     def _print_Pi(self, expr):
 213         return 'pi'
 214
 215     def _print_Poly(self, expr):
 216         terms, symbols = [], [ self._print(s) for s in expr.symbols ]
 217
 218         for coeff, monom in expr.iter_terms():
 219             s_monom = []
 220
 221             for i, exp in enumerate(monom):
 222                 if exp > 0:
 223                     if exp == 1:
 224                         s_monom.append(symbols[i])
 225                     else:
 226                         s_monom.append(symbols[i] + "**%d" % exp)
 227
 228             s_monom = "*".join(s_monom)
 229
 230             if coeff.is_Add:
 231                 if s_monom:
 232                     s_coeff = "(" + self._print(coeff) + ")"
 233                 else:
 234                     s_coeff = self._print(coeff)
 235             else:
 236                 if s_monom and abs(coeff) is S.One:
 237                     if coeff.is_negative:
 238                         terms.extend(['-', s_monom])
 239                     else:
 240                         terms.extend(['+', s_monom])
 241
 242                     continue
 243                 else:
 244                     s_coeff = self._print(coeff)
 245
 246             if not s_monom:
 247                 s_term = s_coeff
 248             else:
 249                 s_term = s_coeff + "*" + s_monom
 250
 251             if s_term.startswith('-'):
 252                 terms.extend(['-', s_term[1:]])
 253             else:
 254                 terms.extend(['+', s_term])
 255
 256         if terms[0] in ['-', '+']:
 257             modifier = terms.pop(0)
 258
 259             if modifier == '-':
 260                 terms[0] = '-' + terms[0]
 261
 262         format = expr.__class__.__name__ + "(%s, %s"
 263
 264         if expr.is_multivariate and expr.order != 'grlex':
 265             format += ", order='%s')" % expr.order
 266         else:
 267             format += ")"
 268
 269         return format % (' '.join(terms), ', '.join(symbols))
 270
 271     def _print_Polynomial(self, expr):
 272         return self._print(expr.sympy_expr)
 273
 274     def _print_Pow(self, expr):
 275         PREC = precedence(expr)
 276         if expr.exp is S.NegativeOne:
 277             return '1/%s'%(self.parenthesize(expr.base, PREC))
 278         else:
 279             return '%s**%s'%(self.parenthesize(expr.base, PREC),
 280                              self.parenthesize(expr.exp, PREC))
 281
 282     def _print_Rational(self, expr):
 283         return '%s/%s'%(expr.p, expr.q)
 284
 285     def _print_Real(self, expr):
 286         prec = expr._prec
 287         if prec < 5:
 288             dps = 0
 289         else:
 290             dps = mlib.prec_to_dps(expr._prec)
 291         return mlib.to_str(expr._mpf_, dps, strip_zeros=False)
 292
 293     def _print_Relational(self, expr):
 294         return '%s %s %s'%(self.parenthesize(expr.lhs, precedence(expr)),
 295                            expr.rel_op,
 296                            self.parenthesize(expr.rhs, precedence(expr)))
 297
 298     def _print_RootOf(self, expr):
 299         poly = self._print(expr.poly)
 300         return "RootOf(%s, index=%d)" % \
 301             (poly[1+poly.index("("):-1], expr.index)
 302
 303     def _print_RootsOf(self, expr):
 304         poly = self._print(expr.poly)
 305         return "RootsOf(" + poly[1+poly.index("("):]
 306
 307     def _print_RootSum(self, expr):
 308         func = self._print(expr.function)
 309         poly = self._print(expr.roots.poly)
 310         return "RootSum(%s, %s)" % \
 311             (func, poly[1+poly.index("("):-1])
 312
 313     def _print_Sample(self, expr):
 314         return "Sample([%s])"%self.stringify(expr, ", ", 0)
 315
 316     def __print_set(self, expr):
 317         items = list(expr)
 318         items.sort( Basic.compare_pretty )
 319
 320         args = ', '.join(self._print(item) for item in items)
 321         if args:
 322             args = '[%s]' % args
 323         return '%s(%s)' % (type(expr).__name__, args)
 324
 325     _print_set       = __print_set
 326     _print_frozenset = __print_set
 327
 328     def _print_SMatrix(self, expr):
 329         return self._print(expr.toMatrix())
 330
 331     def _print_Sum(self, expr):
 332         return 'Sum(%s, (%s))'%(self._print(expr.function), self.stringify(expr.limits[0], ', '))
 333
 334     def _print_Sum2(self, expr):
 335         return "Sum2(%r, (%r, %r, %r))" % (expr.f, expr.i, expr.a, expr.b)
 336
 337     def _print_Symbol(self, expr):
 338         return expr.name
 339
 340     def _print_tuple(self, expr):
 341         if len(expr)==1:
 342             return "(%s,)"%self._print(expr[0])
 343         else:
 344             return "(%s)"%self.stringify(expr, ", ")
 345
 346     def _print_Uniform(self, expr):
 347         return "Uniform(%s, %s)"%(expr.a, expr.b)
 348
 349     def _print_Unit(self, expr):
 350         return expr.abbrev
 351
 352     def _print_Wild(self, expr):
 353         return expr.name + '_'
 354
 355     def _print_WildFunction(self, expr):
 356         return expr.name + '_'
 357
 358     def _print_Zero(self, expr):
 359         return "0"
 360
 361
 362 def sstr(expr):
 363     """return expr in str form"""
 364
 365     p = StrPrinter()
 366     s = p.doprint(expr)
 367
 368     return s
 369
 370
 371 class StrReprPrinter(StrPrinter):
 372     """(internal) -- see sstrrepr"""
 373
 374     def _print_basestring(self, s):
 375         return repr(s)
 376
 377 def sstrrepr(expr):
 378     """return expr in mixed str/repr form
 379
 380        i.e. strings are returned in repr form with quotes, and everything else
 381        is returned in str form.
 382
 383        This function could be useful for hooking into sys.displayhook
 384     """
 385
 386     p = StrReprPrinter()
 387     s = p.doprint(expr)
 388
 389     return s