def _print_Mul(self, expr):
coeff, terms = expr.as_coeff_mul()
if coeff.is_negative:
x = self.dom.createElement('apply')
x.appendChild(self.dom.createElement('minus'))
x.appendChild(self._print_Mul(-expr))
return x
numer, denom = fraction(expr)
if not denom is S.One:
x = self.dom.createElement('apply')
x.appendChild(self.dom.createElement('divide'))
x.appendChild(self._print(numer))
x.appendChild(self._print(denom))
return x
if self.order != 'old':
terms = expr._new_rawargs(*terms).as_ordered_factors()
if coeff == 1 and len(terms) == 1:
return self._print(terms[0])
x = self.dom.createElement('apply')
x.appendChild(self.dom.createElement('times'))
if(coeff != 1):
x.appendChild(self._print(coeff))
for term in terms:
x.appendChild(self._print(term))
return x
def _print_Mul(self, expr):
if _coeff_isneg(expr):
x = self.dom.createElement('apply')
x.appendChild(self.dom.createElement('minus'))
x.appendChild(self._print_Mul(-expr))
return x
from sympy.simplify import fraction
numer, denom = fraction(expr)
if denom is not S.One:
x = self.dom.createElement('apply')
x.appendChild(self.dom.createElement('divide'))
x.appendChild(self._print(numer))
x.appendChild(self._print(denom))
return x
coeff, terms = expr.as_coeff_mul()
if coeff is S.One and len(terms) == 1:
# XXX since the negative coefficient has been handled, I don't
# think a coeff of 1 can remain
return self._print(terms[0])
if self.order != 'old':
terms = Mul._from_args(terms).as_ordered_factors()
x = self.dom.createElement('apply')
x.appendChild(self.dom.createElement('times'))
if(coeff != 1):
x.appendChild(self._print(coeff))
for term in terms:
x.appendChild(self._print(term))
return x
def multiply(expr, mrow):
from sympy.simplify import fraction
numer, denom = fraction(expr)
if denom is not S.One:
frac = self.dom.createElement('mfrac')
if self._settings["fold_short_frac"] and len(str(expr)) < 7:
frac.setAttribute('bevelled', 'true')
xnum = self._print(numer)
xden = self._print(denom)
frac.appendChild(xnum)
frac.appendChild(xden)
mrow.appendChild(frac)
return mrow
coeff, terms = expr.as_coeff_mul()
if coeff is S.One and len(terms) == 1:
mrow.appendChild(self._print(terms[0]))
return mrow
if self.order != 'old':
terms = Mul._from_args(terms).as_ordered_factors()
if coeff != 1:
x = self._print(coeff)
y = self.dom.createElement('mo')
y.appendChild(self.dom.createTextNode(self.mathml_tag(expr)))
mrow.appendChild(x)
mrow.appendChild(y)
for term in terms:
x = self._print(term)
mrow.appendChild(x)
if not term == terms[-1]:
y = self.dom.createElement('mo')
y.appendChild(self.dom.createTextNode(self.mathml_tag(expr)))
mrow.appendChild(y)
return mrow
def multiply(expr, mrow):
from sympy.simplify import fraction
numer, denom = fraction(expr)
if denom is not S.One:
frac = self.dom.createElement('mfrac')
xnum = self._print(numer)
xden = self._print(denom)
frac.appendChild(xnum)
frac.appendChild(xden)
return frac
coeff, terms = expr.as_coeff_mul()
if coeff is S.One and len(terms) == 1:
return self._print(terms[0])
if self.order != 'old':
terms = Mul._from_args(terms).as_ordered_factors()
if(coeff != 1):
x = self._print(coeff)
y = self.dom.createElement('mo')
y.appendChild(self.dom.createTextNode(self.mathml_tag(expr)))
mrow.appendChild(x)
mrow.appendChild(y)
for term in terms:
x = self._print(term)
mrow.appendChild(x)
if not term == terms[-1]:
y = self.dom.createElement('mo')
y.appendChild(self.dom.createTextNode(self.mathml_tag(expr)))
mrow.appendChild(y)
return mrow
def possible_subterms(term):
if any(
isinstance(term, cls)
for cls in (sympy.sin, sympy.cos, sympy.tan, sympy.asin,
sympy.acos, sympy.atan, sympy.exp, sympy.log)):
return [term.args[0]]
elif isinstance(term, sympy.Mul):
r = []
for u in term.args:
numer, denom = fraction(u)
if numer == 1:
r.append(denom)
r.extend(possible_subterms(denom))
else:
r.append(u)
r.extend(possible_subterms(u))
return r
elif isinstance(term, sympy.Pow):
if term.args[1].is_constant(symbol):
return [term.args[0]]
elif term.args[0].is_constant(symbol):
return [term.args[1]]
elif isinstance(term, sympy.Add):
return term.args
return []
def _print_Mul(self, expr):
coeff, terms = expr.as_coeff_mul()
if coeff.is_negative:
x = self.dom.createElement('apply')
x.appendChild(self.dom.createElement('minus'))
x.appendChild(self._print_Mul(-expr))
return x
numer, denom = fraction(expr)
if denom is not S.One:
x = self.dom.createElement('apply')
x.appendChild(self.dom.createElement('divide'))
x.appendChild(self._print(numer))
x.appendChild(self._print(denom))
return x
if self.order != 'old':
terms = expr._new_rawargs(*terms).as_ordered_factors()
if coeff == 1 and len(terms) == 1:
return self._print(terms[0])
x = self.dom.createElement('apply')
x.appendChild(self.dom.createElement('times'))
if (coeff != 1):
x.appendChild(self._print(coeff))
for term in terms:
x.appendChild(self._print(term))
return x
def _print_Mul(self, expr):
coeff, terms = expr.as_coeff_terms()
if coeff.is_negative:
x = self.dom.createElement("apply")
x.appendChild(self.dom.createElement("minus"))
x.appendChild(self._print_Mul(-expr))
return x
numer, denom = fraction(expr)
if not denom is S.One:
x = self.dom.createElement("apply")
x.appendChild(self.dom.createElement("divide"))
x.appendChild(self._print(numer))
x.appendChild(self._print(denom))
return x
if coeff == 1 and len(terms) == 1:
return self._print(terms[0])
x = self.dom.createElement("apply")
x.appendChild(self.dom.createElement("times"))
if coeff != 1:
x.appendChild(self._print(coeff))
for term in terms:
x.appendChild(self._print(term))
return x
def _print_Mul(self, expr):
coeff, terms = expr.as_coeff_terms()
if coeff.is_negative:
x = self.dom.createElement('apply')
x.appendChild(self.dom.createElement('minus'))
x.appendChild(self._print_Mul(-expr))
return x
numer, denom = fraction(expr)
if not denom is S.One:
x = self.dom.createElement('apply')
x.appendChild(self.dom.createElement('divide'))
x.appendChild(self._print(numer))
x.appendChild(self._print(denom))
return x
if coeff == 1 and len(terms) == 1:
return self._print(terms[0])
x = self.dom.createElement('apply')
x.appendChild(self.dom.createElement('times'))
if(coeff != 1):
x.appendChild(self._print(coeff))
for term in terms:
x.appendChild(self._print(term))
return x
def possible_subterms(term):
if any(isinstance(term, cls)
for cls in (sympy.sin, sympy.cos, sympy.tan,
sympy.asin, sympy.acos, sympy.atan,
sympy.exp, sympy.log)):
return [term.args[0]]
elif isinstance(term, sympy.Mul):
r = []
for u in term.args:
numer, denom = fraction(u)
if numer == 1:
r.append(denom)
r.extend(possible_subterms(denom))
else:
r.append(u)
r.extend(possible_subterms(u))
return r
elif isinstance(term, sympy.Pow):
if term.args[1].is_constant(symbol):
return [term.args[0]]
elif term.args[0].is_constant(symbol):
return [term.args[1]]
elif isinstance(term, sympy.Add):
return term.args
return []
def _print_Mul(self, expr):
coeff, tail = expr.as_two_terms()
if not coeff.is_negative:
tex = ""
else:
coeff = -coeff
tex = "- "
numer, denom = fraction(tail)
def convert(terms):
product = []
if not terms.is_Mul:
return str(self._print(terms))
else:
for term in terms.args:
pretty = self._print(term)
if term.is_Add:
product.append(r"\left(%s\right)" % pretty)
else:
product.append(str(pretty))
return r" ".join(product)
if denom is S.One:
if coeff is not S.One:
tex += str(self._print(coeff)) + " "
if numer.is_Add:
tex += r"\left(%s\right)" % convert(numer)
else:
tex += r"%s" % convert(numer)
else:
if numer is S.One:
if coeff.is_Integer:
numer *= coeff.p
elif coeff.is_Rational:
if coeff.p != 1:
numer *= coeff.p
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
else:
if coeff.is_Rational and coeff.p == 1:
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
tex += r"\frac{%s}{%s}" % \
(convert(numer), convert(denom))
return tex
def _print_Mul(self, expr):
coeff, tail = expr.as_two_terms()
if not coeff.is_negative:
tex = ""
else:
coeff = -coeff
tex = "- "
numer, denom = fraction(tail)
def convert(terms):
product = []
if not terms.is_Mul:
return str(self._print(terms))
else:
for term in terms.args:
pretty = self._print(term)
if term.is_Add:
product.append(r"\left(%s\right)" % pretty)
else:
product.append(str(pretty))
return r" ".join(product)
if denom is S.One:
if coeff is not S.One:
tex += str(self._print(coeff)) + " "
if numer.is_Add:
tex += r"\left(%s\right)" % convert(numer)
else:
tex += r"%s" % convert(numer)
else:
if numer is S.One:
if coeff.is_Integer:
numer *= coeff.p
elif coeff.is_Rational:
if coeff.p != 1:
numer *= coeff.p
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
else:
if coeff.is_Rational and coeff.p == 1:
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
tex += r"\frac{%s}{%s}" % \
(convert(numer), convert(denom))
return tex
def _eval_sum_hyper(f, i, a):
""" Returns (res, cond). Sums from a to oo. """
from sympy.functions import hyper
from sympy.simplify import hyperexpand, hypersimp, fraction, simplify
from sympy.polys.polytools import Poly, factor
from sympy.core.numbers import Float
if a != 0:
return _eval_sum_hyper(f.subs(i, i + a), i, 0)
if f.subs(i, 0) == 0:
if simplify(f.subs(i, Dummy("i", integer=True, positive=True))) == 0:
return S.Zero, True
return _eval_sum_hyper(f.subs(i, i + 1), i, 0)
hs = hypersimp(f, i)
if hs is None:
return None
if isinstance(hs, Float):
from sympy.simplify.simplify import nsimplify
hs = nsimplify(hs)
numer, denom = fraction(factor(hs))
top, topl = numer.as_coeff_mul(i)
bot, botl = denom.as_coeff_mul(i)
ab = [top, bot]
factors = [topl, botl]
params = [[], []]
for k in range(2):
for fac in factors[k]:
mul = 1
if fac.is_Pow:
mul = fac.exp
fac = fac.base
if not mul.is_Integer:
return None
p = Poly(fac, i)
if p.degree() != 1:
return None
m, n = p.all_coeffs()
ab[k] *= m ** mul
params[k] += [n / m] * mul
# Add "1" to numerator parameters, to account for implicit n! in
# hypergeometric series.
ap = params[0] + [1]
bq = params[1]
x = ab[0] / ab[1]
h = hyper(ap, bq, x)
f = combsimp(f)
return f.subs(i, 0) * hyperexpand(h), h.convergence_statement
def _eval_sum_hyper(f, i, a):
""" Returns (res, cond). Sums from a to oo. """
from sympy.functions import hyper
from sympy.simplify import hyperexpand, hypersimp, fraction, simplify
from sympy.polys.polytools import Poly, factor
from sympy.core.numbers import Float
if a != 0:
return _eval_sum_hyper(f.subs(i, i + a), i, 0)
if f.subs(i, 0) == 0:
if simplify(f.subs(i, Dummy('i', integer=True, positive=True))) == 0:
return S(0), True
return _eval_sum_hyper(f.subs(i, i + 1), i, 0)
hs = hypersimp(f, i)
if hs is None:
return None
if isinstance(hs, Float):
from sympy.simplify.simplify import nsimplify
hs = nsimplify(hs)
numer, denom = fraction(factor(hs))
top, topl = numer.as_coeff_mul(i)
bot, botl = denom.as_coeff_mul(i)
ab = [top, bot]
factors = [topl, botl]
params = [[], []]
for k in range(2):
for fac in factors[k]:
mul = 1
if fac.is_Pow:
mul = fac.exp
fac = fac.base
if not mul.is_Integer:
return None
p = Poly(fac, i)
if p.degree() != 1:
return None
m, n = p.all_coeffs()
ab[k] *= m**mul
params[k] += [n/m]*mul
# Add "1" to numerator parameters, to account for implicit n! in
# hypergeometric series.
ap = params[0] + [1]
bq = params[1]
x = ab[0]/ab[1]
h = hyper(ap, bq, x)
return f.subs(i, 0)*hyperexpand(h), h.convergence_statement
def _print_VecMul(self, expr):
# Almost identical to _print_Mul
from sympy.core.power import Pow
from sympy.physics.units import Quantity
include_parens = False
if _coeff_isneg(expr):
expr = -expr
tex = "- "
if expr.is_Add:
tex += "("
include_parens = True
else:
tex = ""
from sympy.simplify import fraction
numer, denom = fraction(expr, exact=True)
separator = self._settings['mul_symbol_latex']
numbersep = self._settings['mul_symbol_latex_numbers']
def convert(expr):
if not expr.is_Mul:
return str(self._print(expr))
else:
_tex = last_term_tex = ""
if self.order not in ('old', 'none'):
args = expr.as_ordered_factors()
else:
args = list(expr.args)
# If quantities are present append them at the back
args = sorted(args, key=lambda x: isinstance(x, Quantity) or
(isinstance(x, Pow) and
isinstance(x.base, Quantity)))
for i, term in enumerate(args):
term_tex = self._print(term)
# NOTE: only difference wrt _print_Mul
if (self._needs_mul_brackets(term, first=(i == 0),
last=(i == len(args) - 1))
or isinstance(term, (VecCross, VecDot))):
term_tex = r"\left(%s\right)" % term_tex
if _between_two_numbers_p[0].search(last_term_tex) and \
_between_two_numbers_p[1].match(term_tex):
# between two numbers
_tex += numbersep
elif _tex:
_tex += separator
_tex += term_tex
last_term_tex = term_tex
return _tex
if denom is sp.S.One and Pow(1, -1, evaluate=False) not in expr.args:
# use the original expression here, since fraction() may have
# altered it when producing numer and denom
tex += convert(expr)
else:
snumer = convert(numer)
sdenom = convert(denom)
ldenom = len(sdenom.split())
ratio = self._settings['long_frac_ratio']
if self._settings['fold_short_frac'] and ldenom <= 2 and \
"^" not in sdenom:
# handle short fractions
if self._needs_mul_brackets(numer, last=False):
tex += r"\left(%s\right) / %s" % (snumer, sdenom)
else:
tex += r"%s / %s" % (snumer, sdenom)
elif ratio is not None and \
len(snumer.split()) > ratio*ldenom:
# handle long fractions
if self._needs_mul_brackets(numer, last=True):
tex += r"\frac{1}{%s}%s\left(%s\right)" \
% (sdenom, separator, snumer)
elif numer.is_Mul:
# split a long numerator
a = sp.S.One
b = sp.S.One
for x in numer.args:
if self._needs_mul_brackets(x, last=False) or \
len(convert(a*x).split()) > ratio*ldenom or \
(b.is_commutative is x.is_commutative is False):
b *= x
else:
a *= x
if self._needs_mul_brackets(b, last=True):
tex += r"\frac{%s}{%s}%s\left(%s\right)" \
% (convert(a), sdenom, separator, convert(b))
else:
tex += r"\frac{%s}{%s}%s%s" \
% (convert(a), sdenom, separator, convert(b))
else:
tex += r"\frac{1}{%s}%s%s" % (sdenom, separator, snumer)
else:
tex += r"\frac{%s}{%s}" % (snumer, sdenom)
if include_parens:
tex += ")"
return tex
def _print_Mul(self, expr):
coeff, tail = expr.as_coeff_Mul()
if not coeff.is_negative:
tex = ""
else:
coeff = -coeff
tex = "- "
numer, denom = fraction(tail, exact=True)
separator = self._settings['mul_symbol_latex']
def convert(expr):
if not expr.is_Mul:
return str(self._print(expr))
else:
_tex = last_term_tex = ""
if self.order not in ('old', 'none'):
args = expr.as_ordered_factors()
else:
args = expr.args
for term in args:
pretty = self._print(term)
if term.is_Add:
term_tex = (r"\left(%s\right)" % pretty)
else:
term_tex = str(pretty)
# between two digits, \times must always be used,
# to avoid confusion
if separator == " " and \
re.search("[0-9][} ]*$", last_term_tex) and \
re.match("[{ ]*[-+0-9]", term_tex):
_tex += r" \times "
elif _tex:
_tex += separator
_tex += term_tex
last_term_tex = term_tex
return _tex
if denom is S.One:
if numer.is_Add:
_tex = r"\left(%s\right)" % convert(numer)
else:
_tex = r"%s" % convert(numer)
if coeff is not S.One:
tex += str(self._print(coeff))
# between two digits, \times must always be used, to avoid
# confusion
if separator == " " and re.search("[0-9][} ]*$", tex) and \
re.match("[{ ]*[-+0-9]", _tex):
tex += r" \times " + _tex
else:
tex += separator + _tex
else:
tex += _tex
else:
if numer is S.One:
if coeff.is_Integer:
numer *= coeff.p
elif coeff.is_Rational:
if coeff.p != 1:
numer *= coeff.p
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
else:
if coeff.is_Rational and coeff.p == 1:
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
tex += r"\frac{%s}{%s}" % \
(convert(numer), convert(denom))
return tex
def _print_Mul(self, expr):
coeff, terms = expr.as_coeff_terms()
if not coeff.is_negative:
tex = ""
else:
coeff = -coeff
tex = "- "
numer, denom = fraction(C.Mul(*terms))
mul_symbol_table = {
None : r" ",
"ldot" : r" \,.\, ",
"dot" : r" \cdot ",
"times" : r" \times "
}
seperator = mul_symbol_table[self._settings['mul_symbol']]
def convert(terms):
product = []
if not terms.is_Mul:
return str(self._print(terms))
else:
for term in terms.args:
pretty = self._print(term)
if term.is_Add:
product.append(r"\left(%s\right)" % pretty)
else:
product.append(str(pretty))
return seperator.join(product)
if denom is S.One:
if coeff is not S.One:
tex += str(self._print(coeff)) + seperator
if numer.is_Add:
tex += r"\left(%s\right)" % convert(numer)
else:
tex += r"%s" % convert(numer)
else:
if numer is S.One:
if coeff.is_Integer:
numer *= coeff.p
elif coeff.is_Rational:
if coeff.p != 1:
numer *= coeff.p
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
else:
if coeff.is_Rational and coeff.p == 1:
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
tex += r"\frac{%s}{%s}" % \
(convert(numer), convert(denom))
return tex
def _print_Mul(self, expr):
coeff, tail = expr.as_coeff_Mul()
if not coeff.is_negative:
tex = ""
else:
coeff = -coeff
tex = "- "
numer, denom = fraction(tail)
separator = self._settings['mul_symbol_latex']
def convert(expr):
if not expr.is_Mul:
return str(self._print(expr))
else:
_tex = last_term_tex = ""
if self.order != 'old':
args = expr.as_ordered_factors()
else:
args = expr.args
for term in args:
pretty = self._print(term)
if term.is_Add:
term_tex = (r"\left(%s\right)" % pretty)
else:
term_tex = str(pretty)
# between two digits, \times must always be used,
# to avoid confusion
if separator == " " and \
re.search("[0-9][} ]*$", last_term_tex) and \
re.match("[{ ]*[-+0-9]", term_tex):
_tex += r" \times "
elif _tex:
_tex += separator
_tex += term_tex
last_term_tex = term_tex
return _tex
if denom is S.One:
if numer.is_Add:
_tex = r"\left(%s\right)" % convert(numer)
else:
_tex = r"%s" % convert(numer)
if coeff is not S.One:
tex += str(self._print(coeff))
# between two digits, \times must always be used, to avoid
# confusion
if separator == " " and re.search("[0-9][} ]*$", tex) and \
re.match("[{ ]*[-+0-9]", _tex):
tex += r" \times " + _tex
else:
tex += separator + _tex
else:
tex += _tex
else:
if numer is S.One:
if coeff.is_Integer:
numer *= coeff.p
elif coeff.is_Rational:
if coeff.p != 1:
numer *= coeff.p
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
else:
if coeff.is_Rational and coeff.p == 1:
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
tex += r"\frac{%s}{%s}" % \
(convert(numer), convert(denom))
return tex
def _print_Mul(self, expr):
coeff, _ = expr.as_coeff_Mul()
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:]
tex = "- "
else:
tex = ""
expr = sp.Mul(*args)
from sympy.simplify import fraction
numer, denom = fraction(expr, exact=True)
separator = self._settings['mul_symbol_latex']
numbersep = self._settings['mul_symbol_latex_numbers']
def convert(expr):
# if expr is 1/1
if expr.is_Pow and expr.exp.is_Rational and\
expr.exp.is_negative and expr.base is sp.S.One:
expr = sp.S.One
if not expr.is_Mul:
return str(self._print(expr))
else:
_tex = last_term_tex = ""
if self.order not in ('old', 'none'):
args = expr.as_ordered_factors()
else:
args = expr.args
for i, term in enumerate(args):
term_tex = self._print(term)
if self._needs_mul_brackets(term, last=(i == len(args) - 1)):
term_tex = r"\left(%s\right)" % term_tex
if re.search("[0-9][} ]*$", last_term_tex) and \
re.match("[{ ]*[-+0-9]", term_tex):
# between two numbers
_tex += numbersep
elif _tex:
_tex += separator
_tex += term_tex
last_term_tex = term_tex
return _tex
if denom is sp.S.One:
tex += convert(numer)
else:
snumer = convert(numer)
sdenom = convert(denom)
ldenom = len(sdenom.split())
ratio = self._settings['long_frac_ratio']
if self._settings['fold_short_frac'] \
and ldenom <= 2 and not "^" in sdenom:
# handle short fractions
if self._needs_mul_brackets(numer, last=False):
tex += r"\left(%s\right) / %s" % (snumer, sdenom)
else:
tex += r"%s / %s" % (snumer, sdenom)
elif len(snumer.split()) > ratio*ldenom:
# handle long fractions
if self._needs_mul_brackets(numer, last=True):
tex += r"\frac{1}{%s}%s\left(%s\right)" \
% (sdenom, separator, snumer)
elif numer.is_Mul:
# split a long numerator
a = sp.S.One
b = sp.S.One
for x in numer.args:
if self._needs_mul_brackets(x, last=False) or \
len(convert(a*x).split()) > ratio*ldenom or \
(b.is_commutative is x.is_commutative is False):
b *= x
else:
a *= x
if self._needs_mul_brackets(b, last=True):
tex += r"\frac{%s}{%s}%s\left(%s\right)" \
% (convert(a), sdenom, separator, convert(b))
else:
tex += r"\frac{%s}{%s}%s%s" \
% (convert(a), sdenom, separator, convert(b))
else:
tex += r"\frac{1}{%s}%s%s" % (sdenom, separator, snumer)
else:
tex += r"\frac{%s}{%s}" % (snumer, sdenom)
return tex
def _print_Mul(self, expr):
coeff, terms = expr.as_coeff_mul()
if not coeff.is_negative:
tex = ""
else:
coeff = -coeff
tex = "- "
numer, denom = fraction(Mul(*terms))
seperator = self._settings["mul_symbol_latex"]
def convert(terms):
if not terms.is_Mul:
return str(self._print(terms))
else:
_tex = last_term_tex = ""
for term in terms.args:
pretty = self._print(term)
if term.is_Add:
term_tex = r"\left(%s\right)" % pretty
else:
term_tex = str(pretty)
# between two digits, \times must always be used,
# to avoid confusion
if (
seperator == " "
and re.search("[0-9][} ]*$", last_term_tex)
and re.match("[{ ]*[-+0-9]", term_tex)
):
_tex += r" \times "
elif _tex:
_tex += seperator
_tex += term_tex
last_term_tex = term_tex
return _tex
if denom is S.One:
if numer.is_Add:
_tex = r"\left(%s\right)" % convert(numer)
else:
_tex = r"%s" % convert(numer)
if coeff is not S.One:
tex += str(self._print(coeff))
# between two digits, \times must always be used, to avoid
# confusion
if seperator == " " and re.search("[0-9][} ]*$", tex) and re.match("[{ ]*[-+0-9]", _tex):
tex += r" \times " + _tex
else:
tex += seperator + _tex
else:
tex += _tex
else:
if numer is S.One:
if coeff.is_Integer:
numer *= coeff.p
elif coeff.is_Rational:
if coeff.p != 1:
numer *= coeff.p
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
else:
if coeff.is_Rational and coeff.p == 1:
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
tex += r"\frac{%s}{%s}" % (convert(numer), convert(denom))
return tex
def _print_Mul(self, expr):
if _coeff_isneg(expr):
x = _mathml_comp.RowComponent()
x.append_object(
_mathml_comp.OperatorComponent(_mathml_comp.OPERATOR_MINUS))
x.append_object(self._print_Mul(-expr))
return x
PREC = precedence(expr)
from sympy.simplify import fraction
numer, denom = fraction(expr)
if denom is not S.One:
return _mathml_comp.FractionComponent(self._print(numer),
self._print(denom))
coeff, terms = expr.as_coeff_mul()
if coeff is S.One and len(terms) == 1:
# Since the negative coefficient has been handled, I don't
# thing a coeff of 1 can remain
if precedence(terms[0]) < PREC:
# Return the argument with parentheses around.
tmp_node = _mathml_comp.RowComponent()
tmp_node.append_object(
_mathml_comp.OperatorComponent(
_mathml_comp.OPERATOR_LEFT_PARENTHESIS))
tmp_node.append_object(self._print(terms[0]))
tmp_node.append_object(
_mathml_comp.OperatorComponent(
_mathml_comp.OPERATOR_RIGHT_PARENTHESIS))
return tmp_node
else:
# Return the argument only.
return self._print(terms[0])
if self.order != 'old':
# noinspection PyProtectedMember
terms = Mul._from_args(terms).as_ordered_factors()
# Build result row element(node).
x = _mathml_comp.RowComponent()
if coeff != 1:
if precedence(coeff) < PREC:
# Insert the coefficient number with parentheses around.
x.append_object(
_mathml_comp.OperatorComponent(
_mathml_comp.OPERATOR_LEFT_PARENTHESIS))
x.append_object(self._print(coeff))
x.append_object(
_mathml_comp.OperatorComponent(
_mathml_comp.OPERATOR_RIGHT_PARENTHESIS))
else:
# Insert the coefficient number only.
x.append_object(self._print(coeff))
# Insert a multiply operator.
if not terms[0].is_Symbol:
x.append_object(
_mathml_comp.OperatorComponent(
_mathml_comp.OPERATOR_MULTIPLY))
terms_len = len(terms)
for term_id in range(0, terms_len):
cur_term = terms[term_id]
if precedence(cur_term) < PREC:
x.append_object(
_mathml_comp.OperatorComponent(
_mathml_comp.OPERATOR_LEFT_PARENTHESIS))
x.append_object(self._print(cur_term))
x.append_object(
_mathml_comp.OperatorComponent(
_mathml_comp.OPERATOR_RIGHT_PARENTHESIS))
else:
x.append_object(self._print(cur_term))
if term_id + 1 != terms_len and not cur_term.is_Symbol:
x.append_object(
_mathml_comp.OperatorComponent(
_mathml_comp.OPERATOR_MULTIPLY))
return x
def _print_Mul(self, expr):
coeff, _ = expr.as_coeff_Mul()
if not coeff.is_negative:
tex = ""
else:
for i in range(len(expr.args)):
# another change from the original - ensure noevalMul is preseved (the normal expr = -expr forces evaluation)
if expr.args[i].is_negative:
changed_args = list(expr.args)
changed_args[i] *= -1
expr = noevalMul(*changed_args)
tex = "- "
from sympy.simplify import fraction
numer, denom = fraction(expr, exact=True)
separator = self._settings["mul_symbol_latex"]
# another change from the original
numbersep = r" \times "
# numbersep = self._settings['mul_symbol_latex_numbers']
def convert(expr):
if not expr.is_Mul or not isinstance(expr, noevalMul):
return str(self._print(expr))
else:
_tex = last_term_tex = ""
if self.order not in ("old", "none"):
args = expr.as_ordered_factors()
else:
args = expr.args
for i, term in enumerate(args):
term_tex = self._print(term)
if self._needs_mul_brackets(term, last=(i == len(args) - 1)):
term_tex = r"\left(%s\right)" % term_tex
if re.search("[0-9][} ]*$", last_term_tex) and re.match("[{ ]*[-+0-9]", term_tex):
# between two numbers
_tex += numbersep
elif _tex:
_tex += separator
_tex += term_tex
last_term_tex = term_tex
return _tex
if denom is sympy.S.One:
# the change from the original _print_Mul - instead of passing numer, we pass the original expression
tex += convert(expr)
else:
snumer = convert(numer)
sdenom = convert(denom)
ldenom = len(sdenom.split())
ratio = self._settings["long_frac_ratio"]
if self._settings["fold_short_frac"] and ldenom <= 2 and "^" not in sdenom:
# handle short fractions
if self._needs_mul_brackets(numer, last=False):
tex += r"\left(%s\right) / %s" % (snumer, sdenom)
else:
tex += r"%s / %s" % (snumer, sdenom)
elif len(snumer.split()) > ratio * ldenom:
# handle long fractions
if self._needs_mul_brackets(numer, last=True):
tex += r"\frac{1}{%s}%s\left(%s\right)" % (sdenom, separator, snumer)
elif numer.is_Mul:
# split a long numerator
a = sympy.S.One
b = sympy.S.One
for x in numer.args:
if (
self._needs_mul_brackets(x, last=False)
or len(convert(a * x).split()) > ratio * ldenom
or (b.is_commutative is x.is_commutative is False)
):
b *= x
else:
a *= x
if self._needs_mul_brackets(b, last=True):
tex += r"\frac{%s}{%s}%s\left(%s\right)" % (convert(a), sdenom, separator, convert(b))
else:
tex += r"\frac{%s}{%s}%s%s" % (convert(a), sdenom, separator, convert(b))
else:
tex += r"\frac{1}{%s}%s%s" % (sdenom, separator, snumer)
else:
tex += r"\frac{%s}{%s}" % (snumer, sdenom)
return tex
def _print_Mul(self, expr):
coeff, _ = expr.as_coeff_Mul()
if not coeff.is_negative:
tex = ""
else:
for i in range(len(expr.args)):
# another change from the original - ensure noevalMul is preseved (the normal expr = -expr forces evaluation)
if expr.args[i].is_negative:
changed_args = list(expr.args)
changed_args[i] *= -1
expr = noevalMul(*changed_args)
tex = "- "
from sympy.simplify import fraction
numer, denom = fraction(expr, exact=True)
separator = self._settings['mul_symbol_latex']
# another change from the original
numbersep = r" \times "
# numbersep = self._settings['mul_symbol_latex_numbers']
def convert(expr):
if not expr.is_Mul or not isinstance(expr, noevalMul):
return str(self._print(expr))
else:
_tex = last_term_tex = ""
if self.order not in ('old', 'none'):
args = expr.as_ordered_factors()
else:
args = expr.args
for i, term in enumerate(args):
term_tex = self._print(term)
if self._needs_mul_brackets(term,
last=(i == len(args) - 1)):
term_tex = r"\left(%s\right)" % term_tex
if re.search("[0-9][} ]*$", last_term_tex) and \
re.match("[{ ]*[-+0-9]", term_tex):
# between two numbers
_tex += numbersep
elif _tex:
_tex += separator
_tex += term_tex
last_term_tex = term_tex
return _tex
if denom is sympy.S.One:
# the change from the original _print_Mul - instead of passing numer, we pass the original expression
tex += convert(expr)
else:
snumer = convert(numer)
sdenom = convert(denom)
ldenom = len(sdenom.split())
ratio = self._settings['long_frac_ratio']
if self._settings['fold_short_frac'] \
and ldenom <= 2 and "^" not in sdenom:
# handle short fractions
if self._needs_mul_brackets(numer, last=False):
tex += r"\left(%s\right) / %s" % (snumer, sdenom)
else:
tex += r"%s / %s" % (snumer, sdenom)
elif len(snumer.split()) > ratio * ldenom:
# handle long fractions
if self._needs_mul_brackets(numer, last=True):
tex += r"\frac{1}{%s}%s\left(%s\right)" \
% (sdenom, separator, snumer)
elif numer.is_Mul:
# split a long numerator
a = sympy.S.One
b = sympy.S.One
for x in numer.args:
if self._needs_mul_brackets(x, last=False) or \
len(convert(a * x).split()) > ratio * ldenom or \
(b.is_commutative is x.is_commutative is False):
b *= x
else:
a *= x
if self._needs_mul_brackets(b, last=True):
tex += r"\frac{%s}{%s}%s\left(%s\right)" \
% (convert(a), sdenom, separator, convert(b))
else:
tex += r"\frac{%s}{%s}%s%s" \
% (convert(a), sdenom, separator, convert(b))
else:
tex += r"\frac{1}{%s}%s%s" % (sdenom, separator, snumer)
else:
tex += r"\frac{%s}{%s}" % (snumer, sdenom)
return tex
def _print_Mul(self, expr):
coeff, terms = expr.as_coeff_terms()
if not coeff.is_negative:
tex = ""
else:
coeff = -coeff
tex = "- "
numer, denom = fraction(C.Mul(*terms))
mul_symbol_table = {
None: r" ",
"ldot": r" \,.\, ",
"dot": r" \cdot ",
"times": r" \times "
}
seperator = mul_symbol_table[self._settings['mul_symbol']]
def convert(terms):
product = []
if not terms.is_Mul:
return str(self._print(terms))
else:
for term in terms.args:
pretty = self._print(term)
if term.is_Add:
product.append(r"\left(%s\right)" % pretty)
else:
product.append(str(pretty))
return seperator.join(product)
if denom is S.One:
if coeff is not S.One:
tex += str(self._print(coeff)) + seperator
if numer.is_Add:
tex += r"\left(%s\right)" % convert(numer)
else:
tex += r"%s" % convert(numer)
else:
if numer is S.One:
if coeff.is_Integer:
numer *= coeff.p
elif coeff.is_Rational:
if coeff.p != 1:
numer *= coeff.p
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
else:
if coeff.is_Rational and coeff.p == 1:
denom *= coeff.q
elif coeff is not S.One:
tex += str(self._print(coeff)) + " "
tex += r"\frac{%s}{%s}" % \
(convert(numer), convert(denom))
return tex