def _print_Add(self, sum):
args = list(sum.args)
args.sort(Basic._compare_pretty)
pforms = []
for x in args:
# Check for negative "things" so that this information can be enforce upon
# the pretty form so that it can be made of use (such as in a sum).
if x.is_Mul and x.as_coeff_terms()[0] < 0:
pform1 = self._print(-x)
if len(pforms) == 0:
if pform1.height() > 1:
pform2 = '- '
else:
pform2 = '-'
else:
pform2 = ' - '
pform = stringPict.next(pform2, pform1)
pforms.append(prettyForm(binding=prettyForm.NEG, *pform))
elif x.is_Number and x < 0:
pform1 = self._print(-x)
if len(pforms) == 0:
if pform1.height() > 1:
pform2 = '- '
else:
pform2 = '-'
pform = stringPict.next(pform2, pform1)
else:
pform = stringPict.next(' - ', pform1)
pforms.append(prettyForm(binding=prettyForm.NEG, *pform))
else:
pforms.append(self._print(x))
return prettyForm.__add__(*pforms)
def _print_catalan(self, e):
pform = prettyForm("C")
arg = self._print(e.args[0])
pform_arg = prettyForm(" "*arg.width())
pform_arg = prettyForm(*pform_arg.below(arg))
pform = prettyForm(*pform.right(pform_arg))
return pform
def _print_Relational(self, e):
op = prettyForm(' ' + xsym(e.rel_op) + ' ')
l = self._print(e.lhs)
r = self._print(e.rhs)
pform = prettyForm(*stringPict.next(l, op, r))
return pform
def _print_Add(self, expr, order=None):
if self.order == 'none':
terms = list(expr.args)
else:
terms = self._as_ordered_terms(expr, order=order)
pforms, indices = [], []
def pretty_negative(pform, index):
"""Prepend a minus sign to a pretty form. """
if index == 0:
if pform.height() > 1:
pform_neg = '- '
else:
pform_neg = '-'
else:
pform_neg = ' - '
pform = stringPict.next(pform_neg, pform)
return prettyForm(binding=prettyForm.NEG, *pform)
for i, term in enumerate(terms):
if term.is_Mul and term.as_coeff_mul()[0] < 0:
pform = self._print(-term)
pforms.append(pretty_negative(pform, i))
elif term.is_Rational and term.q > 1:
pforms.append(None)
indices.append(i)
elif term.is_Number and term < 0:
pform = self._print(-term)
pforms.append(pretty_negative(pform, i))
else:
pforms.append(self._print(term))
if indices:
large = True
for pform in pforms:
if pform is not None and pform.height() > 1:
break
else:
large = False
for i in indices:
term, negative = terms[i], False
if term < 0:
term, negative = -term, True
if large:
pform = prettyForm(str(term.p))/prettyForm(str(term.q))
else:
pform = self._print(term)
if negative:
pform = pretty_negative(pform, i)
pforms[i] = pform
return prettyForm.__add__(*pforms)
def adjust(p1, p2):
diff = p1.width() - p2.width()
if diff == 0:
return p1, p2
elif diff > 0:
return p1, prettyForm(*p2.left(' '*diff))
else:
return prettyForm(*p1.left(' '*-diff)), p2
def _print_factorial(self, e):
x = e.args[0]
pform = self._print(x)
# Add parentheses if needed
if not ((x.is_Integer and x.is_nonnegative) or x.is_Symbol):
pform = prettyForm(*pform.parens())
pform = prettyForm(*pform.right('!'))
return pform
def _print_gamma(self, e):
if self._use_unicode:
pform = self._print(e.args[0])
pform = prettyForm(*pform.parens())
pform = prettyForm(*pform.left(greek['gamma'][1]))
return pform
else:
return self._print_Function(e)
def _print_lowergamma(self, e):
if self._use_unicode:
pform = self._print(e.args[0])
pform = prettyForm(*pform.right(", ", self._print(e.args[1])))
pform = prettyForm(*pform.parens())
pform = prettyForm(*pform.left(greek["gamma"][0]))
return pform
else:
return self._print_Function(e)
def _print_RootSum(self, expr):
args = [self._print_Add(expr.expr, order='lex')]
if expr.fun is not S.IdentityFunction:
args.append(self._print(expr.fun))
pform = prettyForm(*self._print_seq(args).parens())
pform = prettyForm(*pform.left('RootSum'))
return pform
def _print_Derivative(self, deriv):
# XXX use U('PARTIAL DIFFERENTIAL') here ?
syms = list(reversed(deriv.variables))
x = None
for sym, num in group(syms, multiple=False):
s = self._print(sym)
ds = prettyForm(*s.left('d'))
if num > 1:
ds = ds**prettyForm(str(num))
if x is None:
x = ds
else:
x = prettyForm(*x.right(' '))
x = prettyForm(*x.right(ds))
f = prettyForm(binding=prettyForm.FUNC, *self._print(deriv.expr).parens())
pform = prettyForm('d')
if len(syms) > 1:
pform = pform**prettyForm(str(len(syms)))
pform = prettyForm(*pform.below(stringPict.LINE, x))
pform.baseline = pform.baseline + 1
pform = prettyForm(*stringPict.next(pform, f))
return pform
def _print_Not(self, e):
if self._use_unicode:
arg = e.args[0]
pform = self._print(arg)
if arg.is_Boolean and not arg.is_Not:
pform = prettyForm(*pform.parens())
return prettyForm(*pform.left(u"\u00ac "))
else:
return self._print_Function(e)
def _print_KroneckerDelta(self, e):
pform = self._print(e.args[0])
pform = prettyForm(*pform.right((prettyForm(','))))
pform = prettyForm(*pform.right((self._print(e.args[1]))))
if self._use_unicode:
a = stringPict(pretty_symbol('delta'))
else:
a = stringPict('d')
b = pform
top = stringPict(*b.left(' '*a.width()))
bot = stringPict(*a.right(' '*b.width()))
return prettyForm(binding=prettyForm.POW, *bot.below(top))
def _print_Piecewise(self, pexpr):
P = {}
for n, ec in enumerate(pexpr.args):
P[n,0] = self._print(ec.expr)
if ec.cond == True:
P[n,1] = prettyForm('otherwise')
else:
P[n,1] = prettyForm(*prettyForm('for ').right(self._print(ec.cond)))
hsep = 2
vsep = 1
len_args = len(pexpr.args)
# max widths
maxw = [max([P[i,j].width() for i in xrange(len_args)]) \
for j in xrange(2)]
# FIXME: Refactor this code and matrix into some tabular environment.
# drawing result
D = None
for i in xrange(len_args):
D_row = None
for j in xrange(2):
p = P[i,j]
assert p.width() <= maxw[j]
wdelta = maxw[j] - p.width()
wleft = wdelta // 2
wright = wdelta - wleft
p = prettyForm(*p.right(' '*wright))
p = prettyForm(*p.left (' '*wleft))
if D_row is None:
D_row = p
continue
D_row = prettyForm(*D_row.right(' '*hsep)) # h-spacer
D_row = prettyForm(*D_row.right(p))
if D is None:
D = D_row # first row in a picture
continue
# v-spacer
for _ in range(vsep):
D = prettyForm(*D.below(' '))
D = prettyForm(*D.below(D_row))
D = prettyForm(*D.parens('{',''))
return D
def _print_Chi(self, e):
# This needs a special case since otherwise it comes out as greek
# letter chi...
prettyFunc = prettyForm("Chi")
prettyArgs = prettyForm(*self._print_seq(e.args).parens())
pform = prettyForm(binding=prettyForm.FUNC, *stringPict.next(prettyFunc, prettyArgs))
# store pform parts so it can be reassembled e.g. when powered
pform.prettyFunc = prettyFunc
pform.prettyArgs = prettyArgs
return pform
def _print_Pow(self, power):
from sympy import fraction
b, e = power.as_base_exp()
if power.is_commutative:
if e is S.NegativeOne:
return prettyForm("1")/self._print(b)
n, d = fraction(e)
if n is S.One and d.is_Atom and not e.is_Integer:
return self._print_nth_root(b, e)
if e.is_Rational and e < 0:
return prettyForm("1")/self._print(b)**self._print(-e)
# None of the above special forms, do a standard power
return self._print(b)**self._print(e)
def join(self, delimiter, args):
pform = None
for arg in args:
if pform is None:
pform = arg
else:
pform = prettyForm(*pform.right(delimiter))
pform = prettyForm(*pform.right(arg))
if pform is None:
return prettyForm("")
else:
return pform
def _print_Derivative(self, deriv):
# XXX use U('PARTIAL DIFFERENTIAL') here ?
syms = list(deriv.symbols)
syms.reverse()
x = None
for sym in syms:
s = self._print(sym)
ds = prettyForm(*s.left('d'))
if x is None:
x = ds
else:
x = prettyForm(*x.right(' '))
x = prettyForm(*x.right(ds))
f = prettyForm(binding=prettyForm.FUNC, *self._print(deriv.expr).parens())
pform = prettyForm('d')
if len(syms) > 1:
pform = pform ** prettyForm(str(len(deriv.symbols)))
pform = prettyForm(*pform.below(stringPict.LINE, x))
pform.baseline = pform.baseline + 1
pform = prettyForm(*stringPict.next(pform, f))
return pform
def _hprint_vec(self, v):
D = None
for a in v:
p = a
if D is None:
D = p
else:
D = prettyForm(*D.right(', '))
D = prettyForm(*D.right(p))
if D is None:
D = stringPict(' ')
return D
def _print_Pow(self, power):
# square roots, other roots or n-th roots
# test for fraction 1/n or power x**-1
if power.is_commutative:
if (isinstance(power.exp, C.Rational) and power.exp.p == 1 and power.exp.q != 1) or (
isinstance(power.exp, C.Pow)
and isinstance(power.exp.args[0], C.Symbol)
and power.exp.args[1] == S.NegativeOne
):
bpretty = self._print(power.base)
# construct root sign, start with the \/ shape
_zZ = xobj("/", 1)
rootsign = xobj("\\", 1) + _zZ
# make exponent number to put above it
if isinstance(power.exp, C.Rational):
exp = str(power.exp.q)
if exp == "2":
exp = ""
else:
exp = str(power.exp.args[0])
exp = exp.ljust(2)
if len(exp) > 2:
rootsign = " " * (len(exp) - 2) + rootsign
# stack the exponent
rootsign = stringPict(exp + "\n" + rootsign)
rootsign.baseline = 0
# diagonal: length is one less than height of base
linelength = bpretty.height() - 1
diagonal = stringPict("\n".join(" " * (linelength - i - 1) + _zZ + " " * i for i in range(linelength)))
# put baseline just below lowest line: next to exp
diagonal.baseline = linelength - 1
# make the root symbol
rootsign = prettyForm(*rootsign.right(diagonal))
# set the baseline to match contents to fix the height
# but if the height of bpretty is one, the rootsign must be one higher
rootsign.baseline = max(1, bpretty.baseline)
# build result
s = prettyForm(hobj("_", 2 + bpretty.width()))
s = prettyForm(*bpretty.above(s))
s = prettyForm(*s.left(rootsign))
return s
elif power.exp.is_Rational and power.exp.is_negative:
# Things like 1/x
return prettyForm("1") / self._print(C.Pow(power.base, -power.exp))
# None of the above special forms, do a standard power
b, e = power.as_base_exp()
return self._print(b) ** self._print(e)
def _print_Limit(self, l):
# XXX we do not print dir ...
e, z, z0, dir = l.args
E = self._print(e)
Lim = prettyForm("lim")
LimArg = self._print(z)
LimArg = prettyForm(*LimArg.right("->"))
LimArg = prettyForm(*LimArg.right(self._print(z0)))
Lim = prettyForm(*Lim.below(LimArg))
Lim = prettyForm(*Lim.right(E))
return Lim
def _print_binomial(self, e):
n, k = e.args
n_pform = self._print(n)
k_pform = self._print(k)
bar = ' '*max(n_pform.width(), k_pform.width())
pform = prettyForm(*k_pform.above(bar))
pform = prettyForm(*pform.above(n_pform))
pform = prettyForm(*pform.parens('(', ')'))
pform.baseline = (pform.baseline + 1)//2
return pform
def _print_RandomDomain(self, d):
try:
pform = self._print('Domain: ')
pform = prettyForm(*pform.right(self._print(d.as_boolean())))
return pform
except:
try:
pform = self._print('Domain: ')
pform = prettyForm(*pform.right(self._print(d.symbols)))
pform = prettyForm(*pform.right(self._print(' in ')))
pform = prettyForm(*pform.right(self._print(d.set)))
return pform
except:
return self._print(None)
def _print_hyper(self, e):
# FIXME refactor Matrix, Piecewise, and this into a tabular environment
ap = [self._print(a) for a in e.ap]
bq = [self._print(b) for b in e.bq]
P = self._print(e.argument)
P.baseline = P.height()//2
# Drawing result - first create the ap, bq vectors
D = None
for v in [ap, bq]:
D_row = self._hprint_vec(v)
if D is None:
D = D_row # first row in a picture
else:
D = prettyForm(*D.below(' '))
D = prettyForm(*D.below(D_row))
# make sure that the argument `z' is centred vertically
D.baseline = D.height()//2
# insert horizontal separator
P = prettyForm(*P.left(' '))
D = prettyForm(*D.right(' '))
# insert separating `|`
D = self._hprint_vseparator(D, P)
# add parens
D = prettyForm(*D.parens('(', ')'))
# create the F symbol
above = D.height()//2 - 1
below = D.height() - above - 1
if self._use_unicode:
pic = (2, 0, 2, u'\u250c\u2500\n\u251c\u2500\n\u2575')
else:
pic = ((3, 0, 3, ' _\n|_\n|\n'))
add = 0
sz, t, b, img = pic
F = prettyForm('\n' * (above - t) + img + '\n' * (below - b),
baseline = above + sz)
add = (sz+1)//2
F = prettyForm(*F.left(self._print(len(e.ap))))
F = prettyForm(*F.right(self._print(len(e.bq))))
F.baseline = above + add
D = prettyForm(*F.right(' ', D))
return D
def _print_FiniteField(self, expr):
if self._use_unicode:
form = u'\u2124_%d'
else:
form = 'GF(%d)'
return prettyForm(pretty_symbol(form % expr.mod))
def _print_floor(self, e):
if self._use_unicode:
pform = self._print(e.args[0])
pform = prettyForm(*pform.parens('lfloor', 'rfloor'))
return pform
else:
return self._print_Function(e)
def _print_Subs(self, e):
pform = self._print(e.expr)
pform = prettyForm(*pform.parens())
h = pform.height() if pform.height() > 1 else 2
rvert = stringPict(vobj('|', h), baseline=pform.baseline)
pform = prettyForm(*pform.right(rvert))
b = pform.baseline
pform.baseline = pform.height() - 1
pform = prettyForm(*pform.right(self._print_seq([
self._print_seq((self._print(v[0]), xsym('=='), self._print(v[1])),
delimiter='') for v in zip(e.variables, e.point) ])))
pform.baseline = b
return pform
def __print_set(self, set_):
items = list(set_)
items.sort( key=cmp_to_key(Basic.compare_pretty) )
s = self._print_seq(items, '(', ')')
s = prettyForm(*stringPict.next(type(set_).__name__, s))
return s
def _print_Float(self, e):
# we will use StrPrinter's Float printer, but we need to handle the
# full_prec ourselves, according to the self._print_level
full_prec = self._settings["full_prec"]
if full_prec == "auto":
full_prec = self._print_level == 1
return prettyForm(sstr(e, full_prec=full_prec))
def _print_ceiling(self, e):
if self._use_unicode:
pform = self._print(e.args[0])
pform = prettyForm(*pform.parens('lceil', 'rceil'))
return pform
else:
return self._print_Function(e)
def _print_PDF(self, pdf):
lim = self._print(pdf.pdf.args[0])
lim = prettyForm(*lim.right(', '))
lim = prettyForm(*lim.right(self._print(pdf.domain[0])))
lim = prettyForm(*lim.right(', '))
lim = prettyForm(*lim.right(self._print(pdf.domain[1])))
lim = prettyForm(*lim.parens())
f = self._print(pdf.pdf.args[1])
f = prettyForm(*f.right(', '))
f = prettyForm(*f.right(lim))
f = prettyForm(*f.parens())
pform = prettyForm('PDF')
pform = prettyForm(*pform.right(f))
return pform
def _print_Transpose(self, T):
pform = self._print(T.arg)
if (T.arg.is_Add or T.arg.is_Mul or T.arg.is_Pow):
pform = prettyForm(*pform.parens())
pform = prettyForm(*pform.right("'"))
return pform
def _print_RootOf(self, expr):
args = [self._print_Add(expr.expr, order='lex'), expr.index]
pform = prettyForm(*self._print_seq(args).parens())
pform = prettyForm(*pform.left('RootOf'))
return pform
def _print_IntegerRing(self, expr):
if self._use_unicode:
return prettyForm(u'\u2124')
else:
return prettyForm('ZZ')
def _print_exp(self, e):
base = prettyForm(pretty_atom('Exp1', 'e'))
return base**self._print(e.args[0])
def _print_Matrix(self, e):
M = e # matrix
S = {} # i,j -> pretty(M[i,j])
for i in range(M.lines):
for j in range(M.cols):
S[i, j] = self._print(M[i, j])
# h- and v- spacers
hsep = 2
vsep = 1
# max width for columns
maxw = [-1] * M.cols
for j in range(M.cols):
maxw[j] = max([S[i, j].width() for i in range(M.lines)])
# drawing result
D = None
for i in range(M.lines):
D_row = None
for j in range(M.cols):
s = S[i, j]
# reshape s to maxw
# XXX this should be generalized, and go to stringPict.reshape ?
assert s.width() <= maxw[j]
# hcenter it, +0.5 to the right 2
# ( it's better to align formula starts for say 0 and r )
# XXX this is not good in all cases -- maybe introduce vbaseline?
wdelta = maxw[j] - s.width()
wleft = wdelta // 2
wright = wdelta - wleft
s = prettyForm(*s.right(' ' * wright))
s = prettyForm(*s.left(' ' * wleft))
# we don't need vcenter cells -- this is automatically done in
# a pretty way because when their baselines are taking into
# account in .right()
if D_row is None:
D_row = s # first box in a row
continue
D_row = prettyForm(*D_row.right(' ' * hsep)) # h-spacer
D_row = prettyForm(*D_row.right(s))
if D is None:
D = D_row # first row in a picture
continue
# v-spacer
for _ in range(vsep):
D = prettyForm(*D.below(' '))
D = prettyForm(*D.below(D_row))
D = prettyForm(*D.parens('[', ']'))
return D
def _print_Sum(self, expr):
ascii_mode = not self._use_unicode
def asum(hrequired, lower, upper, use_ascii):
def adjust(s, wid=None, how='<^>'):
if not wid or len(s) > wid:
return s
need = wid - len(s)
if how == '<^>' or how == "<" or how not in list('<^>'):
return s + ' ' * need
half = need // 2
lead = ' ' * half
if how == ">":
return " " * need + s
return lead + s + ' ' * (need - len(lead))
h = max(hrequired, 2)
d = h // 2
wrequired = max(lower, upper)
w = d + 1
more = hrequired % 2
lines = []
if use_ascii:
lines.append("_" * (w) + ' ')
lines.append("\%s`" % (' ' * (w - 1)))
for i in range(1, d):
lines.append('%s\\%s' % (' ' * i, ' ' * (w - i)))
if more:
lines.append('%s)%s' % (' ' * (d), ' ' * (w - d)))
for i in reversed(range(1, d)):
lines.append('%s/%s' % (' ' * i, ' ' * (w - i)))
lines.append("/" + "_" * (w - 1) + ',')
return d, h + more, lines, 0
else:
w = w + more
d = d + more
vsum = vobj('sum', 4)
lines.append("_" * (w))
for i in range(0, d):
lines.append('%s%s%s' % (' ' * i, vsum[2], ' ' *
(w - i - 1)))
for i in reversed(range(0, d)):
lines.append('%s%s%s' % (' ' * i, vsum[4], ' ' *
(w - i - 1)))
lines.append(vsum[8] * (w))
return d, h + 2 * more, lines, more
f = expr.function
prettyF = self._print(f)
if f.is_Add: # add parens
prettyF = prettyForm(*prettyF.parens())
H = prettyF.height() + 2
# \sum \sum \sum ...
first = True
max_upper = 0
sign_height = 0
for lim in expr.limits:
if len(lim) == 3:
prettyUpper = self._print(lim[2])
prettyLower = self._print(C.Equality(lim[0], lim[1]))
elif len(lim) == 2:
prettyUpper = self._print("")
prettyLower = self._print(C.Equality(lim[0], lim[1]))
elif len(lim) == 1:
prettyUpper = self._print("")
prettyLower = self._print(lim[0])
max_upper = max(max_upper, prettyUpper.height())
# Create sum sign based on the height of the argument
d, h, slines, adjustment = asum(H, prettyLower.width(),
prettyUpper.width(), ascii_mode)
prettySign = stringPict('')
prettySign = prettyForm(*prettySign.stack(*slines))
if first:
sign_height = prettySign.height()
prettySign = prettyForm(*prettySign.above(prettyUpper))
prettySign = prettyForm(*prettySign.below(prettyLower))
if first:
# change F baseline so it centers on the sign
prettyF.baseline -= d - (prettyF.height() // 2 -
prettyF.baseline) - adjustment
first = False
# put padding to the right
pad = stringPict('')
pad = prettyForm(*pad.stack(*[' '] * h))
prettySign = prettyForm(*prettySign.right(pad))
# put the present prettyF to the right
prettyF = prettyForm(*prettySign.right(prettyF))
prettyF.baseline = max_upper + sign_height // 2
return prettyF
def _print_RealDomain(self, expr):
if self._use_unicode:
return prettyForm(u'\u211D')
else:
return prettyForm('RR')
def _print_PolynomialRing(self, expr):
pform = self._print_seq(expr.gens, '[', ']')
pform = prettyForm(*pform.left(self._print(expr.dom)))
return pform
def _print_Order(self, e):
pform = self._print(e.expr)
pform = prettyForm(*pform.parens())
pform = prettyForm(*pform.left('O'))
return pform
def _print_set(self, s):
items = sorted(s, key=default_sort_key)
pretty = self._print_seq(items, '(', ')')
pretty = prettyForm(*stringPict.next(type(s).__name__, pretty))
return pretty
def _print_conjugate(self, e):
pform = self._print(e.args[0])
return prettyForm( *pform.above( hobj('_',pform.width())) )
def emptyPrinter(x):
""" Default empty printer.
"""
return prettyForm(xstr(x))
def _print_atan2(self, e):
pform = prettyForm(*self._print_seq(e.args).parens())
pform = prettyForm(*pform.left('atan2'))
return pform
def _print_tuple(self, t):
if len(t) == 1:
ptuple = prettyForm(*stringPict.next(self._print(t[0]), ','))
return prettyForm(*ptuple.parens('(', ')', ifascii_nougly=True))
else:
return self._print_seq(t, '(', ')')
def _print_basestring(self, e):
return prettyForm(repr(e))
def _print_ExpBase(self, e):
# TODO should exp_polar be printed differently?
# what about exp_polar(0), exp_polar(1)?
base = prettyForm(pretty_atom('Exp1', 'e'))
return base**self._print(e.args[0])
def _print_Atom(self, e):
try:
# print atoms like Exp1 or Pi
return prettyForm(pretty_atom(e.__class__.__name__))
except KeyError:
return self.emptyPrinter(e)
def _print_meijerg(self, e):
# FIXME refactor Matrix, Piecewise, and this into a tabular environment
v = {}
v[(0, 0)] = [self._print(a) for a in e.an]
v[(0, 1)] = [self._print(a) for a in e.aother]
v[(1, 0)] = [self._print(b) for b in e.bm]
v[(1, 1)] = [self._print(b) for b in e.bother]
P = self._print(e.argument)
P.baseline = P.height() // 2
vp = {}
for idx in v:
vp[idx] = self._hprint_vec(v[idx])
for i in range(2):
maxw = max(vp[(0, i)].width(), vp[(1, i)].width())
for j in range(2):
s = vp[(j, i)]
left = (maxw - s.width()) // 2
right = maxw - left - s.width()
s = prettyForm(*s.left(' ' * left))
s = prettyForm(*s.right(' ' * right))
vp[(j, i)] = s
D1 = prettyForm(*vp[(0, 0)].right(' ', vp[(0, 1)]))
D1 = prettyForm(*D1.below(' '))
D2 = prettyForm(*vp[(1, 0)].right(' ', vp[(1, 1)]))
D = prettyForm(*D1.below(D2))
# make sure that the argument `z' is centred vertically
D.baseline = D.height() // 2
# insert horizontal separator
P = prettyForm(*P.left(' '))
D = prettyForm(*D.right(' '))
# insert separating `|`
D = self._hprint_vseparator(D, P)
# add parens
D = prettyForm(*D.parens('(', ')'))
# create the G symbol
above = D.height() // 2 - 1
below = D.height() - above - 1
sz, t, b, add, img = annotated('G')
F = prettyForm('\n' * (above - t) + img + '\n' * (below - b),
baseline=above + sz)
pp = self._print(len(e.ap))
pq = self._print(len(e.bq))
pm = self._print(len(e.bm))
pn = self._print(len(e.an))
def adjust(p1, p2):
diff = p1.width() - p2.width()
if diff == 0:
return p1, p2
elif diff > 0:
return p1, prettyForm(*p2.left(' ' * diff))
else:
return prettyForm(*p1.left(' ' * -diff)), p2
pp, pm = adjust(pp, pm)
pq, pn = adjust(pq, pn)
pu = prettyForm(*pm.right(', ', pn))
pl = prettyForm(*pp.right(', ', pq))
ht = F.baseline - above - 2
if ht > 0:
pu = prettyForm(*pu.below('\n' * ht))
p = prettyForm(*pu.below(pl))
F.baseline = above
F = prettyForm(*F.right(p))
F.baseline = above + add
D = prettyForm(*F.right(' ', D))
return D
def _hprint_vseparator(self, p1, p2):
tmp = prettyForm(*p1.right(p2))
sep = stringPict(vobj('|', tmp.height()), baseline=tmp.baseline)
return prettyForm(*p1.right(sep, p2))
def __init__(self, settings=None):
Printer.__init__(self, settings)
self.emptyPrinter = lambda x: prettyForm(xstr(x))
def _print_Inverse(self, I):
pform = self._print(I.arg)
if (I.arg.is_Add or I.arg.is_Mul or I.arg.is_Pow):
pform = prettyForm(*pform.parens())
pform = prettyForm(*pform.right("^-1"))
return pform
def _print_FractionField(self, expr):
pform = self._print_seq(expr.gens, '(', ')')
pform = prettyForm(*pform.left(self._print(expr.dom)))
return pform
def _print_RationalField(self, expr):
if self._use_unicode:
return prettyForm(u'\u211A')
else:
return prettyForm('QQ')
def _print_Abs(self, e):
pform = self._print(e.args[0])
pform = prettyForm(*pform.parens('|', '|'))
return pform
def _print_Symbol(self, e):
symb = pretty_symbol(e.name)
return prettyForm(symb)
def _print_set(self, s):
items = sorted(s, key=default_sort_key)
pretty = self._print_seq(items, '[', ']')
pretty = prettyForm(*pretty.parens('(', ')', ifascii_nougly=True))
pretty = prettyForm(*stringPict.next(type(s).__name__, pretty))
return pretty
def _print_Integral(self, integral):
f = integral.function
# Add parentheses if arg involves addition of terms and
# create a pretty form for the argument
prettyF = self._print(f)
# XXX generalize parens
if f.is_Add:
prettyF = prettyForm(*prettyF.parens())
# dx dy dz ...
arg = prettyF
for x in integral.limits:
prettyArg = self._print(x[0])
# XXX qparens (parens if needs-parens)
if prettyArg.width() > 1:
prettyArg = prettyForm(*prettyArg.parens())
arg = prettyForm(*arg.right(' d', prettyArg))
# \int \int \int ...
firstterm = True
s = None
for lim in integral.limits:
x = lim[0]
# Create bar based on the height of the argument
h = arg.height()
H = h+2
# XXX hack!
ascii_mode = not self._use_unicode
if ascii_mode:
H += 2
vint= vobj('int', H)
# Construct the pretty form with the integral sign and the argument
pform = prettyForm(vint)
#pform.baseline = pform.height()//2 # vcenter
pform.baseline = arg.baseline + (H-h)//2 # covering the whole argument
if len(lim) > 1:
# Create pretty forms for endpoints, if definite integral.
# Do not print empty endpoints.
if len(lim) == 2:
prettyA = prettyForm("")
prettyB = self._print(lim[1])
if len(lim) == 3:
prettyA = self._print(lim[1])
prettyB = self._print(lim[2])
if ascii_mode: # XXX hack
# Add spacing so that endpoint can more easily be
# identified with the correct integral sign
spc = max(1, 3 - prettyB.width())
prettyB = prettyForm(*prettyB.left(' ' * spc))
spc = max(1, 4 - prettyA.width())
prettyA = prettyForm(*prettyA.right(' ' * spc))
pform = prettyForm(*pform.above(prettyB))
pform = prettyForm(*pform.below(prettyA))
#if ascii_mode: # XXX hack
# # too much vspace beetween \int and argument
# # but I left it as is
# pform = prettyForm(*pform.right(' '))
if not ascii_mode: # XXX hack
pform = prettyForm(*pform.right(' '))
if firstterm:
s = pform # first term
firstterm = False
else:
s = prettyForm(*s.left(pform))
pform = prettyForm(*arg.left(s))
return pform
def _print_meijerg(self, e):
# FIXME refactor Matrix, Piecewise, and this into a tabular environment
v = {}
v[(0, 0)] = [self._print(a) for a in e.an]
v[(0, 1)] = [self._print(a) for a in e.aother]
v[(1, 0)] = [self._print(b) for b in e.bm]
v[(1, 1)] = [self._print(b) for b in e.bother]
P = self._print(e.argument)
vp = {}
for idx in v:
vp[idx] = self._hprint_vec(v[idx])
for i in range(2):
maxw = max(vp[(0, i)].width(), vp[(1, i)].width())
for j in range(2):
s = vp[(j, i)]
left = (maxw - s.width()) // 2
right = maxw - left - s.width()
s = prettyForm(*s.left(' ' * left))
s = prettyForm(*s.right(' ' * right))
vp[(j, i)] = s
D1 = prettyForm(*vp[(0, 0)].right(' ', vp[(0, 1)]))
D1 = prettyForm(*D1.below(' '))
D2 = prettyForm(*vp[(1, 0)].right(' ', vp[(1, 1)]))
D = prettyForm(*D1.below(D2))
# make sure that the argument `z' is centred vertically
D.baseline = D.height() / 2
# insert horizontal separator
P = prettyForm(*P.left(' '))
D = prettyForm(*D.right(' '))
# insert separating `|`
D = self._hprint_vseparator(D, P)
# add parens
D = prettyForm(*D.parens('(', ')'))
# create the G symbol
above = D.height() / 2 - 1
below = D.height() - above - 1
if self._use_unicode:
pic = (
3, 0, 3, 1,
u'\u256d\u2500\u256e\n\u2502\u2576\u2510\n\u2570\u2500\u256f')
else:
pic = (3, 0, 3, 1, ' __\n/__\n\_|')
add = 0
sz, t, b, add, img = pic
F = prettyForm('\n' * (above - t) + img + '\n' * (below - b),
baseline=above + sz)
pp = self._print(len(e.ap))
pq = self._print(len(e.bq))
pm = self._print(len(e.bm))
pn = self._print(len(e.an))
pu = prettyForm(*pm.right(', ', pn))
pl = prettyForm(*pp.right(', ', pq))
ht = F.baseline - above - 2
if ht > 0:
pu = prettyForm(*pu.below('\n' * ht))
p = prettyForm(*pu.below(pl))
F.baseline = above
F = prettyForm(*F.right(p))
F.baseline = above + add
D = prettyForm(*F.right(' ', D))
return D
def _print_ComplexDomain(self, expr):
if self._use_unicode:
return prettyForm(u'\u2102')
else:
return prettyForm('CC')
